Текст книги "iOS. Приемы программирования"

Глава 14. Многозадачность

14.0. Введение

Многозадачность – это способ работы, обеспечивающий фоновое выполнение. Иначе говоря, приложение может работать как обычно – выполнять задачи, порождать новые потоки, слушать уведомления, реагировать на события, – но просто ничего не отображать на экране и не взаимодействовать с пользователем каким-либо образом. Когда пользователь нажимает на устройстве кнопку Home (Домой) – в более ранних версиях iPhone и iPad эта кнопка завершала работу приложения, – программа просто переходит в фоновый режим.

Когда ваше приложение переходит в фоновый режим (например, при нажатии кнопки Home (Домой)), а затем возвращается на передний план (когда пользователь вновь выбирает это приложение), система начинает посылать различные сообщения. Ожидается, что эти сообщения будут получены объектом, который мы назначаем делегатом нашего приложения. Например, когда приложение переходит в фоновый режим, делегат приложения получит метод applicationDidEnterBackground:. Аналогично, когда пользователь вновь вернет приложение в приоритетный режим, то есть возобновит с ним работу, делегат приложения получит делегатное сообщение applicationWillEnterForeground:.

Кроме этих сообщений делегатов iOS также посылает работающему приложению уведомления, когда переводит эту программу в фоновый режим или возвращает обратно в приоритетный режим. При переходе приложения в фоновый режим посылается уведомление UIApplicationDidEnterBackgroundNotification, а при переходе из фонового режима в приоритетный – уведомление UIApplicationWillEnterForegroundNotification. Для регистрации этих уведомлений можно использовать центр уведомлений, задаваемый по умолчанию.

14.1. Обнаружение доступности многозадачности

Необходимо выяснить, поддерживается ли многозадачность на том устройстве с iOS, на котором работает ваше приложение.

Вызовите метод экземпляра isMultitaskingSupported, относящийся к классу UIDevice:

– (BOOL) isMultitaskingSupported{

BOOL result = NO;

if ([[UIDevice currentDevice]

respondsToSelector:@selector(isMultitaskingSupported)]){

result = [[UIDevice currentDevice] isMultitaskingSupported];

}

return result;

}

– (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

if ([self isMultitaskingSupported]){

NSLog(@"Multitasking is supported.");

} else {

NSLog(@"Multitasking is not supported.");

}

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

В зависимости от того, на работу в какой версии iOS рассчитано ваше приложение, его можно запускать и выполнять на различных устройствах, где установлены разные версии iOS. Например, вы можете разрабатывать приложение в последней версии iOS SDK, но в качестве целевой (наиболее ранняя версия iOS, в которой сможет работать ваше приложение) задать более низкую версию. В этом случае приложение сможет работать на устройстве с более ранней версией операционной системы, но, возможно, это устройство не будет поддерживать многозадачность. Золотое правило, действующее как в программировании, так и в жизни вообще (не подумайте, что я берусь философствовать), таково: если вы пытаетесь гадать, то рано или поздно ошибетесь. Поэтому не пытайтесь угадать, на каких устройствах в данное время работает ваше приложение. Ведь если iOS-разработчик указывает в Xcode минимальную поддерживаемую версию iOS, он тем самым автоматически ограничивает свою пользовательскую аудиторию. Наша цель – добиться, чтобы обладатели любых устройств с iOS, существующих в настоящее время, могли пользоваться нашим приложением. Поэтому если вы хотите задействовать в приложении для iOS новейшие возможности многозадачности, обязательно проверяйте, доступна ли многозадачность на данном устройстве. Если многозадачность недоступна, необходимо гарантировать, что приложение корректно отреагирует на это, например выберет альтернативный режим выполнения.

14.2. Выполнение долгосрочной задачи в фоновом режиме

Требуется «занять» немного времени у iOS и выполнить долгосрочную задачу, пока приложение находится в фоновом режиме.

Воспользуйтесь методом экземпляра beginBackgroundTaskWithExpirationHandler:, относящимся к классу UIApplication. После того как задача будет решена, вызовите метод экземпляра endBackgroundTask:, относящийся к классу UIApplication.

Когда приложение переходит в фоновый режим, работа его основного потока приостанавливается. Потоки, которые вы создаете в своем приложении с помощью метода класса detachNewThreadSelector: toTarget: withObject:, относящегося к классу NSThread, также приостанавливаются. Если вы пытаетесь решить долгосрочную задачу за то время, пока приложение находится в фоновом режиме, необходимо вызвать метод экземпляра beginBackgroundTaskWithExpirationHandler:, относящийся к классу UIApplication, чтобы «занять» немного времени у системы iOS. Свойство backgroundTimeRemaining класса UIApplication содержит количество секунд, которые требуются приложению для завершения той или иной задачи. Если приложение не успеет завершить долгосрочную задачу до того, как истечет отведенный временной промежуток, iOS завершит приложение. За каждым вызовом метода beginBackgroundTaskWithExpirationHandler: должен следовать соответствующий вызов метода endBackgroundTask: (другой метод экземпляра UIApplication). Иными словами, если вы просите у iOS дополнительное время на завершение задачи, то должны и сообщить iOS, когда закончите эту задачу. Когда это будет сделано и окажется, что больше нет задач, которые следовало бы выполнить в фоновом режиме, ваше приложение перейдет в фоновый режим целиком и все его потоки будут приостановлены.

Когда приложение работает на переднем плане, свойство backgroundTimeRemaining класса UIApplication равно константе DBL_MAX, означающей максимальную величину, которая может содержаться в значении типа double (число с двойной точностью). В данном случае целочисленное значение, равное такому двойному вещественному числу, обычно составляет –1. После того как у iOS запрашивается дополнительное время перед полной приостановкой приложения, в этом свойстве указывается количество секунд, требуемое программе для завершения задачи (или всех текущих задач).

Можно вызывать в приложении метод beginBackgroundTaskWithExpirationHandler: столько раз, сколько потребуется. Но важно учитывать, что, когда iOS возвращает в этом методе вашей программе метку (токен) или идентификатор задачи, вы должны вызвать метод endBackgroundTask:, и сделать это сразу же, как программа закончит выполнять задачу. Если не сделать этого, операционная система iOS может завершить приложение.

Если приложение работает в фоновом режиме, то не предполагается, что оно останется полностью функциональным и сможет обрабатывать «тяжелые» данные. Действительно, такие приложения рассчитаны лишь на завершение долгосрочных задач.

В качестве примера можно привести приложение, направившее вызов к API веб-службы и еще не получившее с сервера ответ от этого API. На время ожидания приложение будет отправлено в фоновый режим, и приложение сможет запросить дополнительное время для получения ответа с сервера. Как только ответ будет получен, приложение должно сохранить свое состояние, а потом отметить факт завершения задачи, вызвав метод экземпляра endBackgroundTask:, относящийся к классу UIApplication.

Рассмотрим пример. Начнем с того, что определим в делегате приложения свойство типа UIBackgroundTaskIdentifier. Кроме того, определим таймер типа NSTimer, который будет использоваться при ежесекундном выводе сообщений на консоль, после того как приложение уйдет в фоновый режим:

#import «AppDelegate.h»

@interface AppDelegate ()

@property (nonatomic, unsafe_unretained)

UIBackgroundTaskIdentifier backgroundTaskIdentifier;

@property (nonatomic, strong) NSTimer *myTimer;

@end

@implementation AppDelegate

<# Остаток вашего кода находится здесь #>

Теперь создадим таймер и назначим время перехода приложения в фоновый режим:

– (BOOL) isMultitaskingSupported{

BOOL result = NO;

if ([[UIDevice currentDevice]

respondsToSelector:@selector(isMultitaskingSupported)]){

result = [[UIDevice currentDevice] isMultitaskingSupported];

}

return result;

}

– (void) timerMethod:(NSTimer *)paramSender{

NSTimeInterval backgroundTimeRemaining =

[[UIApplication sharedApplication] backgroundTimeRemaining];

if (backgroundTimeRemaining == DBL_MAX){

NSLog(@"Background Time Remaining = Undetermined");

} else {

NSLog(@"Background Time Remaining = %.02f Seconds",

backgroundTimeRemaining);

}

}

– (void)applicationDidEnterBackground:(UIApplication *)application{

if ([self isMultitaskingSupported] == NO){

return;

}

self.myTimer =

[NSTimer scheduledTimerWithTimeInterval:1.0f

target: self

selector:@selector(timerMethod:)

userInfo: nil

repeats: YES];

self.backgroundTaskIdentifier =

[application beginBackgroundTaskWithExpirationHandler: ^(void) {

[self endBackgroundTask];

}];

}

Как видите, в обработчике завершения (Completion Handler) фоновой задачи мы вызываем метод endBackgroundTask делегата приложения. Этот метод написали мы сами, и выглядит он так:

– (void) endBackgroundTask{

dispatch_queue_t mainQueue = dispatch_get_main_queue();

__weak AppDelegate *weakSelf = self;

dispatch_async(mainQueue, ^(void) {

AppDelegate

*strongSelf = weakSelf;

if (strongSelf!= nil){

[strongSelf.myTimer invalidate];

[[UIApplication sharedApplication]

endBackgroundTask: self.backgroundTaskIdentifier];

strongSelf.backgroundTaskIdentifier = UIBackgroundTaskInvalid;

}

});

}

Есть еще пара моментов, которые нужно дополнительно уладить после завершения долгосрочной задачи:

• завершить все потоки и таймеры независимо от того, являются они таймерами из фреймворка Core Foundation или созданы с помощью GCD;

• завершить фоновую задачу, вызвав метод endBackgroundTask: класса UIApplication;

• пометить задачу как завершенную, присвоив значение UIBackgroundTaskInvalid идентификаторам задачи.

И последнее, но немаловажное. Если приложение выходит в приоритетный режим, а долгосрочная задача все еще не завершена, необходимо гарантированно от нее избавиться:

– (void)applicationWillEnterForeground:(UIApplication *)application{

if (self.backgroundTaskIdentifier!= UIBackgroundTaskInvalid){

[self endBackgroundTask];

}

}

В нашем примере, как только приложение переходит в фоновый режим, мы запрашиваем дополнительное время на завершение долгосрочной задачи (в данном случае, например, для выполнения кода нашего таймера). В то время мы регулярно считываем значение свойства backgroundTimeRemaining экземпляра класса UIApplication и выводим найденное значение на консоль. В методе экземпляра beginBackgroundTaskWithExpirationHandler:, который относится к классу UIApplication, мы записали код, который будет выполнен прямо перед тем, как закончится дополнительное время, выделенное приложению на выполнение долгосрочной задачи. (Как правило, это происходит за 5–10 секунд до истечения времени, выделенного на выполнение задачи.) Здесь мы можем просто завершить задачу, вызвав метод экземпляра endBackgroundTask:, относящийся к классу UIApplication.

Если приложение перешло в фоновый режим и запросило у операционной системы дополнительное время на исполнение кода еще до того, как отведенное время истекло, пользователь может «оживить» приложение и вернуть его в приоритетный режим. Если до этого вы приказали исполнять долгосрочную задачу в фоновом режиме и как раз для этого приложение было переведено в фоновый режим, то нужно завершить долгосрочную задачу с помощью метода экземпляра endBackgroundTask:, относящегося к классу UIApplication.

Раздел 14.1.

14.3. Добавление возможностей фонового обновления в приложения

Требуется, чтобы ваше приложение могло обновлять контент в фоновом режиме, пользуясь новыми возможностями, появившимися в последнем iOS SDK.

Добавьте в приложение возможность фонового обновления (background fetch).

Многие приложения, ежедневно поступающие на рынок App Store, обладают возможностями соединения с теми или иными серверами. Некоторые выбирают с сервера данные для обновления, другие отсылают информацию на сервер и т. д. В течение долгого времени в iOS существовал лишь один способ обновлять контент в фоновом режиме. Требовалось «занять» у iOS некоторое количество времени (об этом мы говорили в разделе 14.2), и приложение могло потратить это время на завершение своей работы в фоновом режиме. Но такой способ работы является активным. Существует и пассивный способ решения аналогичных задач, когда приложение просто «сидит», а iOS сама выделяет приложению некоторое время на обработку данных в фоновом режиме. Итак, вам требуется просто подключить к приложению такую возможность и приказать системе iOS разбудить ваше приложение в относительно спокойный момент, когда будет удобно обработать данные в фоновом режиме. Обычно при этом происходит фоновое обновление информации.

Например, вам может потребоваться загрузить новый контент. Предположим, у нас есть приложение для работы с Twitter. Открывая это приложение, пользователь в первую очередь хочет просмотреть новые твиты. До недавнего времени это можно было реализовать лишь одним способом: открыть приложение, а потом потратить некоторое время на обновление списка твитов. Но теперь система iOS может активизировать твиттерное приложение в фоновом режиме и приказать ему обновить ленту сообщений. Таким образом, когда пользователь откроет это приложение, твиты на экране уже будут обновлены.

Чтобы задействовать в приложении возможность фонового обновления, нужно перейти на вкладку Capabilities (Возможности) в настройках вашего проекта, а в области Background Modes (Фоновые режимы) установить флажок Background fetch (Фоновое обновление) (рис. 14.1).

Рис. 14.1. Активизация фонового обновления в приложении

Приложение может использовать фоновые обновления двумя способами. Во-первых, пока приложение работает в фоновом режиме, iOS будит его и приказывает ему получить определенный контент для обновления. Во-вторых, ваше приложение может быть еще не запущено и iOS будит его (опять же в фоновом режиме) и приказывает найти контент для последующего обновления. Но как iOS узнает, какое приложение следует разбудить, а какие должны оставаться неактивизированными? В этом системе должен помочь программист.

Для этого нужно вызвать метод экземпляра setMinimumBackgroundFetchInterval:, относящийся к классу UIApplication. В качестве параметра этому методу передаются временной интервал и частота, с которой iOS должна будить ваше приложение в фоновом режиме и приказывать ему получать новые данные для обновления. По умолчанию это свойство имеет значение UIApplicationBackgroundFetchIntervalNever. При таком значении iOS вообще не активизирует ваше приложение в фоновом режиме. Но значение этого свойства можно установить вручную, сообщив количество секунд, образующих интервал, либо просто передать значение UIApplicationBackgroundFetchIntervalMinimum, при котором iOS будет «прилагать минимальные усилия» – будить ваше приложение, но делать это очень редко.

– (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

[application setMinimumBackgroundFetchInterval:

UIApplicationBackgroundFetchIntervalMinimum];

return YES;

}

Сделав это, реализуйте метод экземпляра application: performFetchWithCompletionHandler, относящийся к делегату вашего приложения. Параметр performFetchWithCompletionHandler: этого метода дает нам блоковый объект, который нужно будет вызвать, как только приложение закончит обновлять данные. Вообще этот метод вызывается в делегате приложения, когда iOS приказывает приложению получить в фоновом режиме новый контент для обновления. Поэтому вам придется отреагировать на это и вызвать обработчик завершения, как только все будет готово. Блоковый объект, который вам потребуется вызвать, будет принимать значение типа UIBackgroundFetchResult:

typedef NS_ENUM(NSUInteger, UIBackgroundFetchResult) {

UIBackgroundFetchResultNewData,

UIBackgroundFetchResultNoData,

UIBackgroundFetchResultFailed

} NS_ENUM_AVAILABLE_IOS(7_0);

Итак, если iOS приказывает вашему приложению обновить контент новыми данными, вы пытаетесь получить эти данные, но их в наличии не оказывается, то вам придется вызвать обработчик завершения и передать ему значение UIBackgroundFetchResultNoData. Так вы сообщите iOS, что для обновления информации вашего приложения не нашлось новых данных, и система сможет откорректировать свой алгоритм планирования и механизмы искусственного интеллекта. В результате система станет вызывать приложение не столь часто. iOS действительно очень толково справляется с такими задачами. Допустим, вы приказываете iOS вызвать приложение в фоновом режиме, чтобы оно могло получить новый контент. Но сервер не дает приложению каких-либо обновлений, и в течение целой недели приложение активизируется на пользовательском устройстве в фоновом режиме, но так и не может получить новых данных и неизменно передает блоку завершения вышеупомянутого метода значение UIBackgroundFetchResultNoData. В таком случае совершенно очевидно, что iOS стоит будить это приложение не так часто. Так можно будет более экономно расходовать вычислительную мощность и, соответственно, заряд батареи.

В этом разделе мы собираемся написать простое приложение, которое будет получать с сервера новости. Чтобы не перегружать этот пример слишком сложным серверным кодом, мы просто сымитируем серверные вызовы. Сначала создадим класс NewsItem, который имеет в качестве свойств дату и текст:

#import <Foundation/Foundation.h>

@interface NewsItem: NSObject

@property (nonatomic, strong) NSDate *date;

@property (nonatomic, copy) NSString *text;

@end

У этого класса не будет никакой реализации, поэтому всю информацию он будет нести только в свойствах. Возвращаемся к делегату нашего приложения и определяем изменяемый массив новостей. Таким образом мы сможем закрепить этот массив в контроллере табличного вида и отобразить новостные элементы:

#import <UIKit/UIKit.h>

@interface AppDelegate: UIResponder <UIApplicationDelegate>

@property (nonatomic, strong) UIWindow *window;

@property (nonatomic, strong) NSMutableArray *allNewsItems;

@end

Теперь выполним отложенное выделение массива. Это означает, что массив не будет выделяться и инициализироваться до тех пор, пока приложение прямо к нему не обратится. Так экономится память. Как только массив будет выделен, мы добавим к нему один новый элемент:

#import «AppDelegate.h»

#import «NewsItem.h»

@implementation AppDelegate

– (NSMutableArray *) allNewsItems{

if (_allNewsItems == nil){

_allNewsItems = [[NSMutableArray alloc] init];

/* Заранее записываем в массив один элемент */

NewsItem *item = [[NewsItem alloc] init];

item.date = [NSDate date];

item.text = [NSString stringWithFormat:@"News text 1"];

[_allNewsItems addObject: item];

}

return _allNewsItems;

}

<# Остаток кода делегата вашего приложения находится здесь #>

Теперь реализуем в нашем приложении метод, который будет имитировать вызов сервера. Можно сказать, что здесь мы играем в орлянку. Точнее, метод случайным образом генерирует одно из двух чисел – 0 или 1. Получив 1, мы считаем, что на сервере есть новые новостные материалы для загрузки. Получив 0, считаем, что такая новая информация на сервере отсутствует. Если мы получили 1, то сразу после этого добавляем в список новый элемент:

– (void) fetchNewsItems:(BOOL *)paramFetchedNewItems{

if (arc4random_uniform(2)!= 1){

if (paramFetchedNewItems!= nil){

*paramFetchedNewItems = NO;

}

return;

}

[self willChangeValueForKey:@"allNewsItems"];

/* Генерируем новый элемент */

NewsItem *item = [[NewsItem alloc] init];

item.date = [NSDate date];

item.text = [NSString stringWithFormat:@"News text %lu",

(unsigned long)self.allNewsItems.count + 1];

[self.allNewsItems addObject: item];

if (paramFetchedNewItems!= nil){

*paramFetchedNewItems = YES;

}

[self didChangeValueForKey:@"allNewsItems"];

}

Логический параметр указателя этого метода сообщит нам, появилась ли новая информация, добавленная в массив.

Теперь реализуем механизм фонового обновления в делегате нашего приложения, так, как было объяснено ранее:

– (void) application:(UIApplication *)application

performFetchWithCompletionHandler:(void (^)(UIBackgroundFetchResult))

completionHandler{

BOOL haveNewContent = NO;

[self fetchNewsItems:&haveNewContent];

if (haveNewContent){

completionHandler(UIBackgroundFetchResultNewData);

} else {

completionHandler(UIBackgroundFetchResultNoData);

}

}

Отлично. В контроллере нашего табличного вида отслеживаем изменения массива новостных элементов в делегате приложения. Как только содержимое массива изменится, мы обновим табличный вид. Но будем делать это с умом. Если приложение работает в фоновом режиме, то действительно следует обновить табличный вид. Но если приложение работает в фоновом режиме, отложим обновление до тех пор, пока табличный вид не перейдет в приоритетный режим:

#import «TableViewController.h»

#import «AppDelegate.h»

#import «NewsItem.h»

@interface TableViewController ()

@property (nonatomic, weak) NSArray *allNewsItems;

@property (nonatomic, unsafe_unretained) BOOL mustReloadView;

@end

@implementation TableViewController

– (void)viewDidLoad{

[super viewDidLoad];

AppDelegate *appDelegate = [UIApplication sharedApplication].delegate;

self.allNewsItems = appDelegate.allNewsItems;

[appDelegate addObserver: self

forKeyPath:@"allNewsItems"

options: NSKeyValueObservingOptionNew

context: NULL];

[[NSNotificationCenter defaultCenter]

addObserver: self

selector:@selector(handleAppIsBroughtToForeground:)

name: UIApplicationWillEnterForegroundNotification

object: nil];

}

– (void) observeValueForKeyPath:(NSString *)keyPath

ofObject:(id)object

change:(NSDictionary *)change

context:(void *)context{

if ([keyPath isEqualToString:@"allNewsItems"]){

if ([self isBeingPresented]){

[self.tableView reloadData];

} else {

self.mustReloadView = YES;

}

}

}

– (void) handleAppIsBroughtToForeground:(NSNotification *)paramNotification{

if (self.mustReloadView){

self.mustReloadView = NO;

[self.tableView reloadData];

}

}

Наконец, потребуется написать необходимые методы источника данных нашего табличного вида, позволяющие записывать новые элементы в табличный вид:

– (NSInteger)tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return self.allNewsItems.count;

}

– (UITableViewCell *)tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

static NSString *CellIdentifier = @"Cell";

UITableViewCell *cell = [tableView

dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

NewsItem *newsItem = self.allNewsItems[indexPath.row];

cell.textLabel.text = newsItem.text;

return cell;

}

– (void) dealloc{

AppDelegate *appDelegate = [UIApplication sharedApplication].delegate;

[appDelegate removeObserver: self forKeyPath:@"allNewsItems"];

[[NSNotificationCenter defaultCenter] removeObserver: self];

}

В данном примере кода мы извлекаем из очереди те ячейки табличного вида, которые имеют идентификатор Cell. Метод dequeueReusableCellWithIdentifier: forIndexPath: нашего табличного вида возвращает валидные ячейки, а не nil, потому что в файле раскадровки мы уже задали этот идентификатор для прототипа ячейки в табличном виде. Во время исполнения раскадровка регистрирует для iOS эту ячейку-прототип с заданным идентификатором. Поэтому мы можем извлекать ячейки из очереди, просто опираясь на данный идентификатор, и не регистрируем ячейки заранее.

Табличные виды подробно рассмотрены в главе 4.

Теперь запустите ваше приложение и нажмите кнопку Home (Главная), чтобы перевести ваше приложение в фоновый режим. Вернитесь в Xcode и в меню Debug (Отладка) выберите Simulate Background Fetch (Имитировать обновление в фоновом режиме) (рис. 14.2). Теперь вновь откройте приложение, не завершая его, и посмотрите, появится ли в табличном виде новый контент. Если не появится – то именно по той причине, что запрограммированная нами логика напоминает игру в орлянку. Приложение случайным образом «определяет», есть ли на «сервере» новый контент. Так имитируются вызовы сервера. Если не получите никакого «нового контента», просто повторите имитацию фонового обновления в меню Debug (Отладка), пока «информация» не будет «получена».

Рис. 14.2. Имитация фонового обновления в Xcode

До сих пор мы обрабатывали в системе iOS запросы на фоновое обновление, пока приложение находилось в фоновом режиме. Но что, если работа приложения полностью завершена и фонового режима в данный момент не существует? Как нам сымитировать описанную ситуацию и определить, сработает ли наша программа? Оказывается, Apple уже и об этом позаботилась. Выберите пункт Manage Schemes (Управление схемами) в меню Product (Продукт) в Xcode. Здесь скопируйте основную схему вашего приложения, нажав кнопку с плюсиком, а затем установив флажок Duplicate Scheme (Дублировать схему) (рис. 14.3).

Рис. 14.3. Дублирование схемы для обеспечения имитации фонового обновления в период, когда приложение не работает даже в фоновом режиме

Теперь перед вами откроется новое диалоговое окно, примерно такое, как на рис. 14.4. Здесь будет предложено установить различные свойства новой схемы. В этом диалоговом окне установите флажок Launch due to a background fetch event (Запуск, обусловленный событием фонового обновления данных), а потом нажмите ОК.

Рис. 14.4. Активизация схемы для запуска приложения с целью фонового обновления

Итак, теперь в Xcode записаны две схемы для приложения (рис. 14.5). Чтобы активизировать приложение с целью фонового обновления, вам просто понадобится выбрать только что созданную вторую схему и запустить приложение в симуляторе или на устройстве. В таком случае ваше приложение не перейдет в приоритетный режим. Вместо этого будет выдан сигнал для обновления данных в фоновом режиме, который, в свою очередь, вызовет метод application: performFetchWithCompletionHandler: делегата нашего приложения. Если вы правильно выполнили все шаги, описанные в этом разделе, то в обоих сценариях у вас будет полностью работоспособное приложение: и когда iOS вызывает программу из фонового режима, и когда приложение запускается с нуля, только для фонового обновления.

Рис. 14.5. Использование новой схемы для запуска вашего приложения и имитации фонового обновления данных