iOS. Приемы программирования.

Глава 1. Реализация контроллеров и видов.

1.0. Введение.

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

Чтобы программировать приложения для iOS 7, вы должны знать основы языка Objective-C, с которым мы будем работать на протяжении всей этой книги. Как понятно из названия, язык Objective-C основан на С, но имеет определенные расширения, которые облегчают оперирование объектами. Объекты и классы имеют фундаментальное значение в объектно-ориентированном программировании (ООП). К числу объектно-ориентированных языков относятся Objective-C, Java, C++ и многие другие. В Objective-C, как и в любом объектно-ориентированном языке, вы имеете доступ не только к объектам, но и к примитивам. Например, число –20 (минус двадцать) можно выразить в виде примитива следующим образом:

NSInteger myNumber = -20;

В этой простой строке кода определяется переменная myNumber, относящаяся к типу данных NSInteger. Ее значение устанавливается в 20. Так определяются переменные в языке Objective-C. Переменная — это простое присваивание имени местоположению в памяти. В таком случае если мы задаем 20 в качестве значения переменной myNumber, то сообщаем машине, что собираемся выполнить фрагмент кода, который поместит указанное значение в область памяти, соответствующую переменной myNumber.

В сущности, все приложения iOS используют архитектуру «модель — вид — контроллер» (MVC). C архитектурной точки зрения модель, вид и контроллер — это три основные составляющие приложения iOS.

Модель — это мозг приложения. Она выполняет все вычисления и создает для себя виртуальный мир, в котором может существовать сама, без видов и контроллеров. Иными словами, вы можете считать модель виртуальной копией вашего приложения, без интерфейса.

Вид — это окно, через которое пользователь взаимодействует с вашим приложением. В большинстве случаев вид отображает содержимое модели, но, кроме того, он же воспринимает и действия пользователя. Любые контакты между пользователем и вашим приложением отправляются в вид. После этого они могут быть перехвачены контроллером вида и переданы в модель.

Контроллеры в программах iOS — это, как правило, контроллеры видов, которые я только что упомянул. Контроллер вида является, в сущности, переходным звеном между моделью и видом. Он интерпретирует события, происходящие с одной стороны, и по мере необходимости использует эту информацию для внесения изменений на другой стороне. Например, если пользователь изменяет какое-либо поле в виде, то контроллер гарантирует, что и модель изменится соответствующим образом. А если модель получит новые данные, то контроллер прикажет виду отобразить их.

В этой главе вы узнаете, как выстраивать структуру приложения iOS и использовать виды и контроллеры видов для создания интуитивно понятных приложений.

В этой главе мы будем создавать большинство компонентов пользовательского интерфейса на базе шаблона Single View Application из Xcode. Чтобы воспроизвести приведенные инструкции, следуйте рекомендациям, приведенным в подразделе «Создание и запуск вашего первого приложения для iOS» данного раздела. Убедитесь в том, что ваше приложение является универсальным, а не ориентировано только на iPhone или на iPad. Универсальное приложение может работать как на iPhone, так и на iPad.

Создание и запуск вашего первого приложения для iOS.

Прежде чем подробнее познакомиться с возможностями Objective-C, вкратце рассмотрим, как создать простое приложение для iOS в среде Xcode. Xcode — это интегрированная среда разработки (IDE) для работы с Apple, позволяющая создавать, строить и запускать ваше приложение в эмуляторе iOS и даже на реальных устройствах с iOS. По ходу книги мы подробнее обсудим Xcode и ее возможности, а пока научимся создавать и запускать самое простое приложение. Я полагаю, что вы уже скачали Xcode из Mac App Store и установили ее на своем компьютере. В таком случае выполните следующие шаги.

1. Откройте Xcode, если еще не сделали этого.

2. Выберите в меню пункт File (Файл), далее — New Project (Новый проект).

3. Слева в диалоговом окне создания нового проекта выберите подкатегорию Application (Приложение) в основной категории iOS. Затем справа щелкните на варианте Single View Application (Приложение с единственным видом) и нажмите кнопку Next (Далее).

4. На следующем экране вы увидите поле Product Name (Название продукта). Здесь укажите название, которое будет понятно вам, например My First iOS App. В разделе Organization name (Название организации) введите название вашей компании или, если работаете самостоятельно, любое другое осмысленное название. Название организации — довольно важная информация, которую, как правило, придется здесь указывать, но пока она нас не особенно волнует. В поле Company Identifier (Идентификатор компании) запишите com.mycompany. Если вы действительно владеете собственной компанией или пишете приложение для фирмы, являющейся вашим работодателем, то замените mycompany настоящим названием. Если просто экспериментируете, придумайте какое-нибудь название. В разделе Devices (Устройства) выберите вариант Universal (Универсальное).

5. Как только зададите все эти значения, просто нажмите кнопку Next (Далее).

6. Система предложит сохранить новый проект на диске. Выберите желаемое местоположение проекта и нажмите кнопку Create (Создать).

7. Перед запуском проекта убедитесь, что к компьютеру не подключено ни одного устройства iPhone или iPad/iPod. Это необходимо, поскольку, если к вашему Mac подключено такое устройство, то Xcode попытается запускать приложения именно на устройстве, а не на эмуляторе. В таком случае могут возникнуть некоторые проблемы с профилями инициализации (о них мы поговорим позже). Итак, отключите от компьютера все устройства с системой iOS, а затем нажмите большую кнопку Run (Запуск) в левом верхнем углу Xcode. Если не можете найти кнопку Run, перейдите в меню Product (Продукт) и выберите в меню элемент Run (Запуск).

Ура! Вот и готово простое приложение, работающее в эмуляторе iOS. Может быть, оно и не кажется особенно впечатляющим: в эмуляторе мы видим просто белый экран. Но это лишь первый шаг к освоению огромного iOS SDK. Давайте же отправимся в это непростое путешествие!

Определение переменных и понятие о них.

Во всех современных языках программирования, в том числе в Objective-C, существуют переменные. Переменные — это просто псевдонимы, обозначающие участки (местоположения) в памяти. Каждая переменная может иметь следующие свойства:

тип данных, представляющий собой либо примитив (например, целое число), либо объект;

• имя;

• значение.

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

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

• NSInteger и NSUInteger. Переменные этого типа могут содержать целочисленные значения, например 10, 20 и т. д. Тип NSInteger может содержать как положительные, так и отрицательные значения, но тип NSUInteger является беззнаковым, на что указывает буква U в его названии. Не забывайте, что слово «беззнаковый» в терминологии языков программирования означает, что число ни при каких условиях не может быть отрицательным. Отрицательные значения могут содержаться только в числовом типе со знаком.

• CGFloat. Содержит числа с плавающей точкой, имеющие десятичные знаки, например 1.31 или 2.40.

• NSString. Позволяет сохранять символьные строки. Такие примеры мы рассмотрим далее.

• NSNumber. Позволяет сохранять числа как объекты.

• id. Переменные типа id могут указывать на объект любого типа. Такие объекты называются нетипизированными. Если вы хотите передать объект из одного места в другое, но по какой-то причине не хотите при этом указывать их тип, то вам подойдет именно такой тип данных.

• NSDictionary и NSMutableDictionary. Это соответственно неизменяемый и изменяемый варианты хеш-таблиц. В хеш-таблице вы можете хранить ключ и ассоциировать этот ключ со значением. Например, ключ phone_num может иметь значение 0 55524 87700. Для считывания значений достаточно ссылаться на ассоциированные с ними ключи.

• NSArray и NSMutableArray. Неизменяемые и изменяемые массивы объектов. Массив — это упорядоченная коллекция элементов. Например, у вас может быть 10 строковых объектов, которые вы хотите сохранить в памяти. Для этого хорошо подойдет массив.

• NSSet, NSMutableSet, NSOrderedSet, NSMutableOrderedSet. Это типы множеств. Множества напоминают массивы тем, что могут содержать в себе наборы объектов, но в отличие от массива множество может включать в себя только уникальные объекты. Массив может содержать несколько экземпляров одного и того же объекта, а в множестве каждый объект может присутствовать только в одном экземпляре. Рекомендую вам четко усвоить разницу между массивами и множествами и использовать их правильно.

• NSData и NSMutableData. Неизменяемые и изменяемые контейнеры для любых данных. Такие типы данных очень вам пригодятся, если вы, например, хотите выполнить считывание содержимого файла в память.

Одни из рассмотренных нами типов данных являются примитивами, другие — классами. Вам придется просто запомнить, какие из них относятся к каждой из категорий. Например, тип данных NSInteger является примитивом, а NSString — классом. Поэтому из NSString можно создавать объекты. В языке Objective-C, как и в C и C++, существуют указатели. Указатель — это тип данных, в котором сохраняется адрес в памяти. По этому адресу уже хранятся фактические данные. Вы уже, наверное, знаете, что указатели на классы обозначаются символом астериска (*):

NSString *myString = @"Objective-C is great!";

Следовательно, если вы хотите присвоить строку переменной типа NSString на языке Objective-C, то вам понадобится просто сохранить данные в указатель типа NSString *. Но если вы собираетесь сохранить в переменной значение, представляющее собой число с плавающей точкой, то не сможете использовать указатель, так как тип данных, к которому относится эта переменная, не является классом:

/* Присваиваем переменной myFloat значение PI */

CGFloat myFloat = M_PI;

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

/* Присваиваем переменной myFloat значение PI */

CGFloat myFloat = M_PI;

/* Создаем переменную указателя, которая направлена на переменную myFloat */

CGFloat *pointerFloat = &myFloat;

Мы получаем данные от исходного числа с плавающей точкой путем простого разыменования (myFloat). Если получение значения происходит с применением указателя, то требуется использовать астериск (*pointerFloat). В некоторых ситуациях указатели могут быть полезны — например, при вызове функции, которая задает в качестве аргумента значение с плавающей точкой, а вы хотите получить новое значение после возврата функции.

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

Как создавать классы и правильно пользоваться ими.

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

Класс должен наследовать от суперкласса. Из этого правила есть немногочисленные исключения. В частности, классы NSObject и NSProxy являются корневыми. У корневых классов не бывает суперкласса.

• Класс должен иметь имя, соответствующее Соглашению об именованиях методов в Cocoa.

• У класса должен быть файл интерфейса, в котором определяется интерфейс этого класса.

• У класса должна быть реализация, в которой вы прописываете все возможности, которые вы «обещали» предоставить согласно интерфейсу класса.

NSObject — это корневой класс, от которого наследуют практически все другие классы. В этом примере мы собираемся добавить класс под названием Person в проект, который был создан в подразделе «Создание и запуск вашего первого приложения для iOS» данного раздела. Далее мы добавим к этому классу два свойства, firstName и lastName, которые относятся к типу NSString. Выполните следующие шаги, чтобы создать класс Person и добавить его в ваш проект.

1. Откройте проект в Xcode и в меню File (Файл) выберите New-File (Новый— Файл).

2. Убедитесь, что слева, в разделе iOS, вы выбрали категорию Cocoa Touch. После этого выберите элемент Objective-C Class (Класс для Objective-C) и нажмите Next (Далее).

3. В разделе Class (Класс) введите имя Person.

4. В разделе Subclass of (Подкласс от) введите NSObject.

Когда справитесь с этим, нажмите кнопку Next (Далее). На данном этапе Xcode предложит вам сохранить этот файл. Просто сохраните новый класс в том каталоге, где находятся ваш проект и все его файлы. Это место выбирается по умолчанию. Затем нажмите кнопку Create (Создать) — и дело сделано.

После этого в ваш проект будут добавлены два новых файла: Person.h и Person.m. Первый файл — это интерфейс вашего класса Person, а второй — файл реализации этого класса. В Objective-C.h-файлы являются заголовочными. В таких файлах вы определяете интерфейс каждого файла. В.m-файле пишется сама реализация класса.

Теперь рассмотрим заголовочный файл нашего класса Person и определим для этого класса два свойства, имеющие тип NSString:

@interface Person: NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

@end

Как и переменные, свойства определяются в особом формате в следующем порядке.

1. Определение свойства должно начинаться с ключевого слова @property.

2. Затем следует указать квалификаторы свойства. Неатомарные (nonatomic) свойства не являются потокобезопасными. О безопасности потоков мы поговорим в главе 14. Вы можете указать и другие квалификаторы свойств: assign, copy, weak, strong или unsafe_unretained. Чуть позже мы подробнее поговорим и о них.

3. Затем укажите тип данных для свойства, например NSInteger или NSString.

4. Наконец, не забудьте задать имя для свойства. Имена свойств должны соответствовать рекомендациям Apple.

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

strong — свойства этого типа будут сохраняться во время исполнения. Они могут быть только экземплярами классов. Иными словами, вы не можете сохранить значение в свойстве типа strong, если значение является примитивом. Можно сохранять объекты, но не примитивы.

• copy — аналогичен strong, но при выполнении присваивания к свойствам этого типа среда времени исполнения будет делать копию объекта в правой части операции присваивания. Объект, находящийся в правой части этой операции, должен соответствовать протоколу NSCopying или NSMutableCopying.

• assign — значения объектов или примитивов, задаваемые в качестве значения свойства типа assign, не будут копироваться или сохраняться этим свойством. Для свойств примитивов этот квалификатор будет создавать адрес в памяти, в котором вы сможете поместить информацию примитива. В случае с объектами свойства такого типа будут просто указывать на объект в правой части равенства.

• unsafe_unretained — аналогичен квалификатору assign.

• weak — практически аналогичен квалификатору assign, но с одним большим отличием. При работе с объектами, когда объект, присвоенный свойству такого типа, высвобождается из памяти, среда времени исполнения будет автоматически устанавливать значение этого свойства в nil.

Итак, у нас есть класс Person с двумя свойствами, firstName и lastName. Вернемся к файлу реализации делегата нашего приложения (AppDelegate.m) и создадим объект типа Person:

#import «AppDelegate.h»

#import «Person.h»

@implementation AppDelegate

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *person = [[Person alloc] init];

person.firstName = @"Steve";

person.lastName = @"Jobs";

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

Добавление нового функционала к классам с помощью методов.

Методы — это строительные блоки, из которых состоят классы. Например, класс Person может иметь логические возможности — обозначим их как «ходить», «дышать», «есть» и «пить». Обычно такие функции инкапсулируются в методах.

Метод может принимать параметры. Параметры — это переменные, передаваемые вызывающей стороной при вызове метода и видимые только этому методу. Например, в упрощенном мире у нашего класса Person был бы метод walk. Но вы могли бы добавить к этому методу параметр или аргумент и назвать его walkingSpeed. Этому параметру вы бы присвоили тип CGFloat. Теперь, если другой программист вызовет этот метод в вашем классе, он может указать, с какой скоростью будет идти Person. Вы как автор класса напишете соответствующий код, который будет обрабатывать различные скорости ходьбы Person. Не переживайте, если у вас возникает ощущение «как-то много работы получается». Рассмотрим следующий пример. В нем я добавил метод в файл реализации того класса Person, который мы создали в подразделе «Как создавать классы и правильно пользоваться ими» данного раздела.

#import «Person.h»

@implementation Person

— (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour{

/* здесь пишем код для этого метода */

}

— (void) runAt10KilometersPerHour{

/* Вызываем метод walk в нашем собственном классе и передаем значение 10 */

[self walkAtKilometersPerHour:10.0f];

}

@end

Типичный метод в языке Objective-C имеет следующие качества.

1. Префикс указывает компилятору, является ли данный код методом экземпляра (—) или методом класса (+). К методу экземпляра можно обратиться лишь после того, как программист выделит и инициализирует экземпляр вашего класса. Получить доступ к методу класса можно, вызвав его непосредственно из этого класса. Не волнуйтесь, если на первый взгляд это кажется сложным. В этой книге мы рассмотрим многочисленные примеры методов, пока просто следите за ходом рассказа.

2. Тип данных для метода, если метод возвращает какое-либо значение. В примере мы указали тип данных void. Так мы сообщаем компилятору, что не собираемся возвращать от метода какое-либо значение.

3. Первая часть имени метода, за которой идет первый параметр. Метод может и не иметь параметров. Методы, не принимающие параметров, довольно широко распространены.

4. Список последующих параметров, идущих за первым.

Рассмотрим пример метода с двумя параметрами:

— (void) singSong:(NSData *)paramSongData loudly:(BOOL)paramLoudly{

/* Параметры, к которым мы можем обратиться здесь, в этом методе, таковы:

paramSongData (для доступа к информации о песне)

paramLoudly сообщает нам, должны мы петь песню громко или нет

*/

}

Важно учитывать, что каждый параметр каждого метода обладает внешним и внутренним именем. Внешнее имя входит в состав метода, а внутреннее имя — это фактическое название (или псевдоним) параметра, которое может использоваться в пределах реализации метода. В предыдущем примере внешнее имя первого параметра — singSong, а внутреннее — paramSongData. Внешнее имя второго параметра — loudly, а внутреннее — paramLoudly. Имя метода и внешние имена его параметров вместе образуют сущность, которая называется селектором метода. В данном случае селектор упомянутого метода будет иметь вид singSong: loudly:. Как будет объяснено далее в этой книге, селектор является идентификатором каждого метода в среде времени исполнения. Никакие два метода в рамках одного и того же класса не могут иметь одинаковые селекторы.

В нашем примере мы определили в файле реализации класса Person (Person.m) три метода:

walkAtKilometersPerHour:;

• runAt10KilometersPerHour;

• singSong: loudly:.

Если бы мы хотели использовать любой из этих методов из какой-нибудь сущности, находящейся вне класса, например из делегата приложения, то должны были бы предоставить эти методы в нашем файле интерфейса (Person.h):

#import <Foundation/Foundation.h>

@interface Person: NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

— (void) walkAtKilometersPerHour:(CGFloat)paramSpeedKilometersPerHour;

— (void) runAt10KilometersPerHour;

/* Не предоставляем метод singSong: loudly: для доступа извне.

Этот метод является внутренним для нашего класса. Зачем же нам открывать к нему доступ? */

@end

Имея такой файл интерфейса, программист может вызывать методы walkAtKilometersPerHour: и runAt10KilometersPerHour извне класса Person. А метод singSong: loudly: так вызывать нельзя, поскольку он не предоставлен в файле интерфейса. Итак, продолжим: попробуем вызвать все три этих метода из делегата нашего приложения и посмотрим, что получится:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *person = [[Person alloc] init];

[person walkAtKilometersPerHour:3.0f];

[person runAt10KilometersPerHour];

/* Если раскомментировать следующую строку кода, то компилятор выдаст

вам ошибку и сообщит, что такого метода в классе Person не существует */

//[person singSong: nil loudly: YES];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Итак, теперь мы умеем определять и вызывать методы экземпляров. А что насчет методов классов? Сначала разберемся, что такое методы классов и чем они отличаются от методов экземпляров.

Метод экземпляра — это метод, относящийся к экземпляру класса. Например, в нашем случае вы можете создать экземпляр класса Person дважды и получить в гипотетической игре, которую разрабатываете, двух разных персонажей. Один персонаж будет ходить со скоростью 3 км/ч, другой — 2 км/ч.

Пусть вы и написали код для метода экземпляра walk всего один раз, но когда во время исполнения создаются два экземпляра класса Person, поступающие от них вызовы методов экземпляра маршрутизируются к соответствующему экземпляру класса (тому, который выполнил вызов).

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

#import «Person.h»

@implementation Person

+ (CGFloat) maximumHeightInCentimeters{

return 250.0f;

}

+ (CGFloat) minimumHeightInCentimeters{

return 40.0f;

}

@end

Метод maximumHeightInCentimeters — это метод класса, возвращающий гипотетический максимальный рост любого персонажа в сантиметрах. Метод класса minimumHeightInCentimeters возвращает минимальный рост любого персонажа. Вот как мы предоставим оба этих метода в файле интерфейса нашего класса:

#import <Foundation/Foundation.h>

@interface Person: NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

@property (nonatomic, assign) CGFloat currentHeight;

+ (CGFloat) maximumHeightInCentimeters;

+ (CGFloat) minimumHeightInCentimeters;

@end

Мы добавили к нашему классу Person еще одно свойство, принимающее значения с плавающей точкой. Оно называется currentHeight. С его помощью экземпляры этого класса могут хранить информацию о своей высоте в памяти (для справки) — точно так же, как имя и фамилию.

А в делегате нашего приложения мы продолжим работать с методами вот так:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

Person *steveJobs = [[Person alloc] init];

steveJobs.firstName = @"Steve";

steveJobs.lastName = @"Jobs";

steveJobs.currentHeight = 175.0f; /* Сантиметры */

if (steveJobs.currentHeight >= [Person minimumHeightInCentimeters] &&

steveJobs.currentHeight <= [Person maximumHeightInCentimeters]){

/* Высота этого персонажа находится в пределах допустимого */

} else {

/* Высота этого персонажа находится вне пределов допустимого */

}

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Соблюдение требований, предъявляемых другими классами, с помощью протоколов.

В языке Objective-C существует концепция под названием «протокол». Протоколы встречаются и во многих других языках, но называются везде по-разному; например, в Java аналогичная сущность называется «интерфейс». Как понятно из названия, протокол — это набор правил, которым класс должен соответствовать, чтобы его можно было использовать тем или иным образом. Если класс выполняет правила определенного протокола, то принято говорить, что он соответствует этому протоколу. Протоколы отличаются от самих классов тем, что не имеют реализации. Это просто правила. Например, у любой машины есть колеса, дверцы и цвет кузова, а также многие другие свойства. Определим эти свойства в протоколе Car. Просто выполните следующие шаги, чтобы создать заголовочный файл, который может содержать наш протокол Car.

1. Откройте ваш проект в Xcode и в меню File (Файл) выберите New-File (Новый — Файл).

2. Убедитесь, что слева, в разделе iOS, вы выбрали категорию Cocoa Touch. После этого выберите элемент Objective-C Protocol (Протокол для Objective-C) и нажмите Next (Далее).

3. В разделе Class (Класс) введите имя Car, затем нажмите кнопку Next (Далее).

4. Далее система предложит вам сохранить ваш протокол на диске. Просто выберите для этого место (как правило, в каталоге с вашим проектом) и нажмите кнопку Create (Создать).

После этого Xcode создаст для вас файл Car.h с таким содержимым:

#import <Foundation/Foundation.h>

@protocol Car <NSObject>

@end

Продолжим и определим свойства для протокола Car, как мы обсуждали ранее в этом разделе:

#import <Foundation/Foundation.h>

@protocol Car <NSObject>

@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;

@property (nonatomic, copy) NSArray *doors;

@end

Теперь, когда наш протокол определен, создадим класс, обозначающий автомобиль, — например, Jaguar, — а потом обеспечим соответствие этого класса протоколу. Просто выполните все шаги, перечисленные в подразделе «Как создавать классы и правильно пользоваться ими» данного раздела, после чего обеспечьте его соответствие протоколу Car следующим образом:

#import <Foundation/Foundation.h>

#import «Car.h»

@interface Jaguar: NSObject <Car>

@

end

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

Auto property synthesis will not synthesize property declared in a protocol

Это означает, что ваш класс Jaguar пытается соответствовать протоколу Car, но на самом деле не реализует всех требуемых свойств и/или методов, описанных в этом протоколе. Теперь вы уже знаете, что в протоколе могут содержаться необходимые и факультативные (опциональные) элементы, которые вы помечаете ключевыми словами @optional или @required. По умолчанию действует квалификатор @required, и поскольку мы явно не указываем квалификатор для этого протокола, компилятор неявно выбирает @required за нас. Следовательно, класс Jaguar теперь обязан реализовывать все аспекты, требуемые протоколом Car, вот так:

#import <Foundation/Foundation.h>

#import «Car.h»

@interface Jaguar: NSObject <Car>

@property (nonatomic, copy) NSArray *wheels;

@property (nonatomic, strong) UIColor *bodyColor;

@property (nonatomic, copy) NSArray *doors;

@end

Отлично. Теперь мы понимаем основы работы с протоколами, то, как они работают и как их определить. Далее в этой книге мы подробнее поговорим о протоколах, а на данный момент вы получили довольно полное представление о них.

Хранение элементов в коллекциях и получение элементов из коллекций.

Коллекции — это такие объекты, в экземплярах которых могут храниться другие объекты. Одна из самых распространенных разновидностей коллекций — это массив, который инстанцирует NSArray или NSMutableArray. В массиве можно хранить любой объект, причем массив может содержать несколько экземпляров одного и того же объекта. В следующем примере мы создаем массив из трех строк:

NSArray *stringsArray = @[

@"String 1",

@"String 2",

@"String 3"

];

__unused NSString *firstString = stringsArray[0];

__unused NSString *secondString = stringsArray[1];

__unused NSString *thirdString = stringsArray[2];

Макрос __unused приказывает компилятору «не жаловаться», когда переменная — в нашем случае переменная firstString — объявлена, но ни разу не использовалась. По умолчанию в такой ситуации компилятор выдает в консоль предупреждение, сообщающее, что переменная не используется. В нашем кратком примере мы объявили переменные, но не задействовали их. Поэтому, если добавить вышеупомянутый макрос в начале объявления переменной, это вполне устроит и нас, и компилятор.

Изменяемый массив — это такой массив, в который можно вносить изменения уже после того, как он был создан. Как мы видели ранее, неизменяемый массив не может быть дополнен новой информацией уже после создания. Вот пример неизменяемого массива:

NSString *string1 = @"String 1";

NSString *string2 = @"String 2";

NSString *string3 = @"String 3";

NSArray *immutableArray = @[string1, string2, string3];

NSMutableArray *mutableArray = [[NSMutableArray alloc]

initWithArray: immutableArray];

[mutableArray exchangeObjectAtIndex:0 withObjectAtIndex:1];

[mutableArray removeObjectAtIndex:1];

[mutableArray setObject: string1 atIndexedSubscript:0];

NSLog(@"Immutable array = %@", immutableArray);

NSLog(@"Mutable Array = %@", mutableArray);

Вывод этой программы таков:

Immutable array = (

«String 1»,

«String 2»,

«String 3»

)

Mutable Array = (

«String 1»,

«String 3»

)

Еще одна распространенная коллекция, которая часто встречается в программах для iOS, — это словарь. Словари похожи на массивы, но каждому объекту в словаре присваивается ключ, и по этому ключу вы можете позже получить интересующий вас объект. Рассмотрим пример:

NSDictionary *personInformation =

@{

@"firstName": @"Mark",

@"lastName": @"Tremonti",

@"age": @30,

@"sex": @"Male"

};

NSString *firstName = personInformation[@"firstName"];

NSString *lastName = personInformation[@"lastName"];

NSNumber *age = personInformation[@"age"];

NSString *sex = personInformation[@"sex"];

NSLog(@"Full name = %@ %@", firstName, lastName);

NSLog(@"Age = %@, Sex = %@", age, sex);

А вот и вывод этой программы:

Full name = Mark Tremonti

Age = 30, Sex = Male

Можно также использовать изменяемые словари, которые довольно сильно похожи на изменяемые массивы. Содержимое изменяемого словаря можно изменить после того, как словарь инстанцирован. Пример:

NSDictionary *personInformation =

@{

@"firstName": @"Mark",

@"lastName": @"Tremonti",

@"age": @30,

@"sex": @"Male"

};

NSMutableDictionary *mutablePersonInformation =

[[NSMutableDictionary alloc] initWithDictionary: personInformation];

mutablePersonInformation[@"age"] = @32;

NSLog(@"Information = %@", mutablePersonInformation);

Вывод этой программы таков:

Information = {

age = 32;

firstName = Mark;

lastName = Tremonti;

sex = Male;

}

Еще можно работать с множествами. Множества похожи на массивы, но любой объект, входящий в состав множества, должен встречаться в нем только один раз. Иными словами, в одном множестве не может быть двух экземпляров одного и того же объекта. Пример множества:

NSSet *shoppingList = [[NSSet alloc] initWithObjects:

@"Milk",

@"Bananas",

@"Bread",

@"Milk", nil];

NSLog(@"Shopping list = %@", shoppingList);

Запустив эту программу, вы получите следующий вывод:

Shopping list = {(

Milk,

Bananas,

Bread

)}

Обратите внимание: элемент Milk упомянут в программе дважды, а в множество добавлен всего один раз. Эта черта множеств — настоящее волшебство. Изменяемые множества можно использовать и вот так:

NSSet *shoppingList = [[NSSet alloc] initWithObjects:

@"Milk",

@"Bananas",

@"Bread",

@"Milk", nil];

NSMutableSet *mutableList = [NSMutableSet setWithSet: shoppingList];

[mutableList addObject:@"Yogurt"];

[mutableList removeObject:@"Bread"];

NSLog(@"Original list = %@", shoppingList);

NSLog(@"Mutable list = %@", mutableList);

А вывод будет таким:

Original list = {(

Milk,

Bananas,

Bread

)}

Mutable list = {(

Milk,

Bananas,

Yogurt

)}

Обсуждая множества и коллекции, следует упомянуть еще два важных класса, о которых вам необходимо знать:

NSOrderedSet — неизменяемое множество, учитывающее, в каком порядке в него добавлялись объекты;

• NSMutableOrderedSet — изменяемый вариант вышеупомянутого изменяемого множества.

По умолчанию множества не учитывают, в каком порядке объекты в них добавлялись. Рассмотрим пример:

NSSet *setOfNumbers = [NSSet setWithArray:@[@3, @4, @1, @5, @10]];

NSLog(@"Set of numbers = %@", setOfNumbers);

Запустив эту программу, получим на экране следующий вывод:

Set of numbers = {(

5,

10,

3,

4,

1

)}

Но на самом деле мы наполняли множество элементами в другом порядке. Если вы хотите сохранить правильный порядок, просто воспользуйтесь классом NSOrderedSet:

NSOrderedSet *setOfNumbers = [NSOrderedSet orderedSetWithArray

:@[@3, @4, @1, @5, @10]];

NSLog(@"Ordered set of numbers = %@", setOfNumbers);

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

NSMutableOrderedSet *setOfNumbers =

[NSMutableOrderedSet orderedSetWithArray:@[@3, @4, @1, @5, @10]];

[setOfNumbers removeObject:@5];

[setOfNumbers addObject:@0];

[setOfNumbers exchangeObjectAtIndex:1 withObjectAtIndex:2];

NSLog(@"Set of numbers = %@", setOfNumbers);

А вот и результаты:

Set of numbers = {(

3,

1,

4,

10,

0

)}

Прежде чем завершить разговор о множествах, упомяну еще об одном удобном классе, который может вам пригодиться. Класс NSCountedSet может несколько раз содержать уникальный экземпляр объекта. Правда, в нем эта задача решается иначе, нежели в массивах. В массиве может несколько раз присутствовать один и тот же объект. А в рассматриваемом здесь «подсчитываемом множестве» каждый объект появляется в множестве как будто заново, но множество ведет подсчет того, сколько раз объект был добавлен в множество, и снижает значение этого счетчика на единицу, как только вы удалите из этого множества экземпляр данного объекта. Вот пример:

NSCountedSet *setOfNumbers = [NSCountedSet setWithObjects:

@10, @20, @10, @10, @30, nil];

[setOfNumbers addObject:@20];

[setOfNumbers removeObject:@10];

NSLog(@"Count for object @10 = %lu",

(unsigned long)[setOfNumbers countForObject:@10]);

NSLog(@"Count for object @20 = %lu",

(unsigned long)[setOfNumbers countForObject:@20]);

Вывод программы:

Count for object @10 = 2

Count for object @20 = 2

Класс NSCountedSet является изменяемым, хотя из его названия это и не следует.

Обеспечение поддержки подписывания объектов в ваших классах.

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

NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";

NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] init];

[dictionary setValue:@"Tim" forKey: kFirstNameKey];

[dictionary setValue:@"Cook" forKey: kLastNameKey];

__unused NSString *firstName = [dictionary valueForKey: kFirstNameKey];

__unused NSString *lastName = [dictionary valueForKey: kLastNameKey];

Но с развитием компилятора LLVM этот код можно сократить, придав ему следующий вид:

NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";

NSDictionary *dictionary = @{

kFirstNameKey: @"Tim",

kLastNameKey: @"Cook",

};

__unused NSString *firstName = dictionary[kFirstNameKey];

__unused NSString *lastName = dictionary[kLastNameKey];

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

NSArray *array = [[NSArray alloc] initWithObjects:@"Tim", @"Cook", nil];

__unused NSString *firstItem = [array objectAtIndex:0];

__unused NSString *secondObject = [array objectAtIndex:1];

А теперь, имея возможность подписывать объекты, мы можем сократить этот код следующим образом:

NSArray *array = @[@"Tim", @"Cook"];

__unused NSString *firstItem = array[0];

__unused NSString *secondObject = array[0];

Компилятор LLVM не останавливается и на этом. Вы можете также добавлять подписывание и к собственным классам. Существует два типа подписывания:

подписывание по ключу — действуя таким образом, вы можете задавать внутри объекта значение для того или иного ключа точно так же, как вы делали бы это в словаре. Указывая ключ, вы также можете получать доступ к значениям внутри объекта и считывать их;

подписывание по индексу — как и при работе с массивами, вы можете устанавливать/получать значения внутри объекта, предоставив для этого объекта индекс. Это целесообразно делать в массивоподобных классах, где элементы естественным образом располагаются в порядке, удобном для индексирования.

Сначала рассмотрим пример подписывания по ключу. Для этого создадим класс под названием Person, имеющий свойства firstName и lastName. Далее мы позволим программисту менять значения этих свойств (имя и фамилию), просто предоставив ключи для этих свойств.

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

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

#import <Foundation/Foundation.h>

/* Мы будем использовать их как ключи для наших свойств firstName

и lastName, так что если имена наших свойств firstName и lastName

в будущем изменятся в реализации, нам не придется ничего переделывать

и наш класс останется работоспособным, поскольку мы сможем просто

изменить значения этих констант в нашем файле реализации */

extern NSString *const kFirstNameKey;

extern NSString *const kLastNameKey;

@interface Person: NSObject

@property (nonatomic, copy) NSString *firstName;

@property (nonatomic, copy) NSString *lastName;

— (id) objectForKeyedSubscript:(id<NSCopying>)paramKey;

— (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey;

@end

Метод objectForKeyedSubscript: будет вызываться в вашем классе всякий раз, когда программист предоставит ключ и захочет прочитать в вашем классе значение, соответствующее данному ключу. Очевидно, тот параметр, который будет вам передан, будет представлять собой ключ, по которому программист хочет считать интересующее его значение. Дополнительно к этому методу мы будем вызывать в нашем классе метод setObject: forKeyedSubscript: всякий раз, когда программист захочет задать значение для конкретного ключа. Итак, в данной реализации мы хотим проверить, ассоциированы ли заданные ключи с именами и фамилиями. Если это так, то собираемся установить/получить в нашем классе значения имени и фамилии:

#import «Person.h»

NSString *const kFirstNameKey = @"firstName";

NSString *const kLastNameKey = @"lastName";

@implementation Person

— (id) objectForKeyedSubscript:(id<NSCopying>)paramKey{

NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;

if ([keyAsObject isKindOfClass: [NSString class]]){

NSString *keyAsString = (NSString *)keyAsObject;

if ([keyAsString isEqualToString: kFirstNameKey] ||

[keyAsString isEqualToString: kLastNameKey]){

return [self valueForKey: keyAsString];

}

}

return nil;

}

— (void) setObject:(id)paramObject forKeyedSubscript:(id<NSCopying>)paramKey{

NSObject<NSCopying> *keyAsObject = (NSObject<NSCopying> *)paramKey;

if ([keyAsObject isKindOfClass: [NSString class]]){

NSString *keyAsString = (NSString *)keyAsObject;

if ([keyAsString isEqualToString: kFirstNameKey] ||

[keyAsString isEqualToString: kLastNameKey]){

[self setValue: paramObject forKey: keyAsString];

}

}

}

@end

Итак, в этом коде мы получаем ключ в методе objectForKeyedSubscript:, а в ответ должны вернуть объект, который ассоциирован в нашем экземпляре с этим ключом. Ключ, который получаем, — это объект, соответствующий протоколу NSCopying. Это означает, что при желании мы можем сделать копию такого объекта. Рассчитываем на то, что ключ будет представлять собой строку, чтобы мы могли сравнить его с готовыми ключами, которые были заранее объявлены в начале класса. В случае совпадения зададим значение данного свойства в этом классе. После этого воспользуемся методом valueForKey:, относящимся к объекту NSObject, чтобы вернуть значение, ассоциированное с заданным ключом. Но, разумеется, прежде, чем так поступить, мы должны гарантировать, что данный ключ — один из тех, которые мы ожидаем. В методе setObject: forKeyedSubscript: мы делаем совершенно противоположное — устанавливаем значения для заданного ключа, а не возвращаем их.

Теперь в любой части вашего приложения вы можете инстанцировать объект типа Person и использовать заранее определенные ключи kFirstNameKey и kLastNameKey, чтобы изменить значения свойств firstName и lastName, вот так:

Person *person = [Person new];

person[kFirstNameKey] = @"Tim";

person[kLastNameKey] = @"Cook";

__unused NSString *firstName = person[kFirstNameKey];

__unused NSString *lastName = person[kLastNameKey];

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

Person *person = [Person new];

person.firstName = @"Tim";

person.lastName = @"Cook";

__unused NSString *firstName = person.firstName;

__unused NSString *lastName = person.lastName;

Вы также можете поддерживать и подписывание по индексу — точно как при работе с массивами. Как было указано ранее, это полезно делать, чтобы обеспечивать программисту доступ к объектам, выстраиваемым в классе в некоем естественном порядке. Но, кроме массивов, существует не так уж много структур данных, где целесообразно упорядочивать и нумеровать элементы, чего не скажешь о подписывании по ключу, которое применяется в самых разных структурах данных. Поэтому пример, которым иллюстрируется подписывание по индексу, немного надуман. В предыдущем примере у нас существовал класс Person с именем и фамилией. Теперь мы хотим предоставить программистам возможность считывать имя, указывая индекс 0, а фамилию — указывая индекс 1. Все, что требуется сделать для этого, — объявить методы objectAtIndexedSubscript: и setObject: atIndexedSubscript: в заголовочном файле класса, а затем написать реализацию. Вот как мы объявляем два этих метода в заголовочном файле класса Person:

— (id) objectAtIndexedSubscript:(NSUInteger)paramIndex;

— (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex;

Реализация также довольно проста. Мы берем индекс и оперируем им так, как это требуется в нашем классе. Ранее мы решили, что у имени должен быть индекс 0, а у фамилии — индекс 1. Итак, получаем индекс 0 для задания значения, присваиваем значение имени первому входящему объекту и т. д.:

— (id) objectAtIndexedSubscript:(NSUInteger)paramIndex{

switch (paramIndex){

case 0:{

return self.firstName;

break;

}

case 1:{

return self.lastName;

break;

}

default:{

[NSException raise:@"Invalid index" format: nil];

}

}

return nil;

}

— (void) setObject:(id)paramObject atIndexedSubscript:(NSUInteger)paramIndex{

switch (paramIndex){

case 0:{

self.firstName = paramObject;

break;

}

case 1:{

self.lastName = paramObject;

break;

}

default:{

[NSException raise:@"Invalid index" format: nil];

}

}

}

Теперь можно протестировать весь написанный ранее код вот так:

Person *person = [Person new];

person[kFirstNameKey] = @"Tim";

person[kLastNameKey] = @"Cook";

NSString *firstNameByKey = person[kFirstNameKey];

NSString *lastNameByKey = person[kLastNameKey];

NSString *firstNameByIndex = person[0];

NSString *lastNameByIndex = person[1];

if ([firstNameByKey isEqualToString: firstNameByIndex] &&

[lastNameByKey isEqualToString: lastNameByIndex]){

NSLog(@"Success");

} else {

NSLog(@"Something is not right");

}

Если вы правильно выполнили все шаги, описанные в этом разделе, то на консоли должно появиться значение Success.

1.1. Отображение предупреждений с помощью UIAlertView.

Постановка задачи.

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

Решение.

Воспользуйтесь UIAlertView.

Обсуждение.

Если вы сами пользуетесь iOS, то вам определенно попадались виды-предупреждения. Пример такого вида показан на рис. 1.1.

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.1. Вид-предупреждение, сообщающий пользователю, что для работы требуется активное соединение с Интернетом

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

— (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear: paramAnimated];

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Alert"

message:@"You've been delivered an alert"

delegate: nil

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView show];

}

Когда этот вид-предупреждение отобразится у пользователя, он увидит экран, подобный показанному на рис. 1.2.

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.2. Простой вид-предупреждение, отображаемый у пользователя

Чтобы показать пользователю вид-предупреждение, мы используем метод предупреждения show. Рассмотрим описания всех параметров, которые могут быть переданы базовому конструктору-инициализатору вида-предупреждения:

• title — строка, которую пользователь увидит в верхней части вида-предупрежения. На рис. 1.2 эта строка — Title;

• message — сообщение, которое отображается у пользователя. На рис. 1.2 для этого сообщения задано значение Message;

• delegate — опциональный объект-делегат, который мы передаем виду-предупреждению. Затем этот объект будет получать уведомление при каждом изменении состояния предупреждения, например, когда пользователь нажмет на экранную кнопку, изображенную в этом виде. Объект, передаваемый данному параметру, должен соответствовать протоколу UIAlertViewDelegate;

• cancelButtonTitle — строка, которая будет присваиваться кнопке отмены (Cancel Button) в виде-предупреждении. Если в виде-предупреждении есть кнопка отмены, то такой вид обычно побуждает пользователя к действию. Если пользователь не хочет совершать предложенное действие, то он нажимает кнопку отмены. Причем на этой кнопке не обязательно должна быть строка-надпись Cancel (Отменить). Надпись для этой кнопки определяете вы сами, и этот параметр опциональный — можно сделать диалоговое окно и без кнопки Отмена;

• otherButtonTitles — надписи на других кнопках, тех, которые вы хотите отобразить в виде-предупреждении. Разделяйте такие надписи запятыми. Нужно убедиться, что в конце списка названий стоит значение nil, называемое сигнальной меткой. Этот параметр не является обязательным.

Можно создать предупреждение вообще без кнопок. Но такое окно пользователь никак не сможет убрать с экрана. Создавая такой вид, вы как программист должны позаботиться о том, чтобы он убирался автоматически, например, через 3 секунды после того, как появится. Вид-предупреждение без кнопок, который не убирается автоматически, — это настоящее бедствие, с точки зрения пользователя. Ваше приложение не только получит низкие оценки на App Store за то, что вид-предупреждение блокирует пользовательский интерфейс. Велика вероятность, что вашу программу вообще удалят с рынка.

Виды-предупреждения можно оформлять с применением различных стилей. В классе UIAlertView есть свойство alertViewStyle типа UIAlertViewStyle:

typedef NS_ENUM(NSInteger, UIAlertViewStyle) {

UIAlertViewStyleDefault = 0,

UIAlertViewStyleSecureTextInput,

UIAlertViewStylePlainTextInput,

UIAlertViewStyleLoginAndPasswordInput

};

Вот что делает каждый из этих стилей:

• UIAlertViewStyleDefault — стандартный стиль вида-предупреждения, подобное оформление мы видели на рис. 1.2;

• UIAlertViewStyleSecureTextInput — при таком стиле в виде-предупреждении будет содержаться защищенное текстовое поле, которое станет скрывать от зрителя символы, вводимые пользователем. Такой вариант предупреждения вам подойдет, например, если вы запрашиваете у пользователя его учетные данные для дистанционного банковского обслуживания;

• UIAlertViewStylePlainTextInput — при таком стиле у пользователя будет отображаться незащищенное текстовое поле. Этот стиль отлично подходит для случаев, когда вы просите пользователя ввести несекретную последовательность символов, например номер его телефона;

• UIAlertViewStyleLoginAndPasswordInput — при таком стиле в виде-предупреждении будет два текстовых поля: незащищенное — для имени пользователя и защищенное — для пароля.

Если вам необходимо получать уведомление, когда пользователь начинает работать с видом-предупреждением, укажите объект-делегат для вашего предупреждения. Этот делегат должен подчиняться протоколу UIAlertViewDelegate. Самый важный метод, определяемый в этом протоколе, — alertView: clickedButtonAtIndex:, который вызывается сразу же, как только пользователь нажимает на одну из кнопок в виде-предупреждении. Индекс нажатой кнопки передается вам через параметр clickedButtonAtIndex.

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

Сначала реализуем два очень простых метода, которые возвращают надпись на той или иной из двух кнопок:

— (NSString *) yesButtonTitle{

return @"Yes";

}

— (NSString *) noButtonTitle{

return @"No";

}

Теперь нужно убедиться, что контроллер нашего вида подчиняется протоколу UIAlertViewDelegate:

#import <UIKit/UIKit.h>

#import «ViewController.h»

@interface ViewController () <UIAlertViewDelegate>

@end

@implementation ViewController

Следующий шаг — создать и отобразить для пользователя окно с предупреждением:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

self.view.backgroundColor = [UIColor whiteColor];

NSString *message = @"Are you sure you want to open this link in Safari?";

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Open Link"

message: message

delegate: self

cancelButtonTitle: [self noButtonTitle]

otherButtonTitles: [self yesButtonTitle], nil];

[alertView show];

}

Вид-предупреждение будет выглядеть примерно как на рис. 1.3.

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.3. Вид-предупреждение с кнопками No (Нет) и Yes (Да)

Далее нужно узнать, какой вариант пользователь выбрал в нашем окне — No (Нет) или Yes (Да). Для этого потребуется реализовать метод alertView: clickedButtonAtIndex:, относящийся к делегату нашего вида-предупреждения:

— (void) alertView:(UIAlertView *)alertView

clickedButtonAtIndex:(NSInteger)buttonIndex{

NSString *buttonTitle = [alertView buttonTitleAtIndex: buttonIndex];

if ([buttonTitle isEqualToString: [self yesButtonTitle]]){

NSLog(@"User pressed the Yes button.");

}

else if ([buttonTitle isEqualToString: [self noButtonTitle]]){

NSLog(@"User pressed the No button.");

}

}

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

Как видите, мы пользуемся методом buttonTitleAtIndex: класса UIAlertView. Мы передаем этому методу индекс кнопки, отсчитываемый с нуля (кнопка находится в нашем виде), и получаем строку, которая представляет собой надпись на этой кнопке — если такая надпись вообще имеется. С помощью этого метода можно определить, какую кнопку нажал пользователь. Индекс этой кнопки будет передан нам как параметр buttonIndex метода alertView: clickedButtonAtIndex:. Если вас интересует надпись на этой кнопке, то нужно будет использовать метод buttonTitleAtIndex: класса UIAlertView. Все готово!

Кроме того, вид-предупреждение можно использовать и для текстового ввода, например, запрашивая у пользователя номер кредитной карточки или адрес. Для этого, как было указано ранее, нужно использовать стиль оформления предупреждения UIAlertViewStylePlainTextInput:

— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Credit Card Number"

message:@"Please enter your credit card number: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView setAlertViewStyle: UIAlertViewStylePlainTextInput];

/* Отобразить для этого текстового поля числовую клавиатуру. */

UITextField *textField = [alertView textFieldAtIndex:0];

textField.keyboardType = UIKeyboardTypeNumberPad;

[alertView show];

}

Если сейчас запустить приложение в эмуляторе, то мы увидим такое изображение, как на рис. 1.4.

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.4. Вид-предупреждение для ввода обычным текстом

В этом коде мы изменяем стиль оформления вида на UIAlertViewStylePlainTextInput, а также делаем еще кое-что. Мы получили ссылку на первое и единственное текстовое поле, которое, как мы знаем, будет присутствовать в виде-предупреждении. Ссылку на текстовое поле применили для того, чтобы изменить тип клавиатуры, связанной с текстовым полем. Подробнее о текстовых полях поговорим в разделе 1.19.

Кроме обычного текста мы можем попросить пользователя набрать и защищенный текст. Как правило, защищается такой текст, который является для пользователя конфиденциальным, например пароль (рис. 1.5). Рассмотрим пример:

— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Password"

message:@"Please enter your password: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView setAlertViewStyle: UIAlertViewStyleSecureTextInput];

[alertView show];

}

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.5. Ввод защищенного текста в окно с предупреждением

Стиль UIAlertViewStyleSecureTextInput очень напоминает UIAlertViewStylePlainTextInput, за исключением того, что вместо символов текста мы подставляем какие-то нейтральные символы.

Следующий стиль довольно полезный. Он позволяет отобразить два текстовых поля: одно для имени пользователя, а другое — для пароля. Текст в первом поле открыт, а во втором — скрыт:

— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

UIAlertView *alertView = [[UIAlertView alloc]

initWithTitle:@"Password"

message:@"Please enter your credentials: "

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:@"OK", nil];

[alertView setAlertViewStyle: UIAlertViewStyleLoginAndPasswordInput];

[alertView show];

}

В результате увидим такое изображение, как на рис. 1.6.

Обсуждение. 1.1. Отображение предупреждений с помощью UIAlertView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.6. Стиль, позволяющий вводить в вид-предупреждение имя пользователя и пароль

См. также.

Раздел 1.19.

1.2. Создание и использование переключателей с помощью UISwitch.

Постановка задачи.

Вы хотите дать пользователям возможность включать и отключать определенные функции.

Решение.

Воспользуйтесь классом UISwitch.

Обсуждение.

Класс UISwitch предоставляет инструмент управления ON/OFF (Вкл./Выкл.), как на рис. 1.7. Этот инструмент используется для работы с автоматической капитализацией, автоматическим исправлением орфографических ошибок и т. д.

Обсуждение. 1.2. Создание и использование переключателей с помощью UISwitch. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.7. Переключатель UISwitch, применяемый в приложении Settings (Настройки) в iPhone

Создать переключатель можно либо с помощью конструктора интерфейса, либо сделав экземпляр такого переключателя в коде. Решим эту задачу вторым способом. Итак, следующая проблема — определить, в каком классе разместить соответствующий код. Это должен быть класс View Controller (Контроллер вида), который мы еще не изучали, но, поскольку в этой главе мы создаем программу типа Single View Application (Приложение с единственным видом), файл реализации (.m) контроллера вида будет называться ViewController.m. Откроем этот файл.

Создадим свойство типа UISwitch и назовем его mainSwitch:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UISwitch *mainSwitch;

@end

@implementation ViewController

Теперь перейдем к файлу реализации контроллера вида (файлу. m) и синтезируем свойство mySwitch:

#import «Creating_and_Using_Switches_with_UISwitchViewController.h»

@implementation Creating_and_Using_Switches_with_UISwitchViewController

@synthesize mySwitch;

Можно продолжить и перейти к созданию переключателя. Найдем метод viewDidLoad в файле реализации нашего контроллера вида:

— (void)viewDidLoad{

[super viewDidLoad];

}

Создадим переключатель и поместим его в виде, в котором находится контроллер нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];

/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame:

CGRectMake(100, 100, 0, 0)];

[self.view addSubview: self.mainSwitch];

}

Итак, мы выделили объект типа UISwitch и применили метод initWithFrame: для инициализации переключателя. Обратите внимание: параметр, который мы должны передать этому методу, относится к типу CGRect. CGRect определяет границы прямоугольника, отсчитывая их от точки с координатами (x; y), находящейся в левом верхнем углу прямоугольника, и также используя данные о его ширине и высоте. Можно создать CGRect, воспользовавшись встраиваемым методом CGRectMake, где первые два параметра, передаваемые методу, — это координаты (x; y), а следующие два — высота и ширина прямоугольника.

Создав переключатель, мы просто добавляем его к виду нашего контроллера.

Теперь запустим приложение на эмуляторе iPhone. На рис. 1.8 показано, что происходит.

Обсуждение. 1.2. Создание и использование переключателей с помощью UISwitch. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.8. Переключатель, размещенный в виде

Как видите, по умолчанию переключатель находится в состоянии Off (Выкл.). Чтобы задать в качестве стандартного противоположное состояние, можно изменить значение свойства on экземпляра UISwitch. Или можно вызвать метод setOn:, относящийся к переключателю:

[self.mySwitch setOn: YES];

Мы можем немного облегчить работу пользователю, применив метод переключателя setOn: animated:. Параметр animated принимает логическое значение. Если логическое значение равно YES, то при переходе переключателя из состояния on в состояние off этот процесс будет анимироваться, а также будут анимироваться любые взаимодействия пользователя с переключателем.

Очевидно, вы можете считывать информацию свойства on переключателя, чтобы узнавать, включен переключатель в данный момент или выключен. В качестве альтернативы можно пользоваться методом переключателя isOn:

if ([self.mySwitch isOn]){

NSLog(@"The switch is on.");

} else {

NSLog(@"The switch is off.");

}

Если вы хотите получать уведомления о том, когда переключатель переходит в состояние «включено» или «выключено», необходимо указать ваш класс как цель (Target) переключателя, воспользовавшись методом addTarget: action: forControlEvents: класса UISwitch:

[self.mySwitch addTarget: self

action:@selector(switchIsChanged:)

forControlEvents: UIControlEventValueChanged];

Затем реализуем метод switchIsChanged:. Когда среда времени исполнения вызовет этот метод в ответ на событие переключателя UIControlEventValueChanged, она передаст переключатель как параметр данного метода и вы сможете узнать, какой именно переключатель инициировал данное событие:

— (void) switchIsChanged:(UISwitch *)paramSender{

NSLog(@"Sender is = %@", paramSender);

if ([paramSender isOn]){

NSLog(@"The switch is turned on.");

} else {

NSLog(@"The switch is turned off.");

}

}

Теперь попробуем запустить наше приложение в эмуляторе iOS. В окне консоли вы увидите примерно такие сообщения:

Sender is = <UISwitch: 0x6e13500;

frame = (100 100; 79 27);

layer = <CALayer: 0x6e13700>>

The switch is turned off.

Sender is = <UISwitch: 0x6e13500;

frame = (100 100; 79 27);

layer = <CALayer: 0x6e13700>>

Переключатель включен.

1.3. Оформление UISwitch.

Постановка задачи.

Вы вставили в ваш пользовательский интерфейс несколько экземпляров UISwitch и теперь хотите оформить их так, чтобы они вписывались в этот графический интерфейс.

Решение.

Используйте одно из свойств настройки тонов/изображений класса UISwitch, например tintColor или onTintColor.

Обсуждение.

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

Существует два основных способа оформления переключателя.

Работа с оттенками. Оттенки — это цветовые тона, которые вы можете применять к компоненту пользовательского интерфейса, например к UISwitch. Новый оттенок накладывается поверх актуального цвета компонента. Например, при работе с обычным UISwitch вы наверняка сталкивались с разными цветами. Когда вы применяете оттенок поверх цвета, этот цвет смешивается с наложенным оттенком. Таким образом создается разновидность оттенка, действующая в данном элементе пользовательского интерфейса.

Изображения. Переключателю соответствуют:

изображение включенного состояния. Находится на переключателе, когда он включен. Ширина изображения составляет 77 точек, высота — 22 точки;

изображение выключенного состояния. Находится на переключателе, когда он выключен. Ширина изображения составляет 77 точек, высота — 22 точки.

На рис. 1.9 показаны примеры изображений, используемых при включенном и выключенном переключателе.

Обсуждение. 1.3. Оформление UISwitch. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.9. Переключатель UISwitch и изображения, соответствующие его включенному и выключенному состояниям

Итак, переключатель может находиться в одном из двух состояний — он либо включен, либо выключен. Теперь рассмотрим, как изменить оттенок переключателя, находящегося в пользовательском интерфейсе. Это можно сделать с помощью трех важных свойств класса UISwitch (все эти свойства относятся к типу UIColor):

tintColor — оттенок, применяемый к переключателю в выключенном состоянии. К сожалению, Apple подобрала для него не совсем точное название (правильнее было бы, конечно, назвать это свойство offTintColor);

• thumbTintColor — оттенок, который будет применяться к рычажку переключателя;

• onTintColor — оттенок, применяемый к переключателю во включенном состоянии.

Далее приведен простой пример кода, изменяющий оттенок переключателя во включенном состоянии на красный, в выключенном — на коричневый. При этом рычажок будет иметь зеленый цвет. Это не самая лучшая комбинация цветов, но в целях, поставленных в данном разделе, я остановлюсь именно на таком варианте:

— (void)viewDidLoad

{

[super viewDidLoad];

/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame: CGRectZero];

self.mainSwitch.center = self.view.center;

[self.view addSubview: self.mainSwitch];

/* Оформляем переключатель */

/* Изменяем оттенок, который будет у переключателя в выключенном виде */

self.mainSwitch.tintColor = [UIColor redColor];

/* Изменяем оттенок, который будет у переключателя во включенном виде */

self.mainSwitch.onTintColor = [UIColor brownColor];

/* Изменяем также оттенок рычажка на переключателе */

self.mainSwitch.thumbTintColor = [UIColor greenColor];

}

Теперь, когда мы закончили работу с оттенками переключателя, перейдем к оформлению внешнего вида переключателя, связанному с использованием изображений «включено» и «выключено». При этом не забываем, что заказные изображения «включено» и «выключено» поддерживаются только в iOS 6 и старше. iOS 7 игнорирует такие изображения и при оформлении внешнего вида работает только с оттенками. Как было указано ранее, оба варианта изображения на переключателе — как для включенного, так и для выключенного состояния — должны иметь ширину 77 точек и высоту 22 точки. Поэтому я подготовил новый комплект таких изображений (для работы с обычным и сетчатым дисплеем). Я добавил их в мой проект в Xcode под названиями On@2x.png и Off@2x.png (для сетчатого дисплея), а также поместил здесь разновидности изображений для обычного дисплея. Теперь нам предстоит создать переключатель, но присвоить ему заказные изображения «включено» и «выключено». Для этого воспользуемся следующими свойствами UISwitch:

onImage — как указано ранее, это изображение будет использоваться, когда переключатель включен;

• offImage — это изображение соответствует переключателю в состоянии «выключено».

А вот код, позволяющий добиться такого эффекта:

— (void)viewDidLoad

{

[super viewDidLoad];

/* Создаем переключатель */

self.mainSwitch = [[UISwitch alloc] initWithFrame: CGRectZero];

self.mainSwitch.center = self.view.center;

/* Убеждаемся, что переключатель не выглядит размытым в iOS-эмуляторе */

self.mainSwitch.frame = [self roundedValuesInRect: self.mainSwitch.frame];

[self.view addSubview: self.mainSwitch];

/* Оформляем переключатель */

self.mainSwitch.onImage = [UIImage imageNamed:@"On"];

self.mainSwitch.offImage = [UIImage imageNamed:@"Off"];

}

См. также.

Раздел 1.2.

1.4. Выбор значений с помощью UIPickerView.

Постановка задачи.

Необходимо предоставить пользователю приложения возможность выбирать значения из списка.

Решение.

Воспользуйтесь классом UIPickerView.

Обсуждение.

Вид выбора (Picker View) — это элемент графического интерфейса, позволяющий отображать для пользователей списки значений, из которых пользователь затем может выбрать одно. В разделе Timer (Таймер) приложения Clock (Часы) в iPhone мы видим именно такой пример (рис. 1.10).

Обсуждение. 1.4. Выбор значений с помощью UIPickerView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.10. Вид выбора, расположенный в верхней части экрана

Как видите, в отдельно взятом виде выбора содержится два независимых визуальных элемента, один слева, другой справа. В левой части вида отображаются часы (0, 1, 2 и т. д.), а в правой — минуты (18, 19, 20, 21, 22 и т. д.). Два этих элемента называются компонентами. В каждом компоненте есть строки (Rows). На самом деле любой элемент в любом компоненте представлен строкой, как мы вскоре увидим. Например, в левом компоненте 0 hours — это строка, 1 — это строка и т. д.

Создадим вид выбора в виде нашего контроллера. Если вы не знаете, где находится исходный код того вида, в котором расположен контроллер, обратитесь к разделу 1.2, где обсуждается этот вопрос.

Сначала перейдем к файлу реализации. m контроллера нашего вида и определим в нем вид выбора:

@interface ViewController ()

@property (nonatomic, strong) UIPickerView *myPicker;

@end

@implementation ViewController

А теперь создадим вид выбора в методе viewDidLoad контроллера нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.myPicker = [[UIPickerView alloc] init];

self.myPicker.center = self.view.center;

[self.view addSubview: self.myPicker];

}

В данном примере необходимо отметить, что вид выбора выравнивается по центру того вида, в котором находится. Если мы запустим это приложение в эмуляторе iOS 7, то увидим пустой экран. Дело в том, что в iOS 7 сам элемент для выбора белый и мы видим фон контроллера вида.

Вид выбора отображается в виде сплошного белого поля потому, что мы еще не наполнили его какими-либо значениями. Сделаем это. Итак, нам потребуется указать источник данных для вида выбора, а потом убедиться в том, что контроллер вида соответствует протоколу, требуемому источником данных. Источник данных экземпляра UIPickerView должен подчиняться протоколу UIPickerViewDataSource, так что обеспечим соответствие данного вида условиям этого протокола в файле. m:

@interface ViewController () <UIPickerViewDataSource, UIPickerViewDelegate>

@property (nonatomic, strong) UIPickerView *myPicker;

@end

@implementation ViewController

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

— (void)viewDidLoad{

[super viewDidLoad];

self.myPicker = [[UIPickerView alloc] init];

self.myPicker.dataSource = self;

self.myPicker.center = self.view.center;

[self.view addSubview: self.myPicker];

}

После этого, попытавшись скомпилировать приложение, вы увидите, что компилятор начинает выдавать предупреждения. Эти предупреждения сообщают, что вы еще не реализовали некоторые методы, внедрения которых требует протокол UIPickerViewDataSource. Чтобы исправить эту ситуацию, нужно нажать Command+Shift+O, ввести UIPickerViewDataSource и нажать Enter. Так вы попадете к тому месту в вашем коде, где определяется данный протокол, и увидите нечто подобное:

@protocol UIPickerViewDataSource<NSObject>

@required

// Возвращает количество столбцов для отображения

— (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView;

// Возвращает количество строк в каждом компоненте

— (NSInteger)pickerView:(UIPickerView *)pickerView

numberOfRowsInComponent:(NSInteger)component;

@end

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

— (NSInteger)numberOfComponentsInPickerView:(UIPickerView *)pickerView{

if ([pickerView isEqual: self.myPicker]){

return 1;

}

return 0;

}

— (NSInteger) pickerView:(UIPickerView *)pickerView

numberOfRowsInComponent:(NSInteger)component{

if ([pickerView isEqual: self.myPicker]){

return 10;

}

return 0;

}

Итак, что здесь происходит? Рассмотрим, какие данные предполагает каждый из методов источника:

numberOfComponentsInPickerView: — этот метод передает объект вида выбора в качестве параметра, а в качестве возвращаемого значения ожидает целое число, указывающее, сколько компонентов вы хотели бы отобразить в этом виде выбора;

• pickerView: numberOfRowsInComponent: — для каждого компонента, добавляемого в вид выбора, необходимо указать системе, какое количество строк вы хотите отобразить в данном компоненте. Этот метод передает вам экземпляр вида выбора, а в качестве возвращаемого значения ожидает целое число, сообщающее среде времени исполнения, сколько строк вы хотели бы отобразить в этом компоненте.

Итак, мы приказываем системе отобразить один компонент всего с 10 строками для вида выбора, который мы создали ранее и назвали myPicker.

Скомпилируйте приложение и запустите его в эмуляторе iPhone (рис. 1.11). Хм-м-м, и что же это?

Обсуждение. 1.4. Выбор значений с помощью UIPickerView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.11. Вот как выглядит вид выбора, когда неизвестно, какую информацию в нем отображать

По всей видимости, наш вид выбора знает, сколько компонентов в нем должно быть и сколько строк он должен отображать в интересующем нас компоненте, но не знает, какой текст должен содержаться в каждой строке. Этот вопрос обязательно следует прояснить, и мы решим данную проблему, предоставив делегат для вида выбора. Делегат экземпляра UIPickerView должен подчиняться протоколу UIPickerViewDelegate и реализовывать все методы, помеченные как @required.

Нас интересует только один метод делегата UIPickerViewDelegate, а именно pickerView: titleForRow: forComponent:. Этот метод передает вам индекс актуального раздела и индекс актуальной строки в данном разделе вида выбора и в качестве возвращаемого значения ожидает экземпляр NSString. Строка, представленная NSString, отобразится в заданном ряду внутри компонента. В рассматриваемом случае я предпочитаю просто отобразить первую строку как «Строка 1», а затем продолжить: «Строка 2», «Строка 3» и т. д. Не забывайте, что потребуется также установить свойство delegate нашего вида выбора:

self.myPicker.delegate = self;

А теперь обработаем только что изученный метод делегата:

— (NSString *)pickerView:(UIPickerView *)pickerView

titleForRow:(NSInteger)row

forComponent:(NSInteger)component{

if ([pickerView isEqual: self.myPicker]){

/* Строка имеет нулевое основание, а мы хотим, чтобы первая строка

(с индексом 0) отображалась как строка 1. Таким образом, нужно

прибавить +1 к индексу каждой строки. */

result = [NSString stringWithFormat:@"Row %ld", (long)row + 1];

}

return nil;

}

Теперь запустим приложение и посмотрим, что происходит (рис. 1.12).

Обсуждение. 1.4. Выбор значений с помощью UIPickerView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.12. Вид выбора с одним разделом и несколькими строками

Виды с возможностью выбора в iOS 6 и старше могут подсвечивать выбранный вариант с помощью свойства showsSelectionIndicator, по умолчанию имеющего значение NO. Вы можете либо напрямую изменить значение этого свойства на YES, либо воспользоваться методом setShowsSelectionIndicator: вида выбора, чтобы включить этот индикатор:

self.myPicker.showsSelectionIndicator = YES;

Снова предположим, что мы создаем вид выбора в окончательной версии нашего приложения. Какая польза от вида выбора, если мы не можем определить, что именно пользователь выбрал в каждом из компонентов? Да, хорошо, что Apple уже позаботилась о решении этой проблемы и предоставила нам возможность спрашивать вид выбора о выбранном варианте. Вызовем метод selectedRowInComponent: класса UIPickerView и передадим индекс компонента (с нулевым основанием), а в качестве возвращаемого значения получим целое число. Это число будет представлять собой индекс с нулевым основанием, сообщающий строку, которая в данный момент выбрана в интересующем нас компоненте.

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

См. также.

Раздел 1.2.

1.5. Выбор даты и времени с помощью UIDatePicker.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UIDatePicker.

Обсуждение.

Класс UIDatePicker очень напоминает класс UIPickerView. Фактически UIDatePicker — это уже заполненный вид выбора. Хорошим примером такого вида является программа Calendar (Календарь) в iPhone (рис. 1.13).

Обсуждение. 1.5. Выбор даты и времени с помощью UIDatePicker. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.13. Вид для выбора даты показан в нижней части экрана

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

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIDatePicker *myDatePicker;

@end

@implementation ViewController

А теперь, как и планировалось, инстанцируем вид для выбора даты:

— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

[self.view addSubview: self.myDatePicker];

}

После этого запустим приложение и посмотрим, как оно выглядит (рис. 1.14).

Обсуждение. 1.5. Выбор даты и времени с помощью UIDatePicker. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.14. Простой вид для выбора даты

Как видите, по умолчанию в виде выбора даты ставится сегодняшняя дата. Начиная работать с такими инструментами, первым делом нужно уяснить, что они могут иметь различные стили оформления и режимы работы. Режим можно изменить, работая со свойством datePickerMode, тип которого — UIDatePickerMode:

typedef enum {

UIDatePickerModeTime,

UIDatePickerModeDate,

UIDatePickerModeDateAndTime,

UIDatePickerModeCountDownTimer,

} UIDatePickerMode;

В зависимости от конкретной задачи, стоящей перед вами, для режима вида выбора даты можно задать любое из значений, перечисленных в списке UIDatePickerMode. Далее по мере обсуждения данной темы мы рассмотрим некоторые из этих значений.

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

NSDate *currentDate = self.myDatePicker.date;

NSLog(@"Date = %@", currentDate);

Подобно классу UISwitch, вид для выбора даты также посылает своим целям инициирующие сообщения (Action Messages) всякий раз, когда отображаемая в виде дата изменяется. Чтобы иметь возможность реагировать на эти сообщения, получатель должен добавить себя в список целей вида выбора даты. Для этого используется метод addTarget: action: forControlEvents: следующим образом:

— (void) datePickerDateChanged:(UIDatePicker *)paramDatePicker{

if ([paramDatePicker isEqual: self.myDatePicker]){

NSLog(@"Selected date = %@", paramDatePicker.date);

}

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

[self.view addSubview: self.myDatePicker];

[self.myDatePicker addTarget: self

action:@selector(datePickerDateChanged:)

forControlEvents: UIControlEventValueChanged];

}

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

Пользуясь видом для выбора даты, можно задавать минимальную и максимальную даты, которые он способен отображать. Для этого сначала нужно переключить вид выбора даты в режим UIDatePickerModeDate, а потом с помощью свойств maximumDate и minimumDate откорректировать этот диапазон:

— (void)viewDidLoad{

[super viewDidLoad];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

self.myDatePicker.datePickerMode = UIDatePickerModeDate;

[self.view addSubview: self.myDatePicker];

NSTimeInterval oneYearTime = 365 * 24 * 60 * 60;

NSDate *todayDate = [NSDate date];

NSDate *oneYearFromToday = [todayDate

dateByAddingTimeInterval: oneYearTime];

NSDate *twoYearsFromToday = [todayDate

dateByAddingTimeInterval:2 * oneYearTime];

self.myDatePicker.minimumDate = oneYearFromToday;

self.myDatePicker.maximumDate = twoYearsFromToday;

}

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

Обсуждение. 1.5. Выбор даты и времени с помощью UIDatePicker. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.15. Минимальная и максимальная даты при работе с видом выбора даты

Если вы хотите применять вид выбора даты в качестве таймера обратного отсчета, нужно задать для этого вида режим UIDatePickerModeCountDownTimer и использовать свойство countDownDuration вида выбора даты для указания длительности обратного отсчета, задаваемой по умолчанию. Например, если вы желаете предложить пользователю такой таймер и задать в качестве периода ведения обратного отсчета 2 минуты, нужно написать следующий код:

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.myDatePicker = [[UIDatePicker alloc] init];

self.myDatePicker.center = self.view.center;

self.myDatePicker.datePickerMode = UIDatePickerModeCountDownTimer;

[self.view addSubview: self.myDatePicker];

NSTimeInterval twoMinutes = 2 * 60;

[self.myDatePicker setCountDownDuration: twoMinutes];

}

Результат показан на рис. 1.16.

Обсуждение. 1.5. Выбор даты и времени с помощью UIDatePicker. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.16. Таймер обратного отсчета в виде для выбора даты, где стандартная длительность обратного отсчета равна 2 минутам

1.6. Реализация инструмента для выбора временных рамок с помощью UISlider.

Постановка задачи.

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

Решение.

Используйте класс UISlider.

Обсуждение.

Вероятно, вы уже знаете, что такое слайдер. Пример слайдера показан на рис. 1.17.

Обсуждение. 1.6. Реализация инструмента для выбора временных рамок с помощью UISlider. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.17. В нижней части экрана находится слайдер, регулирующий уровень громкости

Чтобы создать слайдер, нужно инстанцировать объект типа UISlider. Создадим слайдер и поместим его на вид нашего контроллера. Начнем с файла реализации нашего контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UISlider *slider;

@end

@implementation ViewController

Теперь рассмотрим метод viewDidLoad и создадим сам компонент-слайдер. В этом коде мы будем создавать слайдер, позволяющий выбирать значения в диапазоне от 0 до 100. По умолчанию ползунок слайдера будет установлен в среднем значении шкалы:

— (void)viewDidLoad{

[super viewDidLoad];

self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

200.0f,

23.0f)];

self.slider.center = self.view.center;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 100.0f;

self.slider.value = self.slider.maximumValue / 2.0;

[self.view addSubview: self.slider];

}

Диапазон слайдера совершенно не зависит от его внешнего вида. С помощью указателя диапазона мы приказываем слайдеру вычислить его (слайдера) значение, основываясь на относительной позиции в рамках диапазона. Например, если для слайдера задан диапазон от 0 до 100, то когда ползунок слайдера расположен у левого края шкалы, свойство слайдера value равно 0, а если ползунок стоит у правого края, оно равно 100.

Как будут выглядеть результаты? Теперь вы можете запустить приложение в эмуляторе (рис. 1.18).

Обсуждение. 1.6. Реализация инструмента для выбора временных рамок с помощью UISlider. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.18. Обычный слайдер в центре экрана

Для получения желаемых результатов мы использовали несколько свойств слайдера. Что это за свойства?

• minimumValue — задает минимальное значение диапазона, поддерживаемого слайдером.

• maximumValue — задает максимальное значение диапазона, поддерживаемого слайдером.

• value — текущее значение слайдера. Это свойство доступно как для чтения, так и для изменения, то есть вы можете как считывать это значение, так и записывать в него информацию. Если вы хотите, чтобы при перемещении ползунка в это значение включалась анимация, то можно вызвать метод слайдера setValue: animated: и передать YES в качестве значения параметра animated.

Ползунок слайдера называется также бегунком. Если вы хотите получать событие всякий раз, когда передвигается ползунок слайдера, нужно добавить ваш объект, которому требуется информация о таких событиях, в качестве цели слайдера с помощью относящегося к слайдеру метода addTarget: action: forControlEvents::

— (void) sliderValueChanged:(UISlider *)paramSender{

if ([paramSender isEqual: self.mySlider]){

NSLog(@"New value = %f", paramSender.value);

}

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.mySlider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

200.0f,

23.0f)];

self.slider.center = self.view.center;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 100.0f;

self.slider.value = self.slider.maximumValue / 2.0;

[self.view addSubview: self.slider];

[self.slider addTarget: self

action:@selector(sliderValueChanged:)

forControlEvents: UIControlEventValueChanged];

}

Если сейчас запустить приложение в эмуляторе, вы увидите, что вызывается целевой метод sliderValueChanged: и это происходит всякий раз, как только перемещается ползунок слайдера. Возможно, именно этого вы и хотели. Но в некоторых случаях уведомление требуется лишь тогда, когда пользователь отпустил ползунок, установив его в новом значении. Если вы хотите дождаться такого уведомления, установите для свойства слайдера continuous значение NO. Если это свойство имеет значение YES (задаваемое по умолчанию), то на цели слайдера вызов будет идти непрерывно все то время, пока движется ползунок.

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

• UIControlStateNormal — обычное состояние ползунка, когда его не трогает пользователь;

• UIControlStateHighlighted — изображение, которое должно быть на месте ползунка, когда пользователь начинает его двигать.

Я подготовил два изображения: одно для стандартного состояния ползунка, а другое — для активного (затронутого) состояния. Добавим их к слайдеру:

[self.slider setThumbImage: [UIImage imageNamed:@"ThumbNormal.png"]

forState: UIControlStateNormal];

[self.slider setThumbImage: [UIImage imageNamed:@"ThumbHighlighted.png"]

forState: UIControlStateHighlighted];

Теперь взглянем, как выглядит в эмуляторе неактивный слайдер (рис. 1.19).

Обсуждение. 1.6. Реализация инструмента для выбора временных рамок с помощью UISlider. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.19. Слайдер со специально оформленным ползунком

1.7. Оформление UISlider.

Постановка задачи.

Вы используете компонент графического интерфейса UISlider, оформленный по умолчанию, и хотите на свой вкус изменить его внешний вид.

Решение.

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

Обсуждение.

Apple проделала огромную работу, предоставив нам в iOS SDK методы для оформления компонентов пользовательского интерфейса. В частности, оформление может быть связано с изменением оттенков различных частей компонента в интерфейсе. Схема, демонстрирующая компонентный состав пользовательского интерфейса, приведена на рис. 1.20.

Обсуждение. 1.7. Оформление UISlider. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.20. Различные компоненты UISlider

Для каждого из этих компонентов UISlider существуют метод и свойство, позволяющие изменять внешний вид слайдера. Простейшими из этих свойств являются те, которые позволяют изменять оттенок соответствующего компонента:

• minimumTrackTintColor — это свойство задает оттенок для области минимальных значений;

• thumbTintColor — это свойство, как понятно из его названия, задает цвет ползунка;

• maximumTrackTintColor — это свойство задает оттенок для области максимальных значений.

Все эти свойства относятся к типу UIColor.

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

— (void)viewDidLoad{

[super viewDidLoad];

/* Создаем слайдер */

self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

118.0f,

23.0f)];

self.slider.value = 0.5;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 1.0f;

self.slider.center = self.view.center;

[self.view addSubview: self.slider];

/* Задаем оттенок для области минимальных значений */

self.slider.minimumTrackTintColor = [UIColor redColor];

/* Задаем оттенок для ползунка */

self.slider.maximumTrackTintColor = [UIColor greenColor];

/* Задаем цвет для области максимальных значений */

self.slider.thumbTintColor = [UIColor blackColor];

}

Если вы теперь запустите получившееся приложение, то увидите примерно такую картину, как на рис. 1.21.

Обсуждение. 1.7. Оформление UISlider. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.21. Оттенки всех составных частей слайдера изменены

Иногда вам может потребоваться более полный контроль над тем, как слайдер будет выглядеть на экране. При этом одних только оттенков может быть недостаточно. Именно поэтому Apple предлагает и другие способы изменения внешнего вида слайдера, позволяя вам задавать изображения для различных его компонентов. Речь идет о следующих изображениях.

Изображение для минимального значения. Это изображение, которое будет находиться за пределами слайдера у его левого края. По умолчанию такое изображение не предоставляется, поэтому вы его и не увидите, если просто создадите в виде новый слайдер. Вы можете задать такое изображение, чтобы подсказывать пользователю, как трактуется минимальное значение в контексте данного слайдера. Например, в приложении, с помощью которого пользователь может увеличивать или уменьшать яркость экрана, минимальному значению может соответствовать картинка в виде потухшей лампочки. Она показывает, что чем дальше пользователь будет перемещать ползунок в сторону минимального значения (влево), тем более тусклым будет становиться экран. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMinimumValueImage:. Это изображение должно иметь по 23 точки в высоту и в ширину. При работе с сетчатым дисплеем используйте такое же изображение, только вдвое крупнее.

Изображение для области минимальных значений. Это изображение, которое будет соответствовать колее слайдера левее от ползунка. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMinimumTrackImage: forState:. Это изображение должно иметь 11 точек в ширину и 9 точек в высоту и допускать изменение размера (подробнее о таких изображениях см. в разделе 17.5).

Изображение для ползунка. Изображение ползунка — это единственный движущийся элемент слайдера. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setThumbImage: forState:. Это изображение должно иметь 23 точки в высоту и 23 точки в ширину.

Изображение для области максимальных значений. Это изображение будет соответствовать той части колеи слайдера, которая находится справа от ползунка. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMaximumTrackImage: forState:. Это изображение должно иметь 11 точек в ширину и 9 точек в высоту и допускать изменение размера (подробнее о таких изображениях см. в разделе 17.5).

Изображение для максимального значения. Это изображение, которое будет находиться у правого края слайдера. Оно должно напоминать изображение, соответствующее минимальному значению, но, разумеется, трактуется противоположным образом. Вернувшись к примеру с яркостью лампочки, допустим, что справа от колеи с ползунком у нас изображена яркая лампочка, испускающая лучи. Так пользователю будет понятно, что чем дальше вправо он передвигает ползунок, тем ярче становится экран. Чтобы изменить это изображение, воспользуйтесь относящимся к слайдеру методом экземпляра setMaximumValueImage:. Это изображение должно иметь 23 точки в высоту и столько же в ширину.

Изображения, предоставляемые вами для областей максимальных и минимальных значений, должны при необходимости изменять размер. Подробнее о таких изображениях рассказано в разделе 17.5.

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

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UISlider *slider;

@end

@implementation ViewController

/*

Этот метод возвращает изображение переменного размера для области слайдера, содержащей минимальные значения

*/

— (UIImage *) minimumTrackImage{

UIImage *result = [UIImage imageNamed:@"MinimumTrack"];

UIEdgeInsets edgeInsets;

edgeInsets.left = 4.0f;

edgeInsets.top = 0.0f;

edgeInsets.right = 0.0f;

edgeInsets.bottom = 0.0f;

result = [result resizableImageWithCapInsets: edgeInsets];

return result;

}

/*

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

*/

— (UIImage *) maximumTrackImage{

UIImage *result = [UIImage imageNamed:@"MaximumTrack"];

UIEdgeInsets edgeInsets;

edgeInsets.left = 0.0f;

edgeInsets.top = 0.0f;

edgeInsets.right = 3.0f;

edgeInsets.bottom = 0.0f;

result = [result resizableImageWithCapInsets: edgeInsets];

return result;

}

— (void)viewDidLoad{

[super viewDidLoad];

/* Создаем слайдер */

self.slider = [[UISlider alloc] initWithFrame: CGRectMake(0.0f,

0.0f,

218.0f,

23.0f)];

self.slider.value = 0.5;

self.slider.minimumValue = 0.0f;

self.slider.maximumValue = 1.0f;

self.slider.center = self.view.center;

[self.view addSubview: self.slider];

/* Изменяем изображение для минимального значения */

[self.slider setMinimumValueImage: [UIImage imageNamed:@"MinimumValue"]];

/* Изменяем изображение для области минимальных значений */

[self.slider setMinimumTrackImage: [self minimumTrackImage]

forState: UIControlStateNormal];

/* Изменяем изображение ползунка для обоих возможных состояний ползунка: когда

пользователь его касается и когда не касается */

[self.slider setThumbImage: [UIImage imageNamed:@"Thumb"]

forState: UIControlStateNormal];

[self.slider setThumbImage: [UIImage imageNamed:@"Thumb"]

forState: UIControlStateHighlighted];

/* Изменяем изображение для области максимальных значений */

[self.slider setMaximumTrackImage: [self maximumTrackImage]

forState: UIControlStateNormal];

/* Изменяем изображение, соответствующее максимальному значению */

[self.slider setMaximumValueImage: [UIImage imageNamed:@"MaximumValue"]];

}

Ползунок в iOS 7 выглядит совершенно иначе, нежели в более ранних версиях. Как вы догадываетесь, этот элемент стал очень прямолинейным и тонким на вид. Высота максимальной и минимальной отметок на шкале в iOS 7 составляет всего 1 точку, поэтому задавать для этих элементов специальные изображения абсолютно бесполезно — скорее всего, получится некрасиво. Поэтому для оформления этих элементов UISlider в iOS 7 рекомендуется оперировать лишь оттенками, но не присваивать элементу никаких изображений.

См. также.

Раздел 1.6.

1.8. Группирование компактных параметров с помощью UISegmentedControl.

Постановка задачи.

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

Решение.

Используйте класс UISegmentedControl. Пример работы с этим классом показан на рис. 1.22.

Решение. 1.8. Группирование компактных параметров с помощью UISegmentedControl. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.22. Сегментированный элемент управления, в котором отображаются четыре параметра

Обсуждение.

Сегментированный элемент управления — это сущность, позволяющая отображать в компактном пользовательском интерфейсе наборы параметров, из которых пользователь может выбирать нужный. Чтобы отобразить сегментированный элемент управления, создайте экземпляр класса UISegmentedControl. Начинаем работу с файла реализации (.m) нашего контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UISegmentedControl *mySegmentedControl;

@end

@implementation ViewController

Создаем сегментированный элемент управления в методе viewDidLoad контроллера нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

@"iPad",

@"iPod",

@"iMac", nil];

self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];

self.mySegmentedControl.center = self.view.center;

[self.view addSubview: self.mySegmentedControl];

}

Чтобы представить разные параметры, которые будут предлагаться на выбор в нашем сегментированном элементе управления, мы используем обычный массив строк. Такой элемент управления инициализируется с помощью метода initWithObjects:. Потом передаем сегментированному элементу управления массив строк и изображений. Результат будет как на рис. 1.22.

Теперь пользователь может выбрать в сегментированном элементе управления один из параметров. Допустим, он выбирает iPad. Тогда пользовательский интерфейс сегментированного элемента управления изменится и покажет пользователю, какой параметр будет выбран. Получится такое изображение, как на рис. 1.23.

Обсуждение. 1.8. Группирование компактных параметров с помощью UISegmentedControl. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.23. Пользователь выбрал один из вариантов в сегментированном элементе управления

Возникает вопрос: как узнать, что пользователь выбрал в сегментированном элементе управления новый параметр? Ответ прост. Как и при работе с UISwitch или UISlider, применяется метод addTarget: action: forControlEvents: сегментированного элемента управления, к которому добавляется цель. Для параметра forControlEvents нужно задать значение UIControlEventValueChanged, так как именно это событие запускается, когда пользователь выбирает в сегментированном элементе управления новый параметр:

— (void) segmentChanged:(UISegmentedControl *)paramSender{

if ([paramSender isEqual: self.mySegmentedControl]){

NSInteger selectedSegmentIndex = [paramSender selectedSegmentIndex];

NSString *selectedSegmentText =

[paramSender titleForSegmentAtIndex: selectedSegmentIndex];

NSLog(@"Segment %ld with %@ text is selected",

(long)selectedSegmentIndex,

selectedSegmentText);

}

}

— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

@"iPad",

@"iPod",

@"iMac", nil];

self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];

self.mySegmentedControl.center = self.view.center;

[self.view addSubview: self.mySegmentedControl];

[self.mySegmentedControl addTarget: self

action:@selector(segmentChanged:)

forControlEvents: UIControlEventValueChanged];

}

Если пользователь начинает выбирать слева и выбирает каждый параметр (см. рис. 1.22) до правого края, на консоль будет выведен следующий текст:

Segment 0 with iPhone text is selected

Segment 1 with iPad text is selected

Segment 2 with iPod text is selected

Segment 3 with iMac text is selected

Как видите, мы использовали метод selectedSegmentIndex сегментированного элемента управления, чтобы найти индекс варианта, выбранного в настоящий момент. Если ни один из элементов не выбран, метод возвращает значение –1. Кроме того, мы использовали метод titleForSegmentAtIndex:. Просто передаем этому методу индекс параметра, выбранного в сегментированном элементе управления, а сегментированный элемент управления возвратит текст, соответствующий этому параметру. Ведь просто, правда?

Как вы, вероятно, заметили, как только пользователь отмечает один из параметров в сегментированном элементе управления, этот параметр выбирается и остается выбранным, как показано на рис. 1.23. Если вы хотите, чтобы пользователь выбрал параметр, но кнопка этого параметра не оставалась нажатой, а возвращалась к исходной форме (так сказать, «отщелкивалась обратно», как и обычная кнопка), то нужно задать для свойства momentary сегментированного элемента управления значение YES:

self.mySegmentedControl.momentary = YES;

Одна из самых приятных особенностей сегментированных элементов управления заключается в том, что они могут содержать не только текст, но и изображения. Для этого нужно просто использовать метод-инициализатор initWithObjects: класса UISegmentedControl и передать с этим методом те строки и изображения, которые будут применяться при реализации соответствующего пользовательского интерфейса:

— (void)viewDidLoad{

[super viewDidLoad];

NSArray *segments = [[NSArray alloc] initWithObjects:

@"iPhone",

[UIImage imageNamed:@"iPad"],

@"iPod",

@"iMac",

];

self.mySegmentedControl = [[UISegmentedControl alloc]

initWithItems: segments];

CGRect segmentedFrame = self.mySegmentedControl.frame;

segmentedFrame.size.height = 128.0f;

segmentedFrame.size.width = 300.0f;

self.mySegmentedControl.frame = segmentedFrame;

self.mySegmentedControl.center = self.view.center;

[self.view addSubview: self.mySegmentedControl];

}

В данном примере файл iPad.png — это просто миниатюрное изображение «айпада», добавленное в наш проект.

В iOS 7 Apple отказалась от использования свойства segmentedControlStyle класса UISegmentedControl, поэтому теперь сегментированные элементы управления имеют всего один стиль, задаваемый по умолчанию. Мы больше не можем изменять этот стиль.

1.9. Представление видов и управление ими с помощью UIViewController.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UIViewController.

Обсуждение.

Стратегия разработки для iOS, предложенная Apple, предполагает использование паттерна «модель — вид — контроллер» (MVC) и соответствующее разделение задач. Виды — это элементы, отображаемые для пользователя, а модель — это абстракция с данными, которыми управляет приложение. Контроллер — это перемычка, соединяющая модель и вид. Контроллер (в данном случае речь идет о контроллере вида) управляет отношениями между видом и моделью. Почему же этими отношениями не занимается вид? Ответ довольно прост: если бы мы возлагали эти задачи на вид, код вида становился бы очень запутанным. Кроме того, такой подход тесно связывал бы виды с моделью, что не очень хорошо.

Контроллеры видов можно загружать из файлов XIB (для использования с конструктором интерфейсов) или просто создавать с помощью программирования. Сначала рассмотрим, как создать контроллер вида, не пользуясь файлом XIB.

Контроллеры видов удобно создавать в Xcode. Теперь, когда вы уже создали шаблон приложения с помощью шаблона Empty Application (Пустое приложение), выполните следующие шаги, чтобы создать новый контроллер вида для вашего приложения.

1. В Xcode перейдите в меню File (Файл) и там выберите New-New File (Новый— Новый файл).

2. В диалоговом окне New File (Новый файл) убедитесь, что слева выбраны категория iOS и подкатегория Cocoa Touch. Когда сделаете это, выберите класс UIViewController в правой части диалогового окна, а затем нажмите Next (Далее) (рис. 1.24).

Обсуждение. 1.9. Представление видов и управление ими с помощью UIViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.24. Подкласс нового контроллера вида

3. На следующем экране убедитесь, что в текстовом поле Subclass (Подкласс) указано UIViewController, а также что сняты флажки Targeted for iPad (Разработка для iPad) и With XIB for user interface (Использовать файл XIB для пользовательского интерфейса). Именно такая ситуация показана на рис. 1.25. Нажмите Next (Далее).

Обсуждение. 1.9. Представление видов и управление ими с помощью UIViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.25. Собственный контроллер вида, без использования класса XIB

4. На следующем экране (Save as (Сохранить как)) назовите файл контроллера вида RootViewController и нажмите Save (Сохранить) (рис. 1.26).

Обсуждение. 1.9. Представление видов и управление ими с помощью UIViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.26. Сохранение контроллера вида без использования файла XIB

5. Теперь найдем файл реализации (.m) делегата приложения, который обычно называется AppDelegate.m. В этом файле объявим свойство типа ViewController:

#import «AppDelegate.h»

#import «ViewController.h»

@interface AppDelegate ()

@property (nonatomic, strong) ViewController *viewController;

@end

@implementation AppDelegate

6. Найдем в файле реализации метод application: didFinishLaunchingWithOptions:, относящийся к делегату приложения, инстанцируем контроллер вида и добавим его в наше окно как корневой контроллер вида:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

self.viewController = [[ViewController alloc] initWithNibName: nil

bundle: nil];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

/* Делаем наш контроллер вида корневым контроллером вида */

self.window.rootViewController = self.viewController;

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

Если при создании контроллера вида (см. рис. 1.25) установить флажок With XIB for user interface (Использовать файл XIB для пользовательского интерфейса), то Xcode также сгенерирует файл XIB. В таком случае вам придется загрузить контроллер вашего вида из этого файла XIB, передав в параметр initWithNibName метода initWithNibName: bundle: контроллера вида полное имя файла XIB:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

self.viewController = [[ViewController alloc]

initWithNibName:@"ViewController"

bundle: nil];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

/* Делаем наш контроллер вида корневым контроллером вида */

self.window.rootViewController = self.viewController;

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Если вы все же создали файл XIB, подготавливая контроллер вашего вида, этот файл теперь можно выбрать в Xcode и смастерить пользовательский интерфейс в конструкторе интерфейсов.

См. также.

Раздел 1.0.

1.10. Предоставление возможностей совместного использования информации с применением UIActivityViewController.

Постановка задачи.

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

Решение.

Создайте экземпляр класса UIActivityViewController и реализуйте совместное использование контента в этом классе так, как рассказано в подразделе «Обсуждение» данного раздела.

Экземпляры класса UIActivityViewController на iPhone следует представлять модально, а на iPad — на вспомогательных экранах. Более подробно о вспомогательных экранах рассказано в разделе 1.29. Решение. 1.10. Предоставление возможностей совместного использования информации с применением UIActivityViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.27. Контроллер вида для обмена информацией, открытый на устройстве с iOS

Обсуждение.

В iOS существует масса возможностей совместного использования информации. Все они реализованы в ядре операционной системы. Например, такой неотъемлемой частью ядра сейчас является интеграция с Twitter и Facebook. Вы можете делиться практически любым контентом из этих сетей, находясь где угодно. Сторонние приложения наподобие того, которое собираемся написать мы, также могут использовать присущие iOS возможности совместного использования информации, не углубляясь в низкоуровневые детали сервисов и базовую организацию этих возможностей в iOS. Красота идеи заключается в том, что вам достаточно всего лишь указать, чем вы хотите поделиться, после чего iOS сама подберет возможности совместного использования, обеспечивающие обработку такой информации. Например, если вы хотите совместно использовать изображения и текст, то iOS предложит вам гораздо больше возможностей, чем если бы вы хотели поделиться аудиофайлом.

Совместное использование данных в iOS организовано очень просто. Для обеспечения такой работы вам всего лишь потребуется инстанцировать класс UIActivityViewController с помощью его метода-инициализатора initWithActivityItems: applicationActivities:. Вот какие параметры принимает этот метод:

• initWithActivityItems — массив элементов, которые предполагается совместно использовать. Это могут быть экземпляры NSString, UIImage или экземпляры любых других заказных классов, соответствующих протоколу UIActivityItemSource. Далее мы детально рассмотрим этот протокол;

• applicationActivities — массив экземпляров UIActivity, представляющих собой функции, поддерживаемые в вашем приложении. Например, здесь вы можете указать, может ли приложение организовать собственный механизм совместного использования изображений и строк. Пока мы не будем детально рассматривать этот параметр и просто передадим nil в качестве его значения. Так мы сообщаем iOS, что собираемся пользоваться только системными возможностями совместного использования.

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

Поскольку мы помещаем в нашем контроллере вида текстовое поле, нам необходимо обеспечить обработку его делегатных сообщений, в особенности тех, что поступают от метода textFieldShouldReturn: из протокола UITextFieldDelegate. Следовательно, мы собираемся выбрать контроллер вида в качестве делегата текстового поля. Кроме того, прикрепим к кнопке Share (Поделиться) метод действия. Когда эта кнопка будет нажата, нам потребуется убедиться, что в текстовом поле есть какая-то информация, которой можно поделиться. Если ее там не окажется, мы просто отобразим для пользователя окно с предупреждением, в котором сообщим, что не можем предоставить содержимое текстового поля для совместного использования. Если в текстовом поле окажется какой-либо текст, мы выведем на экран экземпляр класса UIActivityViewController.

Итак, начнем с файла реализации контроллера вида и определим компоненты пользовательского интерфейса:

@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *textField;

@property (nonatomic, strong) UIButton *buttonShare;

@property (nonatomic, strong) UIActivityViewController *activityViewController;

@end

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

— (void) createTextField{

self.textField = [[UITextField alloc] initWithFrame: CGRectMake(20.0f,

35.0f,

280.0f,

30.0f)];

self.textField.translatesAutoresizingMaskIntoConstraints = NO;

self.textField.borderStyle = UITextBorderStyleRoundedRect;

self.textField.placeholder = @"Enter text to share…";

self.textField.delegate = self;

[self.view addSubview: self.textField];

}

— (void) createButton{

self.buttonShare = [UIButton buttonWithType: UIButtonTypeRoundedRect];

self.buttonShare.translatesAutoresizingMaskIntoConstraints = NO;

self.buttonShare.frame = CGRectMake(20.0f, 80.0f, 280.0f, 44.0f);

[self.buttonShare setTitle:@"Share" forState: UIControlStateNormal];

[self.buttonShare addTarget: self

action:@selector(handleShare:)

forControlEvents: UIControlEventTouchUpInside];

[self.view addSubview: self.buttonShare];

}

Когда эта работа будет завершена, нам останется всего лишь вызвать два этих метода в методе viewDidLoad нашего контроллера вида. Таким образом мы правильно разместим компоненты пользовательского интерфейса в окне контроллера вида:

— (void)viewDidLoad{

[super viewDidLoad];

[self createTextField];

[self createButton];

}

В методе textFieldShouldReturn: мы просто убираем с экрана клавиатуру, чтобы отказаться от активного состояния текстового поля. Это просто означает, что если пользователь редактировал текст в текстовом поле, а затем нажал клавишу Enter, то клавиатура должна исчезнуть с экрана. Не забывайте, что только что написанный метод createTextField задает наш контроллер вида в качестве делегата текстового поля. Поэтому потребуется реализовать упомянутый метод следующим образом:

— (BOOL) textFieldShouldReturn:(UITextField *)textField{

[textField resignFirstResponder];

return YES;

}

Последний, но немаловажный элемент — это метод-обработчик нашей кнопки. Как мы уже видели, метод createButton создает для нас кнопку и выбирает метод handleShare: для обработки действия-касания (нажатия) в рамках работы кнопки. Напишем этот метод:

— (void) handleShare:(id)paramSender{

if ([self.textField.text length] == 0){

NSString *message = @"Please enter a text and then press Share";

UIAlertView *alertView = [[UIAlertView alloc] initWithTitle: nil

message: message

delegate: nil

cancelButtonTitle:@"OK"

otherButtonTitles: nil];

[alertView show];

return;

}

self.activityViewController = [[UIActivityViewController alloc]

initWithActivityItems:@[self.textField.text]

applicationActivities: nil];

[self presentViewController: self.activityViewController

animated: YES

completion: ^{

/* Пока ничего не делаем */

}];

}

Теперь, если запустить приложение, ввести в текстовое поле какой-либо текст, а затем нажать кнопку Share (Поделиться), мы получим результат, похожий на то, что изображено на рис. 1.28.

Обсуждение. 1.10. Предоставление возможностей совместного использования информации с применением UIActivityViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.28. Возможности совместного использования экземпляра строки, которым мы пытаемся поделиться

Вы можете выводить на экран параметры совместного использования уже вместе с контроллером вида. Метод viewDidAppear вашего контроллера вида будет вызываться, когда контроллер вида отобразится на экране и гарантированно окажется в иерархии видов вашего приложения. Это означает, что теперь вы сможете отобразить и другие виды поверх вашего контроллера вида.

Не пытайтесь представить контроллер вида для работы с функциями в методе viewDidLoad контроллера вида. На данном этапе подготовки приложения окно контроллера вашего вида еще не прикреплено к иерархии видов приложения, поэтому такая попытка ни к чему не приведет. Чтобы модальные виды работали, ваш вид должен быть частью такой иерархии. Поэтому необходимо представлять контроллер вида для обмена информацией в методе viewDidAppear контроллера вида.

См. также.

Раздел 1.29.

1.11. Предоставление специальных возможностей совместного использования данных с применением UIActivityViewController.

Постановка задачи.

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

Подобные возможности могут понадобиться вам, например, при работе с текстовым редактором. Когда пользователь нажимает кнопку Share (Поделиться), в контроллере вида с функцией должен появиться специальный элемент, в котором написано: Archive (Архивировать). Когда пользователь нажмет кнопку Archive (Архивировать), текст в редактируемой области вашего приложения будет передан специальной функции, а затем ваша функция сможет заархивировать этот текст в файловой системе на устройстве с iOS.

Решение.

Создайте класс типа UIActivity. Иными словами, произведите подкласс от этого класса и дайте новоиспеченному классу любое устраивающее вас имя. Экземпляры подклассов этого класса можно будет передавать методу-инициализатору initWithActivityItems: applicationActivities:, относящемуся к классу UIActivityViewController. Если эти экземпляры реализуют все необходимые методы класса UIActivity, то iOS отобразит их в контроллере вида с функцией.

Обсуждение.

Первый параметр метода initWithActivityItems: applicationActivities: принимает значения различных типов, в частности строки, числа, изображения и т. д. — фактически любые объекты. Если вы представите в параметре initWithActivityItems контроллер активности с массивом объектов произвольных типов, iOS просмотрит все доступные в системе функции — например, для работы с Facebook и Twitter — и предложит пользователю выбрать такую функцию, которая лучше всего отвечает его нуждам. После того как пользователь выберет функцию, iOS передаст тип объектов, находящихся в вашем массиве, в зарегистрированную системную функцию, выбранную пользователем. Затем такие функции смогут проверять тип объектов, которые вы собираетесь предоставлять в совместное пользование, и решать, может ли та или иная функция обработать такие объекты или нет. Функции передают такую информацию системе iOS посредством особого метода, реализуемого в их классах.

Итак, предположим, что мы хотим создать функцию, способную обратить любое количество переданных ей строк. Как вы помните, когда ваше приложение инициализирует контроллер вида с функцией с помощью метода initWithActivityItems: applicationActivities:, он может передать в первом параметре этого метода массив объектов произвольных типов. Поэтому если в функции планируется просмотреть все объекты, находящиеся в этом произвольном массиве, и если все они окажутся строками, то функция обратит их и отобразит все полученные строки в окне (виде) с предупреждением.

1. Произведите подкласс от UIActivity следующим образом:

#import <UIKit/UIKit.h>

@interface StringReverserActivity: UIActivity

@end

2. Поскольку мы собираемся выводить в нашей функции вид с предупреждением и отображать его для пользователя, когда нам будет передан массив строк, мы должны гарантировать соответствие нашей функции протоколу UIAlertViewDelegate. Когда пользователь закроет окно с предупреждением, мы должны пометить нашу функцию как завершенную, вот так:

#import «StringReverserActivity.h»

@interface StringReverserActivity () <UIAlertViewDelegate>

@property (nonatomic, strong) NSArray *activityItems;

@end

@implementation StringReverserActivity

— (void) alertView:(UIAlertView *)alertView

didDismissWithButtonIndex:(NSInteger)buttonIndex{

[self activityDidFinish: YES];

}

3. Далее переопределим метод activityType нашей функции. Возвращаемое значение этого метода представляет собой объект типа NSString, являющийся уникальным идентификатором этой функции. Это значение не будет отображаться для пользователя — оно применяется только на уровне системы iOS для отслеживания идентификатора функции. Нет никаких особых значений, которые требовалось бы возвращать от этого метода, нет также никаких сопутствующих рекомендаций от Apple, но мы будем работать со строками в формате «обратное доменное имя», использовать идентификатор пакета приложения и прикреплять к нему имя нашего класса. Итак, если имеется идентификатор пакета com.pixolity.ios.cookbook.myapp и класс с именем StringReverserActivity, то мы возвратим от этого метода строку com.pixolity.ios.cookbook.myapp.StringReverserActivity, вот так:

— (NSString *) activityType{

return [[NSBundle mainBundle].bundleIdentifier

stringByAppendingFormat:@".%@", NSStringFromClass([self class])];

}

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

— (NSString *) activityTitle{

return @"Reverse String";

}

5. Переходим к методу activityImage, который должен возвращать нам экземпляр UIImage — то самое изображение, что будет выводиться в контроллере вида с функцией. Обязательно предоставляйте по два варианта изображения — для сетчаточного дисплея и для обычного — как для iPad, так и для iPhone/iPod. Разрешение сетчаточного изображения для iPad должно составлять 110 × 110 пикселов, а для iPhone — 86 × 86 пикселов. Неудивительно, что, разделив эти значения на 2, получим ширину и высоту обычных изображений. В этом изображении iOS использует только альфа-канал, поэтому убедитесь, что фон вашего изображения является прозрачным и что вы иллюстрируете его черным или белым цветом. Я уже создал изображение в разделе с ресурсами моего приложения и назвал его Reverse (Обратное). Вы можете ознакомиться с ним на рис. 1.29. А вот и код:

— (UIImage *) activityImage{

return [UIImage imageNamed:@"Reverse"];

}

Обсуждение. 1.11. Предоставление специальных возможностей совместного использования данных с применением UIActivityViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

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

6. Реализуем метод canPerformWithActivityItems: нашей функции. Параметр этого метода содержит массив, который будет задан, когда метод-инициализатор контроллера вида с функцией получит массив компонентов функции. Не забывайте, что тип каждого из объектов данного массива является произвольным. Возвращаемое значение данного метода является логическим и указывает, можем ли мы произвести такую функцию над каждым конкретным элементом массива. Например, наша функция может обратить любое количество данных ей строк. То есть если мы найдем в массиве одну строку, это будет нам на руку, поскольку мы будем точно знать, что впоследствии сможем обратить эту строку. Но если мы получим массив из 1000 объектов, ни один из которых не будет относиться к приемлемому для нас типу, мы отклоним такой запрос, вернув NO от данного метода:

— (BOOL) canPerformWithActivityItems:(NSArray *)activityItems{

for (id object in activityItems){

if ([object isKindOfClass: [NSString class]]){

return YES;

}

}

return NO;

}

7. Теперь реализуем метод prepareWithActivityItems: нашей функции, чей параметр относится к типу NSArray. Этот метод вызывается, если вы возвращаете YES от метода canPerformWithActivityItems:. Придется сохранить данный массив для последующего использования. Но на самом деле можно сохранять не весь массив, а только часть его объектов — те, что относятся к интересующему вас типу. Например, строки:

— (void) prepareWithActivityItems:(NSArray *)activityItems{

NSMutableArray *stringObjects = [[NSMutableArray alloc] init];

for (id object in activityItems){

if ([object isKindOfClass: [NSString class]]){

[stringObjects addObject: object];

}

}

self.activityItems = [stringObjects copy];

}

8. Последнее, но немаловажное: потребуется реализовать метод performActivity нашей функции, который вызывается, если iOS требует от нас произвести выбранные действия над списком ранее предоставленных произвольных объектов. В функции мы собираемся перебрать массив строковых объектов, извлеченных из массива с произвольными типами, обратить их все и отобразить для пользователя в окне с предупреждением:

— (NSString *) reverseOfString:(NSString *)paramString{

NSMutableString *reversed = [[NSMutableString alloc]

initWithCapacity: paramString.length];

for (NSInteger counter = paramString.length — 1;

counter >= 0;

counter—){

[reversed appendFormat:@"%c", [paramString characterAtIndex: counter]];

}

return [reversed copy];

}

— (void) performActivity{

NSMutableString *reversedStrings = [[NSMutableString alloc] init];

for (NSString *string in self.activityItems){

[reversedStrings appendString: [self reverseOfString: string]];

[reversedStrings appendString:@"\n"];

}

UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Reversed"

message: reversedStrings

delegate: self

cancelButtonTitle:@"OK"

otherButtonTitles: nil];

[alertView show];

}

Итак, реализация класса нашей функции завершена. Перейдем к файлу реализации контроллера вида и отобразим контроллер вида функции в списке с нашей специальной функцией:

#import «ViewController.h»

#import «StringReverserActivity.h»

@implementation ViewController

— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

NSArray *itemsToShare = @[

@"Item 1",

@"Item 2",

@"Item 3",

];

UIActivityViewController *activity =

[[UIActivityViewController alloc]

initWithActivityItems: itemsToShare

applicationActivities:@[[StringReverserActivity new]]];

[self presentViewController: activity animated: YES completion: nil];

}

@end

При первом запуске приложения на экране появится картинка, примерно такая, как на рис. 1.30.

Обсуждение. 1.11. Предоставление специальных возможностей совместного использования данных с применением UIActivityViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.30. Специальная функция для обращения строк теперь находится в списке доступных функций

Если теперь вы нажмете в этом списке элемент Reverse String (Обращенная строка), то увидите нечто похожее на рис. 1.31.

Обсуждение. 1.11. Предоставление специальных возможностей совместного использования данных с применением UIActivityViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.31. Наша функция для обращения строк в действии

См. также.

Раздел 1.10.

1.12. Внедрение навигации с помощью UINavigationController.

Постановка задачи.

Необходимо дать пользователю возможность переходить от одного контроллера вида к другому, сопровождая этот процесс плавной анимацией, интегрированной в программу.

Решение.

Используйте экземпляр класса UINavigationController.

Обсуждение.

Если вам доводилось работать с iPhone, iPod touch или iPad, то вы, скорее всего, уже видели в действии навигационный инструмент управления. Например, если перейти в приложение Settings (Настройки) телефона, там можно выбрать команду Wallpaper (Обои) (рис. 1.32). В таком случае вы увидите, как основной экран программы Settings (Настройки) отодвигается влево, а на его место справа выходит экран Wallpaper (Обои). В этом и заключается самая интересная черта навигации iPhone. Вы можете складывать контроллеры видов в стек и поднимать их из стека. Контроллер вида, в данный момент находящийся на верхней позиции стека, виден пользователю. Итак, только самый верхний контроллер вида показывается зрителю, а чтобы отобразить другой контроллер, нужно либо удалить с верхней позиции контроллер, видимый в настоящий момент, либо поместить на верхнюю позицию в стеке новый контроллер вида.

Обсуждение. 1.12. Внедрение навигации с помощью UINavigationController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.32. Контроллер вида настроек, отодвигающий вид с обоями для экрана

Теперь добавим в новый проект навигационный контроллер. Но сначала нужно создать проект. Выполните шаги, описанные в разделе 1.9, чтобы создать пустое приложение с простым контроллером вида. Данный раздел — расширенная версия работы, выполненной в разделе 1.9. Начнем с файла реализации (.m) делегата нашего приложения:

#import «AppDelegate.h»

#import «FirstViewController.h»

@interface AppDelegate ()

@property (nonatomic, strong) UINavigationController *navigationController;

@end

@implementation AppDelegate

Теперь следует инициализировать навигационный контроллер, воспользовавшись его методом initWithRootViewController:, и передать корневой контроллер нашего вида как параметр этого метода. Далее мы зададим навигационный контроллер в в качестве корневого контроллера вида в нашем окне. Здесь главное — не запутаться. UINavigationController — это фактически подкласс UIViewController, а свойство rootViewController, относящееся к нашему окну, принимает любой объект типа UIViewController. Таким образом, если мы хотим сделать навигационный контроллер корневым контроллером нашего вида, мы просто должны задать его в качестве корневого контроллера:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

FirstViewController *viewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: nil];

self.navigationController = [[UINavigationController alloc]

initWithRootViewController: viewController];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.rootViewController = self.navigationController;

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

После этого запустим приложение в эмуляторе (рис. 1.33).

Обсуждение. 1.12. Внедрение навигации с помощью UINavigationController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.33. Пустой контроллер вида, отображаемый внутри навигационного контроллера

Файл реализации корневого контроллера вида создает кнопку в центре экрана (как показано на рис. 1.33). Чуть позже мы изучим этот файл реализации.

На рис. 1.33 мы в первую очередь замечаем полосу в верхней части экрана. Теперь экран уже не чисто-белый. Что это за новый виджет? Это навигационная панель. Мы будем активно пользоваться ею при навигации, например разместим на ней кнопки и сделаем кое-что еще. Кроме того, на этой панели удобно отображать заголовок. Каждый контроллер вида сам для себя указывает заголовок, а навигационный контроллер будет автоматически отображать заголовок того контроллера вида, который окажется на верхней позиции в стеке.

Переходим к файлу реализации корневого контроллера нашего вида в методе viewDidLoad. В качестве свойства контроллера вида укажем First Controller. Здесь же создадим кнопку. Когда пользователь нажмет эту кнопку, мы отобразим на экране второй контроллер вида:

#import «FirstViewController.h»

#import «SecondViewController.h»

@interface FirstViewController ()

@property (nonatomic, strong) UIButton *displaySecondViewController;

@end

@implementation FirstViewController

— (void) performDisplaySecondViewController:(id)paramSender{

SecondViewController *secondController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];

[self.navigationController pushViewController: secondController

animated: YES];

}

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";

self.displaySecondViewController = [UIButton

buttonWithType: UIButtonTypeSystem];

[self.displaySecondViewController

setTitle:@"Display Second View Controller"

forState: UIControlStateNormal];

[self.displaySecondViewController sizeToFit];

self.displaySecondViewController.center = self.view.center;

[self.displaySecondViewController

addTarget: self

action:@selector(performDisplaySecondViewController:)

forControlEvents: UIControlEventTouchUpInside];

[self.view addSubview: self.displaySecondViewController];

}

@end

А теперь создадим второй контроллер вида, уже без файла XIB, и назовем его SecondViewController. Проделайте тот же процесс, что был показан в разделе 1.9. Когда создадите этот контроллер вида, назовите его Second Controller:

#import «SecondViewController.h»

@implementation SecondViewController

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"Second Controller";

}

Теперь мы собираемся всплыть из второго контроллера вида обратно в первый контроллер вида через 5 секунд после того, как первый контроллер вида окажется на экране. Для этого используем метод performSelector: withObject: afterDelay: объекта NSObject, чтобы вызвать новый метод goBack. Второй метод будет вызван через 5 секунд после того, как контроллер первого вида успешно отобразит на экране этот первый вид. В методе goBack просто используем свойство navigationController контроллера вида (а оно встроено в UIViewController, и нам самим не приходится его писать), чтобы вернуться к экземпляру FirstViewController. Для этого воспользуемся методом popViewControllerAnimated: навигационного контроллера, который принимает в качестве параметра логическое значение. Если этот параметр имеет значение YES, то переход к предыдущему контроллеру вида будет анимироваться, если NO — не будет. В результате мы увидим примерно такую картинку, как на рис. 1.34.

Обсуждение. 1.12. Внедрение навигации с помощью UINavigationController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.34. Контроллер вида размещается поверх другого контроллера вида

#import «SecondViewController.h»

@implementation SecondViewController

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"Second Controller";

}

— (void) goBack{

[self.navigationController popViewControllerAnimated: YES];

}

— (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear: paramAnimated];

[self performSelector:@selector(goBack)

withObject: nil

afterDelay:5.0f];

}

@end

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

Итак, если вы теперь откроете приложение в эмуляторе и подождете 5 секунд после того, как отобразится контроллер первого вида, то увидите, что по истечении этого времени на экране автоматически появится контроллер второго вида. Подождите еще 5 секунд — и второй контроллер вида автоматически уйдет с экрана, освободив место первому.

См. также.

Раздел 1.9.

1.13. Управление массивом контроллеров видов, относящихся к навигационному контроллеру.

Постановка задачи.

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

Решение.

Воспользуйтесь свойством viewControllers из класса UINavigationController для доступа к массиву контроллеров видов, связанных с навигационным контроллером, а также для изменения этого массива:

— (void) goBack{

/* Получаем актуальный массив контроллеров видов. */

NSArray *currentControllers = self.navigationController.viewControllers;

/* Создаем на основе этого массива изменяемый массив. */

NSMutableArray *newControllers = [NSMutableArray

arrayWithArray: currentControllers];

/* Удаляем последний объект из массива. */

[newControllers removeLastObject];

/* Присваиваем этот массив навигационному контроллеру. */

self.navigationController.viewControllers = newControllers

}

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

Обсуждение.

Экземпляр класса UINavigationController содержит массив объектов UIViewController. Получив этот массив, вы можете оперировать им как угодно. Например, можно удалить контроллер вида из произвольного места в массиве.

Если мы напрямую управляем контроллерами видов, связанными с навигационным контроллером, то есть путем присвоения массива свойству viewControllers навигационного контроллера, то весь процесс будет протекать без явного перехода между контроллерами и без анимации. Если вы хотите, чтобы эти действия анимировались, используйте метод setViewControllers: animated:, относящийся к классу UINavigationController, как показано в следующем фрагменте кода:

— (void) goBack{

/* Получаем актуальный массив контроллеров видов. */

NSArray *currentControllers = self.navigationController.viewControllers;

/* Создаем на основе этого массива изменяемый массив. */

NSMutableArray *newControllers = [NSMutableArray

arrayWithArray: currentControllers];

/* Удаляем последний объект из массива. */

[newControllers removeLastObject];

/* Присваиваем этот массив навигационному контроллеру. */

[self.navigationController setViewControllers: newControllers

animated: YES];

}

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

Постановка задачи.

В качестве заголовка контроллера вида, ассоциированного в данный момент с навигационным контроллером, требуется отобразить не текст, а изображение.

Решение.

Воспользуйтесь свойством titleView навигационного элемента контроллера вида:

— (void)viewDidLoad{

[super viewDidLoad];

/* Создаем вид с изображением, заменяя им вид с заголовком. */

UIImageView *imageView =

[[UIImageView alloc]

initWithFrame: CGRectMake(0.0f, 0.0f, 100.0f, 40.0f)];

imageView.contentMode = UIViewContentModeScaleAspectFit;

/* Загружаем изображение. Внимание! Оно будет кэшироваться. */

UIImage *image = [UIImage imageNamed@"Logo"];

/* Задаем картинку для вида с изображением. */

[imageView setImage: image];

/* Задаем вид с заголовком. */

self.navigationItem.titleView = imageView;

}

Предыдущий код должен выполняться в контроллере вида, находящемся внутри навигационного контроллера. Я уже загрузил изображение в группу ресурсов моего проекта и назвал это изображение Logo. Как только вы запустите это приложение с приведенным фрагментом кода, увидите результат, напоминающий рис. 1.35. Решение. 1.14. Демонстрация изображения на навигационной панели. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.35. Вид с изображением на нашей навигационной панели

Обсуждение.

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

• обычный текст;

• вид.

Если вы собираетесь работать с текстом, можете использовать свойство title навигационного элемента. Тем не менее, если вам требуется более полный контроль над заголовком или вы просто хотите вывести над навигационной панелью изображение или любой другой вид, можете использовать свойство titleView навигационного элемента контроллера вида. Ему можно присваивать любой объект, являющийся подклассом класса UIView. В примере мы создали вид для изображения, а затем присвоили ему изображение. Потом вывели это изображение в качестве заголовка вида, в настоящий момент находящегося на навигационном контроллере.

Свойство titleView навигационной панели — это самый обычный вид, но Apple рекомендует, чтобы его высота не превышала 128 точек. Поэтому считайте его изображением. Если бы вы загружали изображение, имеющее высоту 128 пикселов, то на сетчатом дисплее это соответствовало бы 64 точкам и все было бы нормально. Но если бы вы загружали изображение высотой 300 пикселов на сетчатом дисплее, то по высоте оно заняло бы 150 точек, то есть заметно превысило бы те 128 точек, которые Apple рекомендует для видов, расположенных в строке заголовка. Для исправления этой ситуации необходимо гарантировать, что вид в строке заголовка по высоте ни в коем случае не окажется больше 128 точек, а также задать для контента режим заполнения вида целиком, а не подгонки вида под содержимое. Для этого можно установить свойство contentMode вашей строки заголовка в UIViewContentModeScaleAspectFit.

1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem.

Постановка задачи.

Необходимо добавить кнопки на навигационную панель.

Решение.

Используйте класс UIBarButtonItem.

Обсуждение.

На навигационной панели могут содержаться различные элементы. Кнопки часто отображаются в ее левой и правой частях. Такие кнопки относятся к классу UIBarButtonItem и могут принимать самые разнообразные формы и очертания. Рассмотрим пример, показанный на рис. 1.36.

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.36. Различные кнопки, отображаемые на навигационной панели

Навигационные панели относятся к классу UINavigationBar, их можно создавать когда угодно и добавлять к любому виду. Итак, просто рассмотрим разные кнопки (с разными очертаниями), добавленные на навигационные панели на рис. 1.36. На кнопках, размещенных справа сверху, видим стрелки, которые направлены вверх и вниз. На кнопке, находящейся слева вверху, имеется стрелка, указывающая влево. Кнопки, расположенные на нижней навигационной панели, имеют разные очертания. В этом разделе мы рассмотрим, как создаются некоторые из таких кнопок.

Работая с данным разделом, выполните шаги, перечисленные в подразделе «Создание и запуск вашего первого приложения для iOS» раздела 1.0 данной главы и создайте пустое приложение. Потом проделайте шаги, описанные в разделе 1.12, и добавьте в делегат вашего приложения навигационный контроллер.

Чтобы создать кнопку для навигационной панели, необходимо сделать следующее.

1. Создать экземпляр класса UIBarButtonItem.

2. Добавить получившуюся кнопку на навигационную панель, воспользовавшись свойством navigationItem, относящимся к контроллеру вида. Свойство navigationItem позволяет взаимодействовать с навигационной панелью. Само это свойство может принимать еще два свойства: rightBarButtonItem и leftBarButtonItem. Оба они относятся к типу UIBarButtonItem.

Теперь рассмотрим пример, в котором добавим кнопку в правую часть нашей навигационной панели. На этой кнопке будет написано Add (Добавить):

— (void) performAdd:(id)paramSender{

NSLog(@"Action method got called.");

}

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";

self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithTitle:@"Add"

style: UIBarButtonItemStylePlain

target: self

action:@selector(performAdd:)];

}

Если сейчас запустить приложение, появится картинка, примерно как на рис. 1.37.

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.37. Навигационная кнопка, добавленная на навигационную панель

Пока все просто. Но если вы регулярно пользуетесь iOS, то, вероятно, заметили, что в системных приложениях iOS применяется готовая конфигурация и кнопка Add (Добавить) там выглядит иначе. На рис. 1.38 показан пример из раздела Alarm (Будильник) приложения Clock (Часы) для iPhone. Обратите внимание на кнопку + в верхней правой части навигационной панели.

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.38. Правильный способ создания кнопки Add (Добавить)

Оказывается, в SDK iOS можно создавать системные кнопки. Это делается с помощью метода-инициализатора nitWithBarButtonSystemItem: target: action:, относящегося к классу UIBarButtonItem:

— (void) performAdd:(id)paramSender{

NSLog(@"Action method got called.");

}

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";

self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAdd:)];

}

В результате получится именно то, чего мы добивались (рис. 1.39).

Первый параметр метода-инициализатора initWithBarButtonSystemItem: target: action:, относящегося к навигационной кнопке, может принимать в качестве параметров любые значения из перечня UIBarButtonSystemItem:

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.39. Системная кнопка Add (Добавить)

typedef NS_ENUM(NSInteger, UIBarButtonSystemItem) {

UIBarButtonSystemItemDone,

UIBarButtonSystemItemCancel,

UIBarButtonSystemItemEdit,

UIBarButtonSystemItemSave,

UIBarButtonSystemItemAdd,

UIBarButtonSystemItemFlexibleSpace,

UIBarButtonSystemItemFixedSpace,

UIBarButtonSystemItemCompose,

UIBarButtonSystemItemReply,

UIBarButtonSystemItemAction,

UIBarButtonSystemItemOrganize,

UIBarButtonSystemItemBookmarks,

UIBarButtonSystemItemSearch,

UIBarButtonSystemItemRefresh,

UIBarButtonSystemItemStop,

UIBarButtonSystemItemCamera,

UIBarButtonSystemItemTrash,

UIBarButtonSystemItemPlay,

UIBarButtonSystemItemPause,

UIBarButtonSystemItemRewind,

UIBarButtonSystemItemFastForward,

#if __IPHONE_3_0 <= __IPHONE_OS_VERSION_MAX_ALLOWED

UIBarButtonSystemItemUndo,

UIBarButtonSystemItemRedo,

#endif

#if __IPHONE_4_0 <= __IPHONE_OS_VERSION_MAX_ALLOWED

UIBarButtonSystemItemPageCurl,

#endif

};

Один из самых интересных инициализаторов из класса UIBarButtonItem — метод initWithCustomView:. В качестве параметра этот метод может принимать любой вид, то есть мы даже можем добавить на навигационную панель в качестве навигационной кнопки UISwitch (см. раздел 1.2). Это будет выглядеть не очень красиво, но мы просто попробуем:

— (void) switchIsChanged:(UISwitch *)paramSender{

if ([paramSender isOn]){

NSLog(@"Switch is on.");

} else {

NSLog(@"Switch is off.");

}

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

self.title = @"First Controller";

UISwitch *simpleSwitch = [[UISwitch alloc] init];

simpleSwitch.on = YES;

[simpleSwitch addTarget: self

action:@selector(switchIsChanged:)

forControlEvents: UIControlEventValueChanged];

self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithCustomView: simpleSwitch];

}

Вот что получается (рис. 1.40).

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.40. Переключатель, добавленный на навигационную панель

На навигационной панели можно создавать очень и очень занятные кнопки. Просто взгляните, что делает Apple со стрелками, направленными вверх и вниз, расположенными в правом верхнем углу на рис. 1.36. А почему бы нам тоже так не сделать? Впечатление такое, как будто в кнопку встроен сегментированный элемент управления (см. раздел 1.8). Итак, нам нужно создать такой элемент управления с двумя сегментами, добавить его на навигационную кнопку и, наконец, поставить эту кнопку на навигационную панель. Начнем:

— (void) segmentedControlTapped:(UISegmentedControl *)paramSender{

switch (paramSender.selectedSegmentIndex){

case 0:{

NSLog(@"Up");

break;

}

case 1:{

NSLog(@"Down");

break;

}

}

}

— (void)viewDidLoad{

[super viewDidLoad];

self.title = @"First Controller";

NSArray *items = @[

@"Up",

@"Down"

];

UISegmentedControl *segmentedControl = [[UISegmentedControl alloc]

initWithItems: items];

segmentedControl.momentary = YES;

[segmentedControl addTarget: self

action:@selector(segmentedControlTapped:)

forControlEvents: UIControlEventValueChanged];

self.navigationItem.rightBarButtonItem =

[[UIBarButtonItem alloc] initWithCustomView: segmentedControl];

}

На рис. 1.41 показано, что должно получиться в итоге.

Обсуждение. 1.15. Добавление кнопок на навигационные панели с помощью UIBsrButtonItem. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.41. Сегментированный элемент управления, встроенный в навигационную кнопку

Элемент navigationItem любого контроллера вида имеет еще два замечательных метода:

• setRightBarButtonItem: animated: — задает правую кнопку навигационной панели;

• setLeftBarButtonItem: animated: — определяет левую кнопку навигационной панели.

Оба метода позволяют указывать, хотите ли вы анимировать кнопку. Задайте значение YES для параметра animated, если анимация нужна:

UIBarButtonItem *rightBarButton =

[[UIBarButtonItem alloc] initWithCustomView: segmentedControl];

[self.navigationItem setRightBarButtonItem: rightBarButton animated: YES];

См. также.

Подраздел «Создание и запуск вашего первого приложения для iOS» раздела 1.0 данной главы. Разделы 1.2, 1.8, 1.12.

1.16. Представление контроллеров, управляющих несколькими видами, с помощью UITabBarController.

Постановка задачи.

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

Решение.

Используйте класс UITabBarController.

Обсуждение.

Если вы пользуетесь iPhone как будильником, то, разумеется, замечали на экране панель вкладок. Взгляните на рис. 1.38. В нижней части экрана расположены значки, которые называются World Clock (Мировое время), Alarm (Будильник), Stopwatch (Секундомер) и Timer (Таймер). Вся черная полоса в нижней части экрана — это панель вкладок, а вышеупомянутые ярлыки — ее элементы.

Панель вкладок — это контейнерный контроллер. Это значит, что мы создаем экземпляры UITabBarController и добавляем их в окно нашего приложения. Для каждого элемента панели вкладок мы добавляем на эту панель навигационный контроллер или контроллер вида. Эти элементы будут отображаться как вкладки на панели. Контроллер панели вкладок содержит панель вкладок типа UITabBar. Мы не создаем этот объект вручную — мы создаем контроллер панели вкладок, а уже он создает для нас такой объект. Проще говоря, считайте, что мы инстанцируем контроллер панели вкладок, а потом задаем контроллеры видов для этой панели. Данные контроллеры видов будут относиться к типу UIViewController или UINavigationController, если мы собираемся создать по контроллеру для каждого элемента панели вкладки (они же — контроллеры видов, задаваемые для контроллера панели вкладок). Навигационные контроллеры относятся к типу UINavigationController и являются подклассами от UIViewController. Следовательно, навигационный контроллер — это контроллер вида, но контроллеры видов, относящиеся к типу UIViewController, не являются навигационными контроллерами.

Итак, предположим, что у нас есть два контроллера видов. Классы этих контроллеров называются FirstViewController и SecondViewController:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

[self.window makeKeyAndVisible];

FirstViewController *firstViewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: NULL];

SecondViewController *secondViewController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];

UITabBarController *tabBarController = [[UITabBarController alloc] init];

[tabBarController setViewControllers:@[firstViewController,

secondViewController

]];

self.window.rootViewController = tabBarController;

return YES;

}

Когда панель вкладок отобразится на экране, ее элементы будут расположены именно так, как показано на рис. 1.38. Имя каждого из этих элементов основывается на названии того контроллера вида, который соответствует конкретному элементу. Определим заголовки для обоих контроллеров наших видов.

Когда загружается панель вкладок, вместе с ней загружается контроллер вида первого входящего в нее элемента. Все остальные контроллеры видов инициализируются, но их виды не загружаются. Это означает, что любой код, который вы напишете во viewDidLoad второго контроллера вида, не выполнится до тех пор, пока пользователь не нажмет второй элемент этой панели в первый раз. Поэтому если вы присвоите заголовок панели контроллеру второго вида в его viewDidLoad и запустите приложение, то обнаружите, что заголовок панели вкладок по-прежнему пуст.

Первый контроллер вида мы назовем First:

#import «FirstViewController.h»

@implementation FirstViewController

— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{

self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"First";

}

return self;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}

А второй контроллер вида будет называться Second:

#import «SecondViewController.h»

@implementation SecondViewController

— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{

self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"Second";

}

return self;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}

Теперь запустим приложение и посмотрим, что получилось (рис. 1.42).

Обсуждение. 1.16. Представление контроллеров, управляющих несколькими видами, с помощью UITabBarController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.42. Очень простая панель вкладок, на которой находятся два контроллера вида

Как видите, у контроллеров видов нет навигационной панели. Что делать? Все просто. Как вы помните, UINavigationController — это подкласс UIViewController. Итак, мы можем добавлять экземпляры навигационных контроллеров на панель вкладок, а внутрь каждого навигационного контроллера загрузить контроллер вида. Чего же мы ждем?

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

// Точка переопределения для специальной настройки,

// выполняемой после запуска приложения.

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

[self.window makeKeyAndVisible];

FirstViewController *firstViewController = [[FirstViewController alloc]

initWithNibName: nil

bundle: NULL];

UINavigationController *firstNavigationController =

[[UINavigationController alloc]

initWithRootViewController: firstViewController];

SecondViewController *secondViewController = [[SecondViewController alloc]

initWithNibName: nil

bundle: NULL];

UINavigationController *secondNavigationController =

[[UINavigationController alloc]

initWithRootViewController: secondViewController];

UITabBarController *tabBarController = [[UITabBarController alloc] init];

[tabBarController setViewControllers:

@[firstNavigationController, secondNavigationController]];

self.window.rootViewController = tabBarController;

return YES;

}

Что получается? Именно то, что мы хотели (рис. 1.43).

Обсуждение. 1.16. Представление контроллеров, управляющих несколькими видами, с помощью UITabBarController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.43. Панель вкладок, на которой контроллеры видов находятся внутри навигационных контроллеров

Как было показано на рис. 1.38, каждый элемент панели вкладок может содержать текст или изображение. Мы узнали, что, пользуясь свойством title контроллера вида, можно задавать такой текст. А что насчет изображения? Оказывается, у каждого контроллера вида есть и свойство tabItem. Это свойство соответствует той вкладке, которая находится в актуальном контроллере вида. Вы можете пользоваться этим свойством, чтобы задавать изображение для вкладки. Изображение для вкладки задается через ее свойство image. Я уже сделал два изображения — прямоугольник и кружок, а теперь выведу их как изображения для вкладок, соответствующих каждому из моих контроллеров видов. Вот код для первого контроллера вида:

— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{

self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"First";

self.tabBarItem.image = [UIImage imageNamed:@"FirstTab"];

}

return self;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}

А вот код для второго контроллера:

— (id)initWithNibName:(NSString *)nibNameOrNil

bundle:(NSBundle *)nibBundleOrNil{

self = [super initWithNibName: nibNameOrNil

bundle: nibBundleOrNil];

if (self!= nil) {

self.title = @"Second";

self.tabBarItem.image = [UIImage imageNamed:@"SecondTab"];

}

return self;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

}

Запустив приложение в эмуляторе, увидим такую картинку, как на рис. 1.44.

Обсуждение. 1.16. Представление контроллеров, управляющих несколькими видами, с помощью UITabBarController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.44. Элементы панели вкладок с изображениями

1.17. Отображение статического текста с помощью UILabel.

Постановка задачи.

Необходимо отображать для пользователя текст. Кроме того, вы хотели бы управлять шрифтом и цветом этого текста.

Статическим называется такой текст, который пользователь не может напрямую изменять во время исполнения.

Решение.

Используйте класс UILabel.

Обсуждение.

Подписи (Labels) встречаются в iOS повсюду. Они используются практически в любых приложениях, за исключением игр, для отображения содержимого которых обычно применяется OpenGL ES, а не основные фреймворки отрисовки, входящие в состав iOS. На рис. 1.45 показаны несколько подписей, имеющихся в приложении Settings (Настройки) для iPhone.

Обсуждение. 1.17. Отображение статического текста с помощью UILabel. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.45. Подписи в качестве названий настроек

Как видите, подписи содержат текстовые названия разделов приложения Settings (Настройки), в частности iCloud, Twitter, FaceTime, Safari и т. д.

Чтобы создать подпись, необходимо инстанцировать объект типа UILabel. Установка или получение текста для подписи осуществляется с помощью свойства text. Итак, определим подпись в файле реализации контроллера нашего вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UILabel *myLabel;

@end

@implementation ViewController

А теперь в viewDidLoad инстанцируем подпись и сообщаем среде времени исполнения, где следует разместить подпись (эта информация указывается в свойстве frame) и в какой вид она должна быть добавлена. В данном случае подпись окажется в виде контроллера нашего вида:

— (void)viewDidLoad{

[super viewDidLoad];

CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

23.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];

}

Теперь запустим приложение и посмотрим, что происходит (рис. 1.46).

Обсуждение. 1.17. Отображение статического текста с помощью UILabel. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.46. Слишком длинная подпись, которая не умещается на экране

Как видите, текст (содержимое) подписи обрезается, а за ним идут точки, поскольку ширины поля для подписи недостаточно для того, чтобы уместился весь текст. Для решения этой проблемы можно было бы увеличить ширину, но что делать с высотой? А что, если мы хотим, чтобы текст переходил на следующую строку. Хорошо, увеличим высоту с 23.0f до 50.0f:

CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

50.0f);

Если сейчас запустить приложение, получится тот же самый результат, что и на рис. 1.46. Вы могли бы спросить: «Я увеличил высоту, так почему же текст не переходит на следующую строку»? Оказывается, у класса UILabel есть свойство numberOfLines, в котором нужно указать, на сколько строк должен разбиваться текст подписи, если в ширину для нее будет недостаточно места. Если задать здесь значение 3, то вы сообщите программе, что текст подписи должен занимать не более трех строк, если этот текст не умещается в одной строке:

— (void)viewDidLoad{

[super viewDidLoad];

CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

70.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.numberOfLines = 3;

self.myLabel.lineBreakMode = NSLineBreakByWordWrapping;

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];

}

Теперь при запуске программы вы получите желаемый результат (рис. 1.47).

Обсуждение. 1.17. Отображение статического текста с помощью UILabel. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.47. Подпись, текст которой занимает три строки

Бывает, что вы не знаете, сколько строк понадобится, чтобы отобразить текст подписи. В таких случаях для свойства numberOfLines подписи задается значение 0.

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

— (void)viewDidLoad{

[super viewDidLoad];

self.view.backgroundColor = [UIColor whiteColor];

CGRect labelFrame = CGRectMake(0.0f,

0.0f,

100.0f,

23.0f);

self.myLabel = [[UILabel alloc] initWithFrame: labelFrame];

self.myLabel.adjustsFontSizeToFitWidth = YES;

self.myLabel.text = @"iOS 7 Programming Cookbook";

self.myLabel.font = [UIFont boldSystemFontOfSize:14.0f];

self.myLabel.center = self.view.center;

[self.view addSubview: self.myLabel];

}

1.18. Оформление UILabel.

Постановка задачи.

Требуется возможность оформлять внешний вид подписей — от настройки теней до настройки выравнивания.

Решение.

Пользуйтесь перечисленными далее свойствами класса UILabel в зависимости от стоящей перед вами задачи.

• shadowColor — свойство типа UIColor. Как понятно из названия, оно указывает цвет отбрасываемой тени для подписи. Устанавливая это свойство, вы должны установить и свойство shadowOffset.

• shadowOffset — это свойство типа CGSize. Оно указывает размер отступа между тенью и текстом. Например, если вы зададите для этого свойства значение (1, 0), то тень будет находиться на одну точку правее текста. Если задать значение (1, 2), то тень окажется на одну правее и на одну точку ниже текста. Если же установить значение (-2, -10), то тень будет отображаться на две точки левее и на десять точек выше текста.

• numberOfLines — свойство представляет собой целое число, указывающее, сколько строк текста может включать в себя подпись. По умолчанию значение этого свойства равно 1. Таким образом, любая создаваемая вами подпись по умолчанию может обработать одну строку текста. Если вы хотите сделать подпись из двух строк, задайте для этого свойства значение 2. Если требуется, чтобы в вашем текстовом поле могло отображаться неограниченное количество текстовых строк, либо вы просто не знаете, сколько строк текста в итоге понадобится отобразить, это свойство должно иметь значение 0. (Лично я нахожу это очень странным. Вместо NSIntegerMax или чего-то подобного в Apple решили обозначать неограниченное количество нулем!)

• lineBreakMode — это свойство относится к типу NSLineBreakMode и указывает способ перехода текста на новую строку внутри текстового поля. Например, если присвоить этому свойству значение NSLineBreakByWordWrapping, то слова разрываться не будут, но если по ширине будет мало места, то текст станет переходить на новую строку. Напротив, если задать для этого свойства значение NSLineBreakByCharWrapping, то при переходе на новую строку может происходить разрыв слова. Вероятно, NSLineBreakByCharWrapping стоит использовать лишь при жестком дефиците места и необходимости уместить на экране как можно больше информации. Я не рекомендую пользоваться этим свойством, если, конечно, вы стремитесь сохранить пользовательский интерфейс аккуратным и четким.

• textAlignment — свойство относится к типу NSTextAlignment и задает выравнивание текста в подписи по горизонтали. Например, для этого свойства можно задать значение NSTextAlignmentCenter, чтобы выровнять текст подписи по центру по горизонтали.

• textColor — это свойство типа UIColor определяет цвет текста подписи.

• font — свойство типа UIFont задает шрифт, которым отображается текст подписи.

• adjustsFontSizeToFitWidth — это свойство типа BOOL. Если оно имеет значение YES, то размер шрифта будет изменяться таким образом, чтобы текст умещался в поле для подписи. Например, когда поле маленькое, а вы хотите записать на нем слишком большой текст. В этом случае среда времени исполнения автоматически уменьшит размер шрифта подписи, чтобы текст гарантированно поместился. Напротив, если для этого свойства задано значение NO, то программа будет действовать в соответствии с актуальной функцией заверстывания строк/слов/символов и текст отобразится не полностью — всего несколько слов.

Обсуждение.

Подписи — одни из простейших компонентов пользовательского интерфейса, которые мы можем использовать в наших приложениях. Но при всей простоте их потенциал очень велик. Поэтому оформление подписей — очень важный фактор, значительно сказывающийся на удобстве использования интерфейса. Поэтому Apple предоставляет нам массу способов оформления экземпляров UILabel. Рассмотрим пример. Мы создаем простое приложение с единственным видом, в котором есть всего один контроллер вида. В центре экрана поместим простую надпись, выполненную огромным шрифтом, — она будет гласить: iOS SDK. Фон вида мы сделаем белым, а цвет тени, отбрасываемой подписью, — светло-серым. Мы убедимся, что тень находится ниже и правее подписи. На рис. 1.48 показан эффект, которого мы стремимся достичь.

Обсуждение. 1.18. Оформление UILabel. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.48. Оформление и отображение подписи на экране

А вот и код для этого:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UILabel *label;

@end

@implementation ViewController

— (void)viewDidLoad{

[super viewDidLoad];

self.label = [[UILabel alloc] init];

self.label.backgroundColor = [UIColor clearColor];

self.label.text = @"iOS SDK";

self.label.font = [UIFont boldSystemFontOfSize:70.0f];

self.label.textColor = [UIColor blackColor];

self.label.shadowColor = [UIColor lightGrayColor];

self.label.shadowOffset = CGSizeMake(2.0f, 2.0f);

[self.label sizeToFit];

self.label.center = self.view.center;

[self.view addSubview: self.label];

}

@end

См. также.

Разделы 1.17, 1.26.

1.19. Прием пользовательского текстового ввода с помощью UITextField.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UITextField.

Обсуждение.

Текстовое поле очень похоже на подпись тем, что в нем также можно отображать текстовую информацию. Но текстовое поле, в отличие от подписи, может принимать текстовый ввод и во время исполнения. На рис. 1.49 показаны два текстовых поля в разделе Twitter приложения Settings (Настройки) в iPhone.

Обсуждение. 1.19. Прием пользовательского текстового ввода с помощью UITextField. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.49. Текстовые поля, в которые можно вводить текст

В текстовом поле можно вводить и отображать только одну строку текста. Именно поэтому стандартная высота текстового поля, задаваемая по умолчанию, — всего 31 пункт. Эту высоту нельзя изменить в конструкторе интерфейса, но если вы создаете текстовое поле прямо в коде, то сделать это можно. Тем не менее при изменении высоты не изменяется количество строк, которые можно записать в текстовом поле, — строка всегда всего одна.

Чтобы определить наше текстовое поле, начнем работу с файла реализации контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UITextField *myTextField;

@end

@implementation ViewController

А потом создадим это текстовое поле:

— (void)viewDidLoad{

[super viewDidLoad];

CGRect textFieldFrame = CGRectMake(0.0f,

0.0f,

200.0f,

31.0f);

self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];

self.myTextField.borderStyle = UITextBorderStyleRoundedRect;

self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;

self.myTextField.textAlignment = NSTextAlignmentCenter;

self.myTextField.text = @"Sir Richard Branson";

self.myTextField.center = self.view.center;

[self.view addSubview: self.myTextField];

}

Прежде чем подробно рассматривать код, взглянем на результат его выполнения (рис. 1.50).

При создании этого текстового поля мы использовали различные свойства класса UITextField:

• borderStyle — свойство имеет тип UITextBorderStyle и указывает, как должны отображаться границы текстового поля;

• contentVerticalAlignment — это значение типа UIControlContentVerticalAlignment, сообщающее текстовому полю, как текст должен отображаться по вертикали в границах этого поля. Если не выровнять текст по центру по вертикали, он по умолчанию отобразится в левом верхнем углу поля;

• textAlignment — это свойство имеет тип UITextAlignment и указывает выравнивание текста в текстовом поле по горизонтали. В данном примере текст выровнен в текстовом поле по центру и по горизонтали;

• text — это свойство доступно как для считывания, так и для записи. То есть можно не только получать из него информацию, но и записывать туда новые данные. Функция считывания возвращает текст, который в данный момент находится в текстовом поле, а функция записи задает для текстового поля то значение, которое вы в ней указываете.

Обсуждение. 1.19. Прием пользовательского текстового ввода с помощью UITextField. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.50. Простое текстовое поле, текст в котором выровнен по центру

Текстовое поле посылает сообщения-делегаты своему объекту-делегату. Такие сообщения отправляются, например, когда пользователь начинает изменять (редактировать) информацию в текстовом поле (как-либо изменяет его содержимое) и когда он прекращает взаимодействовать с полем (покидает его). Чтобы получать уведомления об этих событиях, задайте ваш объект в качестве значения свойства delegate текстового поля. Делегат текстового поля должен соответствовать протоколу UITextFieldDelegate, так что позаботимся об этом:

@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *myTextField;

@end

@implementation ViewController

Нажав и удерживая клавишу Command, щелкните на протоколе UITextFieldDelegate в Xcode. Вы увидите методы, которыми позволяет управлять этот протокол. Рассмотрим эти методы, а также укажем, когда они вызываются.

• textFieldShouldBeginEditing: — возвращает логическое значение, сообщающее текстовому полю (текстовое поле является параметром этого метода), может ли пользователь редактировать содержащуюся в нем информацию (то есть разрешено это или нет). Возвратите здесь значение NO, если не хотите, чтобы пользователь изменял текст в этом поле. Метод запускается, как только пользователь касается этого поля, намереваясь его редактировать (при условии, что в поле допускается редактирование).

• textFieldDidBeginEditing: — вызывается, когда пользователь начинает редактировать текстовое поле. Этот метод запускается уже после того, как пользователь коснулся текстового поля, а метод делегата текстового поля textFieldShouldBeginEditing: возвратил значение YES, сообщив таким образом, что пользователь может редактировать содержимое этого поля.

• textFieldShouldEndEditing: — возвращает логическое значение, сообщающее текстовому полю, закончен текущий акт редактирования или нет. Этот метод запускается перед тем, как пользователь собирается покинуть текстовое поле, или после того, как статус активного объекта (First Responder) переходит к другому полю для ввода текста. Если возвратить NO от этого метода, то пользователь не сможет перейти в другое текстовое поле и начать вводить текст в него. Виртуальная клавиатура останется на экране.

• textFieldDidEndEditing: — вызывается, когда текущий акт редактирования конкретного текстового поля завершается. Это происходит, когда пользователь решает перейти к редактированию какого-то другого текстового поля или нажимает кнопку, предоставленную автором приложения, чтобы убрать с экрана клавиатуру, предназначенную для ввода текста в текстовое поле.

• textField: shouldChangeCharactersInRange: replacementString: — вызывается всякий раз, когда текст в текстовом поле изменяется. Возвращаемое значение этого метода — логическое. Если возвращается YES, это означает, что текст можно изменить. Если возвращается NO, то любые изменения текста в этом поле приняты не будут и даже не произойдут.

• textFieldShouldClear: — в каждом текстовом поле есть кнопка очистки — обычно это круглая кнопка с крестиком. Когда пользователь нажимает эту кнопку, все содержимое текстового поля автоматически стирается. Если вы предоставляете кнопку для очистки текста, но возвращаете от этого метода значение NO, то пользователь может подумать, что ваша программа не работает. Поэтому в данном случае вы должны отдавать себе отчет в том, что делаете. Если пользователь видит кнопку «Стереть», нажимает ее, а текст в поле не исчезает, это очень плохо характеризует программу.

• textFieldShouldReturn: — вызывается после того, как пользователь нажимает клавишу Return/Enter, пытаясь убрать клавиатуру с экрана. Текстовое поле должно быть присвоено этому методу в качестве активного элемента.

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

@interface ViewController () <UITextFieldDelegate>

@property (nonatomic, strong) UITextField *myTextField;

@property (nonatomic, strong) UILabel *labelCounter;

@end

@implementation ViewController

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

— (void) calculateAndDisplayTextFieldLengthWithText:(NSString *)paramText{

NSString *characterOrCharacters = @"Characters";

if ([paramText length] == 1){

characterOrCharacters = @"Character";

}

self.labelCounter.text = [NSString stringWithFormat:@"%lu %@",

(unsigned long)[paramText length],

characterOrCharacters];

}

— (BOOL) textField:(UITextField *)textField

shouldChangeCharactersInRange:(NSRange)range

replacementString:(NSString *)string{

if ([textField isEqual: self.myTextField]){

NSString *wholeText =

[textField.text stringByReplacingCharactersInRange: range

withString: string];

[self calculateAndDisplayTextFieldLengthWithText: wholeText];

}

return YES;

}

— (BOOL)textFieldShouldReturn:(UITextField *)textField{

[textField resignFirstResponder];

return YES;

}

— (void)viewDidLoad{

[super viewDidLoad];

CGRect textFieldFrame = CGRectMake(38.0f,

30.0f,

220.0f,

31.0f);

self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];

self.myTextField.delegate = self;

self.myTextField.borderStyle = UITextBorderStyleRoundedRect;

self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;

self.myTextField.textAlignment = NSTextAlignmentCenter;

self.myTextField.text = @"Sir Richard Branson";

[self.view addSubview: self.myTextField];

CGRect labelCounterFrame = self.myTextField.frame;

labelCounterFrame.origin.y += textFieldFrame.size.height + 10;

self.labelCounter = [[UILabel alloc] initWithFrame: labelCounterFrame];

[self.view addSubview: self.labelCounter];

[self calculateAndDisplayTextFieldLengthWithText: self.myTextField.text];

}

Мы делаем важное вычисление в методе textField: shouldChangeCharactersInRange: replacementString:. Здесь мы объявляем и используем переменную wholeText. Когда вызывается этот метод, параметр replacementString указывает строку, которую пользователь ввел в текстовое поле. Вы, возможно, полагаете, что пользователь может вводить по одному символу в каждый момент времени, поэтому почему бы не присвоить данному полю значение char? Но не забывайте, что пользователь может вставить в текстовое поле целый фрагмент текста, по этой причине данный параметр должен быть строковым. Параметр shouldChangeCharactersInRange указывает место в текстовом поле, с которого пользователь начинает вводить текст. Итак, с помощью двух этих параметров мы создаем строку, которая сначала считывает весь текст из текстового поля, а потом использует заданный диапазон, чтобы разместить новый текст рядом со старым. Итак, получается, что вводимый нами текст будет появляться в поле после того, как метод textField: shouldChangeCharactersInRange: replacementString: возвратит YES. На рис. 1.51 показано, как приложение будет выглядеть в эмуляторе.

Обсуждение. 1.19. Прием пользовательского текстового ввода с помощью UITextField. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.51. Реагирование на сообщения-делегаты текстового поля

В текстовом поле может отображаться не только текст, но и подстановочные (джокерные) символы. Подстановочный текст отображается до того, как пользователь введет в это поле какой-нибудь собственный текст, пока свойство text текстового поля является пустым. В качестве подстановочного текста вы можете использовать любую строку, какую хотите, но лучше этим текстом подсказать пользователю, для ввода какой именно информации предназначено данное поле. Многие программисты указывают в подстановочном тексте, значения какого типа может принимать данное поле. Например, на рис. 1.49 в двух текстовых полях (для ввода имени пользователя и пароля) стоит подстановочный текст Required (Обязательно). Можно использовать свойство placeholder текстового поля для установки или получения актуального подстановочного текста:

CGRect textFieldFrame = CGRectMake(38.0f,

30.0f,

220.0f,

31.0f);

self.myTextField = [[UITextField alloc]

initWithFrame: textFieldFrame];

self.myTextField.delegate = self;

self.myTextField.borderStyle = UITextBorderStyleRoundedRect;

self.myTextField.contentVerticalAlignment =

UIControlContentVerticalAlignmentCenter;

self.myTextField.textAlignment = UITextAlignmentCenter;

self.myTextField.placeholder = @"Enter text here…";

[self.view addSubview: self.myTextField];

Результат показан на рис. 1.52.

У текстовых полей есть два очень приятных свойства, которые называются leftView и rightView. Они относятся к типу UIView и доступны как для чтения, так и для записи. Они проявляются, как понятно из названий, в левой (left) и правой (right) частях текстового поля, когда вы присваиваете им определенный вид. Первое свойство (левый вид) может использоваться, например, при показе курсов валют. В этом случае слева отображается курс валюты страны, в которой проживает пользователь. Поле с этими данными относится к типу UILabel. Вот как можно решить такую задачу:

Обсуждение. 1.19. Прием пользовательского текстового ввода с помощью UITextField. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.52. Подстановочный текст отображается, когда пользователь еще ничего не ввел в поле

UILabel *currencyLabel = [[UILabel alloc] initWithFrame: CGRectZero];

currencyLabel.text = [[[NSNumberFormatter alloc] init] currencySymbol];

currencyLabel.font = self.myTextField.font;

[currencyLabel sizeToFit];

self.myTextField.leftView = currencyLabel;

self.myTextField.leftViewMode = UITextFieldViewModeAlways;

Если просто присвоить вид свойству leftView или rightView текстового поля, то эти виды не появятся автоматически. То, когда они появятся на экране, зависит от режима, управляющего их внешним видом. Данный режим контролируется свойствами leftViewMode и rightViewMode соответственно. Эти режимы относятся к типу UITextFieldViewMode:

typedef NS_ENUM(NSInteger, UITextFieldViewMode) {

UITextFieldViewModeNever,

UITextFieldViewModeWhileEditing,

UITextFieldViewModeUnlessEditing,

UITextFieldViewModeAlways

}

Итак, например, если задать UITextFieldViewModeWhileEditing в качестве режима левого вида и присвоить ему значение, то этот вид будет отображаться только в то время, как пользователь редактирует текстовое поле. И наоборот, если задать здесь значение UITextFieldViewModeUnlessEditing, левый вид будет отображаться, только пока пользователь не редактирует текстовое поле. Как только редактирование начнется, левый вид исчезнет. Теперь запустим наш код в эмуляторе (рис. 1.53).

Обсуждение. 1.19. Прием пользовательского текстового ввода с помощью UITextField. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.53. Текстовое поле с левым видом

См. также.

Раздел 1.17.

1.20. Отображение длинных текстовых строк с помощью UITextView.

Постановка задачи.

Требуется отображать в пользовательском интерфейсе несколько строк текста с возможностью прокрутки.

Решение.

Воспользуйтесь классом UITextView.

Обсуждение.

Класс UITextView позволяет отображать несколько строк текста и создавать прокручиваемое содержимое. Это означает, что если содержимое не умещается в границах текстового вида, то внутренние компоненты этого текстового вида позволяют пользователю прокручивать текст вверх и вниз и просматривать различные его части. В качестве примера текстового вида, входящего в приложение iOS, рассмотрим программу Notes (Блокнот) в iPhone (рис. 1.54).

Обсуждение. 1.20. Отображение длинных текстовых строк с помощью UITextView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.54. Программа Notes (Блокнот) в iPhone, здесь текст отображается в текстовом виде

Создадим текстовый вид и посмотрим, как он работает. Для начала определим текстовый вид в файле реализации контроллера нашего вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UITextView *myTextView;

@end

implementation ViewController

Далее необходимо создать сам текстовый вид. Мы сделаем текстовый вид таким же по размеру, как и вид контроллера вида:

— (void)viewDidLoad{

[super viewDidLoad];

self.myTextView = [[UITextView alloc] initWithFrame: self.view.bounds];

self.myTextView.text = @"Some text here…";

self.myTextView.contentInset = UIEdgeInsetsMake(10.0f, 0.0f, 0.0f, 0.0f);

self.myTextView.font = [UIFont systemFontOfSize:16.0f];

[self.view addSubview: self.myTextView];

}

Запустим приложение в эмуляторе iOS и посмотрим, как оно выглядит (рис. 1.55).

Обсуждение. 1.20. Отображение длинных текстовых строк с помощью UITextView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.55. Текстовый вид, занимающий все экранное пространство

Если коснуться текстового поля пальцем, то можно увидеть, как снизу всплывает виртуальная клавиатура. Она довольно крупная и закрывает текстовый вид почти наполовину. То есть если пользователь начнет вводить текст и дойдет примерно до середины окна по вертикали, весь остальной текст, который будет вводиться, окажется заслоненным клавиатурой (рис. 1.56).

Чтобы избежать такой ситуации, необходимо слушать определенные уведомления:

• UIKeyboardWillShowNotification — система выдает такое уведомление всякий раз, когда клавиатура выводится на экран для работы с каким-либо компонентом: текстовым полем, текстовым видом и т. д.;

• UIKeyboardDidShowNotification — система выдает такое уведомление, когда клавиатура отобразится целиком;

• UIKeyboardWillHideNotification — система выдает такое уведомление перед тем, как клавиатура скроется из вида;

Обсуждение. 1.20. Отображение длинных текстовых строк с помощью UITextView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.56. Клавиатура, наполовину занимающая текстовый вид

• UIKeyboardDidHideNotification — система выдает такое уведомление после того, как клавиатура полностью скроется из вида.

Уведомления клавиатуры содержат словарь, доступный с помощью свойства userInfo. Он указывает границы клавиатуры на экране и относится к типу NSDictionary. В словаре среди прочего имеется ключ UIKeyboardFrameEndUserInfoKey, содержащий объект типа NSValue. В свою очередь, этот объект содержит прямоугольник, ограничивающий размеры клавиатуры, когда она полностью отображена на экране. Эта прямоугольная область обозначается как CGRect.

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

— (void) handleKeyboardDidShow:(NSNotification *)paramNotification{

/* Получаем контур клавиатуры. */

NSValue *keyboardRectAsObject =

[[paramNotification userInfo]

objectForKey: UIKeyboardFrameEndUserInfoKey];

/* Помещаем эту информацию в CGRect. */

CGRect keyboardRect;

[keyboardRectAsObject getValue:&keyboardRect];

/* Задаем нижнюю границу нашего текстового вида так, чтобы он доходил ровно до верхней границы клавиатуры. */

self.myTextView.contentInset =

UIEdgeInsetsMake(0.0f,

0.0f,

keyboardRect.size.height,

0.0f);

}

— (void) handleKeyboardWillHide:(NSNotification *)paramNotification{

/* Делаем текстовый вид таким же по размеру, как и вид, содержащий его. */

self.myTextView.contentInset = UIEdgeInsetsZero;

}

— (void) viewWillAppear:(BOOL)paramAnimated{

[super viewWillAppear: paramAnimated];

[[NSNotificationCenter defaultCenter]

addObserver: self

selector:@selector(handleKeyboardDidShow:)

name: UIKeyboardDidShowNotification

object: nil];

[[NSNotificationCenter defaultCenter]

addObserver: self

selector:@selector(handleKeyboardWillHide:)

name: UIKeyboardWillHideNotification

object: nil];

self.myTextView = [[UITextView alloc] initWithFrame: self.view.bounds];

self.myTextView.text = @"Some text here…";

self.myTextView.font = [UIFont systemFontOfSize:16.0f];

[self.view addSubview: self.myTextView];

}

— (void) viewWillDisappear:(BOOL)paramAnimated{

[super viewWillDisappear: paramAnimated];

[[NSNotificationCenter defaultCenter] removeObserver: self];

}

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

Если вы намереваетесь изменять структуру пользовательского интерфейса, когда клавиатура выводится на экран и когда она с него убирается, то вам никак не обойтись без слушания клавиатурных уведомлений. Сообщения делегата UITextField запускаются всякий раз, когда начинается редактирование текстового поля, независимо от того, есть ли в этот момент на экране клавиатура. Не забывайте, что пользователь может подключить к устройству iOS беспроводную клавиатуру (с помощью Bluetooth). С этой клавиатуры он сможет редактировать содержимое текстовых полей, а также любых других информационных объектов вашего приложения. При подключении клавиатуры по Bluetooth виртуальная клавиатура на экране отображаться не будет. И если в вашем приложении пользовательский интерфейс станет обязательно перестраиваться, как только начинается ввод данных с клавиатуры, то при подключении беспроводной клавиатуры по Bluetooth такая перестройка окажется ненужной.

Теперь, если пользователь попытается ввести какой-либо текст в текстовый вид, клавиатура «выплывет» на экран снизу, и мы присвоим значение высоты клавиатуры в качестве нижней границы содержимого текстового вида. Таким образом, текстовый вид уменьшится в размерах и пользователь сможет вводить в него столько текста, сколько потребуется, — клавиатура не будет заслонять текст.

1.21. Добавление кнопок в пользовательский интерфейс с помощью UIButton.

Постановка задачи.

Необходимо отобразить в пользовательском интерфейсе кнопку и обрабатывать события касания, связанные с этой кнопкой.

Решение.

Воспользуйтесь классом UIButton.

Обсуждение.

Кнопки позволяют пользователям инициировать в приложениях те или иные действия. Например, пакет настроек iCloud в приложении Settings (Настройки) содержит кнопку Delete Account (Удалить учетную запись) (рис. 1.57). Если нажать эту кнопку, в приложении iCloud произойдет действие. Оно зависит от конкретного приложения. Не все приложения действуют одинаково, если пользователь нажимает в них кнопку Delete (Удалить). Как мы вскоре увидим, на кнопках могут присутствовать как изображения, так и текст.

Обсуждение. 1.21. Добавление кнопок в пользовательский интерфейс с помощью UIButton. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.57. Кнопка Delete Account (Удалить учетную запись)

Кнопка может присваивать действия различным инициаторам (триггерам). Например, кнопка может производить одно действие, когда пользователь нажимает ее пальцем, и другое — когда убирает с нее палец. Эти движения становятся действиями, а объекты, реализующие действия, — их целями. Определим кнопку в файле реализации контроллера нашего вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIButton *myButton;

@end

@implementation ViewController

По умолчанию высота UIButton в iOS 7 указывается как 44.0f пункта.

Теперь переходим к реализации кнопки (рис. 1.58):

— (void) buttonIsPressed:(UIButton *)paramSender{

NSLog(@"Button is pressed.");

}

— (void) buttonIsTapped:(UIButton *)paramSender{

NSLog(@"Button is tapped.");

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myButton = [UIButton buttonWithType: UIButtonTypeRoundedRect];

self.myButton.frame = CGRectMake(110.0f,

200.0f,

100.0f,

44.0f);

[self.myButton setTitle:@"Press Me"

forState: UIControlStateNormal];

[self.myButton setTitle:@"I'm Pressed"

forState: UIControlStateHighlighted];

[self.myButton addTarget: self

action:@selector(buttonIsPressed:)

forControlEvents: UIControlEventTouchDown];

[self.myButton addTarget: self

action:@selector(buttonIsTapped:)

forControlEvents: UIControlEventTouchUpInside];

[self.view addSubview: self.myButton];

}

Обсуждение. 1.21. Добавление кнопок в пользовательский интерфейс с помощью UIButton. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.58. В центре экрана находится системная кнопка

В коде из данного примера мы применяем метод setTitle: forState: кнопки, задавая для нее два разных заголовка. Заголовок — это надпись на кнопке. В разное время кнопка может находиться в различных состояниях: обычном и утопленном (нажатом). В каждом из состояний надпись на ней может меняться. Например, в данном случае, когда пользователь впервые видит кнопку, на ней будет написано Press Me (Нажми меня). А когда он нажмет ее, надпись на кнопке изменится на I'm Pressed (Я нажата).

Аналогичная ситуация складывается и с действиями, инициируемыми кнопкой. Мы используем метод addTarget: action: forControlEvents:, чтобы указать для нашей кнопки два действия:

• действие, инициируемое, когда пользователь нажимает кнопку;

• другое действие, происходящее, когда пользователь уже нажал кнопку и убирает палец с экрана. Такое событие называется окончанием нажатия кнопки (touch-inside-up).

Еще одна вещь, которую необходимо знать о UIButton, заключается в том, что кнопке обязательно должен быть присвоен тип. Присваивание выполняется путем вызова метода класса buttonWithType на этапе инициализации, как показано в приведенном коде-примере. В качестве параметра этого метода передайте значение типа UIButtonType:

typedef NS_ENUM(NSInteger, UIButtonType) {

UIButtonTypeCustom = 0,

UIButtonTypeSystem NS_ENUM_AVAILABLE_IOS(7_0),

UIButtonTypeRoundedRect,

UIButtonTypeDetailDisclosure,

UIButtonTypeInfoLight,

UIButtonTypeInfoDark,

UIButtonTypeContactAdd,

UIButtonTypeRoundedRect = UIButtonTypeSystem,

}

Кроме того, на кнопке может находиться изображение, которое заменяет ее стандартный внешний вид. Если у вас есть изображение или серия изображений, которые вы хотите присвоить различным состояниям кнопки, убедитесь, что кнопка относится к типу UIButtonTypeCustom. Здесь я подготовил два изображения: одно для обычного состояния кнопки, а другое — для нажатого (утопленного). Сейчас я создам кнопку и присвою ей два этих изображения:

UIImage *normalImage = [UIImage imageNamed:@"NormalBlueButton.png"];

UIImage *highlightedImage = [UIImage imageNamed:@"HighlightedBlueButton"];

self.myButton = [UIButton buttonWithType: UIButtonTypeCustom];

self.myButton.frame = CGRectMake(110.0f,

200.0f,

100.0f,

44.0f);

[self.myButton setBackgroundImage: normalImage

forState: UIControlStateNormal];

[self.myButton setTitle:@"Normal"

forState: UIControlStateNormal];

[self.myButton setBackgroundImage: highlightedImage

forState: UIControlStateHighlighted];

[self.myButton setTitle:@"Pressed"

forState: UIControlStateHighlighted];

На рис. 1.59 показано, как выглядит приложение, если его запустить в эмуляторе iOS. Чтобы задать фоновое изображение, мы используем относящийся к кнопке метод setBackgroundImage: forState:. Работая с фоновым изображением, мы можем пользоваться методами setTitle: forState: для отображения текста поверх фонового изображения. Если ваше изображение содержит текст и, таким образом, никакой надписи на кнопке не требуется, можете воспользоваться методом setImage: forState: или просто удалить заголовки с кнопки.

Обсуждение. 1.21. Добавление кнопок в пользовательский интерфейс с помощью UIButton. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.59. Кнопка с фоновым изображением

1.22. Показ изображений с помощью UIImageView.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UIImageView.

Обсуждение.

Класс UIImageView — один из наименее сложных в iOS SDK. Как вы знаете, существует особый вид, в котором демонстрируются изображения. Чтобы демонстрировать изображения, нужно всего лишь инстанцировать объект типа UIImageView и добавлять его к вашим видам. Например, у меня есть картинка Apple MacBook Air и я хочу показать ее в виде для изображений. Начнем с файла реализации контроллера:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIImageView *myImageView;

@end

@implementation ViewController

Инстанцируем вид для изображений и разместим в нем изображение:

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: macBookAir];

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];

}

Теперь, запустив программу, мы увидим такую картинку, как на рис. 1.60.

Обсуждение. 1.22. Показ изображений с помощью UIImageView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.60. Вид с изображением, которое довольно велико и не умещается на экране

Отмечу, что картинка Apple MacBook Air, которую я загружаю в этот вид, имеет разрешение 980 × 519 пикселов и, конечно же, не умещается на экране iPhone. Как решить эту проблему? Для начала нужно убедиться в том, что мы инициализируем наш вид для изображений с помощью метода initWithFrame:, а не initWithImage:, поскольку второй метод задает высоту и ширину вида с изображением равными высоте и ширине самого изображения. Итак, сначала решим эту проблему:

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithFrame: self.view.bounds];

self.myImageView.image = macBookAir;

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];

}

Как теперь будет выглядеть наше приложение? Рассмотрим рис. 1.61.

Обсуждение. 1.22. Показ изображений с помощью UIImageView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.61. Изображение, которое умещается по ширине на экране устройства

Но мы не этого хотели добиться, правда? Действительно, контуры вида с изображением нам теперь подходят, но сама картинка стала отображаться неправильно. Что же можно сделать? Можно решить возникшую проблему, задав для вида с изображением свойство contentMode. Это свойство типа UIContentMode:

typedef NS_ENUM(NSInteger, UIViewContentMode) {

UIViewContentModeScaleToFill,

UIViewContentModeScaleAspectFit,

UIViewContentModeScaleAspectFill,

UIViewContentModeRedraw,

UIViewContentModeCenter,

UIViewContentModeTop,

UIViewContentModeBottom,

UIViewContentModeLeft,

UIViewContentModeRight,

UIViewContentModeTopLeft,

UIViewContentModeTopRight,

UIViewContentModeBottomLeft,

UIViewContentModeBottomRight,

}

Вот описание некоторых наиболее полезных значений из перечня UIViewContentMode:

• UIViewContentModeScaleToFill — позволяет масштабировать картинку в виде для изображения так, что она целиком заполнит вид в его границах;

• UIViewContentModeScaleAspectFit — позволяет гарантировать, что картинка внутри вида с изображением будет иметь правильное соотношение сторон (характеристическое отношение) и будет вписываться в границы вида с изображением;

• UIViewContentModeScaleAspectFill — позволяет гарантировать, что картинка внутри вида с изображением будет иметь правильное соотношение сторон и будет вписываться в границы вида с изображением. Чтобы данное значение действовало как следует, необходимо присвоить свойству clipsToBounds вида с изображением значение YES.

Свойство clipsToBounds вида UIView определяет, должны ли «подокна» этого вида обрезаться, если они выходят за границы содержащего их вида. Можно пользоваться этим свойством, если вы хотите с абсолютной точностью гарантировать, что «подокна» конкретного вида не будут отображаться вне границ содержащего их вида (или что они при необходимости непременно будут выходить за его границы — в зависимости от того, что именно вам требуется).

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

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithFrame: self.view.bounds];

self.myImageView.contentMode = UIViewContentModeScaleAspectFit;

self.myImageView.image = macBookAir;

self.myImageView.center = self.view.center;

[self.view addSubview: self.myImageView];

}

Получается как раз такой результат, которого мы добивались (рис. 1.62).

Обсуждение. 1.22. Показ изображений с помощью UIImageView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.62. Такое соотношение сторон картинки нам подходит

1.23. Создание прокручиваемого контента с помощью UIScrollView.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UIScrollView.

Обсуждение.

Прокручиваемый вид (Scroll View) — одно из очевидных достоинств, которые и делают операционную систему iOS такой удобной. Подобные виды встречаются практически в любых программах. Мы уже познакомились с приложениями Clock (Часы) и Contacts (Контакты). Вы заметили, что их содержимое можно прокручивать вверх и вниз? Да, в этом и заключается магия, присущая видам, о которых пойдет речь в этом разделе.

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

Найдем для примера большую картинку и загрузим ее в вид с изображением. Я воспользуюсь той самой картинкой, с которой мы работали в разделе 1.22: MacBook Air. Добавлю ее в вид с изображением, который помещу в вид с прокручиваемым контентом. Потом воспользуюсь свойством contentSize прокручиваемого вида, чтобы убедиться в том, что размеры этого материала равны размерам изображения (высоте и ширине). Начнем работу с файла реализации контроллера нашего вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIScrollView *myScrollView;

@property (nonatomic, strong) UIImageView *myImageView;

@end

@implementation ViewController

И поместим вид с изображением внутрь прокручиваемого вида:

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *imageToLoad = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: imageToLoad];

self.myScrollView = [[UIScrollView alloc] initWithFrame: self.view.bounds];

[self.myScrollView addSubview: self.myImageView];

self.myScrollView.contentSize = self.myImageView.bounds.size;

[self.view addSubview: self.myScrollView];

}

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

UIScrollView обладает такой удобной особенностью, как поддержка делегирования. Поэтому такой вид может сообщать приложению о действительно важных событиях с помощью делегата. Делегат для прокручиваемого вида должен отвечать требованиям протокола UIScrollViewDelegate. Вот некоторые методы, определяемые в этом протоколе:

• scrollViewDidScroll: — вызывается всякий раз, когда содержимое прокручиваемого вида прокручивается;

• scrollViewWillBeginDecelerating: — вызывается, когда пользователь прокручивает содержимое вида и отрывает палец от сенсорного экрана в то время, как вид продолжает прокручиваться;

• scrollViewDidEndDecelerating: — вызывается, когда прокручивание информации, содержащейся в виде, заканчивается;

• scrollViewDidEndDragging: willDecelerate: — вызывается, когда пользователь завершает перетаскивание содержимого в прокручиваемом виде. Этот метод очень напоминает scrollViewDidEndDecelerating:, но следует помнить, что пользователь может перетаскивать элементы содержимого такого вида и не прокручивая его. Можно просто прикоснуться пальцем к элементу содержимого, переместить палец в другую точку на экране, а потом оторвать палец от экрана, не сдвинув содержимое самого вида ни на миллиметр. Этим перетаскивание и отличается от прокрутки. Прокрутка напоминает перетаскивание, но пользователь «сообщает импульс», приводящий к перемещению содержимого, если снимает палец с экрана, пока информация еще прокручивается. То есть пользователь убирает палец, не дождавшись завершения прокрутки. Перетаскивание можно сравнить с тем, как вы удерживаете педаль газа в машине или педаль велосипеда. Продолжая эту аналогию, можно сравнить прокрутку с движением по инерции на машине или велосипеде.

Сделаем предыдущее приложение немного интереснее. Теперь нужно установить уровень яркости картинки в нашем виде с изображением (этот показатель также называется «альфа-уровень» или «альфа-значение») равным 0.50f (полупрозрачный) на момент, когда пользователь начинает прокрутку изображения, и вернуть этот уровень к значению 1.0f (непрозрачный) к моменту, когда прокрутка завершается. Сначала обеспечим соответствие протоколу UIScrollViewDelegate:

#import «ViewController.h»

@interface ViewController () <UIScrollViewDelegate>

@property (nonatomic, strong) UIScrollView *myScrollView;

@property (nonatomic, strong) UIImageView *myImageView;

@end

@implementation ViewController

Потом реализуем данную функциональность:

— (void)scrollViewDidScroll:(UIScrollView *)scrollView{

/* Вызывается, когда пользователь совершает прокрутку

или перетаскивание. */

self.myScrollView.alpha = 0.50f;

}

— (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{

/* Вызывается только после прокрутки. */

self.myScrollView.alpha = 1.0f;

}

— (void)scrollViewDidEndDragging:(UIScrollView *)scrollView

willDecelerate:(BOOL)decelerate{

/* Гарантируем, что альфа-значение вернется к исходному,

даже если пользователь просто перетаскивает элементы. */

self.myScrollView.alpha = 1.0f;

}

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *imageToLoad = [UIImage imageNamed:@"MacBookAir"];

self.myImageView = [[UIImageView alloc] initWithImage: imageToLoad];

self.myScrollView = [[UIScrollView alloc] initWithFrame: self.view.bounds];

[self.myScrollView addSubview: self.myImageView];

self.myScrollView.contentSize = self.myImageView.bounds.size;

self.myScrollView.delegate = self;

[self.view addSubview: self.myScrollView];

}

Как можно заметить, в прокручиваемых видах имеются индикаторы. Индикатор — это тонкая контрольная линия, которая отображается с краю прокручиваемого вида, когда его содержимое прокручивается или перемещается (рис. 1.63).

Индикаторы просто показывают пользователю, как вид расположен в настоящий момент относительно его содержимого (в верхней части, на полпути к низу и т. д.). Внешним видом индикаторов можно управлять, изменяя значение свойства indicatorStyle. Например, в следующем коде я делаю индикатор прокручиваемого вида белым:

self.myScrollView.indicatorStyle = UIScrollViewIndicatorStyleWhite;

Обсуждение. 1.23. Создание прокручиваемого контента с помощью UIScrollView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.63. Черные индикаторы, появляющиеся справа и снизу прокручиваемого вида

Одна из наиболее замечательных особенностей прокручиваемых видов заключается в том, что в них возможна разбивка на страницы. Она функционально подобна прокрутке, но прокрутка прекращается, как только пользователь переходит на следующую страницу. Вероятно, вы уже знакомы с этой функцией, если вам доводилось пользоваться программой Photos (Фотографии) в iPhone или iPad. Просматривая фотографии, можно перемещаться между ними скольжением. Каждое скольжение открывает на экране предыдущую или последующую фотографию. При одном скольжении вы никогда не прокручиваете последовательность до самого начала или до самого конца. Когда начинается прокручивание и вид обнаруживает следующее изображение, прокрутка останавливается на этом изображении и оно начинает подрагивать на экране. Таким образом, анимация прокрутки прерывается. Это и есть разбивка на страницы. Если вы еще не пробовали ее на практике, настоятельно рекомендую попробовать. Весь дальнейший рассказ останется непонятен, если вы не будете представлять, как выглядит приложение, поддерживающее разбивку на страницы.

В следующем примере с кодом я использую три изображения: iPhone, iPad и MacBook Air. Каждое из них я поместил в отдельный вид типа image view, а потом добавил эти виды к прокручиваемому виду. Затем включаем разбивку на страницы, задавая для свойства pagingEnabled прокручиваемого вида значение YES:

— (UIImageView *) newImageViewWithImage:(UIImage *)paramImage

frame:(CGRect)paramFrame{

UIImageView *result = [[UIImageView alloc] initWithFrame: paramFrame];

result.contentMode = UIViewContentModeScaleAspectFit;

result.image = paramImage;

return result;

}

— (void)viewDidLoad{

[super viewDidLoad];

UIImage *iPhone = [UIImage imageNamed:@"iPhone"];

UIImage *iPad = [UIImage imageNamed:@"iPad"];

UIImage *macBookAir = [UIImage imageNamed:@"MacBookAir"];

CGRect scrollViewRect = self.view.bounds;

self.myScrollView = [[UIScrollView alloc] initWithFrame: scrollViewRect];

self.myScrollView.pagingEnabled = YES;

self.myScrollView.contentSize = CGSizeMake(scrollViewRect.size.width *

3.0f, scrollViewRect.size.height);

[self.view addSubview: self.myScrollView];

CGRect imageViewRect = self.view.bounds;

UIImageView *iPhoneImageView = [self newImageViewWithImage: iPhone

frame: imageViewRect];

[self.myScrollView addSubview: iPhoneImageView];

/* Для перехода на следующую страницу изменяем положение следующего вида с изображением по оси X. */

imageViewRect.origin.x += imageViewRect.size.width;

UIImageView *iPadImageView = [self newImageViewWithImage: iPad

frame: imageViewRect];

[self.myScrollView addSubview: iPadImageView];

/* Для перехода на следующую страницу изменяем положение следующего вида с изображением по оси X. */

imageViewRect.origin.x += imageViewRect.size.width;

UIImageView *macBookAirImageView =

[self newImageViewWithImage: macBookAir

frame: imageViewRect];

[self.myScrollView addSubview: macBookAirImageView];

}

Итак, теперь у нас есть три страницы, содержимое которых можно прокручивать (рис. 1.64).

Обсуждение. 1.23. Создание прокручиваемого контента с помощью UIScrollView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.64. Прокрутка содержимого в виде, в котором поддерживается разбивка на страницы

1.24. Загрузка веб-страниц с помощью UIWebView.

Постановка задачи.

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

Решение.

Воспользуйтесь классом UIWebView.

Обсуждение.

Веб-вид (Web View) — это окно, которое браузер Safari использует для загрузки в систему iOS информации из Сети. Класс UIWebView позволяет использовать в приложениях для iOS всю мощь Safari. Все, что вам нужно сделать, — поместить веб-вид в вашем пользовательском интерфейсе и применить один из методов загрузки:

• loadData: MIMEType: textEncodingName: baseURL: — загружает в веб-вид экземпляр класса NSData;

• loadHTMLString: baseURL: — загружает в веб-вид экземпляр класса NSString. Строка должна содержать валидный HTML-код так, чтобы ее мог обработать браузер;

• loadRequest: — загружает экземпляр класса NSURLRequest. Этот метод пригодится в тех случаях, когда вы хотите загрузить в веб-вид, расположенный в вашем приложении, удаленное содержимое, на которое указывает URL.

Рассмотрим пример. Начнем с файла реализации контроллера нашего вида:

#import «ViewController.h»

@interface ViewController ()

@property(nonatomic, strong) UIWebView *myWebView;

@end

@implementation ViewController

Теперь я хочу загрузить в веб-вид строку iOS 7 Programming Cookbook. Чтобы убедиться в том, что все работает как надо и что наш веб-вид способен отображать насыщенный (форматированный) текст, я на этом не остановлюсь и выделю слово Cookbook полужирным шрифтом, а остальной текст оставлю без изменений (рис. 1.65):

— (void)viewDidLoad{

[super viewDidLoad];

self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

[self.view addSubview: self.myWebView];

NSString *htmlString = @"iOS 7 Programming <strong>Cookbook</strong>";

[self.myWebView loadHTMLString: htmlString

baseURL: nil];

}

Обсуждение. 1.24. Загрузка веб-страниц с помощью UIWebView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.65. Загрузка форматированного текста в веб-вид

Еще один способ работы с веб-видом — загрузка в него удаленного контента, на который указывает URL. Для этого можно пользоваться методом loadRequest:. Перейдем к следующему примеру, в котором загрузим основную страницу сайта Apple в веб-вид, расположенный в нашей программе для iOS (рис. 1.66):

— (void)viewDidLoad{

[super viewDidLoad];

self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

self.myWebView.scalesPageToFit = YES;

[self.view addSubview: self.myWebView];

NSURL *url = [NSURL URLWithString:@"http://www.apple.com"];

NSURLRequest *request = [NSURLRequest requestWithURL: url];

[self.myWebView loadRequest: request];

}

Обсуждение. 1.24. Загрузка веб-страниц с помощью UIWebView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.66. Веб-вид, в который загружена домашняя страница Apple

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

Обсуждение. 1.24. Загрузка веб-страниц с помощью UIWebView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.67. Индикатор процесса загрузки

В iOS эта задача решается с помощью делегирования. Мы сделаем подписку на делегат веб-вида, и веб-вид будет получать уведомление всякий раз, когда делегат станет загружать контент. Когда загрузка контента завершится, мы получим от веб-вида соответствующее сообщение. Все это мы сделаем, применив свойство delegate веб-вида. Делегат веб-вида должен соответствовать протоколу UIWebViewDelegate.

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

@interface ViewController () <UIWebViewDelegate>

@property(nonatomic, strong) UIWebView *myWebView;

@end

@implementation ViewController

Потом перейдем к реализации. Здесь мы будем использовать три метода из тех, которые объявляются в протоколе UIWebViewDelegate:

webViewDidStartLoad: — вызывается, как только вид начинает загрузку содержимого;

webViewDidFinishLoad: — вызывается, как только вид заканчивает загрузку содержимого;

webView: didFailLoadWithError: — вызывается, как только вид останавливает загрузку содержимого, например, из-за возникшей ошибки или разрыва сетевого соединения:

— (void)webViewDidStartLoad:(UIWebView *)webView{

[[UIApplication sharedApplication]

setNetworkActivityIndicatorVisible: YES];

}

— (void)webViewDidFinishLoad:(UIWebView *)webView{

[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible: NO];

}

— (void)webView:(UIWebView *)webView didFailLoadWithError:(NSError *)error{

[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible: NO];

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myWebView = [[UIWebView alloc] initWithFrame: self.view.bounds];

self.myWebView.delegate = self;

self.myWebView.scalesPageToFit = YES;

[self.view addSubview: self.myWebView];

NSURL *url = [NSURL URLWithString:@"http://www.apple.com"];

NSURLRequest *request = [NSURLRequest requestWithURL: url];

[self.myWebView loadRequest: request];

}

1.25. Отображение протекания процессов с помощью UIProgressView.

Постановка задачи.

Необходимо отображать на экране индикатор протекания процесса (Progress Bar), отражающий ход выполнения той или иной задачи, например индикатор загрузки файла, скачиваемого c определенного URL.

Решение.

Инстанцируйте вид типа UIProgressView и разместите его в другом виде.

Обсуждение.

Вид протекания процесса программисты обычно называют прогресс-баром. Образец такого вида показан на рис. 1.68.

Обсуждение. 1.25. Отображение протекания процессов с помощью UIProgressView. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.68. Простой вид с индикатором протекания процесса

Виды, отображающие протекание процессов, обычно демонстрируются пользователю для показа выполнения задачи с четко определенными начальной и конечной точками. Примером такой задачи является, например, скачивание 30 файлов. Очевидно, что такая задача будет выполнена, когда все 30 файлов будут скопированы на устройство. Вид, отображающий протекание процесса, является экземпляром UIProgressView и инициализируется с помощью специального метода-инициализатора данного класса — initWithProgressViewStyle:. В качестве параметра данный метод принимает стиль (оформление) панели протекания, которую предполагается создать. Этот параметр относится к типу UIProgressViewStyle и, соответственно, может иметь одно из следующих значений:

• UIProgressViewStyleDefault — это стандартное оформление вида протекания процесса. Именно в этом стиле оформлен вид, показанный на рис. 1.68;

• UIProgressViewStyleBar — напоминает UIProgressViewStyleDefault, но предназначено для использования с видами отображения протекания процессов, добавляемыми на панель инструментов.

Экземпляр UIProgressView определяет свойство под названием progress (типа float). Это свойство сообщает системе iOS, как должна отображаться полоса в виде, отражающем протекание процесса. Значение этого свойства должно быть в диапазоне от 0 до 1.0. Если сообщается значение 0, то заполнение индикатора состояния еще не началось. Значение 1.0 соответствует 100 %-ной завершенности. Степень прогресса, показанная на рис. 1.68, составляет 0.5 (или 50 %).

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

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIProgressView *progressView;

@end

@implementation ViewController

Далее инстанцируем объект типа UIProgressView:

— (void)viewDidLoad{

[super viewDidLoad];

self.progressView = [[UIProgressView alloc]

initWithProgressViewStyle: UIProgressViewStyleBar];

self.progressView.center = self.view.center;

self.progressView.progress = 20.0f / 30.0f;

[self.view addSubview: self.progressView];

}

Итак, создать вид протекания процесса совсем не сложно. В сущности, нужно просто правильно отобразить ход процесса, так как свойство progress данного вида должно иметь значение в диапазоне от 0 до 1.0, то есть нормализованное значение. Итак, если вам предстоит решить 30 задач и вы уже выполнили 20 из них, то нужно присвоить свойству progress вида протекания процесса результат следующего равенства:

self.progressView.progress = 20.0f / 30.0f;

Значения 20 и 30 передаются данному равенству как значения с плавающей точкой, поскольку компилятору нужно сообщить, что операция деления будет производиться над числами с плавающей точкой и в результате деления получится десятичная дробь. Если приказать компилятору поместить в свойстве progress вида протекания процесса целочисленное деление 20/30, то вы получите целочисленный результат 0. Это происходит потому, что компилятор выполняет целочисленное деление, отсекая полученный результат до ближайшего предшествующего целого числа. Короче говоря, на индикаторе протекания действия прогресс все время будет оставаться нулевым, пока процесс не завершится и частное от деления 30/30 не станет равно 1. Пользователю такой индикатор загрузки будет ни к чему.

1.26. Создание и отображение текстов с оформлением.

Постановка задачи.

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

Решение.

Создайте экземпляр класса NSAttributedString или его изменяемого варианта, NSMutableAttributedString, и либо задайте его как текст компонента пользовательского интерфейса (например, как текст подписи UILabel) с помощью специального строкового свойства, снабженного атрибутами, либо просто воспользуйтесь встроенными методами атрибутированной строки для отрисовки текста на холсте.

Обсуждение.

О насыщенном тексте слагают легенды. Многим из наших коллег-программистов приходилось сталкиваться с необходимостью отображения в пользовательском интерфейсе такой текстовой строки, в которой применяется сразу несколько видов форматирования. Например, в одной строке может понадобиться одновременно вывести и обычный текст, и курсив, причем курсивом будет записано всего одно слово. Возможно, одно из слов в предложении потребуется подчеркнуть. Для этого некоторые пытаются использовать веб-виды (Web Views), но это решение не является оптимальным, поскольку веб-виды довольно медленно отображают свой контент и неизбежно негативно воздействуют на производительность приложения. В iOS 7 можно приступать к применению атрибутированных строк. Не знаю, почему Apple решила внедрить такую возможность в iOS только сейчас, ведь Mac-разработчики пользуются атрибутированными строками уже довольно давно.

Прежде чем приступить к основной части раздела, я хотел бы четко пояснить, что понимается под термином «атрибутированная строка». Взгляните на рис. 1.69. Мы собираемся написать программу, которая будет достигать именно такого эффекта.

Обсуждение. 1.26. Создание и отображение текстов с оформлением. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.69. Атрибутированная строка отображена на экране в простой подписи

Необходимо отметить, что этот текст отображается в одном экземпляре класса UILabel.

Итак, что мы видим в этом примере? Перечислю.

• Текст iOS имеет следующие атрибуты:

• полужирный шрифт размером 60 точек;

• черный цвет фона;

• красный цвет шрифта.

• Текст SDK имеет следующие атрибуты:

• полужирный шрифт размером 60 точек;

• белый цвет шрифта;

• светло-серую тень;

• красный цвет фона.

Удобнее всего создавать атрибутированные строки с помощью метода initWithString:, относящегося к изменяемому классу NSMutableAttributedString, и передавать этому методу экземпляр NSString. Так создается атрибутированная строка без каких-либо атрибутов. Затем, чтобы присвоить атрибуты различным частям строки, мы воспользуемся методом setAttributes: range: класса NSMutableAttributedString. Этот метод принимает два параметра:

• setAttributes — словарь, ключи которого являются символьными атрибутами и значение каждого ключа зависит от самого ключа. Вот наиболее важные ключи, которые можно задать в этом словаре:

• NSFontAttributeName — значение этого ключа является экземпляром UIFont и определяет шрифт для того или иного фрагмента строки;

• NSForegroundColorAttributeName — значение этого ключа относится к типу UIColor и определяет цвет шрифта определенного фрагмента строки;

• NSBackgroundColorAttributeName — значение этого ключа относится к типу UIColor и определяет цвет фона, на котором будет отрисовываться определенный фрагмент строки;

• NSShadowAttributeName — значение этого ключа должно быть экземпляром NSShadow и задавать тень, которую будет отбрасывать определенный фрагмент строки;

• range — значение типа NSRange, определяющее начальную точку и длину группы символов, к которой вы хотите применить указанные атрибуты.

Чтобы просмотреть все ключи, которые можно передавать этому методу, просто изучите онлайновую документацию Apple по классу NSMutableAttributedString. Я не буду помещать здесь ссылку на документацию, так как Apple может рано или поздно изменить эту ссылку, а вот поиск вас точно не подведет.

Разобьем наш пример на два словаря с атрибутами. Словарь атрибутов для слова iOS создается в коде таким образом:

NSDictionary *attributesForFirstWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor redColor],

NSBackgroundColorAttributeName: [UIColor blackColor]

};

А слово SDK создается с помощью следующих атрибутов:

NSShadow *shadow = [[NSShadow alloc] init];

shadow.shadowColor = [UIColor darkGrayColor];

shadow.shadowOffset = CGSizeMake(4.0f, 4.0f);

NSDictionary *attributesForSecondWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor whiteColor],

NSBackgroundColorAttributeName: [UIColor redColor],

NSShadowAttributeName: shadow

};

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

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UILabel *label;

@end

@implementation ViewController

— (NSAttributedString *) attributedText{

NSString *string = @"iOS SDK";

NSMutableAttributedString *result = [[NSMutableAttributedString alloc]

initWithString: string];

NSDictionary *attributesForFirstWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor redColor],

NSBackgroundColorAttributeName: [UIColor blackColor]

};

NSShadow *shadow = [[NSShadow alloc] init];

shadow.shadowColor = [UIColor darkGrayColor];

shadow.shadowOffset = CGSizeMake(4.0f, 4.0f);

NSDictionary *attributesForSecondWord = @{

NSFontAttributeName: [UIFont boldSystemFontOfSize:60.0f],

NSForegroundColorAttributeName: [UIColor whiteColor],

NSBackgroundColorAttributeName: [UIColor redColor],

NSShadowAttributeName: shadow

};

/* Находим фрагмент iOS в целой строке и задаем атрибуты для этого фрагмента */

[result setAttributes: attributesForFirstWord

range: [string rangeOfString:@"iOS"]];

/* Делаем то же самое со строкой SDK */

[result setAttributes: attributesForSecondWord

range: [string rangeOfString:@"SDK"]];

return [[NSAttributedString alloc] initWithAttributedString: result];

}

— (void)viewDidLoad{

[super viewDidLoad];

self.label = [[UILabel alloc] init];

self.label.backgroundColor = [UIColor clearColor];

self.label.attributedText = [self attributedText];

[self.label sizeToFit];

self.label.center = self.view.center;

[self.view addSubview: self.label];

}

@end

См. также.

Разделы 1.17 и 1.18.

1.27. Представление видов «Основной — детали» с помощью UISplitViewController.

Постановка задачи.

Необходимо максимально эффективно использовать большой экран iPad, представив на нем два расположенных рядом контроллера видов.

Решение.

Воспользуйтесь классом UISplitViewController.

Обсуждение.

Контроллеры видов split view (будем называть эти виды разделенными экранами) есть только в iPad. Если вы работаете с iPad, то, вероятно, уже сталкивались с ними. Можно просто открыть приложение Settings (Настройки) в альбомном режиме и посмотреть. Видите, какой контроллер разделенного экрана показан на рис. 1.70?

У контроллера разделенного экрана есть левая и правая стороны. Слева отображаются основные настройки. При нажатии каждой из этих настроек открываются детали этого элемента, которые мы видим в правой части разделенного экрана.

Даже не пытайтесь инстанцировать объект типа UISplitViewController на каком-нибудь устройстве, кроме iPad. В результате вы получите исключение. Обсуждение. 1.27. Представление видов «Основной — детали» с помощью UISplitViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.70. Контроллер с разделенным экраном в приложении Settings (Настройки) в iPad

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

1. В Xcode перейдите в меню File (Файл) и выполните New\New Project (Новый\ Новый проект).

2. В окне New Project (Новый проект) выберите слева iOS\Application (iOS\Приложение), а потом укажите вариант Master-Detail Application (Приложение «Основной — детали») (рис. 1.71) и нажмите Next (Далее).

Обсуждение. 1.27. Представление видов «Основной — детали» с помощью UISplitViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.71. Выбираем в Xcode шаблон приложения «Основной — детали»

3. На следующем экране выберите название вашего продукта и убедитесь в том, что для семейства устройств указан параметр Universal (Универсальное). Мы хотим, чтобы создаваемое приложение могло работать и на iPhone, и на iPad (рис. 1.72). Сделав это, нажмите Next (Далее).

Обсуждение. 1.27. Представление видов «Основной — детали» с помощью UISplitViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.72. Задаем в Xcode настройки проекта «Основной — детали»

4. Теперь выберем место для сохранения проекта. Сделав это, нажмите кнопку Create (Создать).

Итак, проект создан. На кнопке поэтапного выбора Scheme (Схема), расположенной в левом верхнем углу, должно быть указано, что приложение будет работать в эмуляторе iPad, а не в эмуляторе iPhone. Если в Xcode создается универсальное приложение «Основной — детали», то Xcode обеспечивает возможность работы с этим приложением и на iPhone, но при запуске приложения на iPhone структура его будет иной, нежели при запуске на iPad. В приложении окажется навигационный контроллер, внутри которого будет контроллер вида. Если то же самое приложение запустить на iPad, то мы увидим разделенный экран, в котором будут расположены два контроллера вида.

В шаблоне проекта с разделенным экраном есть два файла, о которых следует поговорить отдельно:

• MasterViewController — контроллер основного вида, располагающегося в левой части разделенного экрана в iPad. В iPhone это первый контроллер, который увидит пользователь;

• DetailViewController — контроллер вида с деталями, который отображается в правой части разделенного экрана на iPad. В iPhone это тот контроллер, который занимает верхнюю позицию в стеке, как только пользователь выбирает любой элемент в корневом (первом, основном) контроллере вида.

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

Если запустить такое приложение в эмуляторе iPad, то в альбомном режиме мы увидим контроллеры основного вида и вида с деталями в разделенном экране, но если изменить ориентацию на книжную, то вид с основными параметрами исчезнет и на его месте появится навигационная кнопка Master (Основной). Она будет располагаться в левой верхней части навигационной панели контроллера с детальной информацией. Хотя это и неплохой вариант, но мы ожидали иного, так как сравниваем наш проект с приложением Settings (Настройки) из iPad. Если в iPad повернуть экран с приложением Settings (Настройки) так, чтобы он приобрел книжную ориентацию, то на экране все равно останутся оба контроллера видов: и с основной информацией, и с деталями. Как нам добиться такого результата? Оказывается, Apple предлагает API (интерфейс программирования приложений), с помощью которого как раз и можно решить такую задачу. Просто переходим в файл DetailViewController.m и реализуем следующий метод:

— (BOOL) splitViewController:(UISplitViewController *)svc

shouldHideViewController:(UIViewController *)vc

inOrientation:(UIInterfaceOrientation)orientation{

return NO;

}

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

— (void)splitViewController:(UISplitViewController *)splitController

willHideViewController:(UIViewController *)viewController

withBarButtonItem:(UIBarButtonItem *)barButtonItem

forPopoverController:(UIPopoverController *)popoverController{

barButtonItem.title = NSLocalizedString(@"Master", @"Master");

[self.navigationItem setLeftBarButtonItem: barButtonItem animated: YES];

self.masterPopoverController = popoverController;

}

— (void)splitViewController:(UISplitViewController *)splitController

willShowViewController:(UIViewController *)viewController

invalidatingBarButtonItem:(UIBarButtonItem *)barButtonItem{

[self.navigationItem setLeftBarButtonItem: nil animated: YES];

self.masterPopoverController = nil;

}

Эти методы требовались нам просто для управления кнопкой из навигационной панели, но теперь мы больше не пользуемся ею и можем избавиться от этих методов. Их можно просто закомментировать или вообще удалить из файла DetailViewController.m.

Заглянув на заголовочный файл контроллера вашего основного вида, вы увидите там нечто подобное:

#import <UIKit/UIKit.h>

@class DetailViewController;

@interface MasterViewController: UITableViewController

@property (strong, nonatomic) DetailViewController *detailViewController;

@end

Как видите, в контроллере основного вида стоит ссылка на контроллер вида с деталями. С помощью этой связи мы можем сообщать контроллеру вида с деталями о сделанном выборе, а также передавать ему другие значения — об этом чуть позже.

По умолчанию если вы запустите приложение в эмуляторе iPad, то увидите пользовательский интерфейс, очень напоминающий тот, что показан на рис. 1.73. В стандартной реализации, которую Apple предоставляет нам с контроллером основного вида, содержится изменяемый массив. Этот массив заполняется экземплярами NSDate всякий раз, когда вы нажимаете кнопку «плюс» (+) на навигационной панели в этом контроллере вида. Стандартная реализация очень проста, и вы можете ее модифицировать, немного разобравшись в табличных видах. О том, что такое табличные виды и как они заполняются, подробно рассказано в главе 4.

Обсуждение. 1.27. Представление видов «Основной — детали» с помощью UISplitViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.73. Контроллер пустого вида с разделенным экраном, работающий в эмуляторе iPad

1.28. Организация разбивки на страницы с помощью UIPageViewController.

Постановка задачи.

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

Решение.

Воспользуйтесь UIPageViewController.

Обсуждение.

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

Контроллеры видов с постраничной организацией работают как в iPhone, так и в iPad.

1. В Xcode перейдите в меню File (Файл) и выберите New\New Project (Новый\ Новый проект).

2. Убедитесь, что в левой части окна New Project (Новый проект) выбрана операционная система iOS, а далее — команда Application (Приложение). Сделав это, укажите справа шаблон Page-Based Application (Приложение с постраничной организацией) (рис. 1.74) и нажмите Next (Далее).

Обсуждение. 1.28. Организация разбивки на страницы с помощью UIPageViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.74. Создание в Xcode приложения с постраничной организацией

3. Теперь выберите имя продукта и убедитесь в том, что указанное вами семейство устройств (Device) является универсальным (Universal). Это необходимо сделать, поскольку, как правило, ваше приложение потребуется использовать и на iPhone, и на iPad (рис. 1.75). Сделав это, нажмите Next (Далее).

Обсуждение. 1.28. Организация разбивки на страницы с помощью UIPageViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.75. Задаем настройки проекта для приложения с постраничной организацией

4. Выберите, где вы хотите сохранить проект. Сделав это, нажмите кнопку Create (Создать). Итак, вы успешно создали проект.

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

• класс делегата — делегат приложения просто создает экземпляр класса RootViewController и представляет его пользователю. Для iPad используется один архив XIB, для iPhone — другой, но оба они при работе опираются на вышеупомянутый класс;

• RootViewController — создает экземпляр UIPageViewController и добавляет к себе этот контроллер вида. Поэтому пользовательский интерфейс контроллера данного вида — это фактически смесь двух контроллеров видов, самого RootViewController и UIPageViewController;

• DataViewController — для каждой страницы в контроллере постраничного вида пользователю предлагается по одному экземпляру данного класса. Данный класс является подклассом UIViewController;

• ModelController — это обычный подкласс NSObject, соответствующий протоколу UIPageViewControllerDataSource. Этот класс является источником данных для контроллера вида-страницы.

Итак, мы видим, что у контроллера страничного вида есть и делегат, и источник данных. При использовании стандартного шаблона для приложений с постраничной организацией, входящего в состав Xcode, корневой контроллер вида становится делегатом, а контроллер модели — источником данных для контроллера страничного вида. Чтобы понять, как же на самом деле работает контроллер вида-страницы, необходимо разобраться в протоколах, регламентирующих в нем процессы делегирования и обращения к источнику данных. Начнем с протокола делегата, UIPageViewControllerDelegate. В этом протоколе есть два важных метода:

— (void)pageViewController:(UIPageViewController *)pageViewController

didFinishAnimating:(BOOL)finished

previousViewControllers:(NSArray *)previousViewControllers

transitionCompleted:(BOOL)completed;

— (UIPageViewControllerSpineLocation)pageViewController

:(UIPageViewController *)pageViewController

spineLocationForInterfaceOrientation:(UIInterfaceOrientation)orientation;

Первый метод вызывается, когда пользователь переходит к следующей или предыдущей странице или решает перелистнуть страницу вперед или назад, но передумывает в момент, пока страница еще движется. (В последнем случае пользователь возвращается к той странице, которую просматривал перед актом листания.) Свойство transitionCompleted получает значение YES, если удалось отобразить анимацию листания страницы, и NO — если пользователь решил страницу не перелистывать и прервал анимацию в ходе ее выполнения.

Второй метод вызывается при каждом изменении ориентации устройства. Этот метод можно использовать для того, чтобы указывать положение сгиба страницы, возвращая значение типа UIPageViewControllerSpineLocation:

typedef NS_ENUM(NSInteger, UIPageViewControllerSpineLocation) {

UIPageViewControllerSpineLocationNone = 0,

UIPageViewControllerSpineLocationMin = 1,

UIPageViewControllerSpineLocationMid = 2,

UIPageViewControllerSpineLocationMax = 3

};

Возможно, все это выглядит немного запутанно, но позвольте мне продемонстрировать, что имеется в виду. Если мы используем расположение сгиба ViewControllerSpineLocationMin, то для отображения страничного вида пользователю потребуется всего один контроллер вида. Если пользователь перейдет к следующей странице, то увидит уже новый контроллер вида. Но если мы зададим для отображения сгиба UIPageViewControllerSpineLocationMid, то для демонстрации такого варианта нам понадобятся уже два контроллера видов одновременно. Один будет представлять левую страницу, другой — правую, а между ними расположится сгиб. Сейчас покажу, что я имею в виду. На рис. 1.76 изображен пример страничного вида, имеющего альбомную ориентацию. Здесь для расположения изгиба выбрано значение UIPageViewControllerSpineLocationMin.

Обсуждение. 1.28. Организация разбивки на страницы с помощью UIPageViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.76. Один контроллер вида. Представлен контроллер вида-страницы с альбомной ориентацией

Теперь, если вернуть расположение сгиба, соответствующее UIPageViewControllerSpineLocationMid, получим примерно такой результат, как на рис. 1.77.

Обсуждение. 1.28. Организация разбивки на страницы с помощью UIPageViewController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.77. Два контроллера видов, отображенные в контроллере вида-страницы, где страница имеет альбомную ориентацию

Как видно на рис. 1.77, сгиб расположен точно по центру экрана, между двумя контроллерами видов. Когда пользователь перелистывает страницу справа налево, страница оказывается слева, а справа контроллер вида-страницы отображает новую страницу. Вся логика заключена в следующем методе делегата:

— (UIPageViewControllerSpineLocation)pageViewController

:(UIPageViewController *)pageViewController

spineLocationForInterfaceOrientation:(UIInterfaceOrientation)orientation;

Итак, мы разобрались с делегатом контроллера страничного вида, а что насчет источника данных? Источник данных контроллера страничного вида должен соответствовать протоколу UIPageViewControllerDataSource. Этот протокол предоставляет два следующих важных метода:

— (UIViewController *)

pageViewController:(UIPageViewController *)pageViewController

viewControllerBeforeViewController:(UIViewController *)viewController;

— (UIViewController *)

pageViewController:(UIPageViewController *)pageViewController

viewControllerAfterViewController:(UIViewController *)viewController;

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

Как вы могли убедиться, среда Xcode значительно упрощает создание приложений с постраничной организацией. Все, что, по сути, от вас требуется, — предоставить содержимое для модели данных (ModelController) и двигаться дальше. Если требуется отдельно настроить цвета и изображения в контроллерах ваших видов, то можно либо сделать это в конструкторе интерфейса (Interface Builder), позволяющем напрямую изменять файлы раскадровки, либо написать собственный код для реализации каждого из контроллеров видов.

1.29. Отображение вспомогательных экранов с помощью UIPopoverController.

Постановка задачи.

Вы хотите отображать на iPad окно с информацией, не занимая при этом целый экран.

Решение.

Воспользуйтесь вспомогательными экранами.

Обсуждение.

Вспомогательные экраны (Popover) применяются для вывода на экран iPad дополнительной информации. В качестве примера можно привести браузер Safari из iPad. Если пользователь нажмет кнопку Bookmarks (Закладки), то на экране появится еще одно окошко, в котором будет перечислено содержимое панели закладок (рис. 1.78).

Обсуждение. 1.29. Отображение вспомогательных экранов с помощью UIPopoverController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.78. Вспомогательный экран с закладками браузера Safari на планшете iPad

По умолчанию, если на устройстве отображен вспомогательный экран, а пользователь нажмет что-нибудь за его пределами, этот вспомогательный экран автоматически закроется. Вы можете задать поведение, при котором вспомогательный экран не закрывается, когда пользователь дотрагивается до какой-то конкретной части экрана, — об этом поговорим в дальнейшем. Содержимое вспомогательных экранов отображается с применением контроллеров видов. Обратите внимание: на вспомогательных экранах могут присутствовать и навигационные контроллеры, поскольку они являются подклассами UIViewController.

Вспомогательные экраны применяются только на устройствах iPad. Если у вас есть контроллер вида, чей код выполняется и на iPad, и на iPhone, необходимо гарантировать, что вспомогательные экраны не будут инстанцироваться на других устройствах, кроме iPad.

Вспомогательные экраны можно отображать и использовать двумя способами:

• открывать их из навигационной кнопки экземпляра UIBarButtonItem;

• открывать из прямоугольной области в виде.

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

Для создания демонстрационного приложения со вспомогательными экранами нужно сначала обдумать стратегию, зависящую от поставленных перед вами требований. Например, требуется написать приложение с контроллером вида, загруженным в навигационный контроллер. В корневом контроллере вида будет отображаться кнопка +, расположенная в правом углу навигационной панели. Если на устройстве iPad нажать кнопку +, откроется вспомогательный экран с двумя кнопками. На одной будет написано Photo (Фото), на другой — Audio (Аудио). При нажатии той же самой навигационной кнопки на iPhone отобразится предупреждающий вид (Alert View) с тремя кнопками — двумя вышеупомянутыми и кнопкой Cancel (Отмена), чтобы пользователь мог сам закрыть это окно, если захочет. При нажатии любой из этих кнопок (и в предупреждающем виде iPhone, и на вспомогательном экране iPad) мы фактически ничего не сделаем — просто уберем это окошко.

Итак, продолжим и создадим в Xcode универсальный проект Single View (Приложение с единственным видом). Назовем проект Displaying Popovers with UIPopoverController («Отображение вспомогательных экранов с помощью UIPopoverController»). Затем, воспользовавшись приемами, описанными в разделе 6.1, добавим в раскадровку навигационный контроллер, чтобы у контроллеров видов появилась навигационная панель.

После этого перейдем к определению корневого контроллера вида и укажем здесь свойство типа UIPopoverController:

#import «ViewController.h»

@interface ViewController () <UIAlertViewDelegate>

@property (nonatomic, strong) UIPopoverController *myPopoverController;

@property (nonatomic, strong) UIBarButtonItem *barButtonAdd;

@end

@implementation ViewController

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

Как видите, мы также определяем для контроллера вида свойство barButtonAdd. Это навигационная кнопка, которую мы добавим на нашу панель. Мы собираемся отображать вспомогательный экран после того, как пользователь нажмет эту кнопку (подробнее о навигационных кнопках рассказано в разделе 1.15). При этом необходимо гарантировать, что мы инстанцируем вспомогательный экран только для iPad. Прежде чем идти дальше и инстанцировать корневой контроллер вида с навигационной кнопкой, создадим подкласс от UIViewController и назовем его PopoverContentViewController. В дальнейшем будем отображать его содержимое на вспомогательном экране. В разделе 1.9 подробнее рассказано о контроллерах видов и о том, как их создавать.

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

#import <UIKit/UIKit.h>

@interface PopoverContentViewController: UIViewController

/* Не следует определять данное свойство как strong. В противном случае возникнет цикл удержания (Retain Cycle) между контроллером информационного вида и контроллером вспомогательного экрана, так как контроллер вспомогательного экрана не даст исчезнуть контроллеру информационного вида и наоборот. */

@property (nonatomic, weak) UIPopoverController *popoverController;

@end

И здесь же, в файле реализации контроллера вида с содержимым, объявим кнопки панели:

#import «PopoverContentViewController.h»

@interface PopoverContentViewController ()

@property (nonatomic, strong) UIButton *buttonPhoto;

@property (nonatomic, strong) UIButton *buttonAudio;

@end

@implementation PopoverContentViewController

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

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

— (BOOL) isInPopover{

Class popoverClass = NSClassFromString(@"UIPopoverController");

if (popoverClass!= nil &&

UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad &&

self.popoverController!= nil){

return YES;

} else {

return NO;

}

}

— (void) gotoAppleWebsite:(id)paramSender{

if ([self isInPopover]){

/* Перейти на сайт и закрыть вспомогательный экран. */

[self.popoverController dismissPopoverAnimated: YES];

} else {

/* Обработать ситуацию с iPhone. */

}

}

— (void) gotoAppleStoreWebsite:(id)paramSender{

if ([self isInPopover]){

/* Перейти на сайт и закрыть вспомогательный экран. */

[self.popoverController dismissPopoverAnimated: YES];

} else {

/* Обработать ситуацию с iPhone. */

}

}

— (void)viewDidLoad{

[super viewDidLoad];

self.contentSizeForViewInPopover = CGSizeMake(200.0f, 125.0f);

CGRect buttonRect = CGRectMake(20.0f,

20.0f,

160.0f,

37.0f);

self.buttonPhoto = [UIButton buttonWithType: UIButtonTypeRoundedRect];

[self.buttonPhoto setTitle:@"Photo"

forState: UIControlStateNormal];

[self.buttonPhoto addTarget: self

action:@selector(gotoAppleWebsite:)

forControlEvents: UIControlEventTouchUpInside];

self.buttonPhoto.frame = buttonRect;

[self.view addSubview: self.buttonPhoto];

buttonRect.origin.y += 50.0f;

self.buttonAudio = [UIButton buttonWithType: UIButtonTypeRoundedRect];

[self.buttonAudio setTitle:@"Audio"

forState: UIControlStateNormal];

[self.buttonAudio addTarget: self

action:@selector(gotoAppleStoreWebsite:)

forControlEvents: UIControlEventTouchUpInside];

self.buttonAudio.frame = buttonRect;

[self.view addSubview: self.buttonAudio];

}

Теперь в методе viewDidLoad корневого контроллера вида создадим навигационную кнопку. В зависимости от типа устройства при нажатии навигационной кнопки мы будем отображать либо вспомогательный экран (на iPad), либо предупреждающий вид (на iPhone):

— (void)viewDidLoad{

[super viewDidLoad];

/* Проверяем, существует ли этот класс в том варианте iOS,

где действует приложение. */

Class popoverClass = NSClassFromString(@"UIPopoverController");

if (popoverClass!= nil &&

UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad){

PopoverContentViewController *content =

[[PopoverContentViewController alloc] initWithNibName: nil

bundle: nil];

self.popoverController = [[UIPopoverController alloc]

initWithContentViewController: content];

content.popoverController = self.popoverController;

self.barButtonAdd = [[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAddWithPopover:)];

} else {

self.barButtonAdd = [[UIBarButtonItem alloc]

initWithBarButtonSystemItem: UIBarButtonSystemItemAdd

target: self

action:@selector(performAddWithAlertView:)];

}

[self.navigationItem setRightBarButtonItem: self.barButtonAdd

animated: NO];

}

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

Мы решили, что при нажатии навигационной кнопки + на устройстве iPad будет запускаться метод performAddWithPopover:. Если мы имеем дело не с iPad, то нужно, чтобы при нажатии этой кнопки запускался метод performAddWithAlertView:. Итак, реализуем два этих метода, а также позаботимся о методах делегатов предупреждающего вида — чтобы нам было известно, какую кнопку в предупреждающем виде нажимает пользователь, работающий с iPhone:

— (NSString *) photoButtonTitle{

return @"Photo";

}

— (NSString *) audioButtonTitle{

return @"Audio";

}

— (void) alertView:(UIAlertView *)alertView

didDismissWithButtonIndex:(NSInteger)buttonIndex{

NSString *buttonTitle = [alertView buttonTitleAtIndex: buttonIndex];

if ([buttonTitle isEqualToString: [self photoButtonTitle]]){

/* Добавляем фотографию… */

}

else if ([buttonTitle isEqualToString: [self audioButtonTitle]]){

/* Добавляем аудио… */

}

}

— (void) performAddWithAlertView:(id)paramSender{

[[[UIAlertView alloc] initWithTitle: nil

message:@"Add…"

delegate: self

cancelButtonTitle:@"Cancel"

otherButtonTitles:

[self photoButtonTitle],

[self audioButtonTitle], nil] show];

}

— (void) performAddWithPopover:(id)paramSender{

[self.popoverController

presentPopoverFromBarButtonItem: self.barButtonAdd

permittedArrowDirections: UIPopoverArrowDirectionAny

animated: YES];

}

Если запустить это приложение в эмуляторе iPad, то при нажатии кнопки + на навигационной панели мы увидим примерно такой интерфейс, как на рис. 1.79.

Обсуждение. 1.29. Отображение вспомогательных экранов с помощью UIPopoverController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.79. Простой вспомогательный экран, отображаемый после нажатия навигационной кнопки

Если запустить это же универсальное приложение в эмуляторе iPhone и нажать на навигационной панели кнопку +, результат будет примерно как на рис. 1.80.

Обсуждение. 1.29. Отображение вспомогательных экранов с помощью UIPopoverController. Глава 1. Реализация контроллеров и видов. iOS. Приемы программирования.

Рис. 1.80. В универсальном приложении вспомогательные экраны заменяются предупреждающими видами

Здесь мы воспользовались важным свойством контроллера информационного вида: preferredContentSize. Когда вспомогательный экран отображает контроллер своего информационного вида, он будет автоматически считывать значение этого свойства и корректировать свой размер (высоту и ширину). Кроме того, мы использовали метод presentPopoverFromBarButtonItem: permittedArrowDirections: animated: вспомогательного экрана в корневом контроллере нашего вида. Этот метод нужен, чтобы вспомогательный экран отображался над кнопкой навигационной панели. Первый параметр, принимаемый данным методом, — это кнопка навигационной панели, та, над которой должен всплывать контроллер вспомогательного экрана. Второй параметр указывает при появлении вспомогательного экрана направление его развертывания относительно объекта, из которого он появляется. Например, на рис. 1.79 видно, что стрелка вспомогательного экрана указывает вверх от кнопки с навигационной панели. Значение, передаваемое этому параметру, должно относиться к типу UIPopoverArrowDirection::

typedef NS_OPTIONS(NSUInteger, UIPopoverArrowDirection) {

UIPopoverArrowDirectionUp = 1UL << 0,

UIPopoverArrowDirectionDown = 1UL << 1,

UIPopoverArrowDirectionLeft = 1UL << 2,

UIPopoverArrowDirectionRight = 1UL << 3,

UIPopoverArrowDirectionAny = UIPopoverArrowDirectionUp |

UIPopoverArrowDirectionDown |

UIPopoverArrowDirectionLeft |

UIPopoverArrowDirectionRight,

UIPopoverArrowDirectionUnknown =

NSUIntegerMax

};

См. также.

Разделы 1.9 и 1.15.

Глава 2. Создание динамических и интерактивных пользовательских интерфейсов.

2.0. Введение.

Когда iPhone только появился на рынке, он поистине задал стандарт интерактивности в мобильных приложениях. Приложения iOS были и остаются поразительно интерактивными — вы можете на ходу манипулировать различными компонентами пользовательского интерфейса, корректируя их для максимально полного удовлетворения своих потребностей.

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

Приведу другой пример. Допустим, у вас есть приложение для обмена фотографиями, работающее на iPad. В левой части экрана находятся несколько картинок, которые были извлечены из пользовательского фотоальбома на Рабочий стол. Справа расположен компонент, напоминающий корзину. Каждая фотография, перенесенная в корзину, будет доступна для пакетного совместного использования через какую-нибудь социальную сеть, например Facebook. Вы хотите обогатить интерактивность приложения с помощью анимации так, чтобы пользователь мог «кидать» фотографии в корзину слева, а фотографии закреплялись в корзине. Все это можно было сделать и раньше, но для выполнения таких операций требовались глубокие знания Core Animation, а также довольно хорошее понимание физики.

Пользуясь UI Dynamics — новой технологией от Apple, — вы можете значительно упростить реализацию многих таких возможностей в приложении. На самом деле достаточно всего нескольких строк кода, чтобы реализовать в ваших видах очень интересную физику и необычное поведение.

Apple категоризировала такие действия в классах поведений, которые можно прикреплять к аниматору. Например, вы можете добавить к кнопке в вашем виде тяготение. В таком случае кнопка будет падать из верхней части вида (если вы ее там поместили) до самого его низа и даже сможет выпадать за его пределы. Если вы хотите этому воспрепятствовать и сделать так, чтобы кнопка падала только до дна вида и не дальше, то к аниматору нужно прикрепить и другое поведение — столкновение. Аниматор будет управлять поведениями, которые вы добавите к разным видам вашего приложения, а также их взаимодействиями. Вам не придется об этом беспокоиться. Далее перечислены несколько классов, обеспечивающих различное поведение компонентов пользовательского интерфейса:

• UICollisionBehavior — обеспечивает обнаружение столкновений;

• UIGravityBehavior — как понятно из названия, обеспечивает имитацию тяготения;

• UIPushBehavior — позволяет имитировать в ваших видах толчки. Допустим, вы дотронулись пальцем до экрана, а потом стали постепенно двигать палец к его верхнему краю. Если к виду прикреплена кнопка, оснащенная толчковым поведением, то вы могли бы толкать эту кнопку пальцем, как если бы она лежала на столе;

• UISnapBehavior — обеспечивает прикрепление видов к тем или иным местам на экране.

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

Опорный вид используется также в качестве контекста для анимации, которой управляет аниматор. Например, аниматору требуется определить, столкнутся ли два квадрата друг с другом. Для этого он использует методы Core Graphics, позволяющие определить, будут ли два этих квадрата накладываться друг на друга в контексте их вышестоящего вида — в данном случае опорного вида.

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

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

Постановка задачи.

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

Решение.

Инициализируйте объект типа UIGravityBehavior и добавьте к нему те компоненты пользовательского интерфейса, которые должны испытывать тяготение к этому объекту. Сделав это, создайте экземпляр UIDynamicAnimator, добавьте к аниматору поведение тяготения, а всю остальную работу аниматор сделает за вас.

Обсуждение.

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

Итак, определим аниматор и вид:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end

@implementation ViewController

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

Далее создадим небольшой вид, присвоим ему цвет и поместим в центре вида нашего контроллера. Так мы получим экземпляр класса UIGravityBehavior, воспользовавшись методом-инициализатором initWithItems:. Этот инициализатор принимает массив объектов, соответствующих протоколу UIDynamicItem. По умолчанию этому протоколу соответствуют все экземпляры UIView, поэтому, как только вид готов, можно идти дальше:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

/* Создаем маленький квадратный вид и добавляем его к self.view */

self.squareView = [[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 100.0f, 100.0f)];

self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;

[self.view addSubview: self.squareView];

/* Создаем аниматор и реализуем тяготение */

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems:@[self.squareView]];

[self.animator addBehavior: gravity];

}

Если вы не хотите добавлять тяготение ко всем вашим видам, как только инициализируете это поведение, то можете добавить его позже с помощью метода экземпляра addItem:, относящегося к классу UIGravityBehavior. Этот метод также принимает объект, соответствующий указанному ранее протоколу.

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

См. также.

Раздел 2.0.

2.2. Обнаружение столкновений между компонентами пользовательского интерфейса и реагирование на них.

Постановка задачи.

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

Решение.

Инстанцируйте объект типа UICollisionBehavior и прикрепите его к объекту аниматора. Присвойте свойству translatesReferenceBoundsIntoBoundary поведения столкновений значение YES и убедитесь в том, что аниматор инициализирован с вышестоящим видом в качестве опорной сущности. Так вы гарантируете, что дочерние виды, на которые распространяется поведение столкновения (о чем мы вскоре поговорим), не будут выпадать за пределы вышестоящего вида.

Обсуждение.

Поведение столкновения, относящееся к типу UICollisionBehavior, затрагивает объекты, соответствующие протоколу UIDynamicItem. Все виды типа UIView уже ему соответствуют, поэтому вам придется лишь инстанцировать ваши виды и добавить их к поведению столкновения. Поведение столкновения требует определить на экране границы, которые будут непреодолимы для элементов, находящихся в аниматоре. Например, если вы зададите линию, которая будет идти из нижнего левого угла вашего опорного вида в нижний правый угол (соответственно, это будет линия, вплотную прилегающая к его нижнему краю), а также добавите к этому виду поведение тяготения, то виды, расположенные на экране, будут двигаться под действием тяготения вниз, но не смогут «провалиться» с экрана, так как столкнутся с его нижним краем, который задается поведением столкновения.

Если вы хотите, чтобы границы области, в которой действует поведение столкновения, совпадали с границами опорного вида, то присвойте свойству translatesReferenceBoundsIntoBoundary экземпляра поведения столкновения значение YES. Если хотите самостоятельно провести линии, соответствующие границам такой области, просто воспользуйтесь методом экземпляра addBoundaryWithIdentifier: fromPoint: toPoint:, относящимся к классу UICollisionBehavior.

В этом примере мы собираемся создать два цветных вида, один из которых расположен на другом. После этого добавим к аниматору поведение тяготения, чтобы эти виды не перекрывали друг друга. Кроме того, они не будут выходить за границы опорного вида (то есть вида контроллера).

Итак, для начала определим массив видов и аниматор:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *squareViews;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end

@implementation ViewController

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

Потом, когда вид появится на экране, зададим поведения столкновения и тяготения и добавим их к аниматору:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

/* Создаем виды */

NSUInteger const NumberOfViews = 2;

self.squareViews = [[NSMutableArray alloc] initWithCapacity: NumberOfViews];

NSArray *colors = @[[UIColor redColor], [UIColor greenColor]];

CGPoint currentCenterPoint = self.view.center;

CGSize eachViewSize = CGSizeMake(50.0f, 50.0f);

for (NSUInteger counter = 0; counter < NumberOfViews; counter++){

UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, eachViewSize.width, eachViewSize.height)];

newView.backgroundColor = colors[counter];

newView.center = currentCenterPoint;

currentCenterPoint.y += eachViewSize.height + 10.0f;

[self.view addSubview: newView];

[self.squareViews addObject: newView];

}

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems: self.squareViews];

[self.animator addBehavior: gravity];

/* Реализуем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

collision.translatesReferenceBoundsIntoBoundary = YES;

[self.animator addBehavior: collision];

}

Получим примерно такой же результат, как на рис. 2.1.

Обсуждение. 2.2. Обнаружение столкновений между компонентами пользовательского интерфейса и реагирование на них. Глава 2. Создание динамических и интерактивных пользовательских интерфейсов. iOS. Приемы программирования.

Рис. 2.1. Взаимодействующие поведения тяготения и столкновения

В этом примере показано, что поведение обнаружения столкновений работает отлично, если свойство translatesReferenceBoundsIntoBoundary имеет значение YES. Но что, если мы захотим очертить собственные границы столкновений? Здесь и пригодится метод экземпляра addBoundaryWithIdentifier: fromPoint: toPoint:, относящийся к поведению столкновения. Вот параметры, которые следует передать этому методу:

• addBoundaryWithIdentifier — строковый идентификатор для вашей границы. Он используется для того, чтобы впоследствии вы могли получить от границы информацию о столкновении. Вы могли бы передать такой же идентификатор методу boundaryWithIdentifier: и получить в ответ объект границы. Объект относится к типу UIBezierPath и может поддерживать довольно сложные, сильно искривленные границы. Но большинство программистов предпочитают указывать простые горизонтальные или вертикальные границы, что мы и сделаем;

• fromPoint — начальная точка границы, относится к типу CGPoint;

• toPoint — конечная точка границы, относится к типу CGPoint.

Итак, предположим, что вы хотите провести границу в нижней части опорного вида (в данном случае вида с контроллером), но не хотите, чтобы она совпадала с нижним краем. Вместо этого вам нужна граница, расположенная на 100 точек выше нижнего края. В таком случае свойство поведения столкновения translatesReferenceBoundsIntoBoundary не поможет, так как вы хотите задать иную границу, не совпадающую с пределами опорного вида. Нужно воспользоваться методом addBoundaryWithIdentifier: fromPoint: toPoint:, вот так:

/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

[collision

addBoundaryWithIdentifier:@"bottomBoundary"

fromPoint: CGPointMake(0.0f, self.view.bounds.size.height — 100.0f)

toPoint: CGPointMake(self.view.bounds.size.width,

self.view.bounds.size.height — 100.0f)];

[self.animator addBehavior: collision];

Теперь, если мы объединим это поведение с тяготением, как делали раньше, то квадраты будут падать в опорном виде сверху вниз, но не достигнут его дна, так как проведенная нами нижняя граница находится немного выше. В рамках этого раздела я также хочу продемонстрировать возможность обнаружения столкновений между различными элементами, обладающими поведением столкновения. Класс UICollisionBehavior имеет свойство collisionDelegate, которое будет выступать в качестве делегата при обнаружении столкновений у элементов, обладающих поведением столкновения. Этот объект-делегат должен соответствовать протоколу UICollisionBehaviorDelegate. Данный протокол обладает некоторыми методами, которые мы можем реализовать. Вот два наиболее важных из этих методов:

• collisionBehavior: beganContactForItem: withBoundaryIdentifier: atPoint: — вызывается в делегате, когда один из элементов, обладающих поведением столкновения, ударяется об одну из границ, добавленных к этому поведению;

• collisionBehavior: endedContactForItem: withBoundaryIdentifier: atPoint: — вызывается, когда элемент, столкнувшийся с границей, отскочил от нее и, таким образом, контакт элемента с границей прекратился.

Чтобы продемонстрировать вам делегат в действии и показать, как его можно использовать, расширим приведенный пример. Как только квадратики достигают нижней границы опорного вида, мы делаем их красными, увеличиваем на 200 %, а потом заставляем рассыпаться, как при взрыве, и исчезать из виду:

NSString *const kBottomBoundary = @"bottomBoundary";

@interface ViewController () <UICollisionBehaviorDelegate>

@property (nonatomic, strong) NSMutableArray *squareViews;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end

@implementation ViewController

— (void)collisionBehavior:(UICollisionBehavior*)paramBehavior

beganContactForItem:(id <UIDynamicItem>)paramItem

withBoundaryIdentifier:(id <NSCopying>)paramIdentifier

atPoint:(CGPoint)paramPoint{

NSString *identifier = (NSString *)paramIdentifier;

if ([identifier isEqualToString: kBottomBoundary]){

[UIView animateWithDuration:1.0f animations: ^{

UIView *view = (UIView *)paramItem;

view.backgroundColor = [UIColor redColor];

view.alpha = 0.0f;

view.transform = CGAffineTransformMakeScale(2.0f, 2.0f);

} completion: ^(BOOL finished) {

UIView *view = (UIView *)paramItem;

[paramBehavior removeItem: paramItem];

[view removeFromSuperview];

}];

}

}

— (void)viewDidAppearBOOL)animated{

[super viewDidAppear: animated];

/* Создаем виды */

NSUInteger const NumberOfViews = 2;

self.squareViews = [[NSMutableArray alloc] initWithCapacity: NumberOfViews];

NSArray *colors = @[[UIColor redColor], [UIColor greenColor]];

CGPoint currentCenterPoint = CGPointMake(self.view.center.x, 0.0f);

CGSize eachViewSize = CGSizeMake(50.0f, 50.0f);

for (NSUInteger counter = 0; counter < NumberOfViews; counter++){

UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, eachViewSize.width, eachViewSize.height)];

newView.backgroundColor = colors[counter];

newView.center = currentCenterPoint;

currentCenterPoint.y += eachViewSize.height + 10.0f;

[self.view addSubview: newView];

[self.squareViews addObject: newView];

}

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems: self.squareViews];

[self.animator addBehavior: gravity];

/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems: self.squareViews];

[collision

addBoundaryWithIdentifier: kBottomBoundary

fromPoint: CGPointMake(0.0f, self.view.bounds.size.height — 100.0f)

toPoint: CGPointMake(self.view.bounds.size.width,

self.view.bounds.size.height — 100.0f)];

collision.collisionDelegate = self;

[self.animator addBehavior: collision];

}

Объясню, что происходит в коде. Во-первых, мы создаем два вида и кладем их один на другой. Эти виды представляют собой два обычных разноцветных квадрата: второй находится на первом. Оба они добавлены к контроллеру вида. Как и в предыдущих примерах, мы добавляем к аниматору поведение тяготения. Это означает, что, как только анимация начнет действовать, виды станут как будто сползать по опорному виду сверху вниз. Мы не задаем границы опорного вида в качестве границ столкновения, а самостоятельно проводим границу столкновения, располагая ее в 100 точках над нижней границей экрана. У нас получается невидимая линия, проходящая по экрану слева направо. Она не позволяет видам бесконечно падать вниз и выходить за пределы опорного вида.

Кроме того, как видите, мы задаем вид с контроллером в качестве делегата поведения столкновения. Таким образом, он получает обновления от этого поведения, сообщающие, произошло ли столкновение и если произошло, то когда. Как только вы узнаете о факте столкновения, то, вероятно, захотите определить, было ли это столкновение с границей (например, созданной нами) или с одним из элементов сцены. Например, если вы создали в опорном виде множество виртуальных стен, а маленькие виды-квадраты могут сталкиваться с этими стенами, то можете реализовать иной эффект (скажем, взрыв), зависящий от того, с чем именно произошло столкновение. О том, с каким элементом произошло столкновение, вы сможете узнать из делегатного метода, вызываемого в контроллере вида и дающего идентификатор той границы, с которой столкнулся элемент. Зная, какой это был объект, мы можем решить, что делать дальше.

В примере мы сравниваем идентификатор, получаемый от поведения столкновения, с константой kBottomBoundary, которую присвоили барьеру при создании этого барьера. Создаем для объекта такую анимацию: квадрат под действием тяготения движется по экрану вниз, вплоть до установленной нами границы. Граница гарантирует, что квадрат остановится на расстоянии 100 точек от нижнего края экрана, на проведенной линии.

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

• UICollisionBehaviorModeItems — при таком значении поведение будет регистрировать столкновения между динамическими элементами — в данном случае между движущимися квадратиками;

• UICollisionBehaviorModeBoundaries — при этом значении регистрируются столкновения между динамическими элементами и установленными нами границами, расположенными в опорном виде;

• UICollisionBehaviorModeEverything — при таком значении регистрируются любые столкновения, независимо от того, участвуют в них сами элементы, элементы и границы или что-либо еще. Это значение для данного свойства задается по умолчанию.

Можно комбинировать рассмотренные ранее значения с помощью побитового оператора ИЛИ и создавать сочетания режимов столкновения, соответствующие поставленным перед вами бизнес-требованиям.

Рекомендую поэкспериментировать со значениями свойства collisionMode и в предыдущем примере задать для этого свойства значение UICollisionBehaviorModeBoundaries, а потом запустить приложение. Вы увидите, как оба квадратика упадут в нижнюю часть экрана, окажутся на проведенной границе, но не столкнутся, а вдвинутся друг в друга. Дело в том, что код просто проигнорирует столкновение между ними.

См. также.

Раздел 2.1.

2.3. Анимирование компонентов пользовательского интерфейса с помощью толчков.

Постановка задачи.

Требуется визуально перебрасывать виды с одного места на экране на другое.

Решение.

Инициализируйте объект поведения типа UIPushBehavior с помощью относящегося к нему метода initWithItems: mode: и передайте ему значение UIPushBehaviorModeContinuous. Как только будете готовы толкать элементы под углом, вызовите для толчка метод setAngle:. Этот метод задает угол (в радианах) для данного поведения. Затем потребуется установить магнитуду, то есть силу толчка. Эта величина задается с помощью относящегося к толчку поведения setMagnitude:. Магнитуда рассчитывается следующим образом: магнитуда величиной 1 точка соответствует ускорению 100 точек/с2, прилагаемому к целевым видам.

Обсуждение.

Толчки, прилагаемые к экранным элементам, очень полезны — особенно толчки, вызывающие непрерывное движение. Допустим, вы разрабатываете приложение-фотоальбом для iPad. В верхней части экрана создали три слайда, каждый из которых соответствует странице альбома, созданной пользователем. В нижней части экрана располагаются различные картинки, которые пользователь может перетаскивать и раскладывать на страницах. Один из способов, позволяющих реализовать для пользователя такую возможность, — добавление к опорному виду регистратора жестов касания (tap gesture recognizer), создание которого рассмотрено в разделе 10.5. Этот регистратор обеспечивает отслеживание пользовательских жестов касания и позволяет перемещать изображения на целевой слайд. Процесс выглядит как перетаскивание. Другой, пожалуй, более оптимальный способ решения этой задачи — использование толчкового поведения, которое разработчики Apple включили в UIKit.

Толчковое поведение относится к типу UIPushBehavior и обладает магнитудой и углом. Угол измеряется в радианах, а магнитуда в 1 точку приводит к ускорению движения, равному 100 точек/с2. Толчковые поведения создаются точно так же, как и любые другие: сначала их необходимо инициализировать, а потом добавить к аниматору типа UIDynamicAnimator.

В этом примере мы собираемся создать вид и поместить его в центре более крупного вида контроллера. Мы подключим к аниматору поведение столкновений, благодаря чему маленький вид не будет вылетать за пределы большого вида (с контроллером). О том, как работать со столкновениями, мы поговорили в разделе 2.2. Затем добавим регистратор жестов касания (см. раздел 10.5) к контроллеру вида. Этот регистратор будет уведомлять нас о каждом жесте касания, произошедшем на экране.

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

В данном разделе предполагается, что читатель понимает основы тригонометрии. Но даже если вы с ними не знакомы — ничего страшного, поскольку для работы потребуются лишь те формулы, которые я описываю в примерах кода к этому разделу. На рис. 2.2 показано, как вычисляется угол между двумя точками. Итак, я надеюсь, что объяснение получится достаточно подробным, чтобы вы могли написать собственное решение данной проблемы.

Обсуждение. 2.3. Анимирование компонентов пользовательского интерфейса с помощью толчков. Глава 2. Создание динамических и интерактивных пользовательских интерфейсов. iOS. Приемы программирования.

Рис. 2.2. Расчет угла между двумя точками

Итак, начнем с определения всех важных свойств нашего контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UIPushBehavior *pushBehavior;

@end

@implementation ViewController

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

В этом примере мы добавим к аниматору поведение столкновения и толчковое поведение. Толчковое поведение добавляется к классу в качестве свойства, а поведение столкновений — просто как локальная переменная. Дело в том, что, как только мы добавим к аниматору поведение столкновения, именно аниматор будет вычислять все столкновения с границами опорного вида и нам больше не придется ссылаться на это поведение столкновений. Однако если говорить о толчковом поведении, то при обработке касаний придется обновлять это толчковое поведение, чтобы графический элемент подталкивался к точке касания. Вот почему нам требуется связь касания с толчковым поведением, но не требуется такая связь со столкновениями.

Далее напишем метод, создающий маленький квадратный вид и помещающий его в центре большого вида с контроллером:

— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];

self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;

[self.view addSubview: self.squareView];

}

Затем применим регистратор жестов касания, чтобы обнаруживать прикосновения к виду с контроллером:

— (void) createGestureRecognizer{

UITapGestureRecognizer *tapGestureRecognizer =

[[UITapGestureRecognizer alloc] initWithTarget: self

action:@selector(handleTap:)];

[self.view addGestureRecognizer: tapGestureRecognizer];

}

Эти методы выполняют за нас всю необходимую работу. Позже, когда вид отобразится на экране, мы будем вызывать эти методы и они будут действовать.

И не забудем написать метод, который будет задавать поведение столкновения и толчковое поведение:

— (void) createAnimatorAndBehaviors{

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;

self.pushBehavior = [[UIPushBehavior alloc]

initWithItems:@[self.squareView]

mode: UIPushBehaviorModeContinuous];

[self.animator addBehavior: collision];

[self.animator addBehavior: self.pushBehavior];

}

Подробнее о поведении столкновений рассказано в разделе 2.2. Как только мы запрограммируем все эти методы, нам понадобится вызывать их, когда вид появится на экране:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnimatorAndBehaviors];

}

Отлично. Теперь, взглянув на файл реализации метода createGestureRecognizer, вы увидите, что мы устанавливаем регистратор жестов касаний в методе контроллера вида — этот метод называется handleTap:. В методе handleTap: вычисляем расстояние между центральной точкой маленького квадратного вида и той точкой опорного вида, до которой дотронулся пользователь. В результате имеем магнитуду силы толчка. Кроме того, рассчитаем угол между центром маленького квадратного вида и точкой касания, чтобы определить угол толчка:

— (void) handleTap:(UITapGestureRecognizer *)paramTap{

/* Получаем угол между центральной точкой квадратного вида и точкой касания */

CGPoint tapPoint = [paramTap locationInView: self.view];

CGPoint squareViewCenterPoint = self.squareView.center;

/* Вычисляем угол между центральной точкой квадратного вида и точкой касания, чтобы определить угол толчка

Формула для определения угла между двумя точками:

arc tangent 2((p1.x — p2.x), (p1.y — p2.y)) */

CGFloat deltaX = tapPoint.x — squareViewCenterPoint.x;

CGFloat deltaY = tapPoint.y — squareViewCenterPoint.y;

CGFloat angle = atan2(deltaY, deltaX);

[self.pushBehavior setAngle: angle];

/* Используем расстояние между точкой касания и центром квадратного вида для вычисления магнитуды толчка

Формула определения расстояния:

Квадратный корень из ((p1.x — p2.x)^2 + (p1.y — p2.y)^2) */

CGFloat distanceBetweenPoints =

sqrt(pow(tapPoint.x — squareViewCenterPoint.x, 2.0) +

pow(tapPoint.y — squareViewCenterPoint.y, 2.0));

[self.pushBehavior setMagnitude: distanceBetweenPoints / 200.0f];

}

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

Теперь, запустив приложение, вы сначала увидите маленький зеленый квадрат в центре экрана. Дотроньтесь до экрана в любой точке поля, окружающего квадрат (белое пространство), чтобы зеленый квадрат (вид) стал двигаться. В данном примере я беру расстояние между точкой касания и центром квадрата и делю его на 200, чтобы получить реалистичную магнитуду толчка, но вы в данном примере можете увеличить ускорение, выбрав, скажем, значение 100, а не 200. Всегда лучше экспериментировать с разными числовыми значениями, чтобы подобрать оптимальный вариант для вашего приложения.

См. также.

Раздел 2.2.

2.4. Прикрепление нескольких динамических элементов друг к другу.

Постановка задачи.

Требуется прикреплять друг к другу динамические элементы, например виды, так, чтобы движения одного вида автоматически приводили в движение второй. В качестве альтернативы можно прикреплять динамический элемент к точке привязки, чтобы при движении этой точки (в результате действий приложения или пользователя) этот элемент автоматически перемещался вместе с ней.

Решение.

Инстанцируйте поведение прикрепления, относящееся к типу UIAttachmentBehavior, с помощью метода экземпляра initWithItem: point: attachedToAnchor: этого класса. Добавьте это поведение к аниматору (см. раздел 2.0), отвечающему за динамику и физику движения.

Обсуждение.

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

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

В этом примере мы собираемся создать такой эффект, который продемонстрирован на рис. 2.3.

Обсуждение. 2.4. Прикрепление нескольких динамических элементов друг к другу. Глава 2. Создание динамических и интерактивных пользовательских интерфейсов. iOS. Приемы программирования.

Рис. 2.3. Именно такого эффекта мы хотим добиться в данном разделе с помощью поведения прикрепления

Как видите, на экране находятся три вида. Основной вид расположен в центре, в правом верхнем углу этого вида есть еще один вид, более мелкий. Маленький вид — это и есть тот элемент, который будет следовать за точкой привязки, по принципу, который я описал в примере с фотографией. Наконец, необходимо отметить, что точка привязки в данном примере будет перемещаться по экрану под действием жеста панорамирования и регистратора соответствующих жестов (см. раздел 10.3). Затем в результате таких движений станет двигаться большой вид, расположенный в центре экрана. Итак, начнем с определения необходимых свойств контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIView *squareViewAnchorView;

@property (nonatomic, strong) UIView *anchorView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UIAttachmentBehavior *attachmentBehavior;

@end

@implementation ViewController

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

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

— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];

self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;

self.squareViewAnchorView = [[UIView alloc] initWithFrame:

CGRectMake(60.0f, 0.0f, 20.0f, 20.0f)];

self.squareViewAnchorView.backgroundColor = [UIColor brownColor];

[self.squareView addSubview: self.squareViewAnchorView];

[self.view addSubview: self.squareView];

}

Далее создадим вид с точкой привязки:

— (void) createAnchorView{

self.anchorView = [[UIView alloc] initWithFrame:

CGRectMake(120.0f, 120.0f, 20.0f, 20.0f)];

self.anchorView.backgroundColor = [UIColor redColor];

[self.view addSubview: self.anchorView];

}

После этого потребуется создать регистратор жестов панорамирования и аниматор, как мы уже делали в предыдущих разделах этой главы:

— (void) createGestureRecognizer{

UIPanGestureRecognizer *panGestureRecognizer =

[[UIPanGestureRecognizer alloc] initWithTarget: self

action:@selector(handlePan:)];

[self.view addGestureRecognizer: panGestureRecognizer];

}

— (void) createAnimatorAndBehaviors{

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем распознавание столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;

self.attachmentBehavior = [[UIAttachmentBehavior alloc]

initWithItem: self.squareView

point: self.squareViewAnchorView.center

attachedToAnchor: self.anchorView.center];

[self.animator addBehavior: collision];

[self.animator addBehavior: self.attachmentBehavior];

}

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnchorView];

[self createAnimatorAndBehaviors];

}

Как видите, мы реализуем поведение привязки с помощью его метода экземпляра initWithItem: point: attachedToAnchor:. Этот метод принимает следующие параметры:

• initWithItem — динамический элемент (в нашем примере — вид), который должен быть подключен к точке привязки;

• point — точка внутри динамического элемента, которая должна быть соединена с точкой привязки. В данном поведении центральная точка элемента используется для установки соединения с точкой привязки. Но вы можете изменить этот параметр, присвоив ему другое значение;

• attachedToAnchor — сама точка привязки, измеряемая как значение CGPoint.

Теперь, когда мы соединили верхний правый угол квадратного вида с точкой привязки (представленной как вид точки привязки), необходимо продемонстрировать, что, двигая точку привязки, мы опосредованно будем двигать и квадратный вид. Вернемся к методу createGestureRecognizer, написанному ранее. Там мы задействовали регистратор жестов касания, который будет отслеживать движение пальца пользователя по экрану. Мы решили обрабатывать регистратор жестов в методе handlePan: вида и реализуем этот метод так:

(void) handlePan:(UIPanGestureRecognizer *)paramPan{

CGPoint tapPoint = [paramPan locationInView: self.view];

[self.attachmentBehavior setAnchorPoint: tapPoint];

self.anchorView.center = tapPoint;

}

Здесь мы обнаруживаем в нашем виде движущуюся точку, а потом перемещаем в нее точку привязки. После того как мы это сделаем, произойдет прикрепление и мы сможем двигать также маленький квадрат.

См. также.

Разделы 2.0 и 10.3.

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

Постановка задачи.

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

Решение.

Инстанцируйте объект типа UISnapBehavior и добавьте его к аниматору типа UIDynamicAnimator.

Обсуждение.

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

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

В данном рецепте мы собираемся создать маленький вид в центре основного вида контроллера, а потом прикрепить регистратор жестов касания (см. раздел 10.5) к виду с контроллером. Всякий раз, когда пользователь прикасается к экрану в какой-то точке, мы будем зацеплять за эту точку маленький квадратный вид. Итак, приступим к определению необходимых свойств вида с контроллером:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIView *squareView;

@property (nonatomic, strong) UIDynamicAnimator *animator;

@property (nonatomic, strong) UISnapBehavior *snapBehavior;

@end

@implementation ViewController

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

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

— (void) createGestureRecognizer{

UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc]

initWithTarget: self

action:@selector(handleTap:)];

[self.view addGestureRecognizer: tap];

}

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

— (void) createSmallSquareView{

self.squareView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 80.0f, 80.0f)];

self.squareView.backgroundColor = [UIColor greenColor];

self.squareView.center = self.view.center;

[self.view addSubview: self.squareView];

}

Переходим к созданию аниматора (см. раздел 2.0), после чего прикрепляем к нему поведение зацепления. Инициализируем поведение зацепления типа UISnapBehavior с помощью метода initWithItem: snapToPoint:. Этот метод принимает два параметра:

• initWithItem — динамический элемент (в данном случае наш вид), к которому должно применяться поведение зацепления. Как и другие динамические поведения пользовательского интерфейса, этот элемент должен соответствовать протоколу UIDynamicItem. Все экземпляры UIView по умолчанию соответствуют этому протоколу, поэтому все нормально;

• snapToPoint — точка опорного вида (см. раздел 2.0), за которую должен зацепляться динамический элемент.

Следует сделать одно важное замечание о таком зацеплении: чтобы оно работало с конкретным элементом, к аниматору уже должен быть добавлен как минимум один экземпляр зацепления для этого элемента — кроме того экземпляра, который удерживает элемент на текущей позиции. После этого все последующие зацепления будут работать правильно. Позвольте это продемонстрировать. Сейчас мы реализуем метод, который будет создавать поведение зацепления и аниматор, а потом добавлять это поведение к аниматору:

— (void) createAnimatorAndBehaviors{

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[self.squareView]];

collision.translatesReferenceBoundsIntoBoundary = YES;

[self.animator addBehavior: collision];

/* Пока зацепляем квадратный вид с его актуальным центром */

self.snapBehavior = [[UISnapBehavior alloc]

initWithItem: self.squareView

snapToPoint: self.squareView.center];

self.snapBehavior.damping = 0.5f; /* Medium oscillation */

[self.animator addBehavior: self.snapBehavior];

}

Как видите, здесь мы зацепляем небольшой квадратный вид, связывая его с текущим центром, — в сущности, просто оставляем его на месте. Позже, когда мы регистрируем на экране жесты касания, мы обновляем поведение зацепления. Кроме того, необходимо отметить, что мы задаем для этого поведения свойство damping. Это свойство будет управлять эластичностью, с которой элемент будет зацеплен за точку. Чем выше значение, тем меньше эластичность, соответственно, тем слабее «колышется» элемент. Здесь можно задать любое значение в диапазоне от 0 до 1. Теперь, когда вид появится на экране, вызовем эти методы, чтобы инстанцировать маленький квадратный вид, установить регистратор жестов касания, а также настроить аниматор и поведение зацепления:

— (void)viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

[self createGestureRecognizer];

[self createSmallSquareView];

[self createAnimatorAndBehaviors];

}

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

Здесь необходимо отметить, что вы не сможете просто обновить существующее поведение — потребуется повторно его инстанцировать. Итак, прежде, чем мы инстанцируем новый экземпляр поведения зацепления, понадобится удалить старый экземпляр (при его наличии), а потом добавить к аниматору новый. У каждого аниматора может быть всего одно поведение зацепления, ассоциированное с конкретным динамическим элементом, в данном случае с маленьким квадратным видом. Если добавить к одному и тому же аниматору несколько поведений зацепления, относящихся к одному и тому же динамическому элементу, то аниматор проигнорирует все эти поведения, так как не будет знать, какое из них выполнять первым. Поэтому, чтобы поведения зацепления работали, сначала удалите все зацепления для этого элемента из вашего аниматора, воспользовавшись его методом removeBehavior:, а потом добавьте новое поведение зацепления следующим образом:

— (void) handleTap:(UITapGestureRecognizer *)paramTap{

/* Получаем угол между центром квадратного вида и точкой касания */

CGPoint tapPoint = [paramTap locationInView: self.view];

if (self.snapBehavior!= nil){

[self.animator removeBehavior: self.snapBehavior];

}

self.snapBehavior = [[UISnapBehavior alloc] initWithItem: self.squareView

snapToPoint: tapPoint];

self.snapBehavior.damping = 0.5f; /* Средняя осцилляция */

[self.animator addBehavior: self.snapBehavior];

}

См. также.

Разделы 2.0 и 10.5.

2.6. Присваивание характеристик динамическим эффектам.

Постановка задачи.

Вероятно, вас устраивает стандартная физика, по умолчанию встроенная в динамические поведения из UIKit. Но при работе с элементами, которыми вы управляете с помощью динамических поведений, может потребоваться присваивать этим элементам и иные характеристики, например массу и эластичность.

Решение.

Инстанцируйте объект типа UIDynamicItemBehavior и присвойте ему ваши динамические элементы. После инстанцирования пользуйтесь различными свойствами этого класса для изменения характеристик динамических элементов. Затем добавьте это поведение к аниматору (см. раздел 2.0) — и все остальное аниматор сделает за вас.

Обсуждение.

Динамические поведения отлично подходят для добавления реалистичной физики к элементам, соответствующим протоколу UIDynamicItem, например ко всем видам типа UIView. Но в некоторых приложениях вам может понадобиться явно указать характеристики конкретного элемента. Например, в приложении, где используются эффекты тяготения и столкновения (см. разделы 2.1 и 2.2), вы, возможно, захотите указать, что один из элементов на экране, подвергающийся действию тяготения и столкновениям, должен отскакивать от границы сильнее, чем другой элемент. В другом случае, возможно, захотите указать, что в ходе воплощения различных визуальных эффектов, применяемых аниматором к элементу, этот элемент вообще не должен вращаться.

Подобные задачи решаются без труда с помощью экземпляров класса UIDynamicItemBehavior. Эти экземпляры также являются динамическими поведениями, и мы можем добавлять их к аниматору с помощью метода экземпляра addBehavior:, относящегося к классу UIDynamicAnimator, — в этой главе мы так уже делали. Когда вы инициализируете экземпляр этого класса, вы вызываете метод-инициализатор initWithItems: и передаете ваш вид либо какой угодно объект, соответствующий протоколу UIDynamicItem. В качестве альтернативы можете инициализировать экземпляр элемента с динамическим поведением с помощью метода init, а потом добавлять к этому поведению разнообразные объекты, пользуясь методом addItem:.

Экземпляры класса UIDynamicItemBehavior обладают настраиваемыми свойствами, которые вы можете корректировать, чтобы модифицировать поведение динамических элементов (например, видов). Далее перечислены и объяснены некоторые наиболее важные свойства этого класса.

• allowsRotation — логическое значение. Если оно равно YES, то, как понятно из названия, это свойство позволяет аниматору вращать динамические элементы в ходе применения к ним визуальных эффектов. В идеале вы должны устанавливать значение этого свойства в YES, если желаете имитировать реалистичную физику, но если по каким-то причинам в приложении необходимо гарантировать, что определенный элемент ни при каких условиях вращаться не будет, задайте для этого свойства значение NO и прикрепите элемент к этому поведению.

• resistance — сопротивление элемента движению. Это свойство может иметь значения в диапазоне от 0 до CGFLOAT_MAX. Чем выше значение, тем сильнее будет сопротивление, оказываемое элементом воздействующим на него силам (тем силам, которые вы к нему прикладываете). Например, если вы добавите к аниматору поведение тяготения и создадите в центре экрана вид с сопротивлением CGFLOAT_MAX, то тяготение не сможет сдвинуть этот вид к центру экрана. Вид просто останется там, где вы его создали.

• friction — это значение с плавающей точкой в диапазоне от 0 до 1. Оно указывает силу трения, которая должна действовать на края данного элемента, когда другие элементы соударяются с ним или проскальзывают по его краю. Чем выше значение, тем больше сила трения, применяемая к элементу.

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

• elasticity — это значение с плавающей точкой в диапазоне от 0 до 1. Оно указывает, насколько эластичным должен быть элемент. Чем выше это значение, тем более пластичным и «желеобразным» будет этот элемент с точки зрения аниматора. О том, что такое эластичность, подробно рассказано в разделе 2.5.

• density — это значение с плавающей точкой в диапазоне от 0 до 1 (по умолчанию применяется значение 1). Оно не используется непосредственно для воздействия на поведение динамических поведений элементов, но с его помощью аниматор рассчитывает массу объектов и то, как эта масса отражается на визуальных эффектах. Например, если вы столкнете один элемент с другим (см. раздел 2.3), но у одного из них будет плотность 1, а у другого — 0,5, то при одинаковых высоте и ширине обоих элементов масса первого элемента будет больше, чем масса второго. Аниматор вычисляет массу элементов, исходя из их плотности и размеров экрана. Поэтому если вы столкнете маленький вид с высокой плотностью с большим видом с очень низкой плотностью, то маленький вид, в зависимости от конкретного размера и плотности этого элемента, может быть воспринят аниматором как более массивный объект, нежели крупный вид. В таком случае, аниматор может сильнее оттолкнуть тот элемент, который на экране кажется более крупным, тогда как толчок, сообщаемый крупным элементом мелкому, получится не столь значительным.

Перейдем к примеру. Он отчасти основан на примере, рассмотренном в разделе 2.2. В примере из этого раздела мы собираемся расположить один вид на другом, но тот вид, который находится снизу, будет очень эластичным, а эластичность вида, расположенного сверху, будет сравнительно невысока. Таким образом, когда оба вида упадут на дно экрана, где столкнутся с нижней границей, нижний вид отскочит от нее значительно сильнее, чем верхний. Итак, начнем с определения аниматора и других свойств контроллера вида:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIDynamicAnimator *animator;

@end

@implementation ViewController

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

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

— (UIView *) newViewWithCenter:(CGPoint)paramCenter

backgroundColor:(UIColor *)paramBackgroundColor{

UIView *newView =

[[UIView alloc] initWithFrame:

CGRectMake(0.0f, 0.0f, 50.0f, 50.0f)];

newView.backgroundColor = paramBackgroundColor;

newView.center = paramCenter;

return newView;

}

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

UIView *topView = [self newViewWithCenter: CGPointMake(100.0f, 0.0f)

backgroundColor: [UIColor greenColor]];

UIView *bottomView = [self newViewWithCenter: CGPointMake(100.0f, 50.0f)

backgroundColor: [UIColor redColor]];

[self.view addSubview: topView];

[self.view addSubview: bottomView];

Далее добавим к видам поведение тяготения — этому мы научились в разделе 2.1:

self.animator = [[UIDynamicAnimator alloc]

initWithReferenceView: self.view];

/* Создаем тяготение */

UIGravityBehavior *gravity = [[UIGravityBehavior alloc]

initWithItems:@[topView, bottomView]];

[self.animator addBehavior: gravity];

Мы не хотим, чтобы виды выпадали за пределы экрана, достигнув его дна. Поэтому воспользуемся знаниями, приобретенными в разделе 2.2, и зададим для аниматора нижнюю границу, а также запрограммируем поведение столкновения:

/* Создаем обнаружение столкновений */

UICollisionBehavior *collision = [[UICollisionBehavior alloc]

initWithItems:@[topView, bottomView]];

collision.translatesReferenceBoundsIntoBoundary = YES;

[self.animator addBehavior: collision];

Наконец, очень важно добавить видам динамическое поведение, чтобы сделать верхний вид менее эластичным, чем нижний:

/* Теперь указываем эластичность элементов */

UIDynamicItemBehavior *moreElasticItem = [[UIDynamicItemBehavior alloc]

initWithItems:@[bottomView]];

moreElasticItem.elasticity = 1.0f;

UIDynamicItemBehavior *lessElasticItem = [[UIDynamicItemBehavior alloc]

initWithItems:@[topView]];

lessElasticItem.elasticity = 0.5f;

[self.animator addBehavior: moreElasticItem];

[self.animator addBehavior: lessElasticItem];

Итак, можете запустить приложение и посмотреть, как виды будут отскакивать от нижней границы экрана, как только ударятся об нее (рис. 2.4).

Обсуждение. 2.6. Присваивание характеристик динамическим эффектам. Глава 2. Создание динамических и интерактивных пользовательских интерфейсов. iOS. Приемы программирования.

Рис. 2.4. Один вид эластичнее другого

См. также.

Раздел 2.0.

ГлаваЗ. Автоматическая компоновка и язык визуального форматирования.

3.0. Введение.

Выравнивание компонентов пользовательского интерфейса всегда было для программиста большой проблемой. В большинстве контроллеров видов в сложных приложениях для iOS содержится множество кода, решающего такие якобы тривиальные задачи, как упорядочение на экране фрейма с графическими элементами, выравнивание компонентов по горизонтали и вертикали и обеспечение того, что компоненты будут нормально выглядеть в различных версиях iOS. Причем проблема не только в этом, ведь многие программисты желают пользоваться одними и теми же контроллерами видов на разных устройствах, например на iPhone и iPad. Из-за этого код дополнительно усложняется. Apple упростила для нас решение таких задач, предоставив возможность автоматической компоновки (Auto Layout). Автоматическая компоновка, давно применявшаяся в OS X, теперь реализована и в iOS. Чуть позже мы подробно поговорим об автоматической компоновке, но для начала я позволю себе краткое введение и расскажу, для чего она нужна.

Допустим, у вас есть кнопка, которая обязательно должна находиться в центре экрана. Отношение между центром кнопки и центром вида, в котором она находится, можно упрощенно описать следующим образом:

• свойство кнопки center.x равно свойству вида center.x;

• свойство кнопки center.y равно свойству вида center.y.

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

object1.property1 = (object2.property2 * multiplier) + constant value

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

button.center.x = (button.superview.center.x * 1) + 0

button.center.y = (button.superview.center.y * 1) + 0

С помощью этой же формулы вы можете делать некоторые по-настоящему отличные вещи при разработке пользовательского интерфейса приложений для iOS — вещи, которые ранее были просто неосуществимы. В iOS SDK вышеупомянутая формула обернута в класс, который называется NSLayoutConstraint. Каждый экземпляр этого класса соответствует ровно одному ограничению. Например, если вы хотите расположить кнопку в центре вида, владеющего этой кнопкой, то требуется центрировать координаты x и y этой кнопки. Таким образом, речь идет о создании двух ограничений. Но далее в этой главе мы познакомимся с языком визуального форматирования (Visual Format Language). Он отлично дополняет язык программирования для iOS и еще сильнее упрощает работу с макетами пользовательского интерфейса.

Ограничения можно создавать с помощью так называемых перекрестных видов. Например, если в одном виде у вас находится две кнопки и вы хотите, чтобы по вертикали между ними было 100 точек свободного пространства, то нужно создать ограничение, благодаря которому выполнялось бы это правило, но добавить его к общему родителю обеих этих кнопок. Скорее всего, это владеющий ими вид. Вот эти правила.

• Если ограничение находится между двумя видами, которые располагаются в общем родительском виде (то есть у обоих этих видов один и тот же вышестоящий родительский вид), добавьте ограничения к родительскому виду.

• Если ограничение находится между видом и его родительским видом, добавьте ограничение к родительскому виду.

• Если ограничение находится между двумя видами, которые не располагаются в общем родительском виде, добавьте это ограничение к общему предку интересующих вас видов.

На рис. 3.1 показано, как именно действуют эти ограничения.

3.0. Введение. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.1. Отношения между ограничениями и видами, к которым эти ограничения должны добавляться

Ограничения создаются с помощью метода класса constraintWithItem: attribute: related By: toItem: attribute: multiplier: constant:, который относится к классу NSLayoutConstraint. Этот метод принимает следующие параметры:

• constraintWithItem — параметр типа id. Он соответствует объекту object1 в формуле, рассмотренной ранее;

• attribute — этот параметр представляет свойство property1 в вышеупомянутой формуле и должен относиться к типу NSLayoutAttribute;

• relatedBy — параметр соответствует знаку равенства в нашей формуле. Значение этого параметра относится к типу NSLayoutRelation и, как вы вскоре убедитесь, может выступать не только в качестве знака равенства, но и в роли знаков «больше» и «меньше». Мы подробно обсудим эти нюансы в данной главе;

• toItem — это параметр типа id. Он соответствует объекту object2 в формуле, рассмотренной ранее;

• attribute — параметр представляет свойство property2 в вышеупомянутой формуле и должен относиться к типу NSLayoutAttribute;

• multiplier — это параметр типа CGFloat, представляющий множитель в нашей формуле;

• constant — параметр также относится к типу CGFloat и представляет константу в формуле.

После создания ограничений вы сможете просто добавить их к соответствующему виду (рис. 3.1), воспользовавшись одним из следующих методов класса UIView:

• addConstraint: — метод позволяет добавить к виду одно ограничение типа NSLayoutConstraint;

• addConstraints: — этот метод позволяет добавить к виду массив ограничений. Ограничения должны относиться к типу NSLayoutConstraint, но в данном случае они будут обернуты в массив типа NSArray.

Автоматическая компоновка позволяет решать разнообразные задачи, в чем вы убедитесь в оставшейся части этой главы. Тем не менее чем подробнее вы будете знакомиться с этой темой, тем очевиднее будет становиться следующий факт: применяя автоматическую компоновку, вы вынуждены создавать все новые ограничения типа NSLayoutConstraint. Из-за этого ваш код будет разрастаться, а поддержка его — постоянно усложняться. Именно поэтому компания Apple разработала язык визуального форматирования, на котором можно описывать ограничения, пользуясь обычными символами ASCII. Например, если у вас есть две кнопки и вы хотите, чтобы по горизонтали эти кнопки всегда отстояли друг от друга на 100 точек, то нужно написать на языке визуального форматирования подобный код:

[button1]-100-[button2]

Ограничения, выражаемые на языке визуального форматирования, создаются с помощью метода класса constraintsWithVisualFormat: options: metrics: views:, относящегося к классу NSLayoutConstraint. Вот краткое описание каждого из параметров этого метода:

• constraintsWithVisualFormat — выражение на языке визуального форматирования, записанное как NSString;

• options — параметр типа NSLayoutFormatOptions. При работе с языком визуального форматирования этому параметру обычно передается значение 0;

• metrics — словарь констант, которые вы используете в выражении на языке визуального форматирования. Пока ради упрощения примеров будем передавать этому параметру значение nil;

• views — это словарь видов, для которых вы написали ограничение в первом параметре данного метода. Чтобы создать такой словарь, просто воспользуйтесь функцией NSDictionaryOfVariableBindings из языка C и передайте этому методу ваши новые объекты. Ключи в этом словаре — это названия видов, которые вы должны использовать в первом параметре метода. Не переживайте, если пока все это кажется странным и даже бессмысленным. Вскоре все будет понятно! Как только вы изучите несколько примеров, сразу получится стройная картина.

Вооружившись базовой информацией, не забивая голову ничем лишним, перейдем к практическим разделам. В качестве зарядки поупражняемся немного с ограничениями. Готовы? Поехали!

3.1. Размещение компонентов пользовательского интерфейса в центре экрана.

Постановка задачи.

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

Решение.

Создайте два ограничения: одно для выравнивания позиции center.x целевого вида по позиции center.x вышестоящего вида, другое — для выравнивания позиции center.y целевого вида по позиции center.y вышестоящего вида.

Обсуждение.

Начнем с создания простой кнопки, которую выровняем по центру экрана. Как было указано в подразделе «Решение» текущего раздела, для этого всего лишь требуется гарантировать, что координаты x и y центра нашей кнопки будут соответствовать координатам x и y центра того вида, в котором находится кнопка. Для этого мы напишем два ограничения и добавим их к виду, включающему нашу кнопку (вышестоящему виду этой кнопки). Вот простой код, позволяющий добиться такого эффекта:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIButton *button;

@end

@implementation ViewController

— (void)viewDidLoad{

[super viewDidLoad];

/* 1) Создаем кнопку */

self.button = [UIButton buttonWithType: UIButtonTypeSystem];

self.button.translatesAutoresizingMaskIntoConstraints = NO;

[self.button setTitle:@"Button" forState: UIControlStateNormal];

[self.view addSubview: self.button];

UIView *superview = self.button.superview;

/* 2) Создаем ограничение для центрирования кнопки по горизонтали */

NSLayoutConstraint *centerXConstraint =

[NSLayoutConstraint constraintWithItem: self.button

attribute: NSLayoutAttributeCenterX

relatedBy: NSLayoutRelationEqual

toItem: superview

attribute: NSLayoutAttributeCenterX

multiplier:1.0f

constant:0.0f];

/* 3) Создаем ограничение для центрирования кнопки по вертикали */

NSLayoutConstraint *centerYConstraint =

[NSLayoutConstraint constraintWithItem: self.button

attribute: NSLayoutAttributeCenterY

relatedBy: NSLayoutRelationEqual

toItem: superview

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f];

/* Добавляем ограничения к вышестоящему виду кнопки */

[superview addConstraints:@[centerXConstraint, centerYConstraint]];

}

@end

Этот контроллер вида пытается сообщить iOS, что он поддерживает все возможные ориентации интерфейса, применимые на этом устройстве. Этот факт подтверждает, что кнопка действительно будет расположена в центре экрана, независимо от типа устройства и его ориентации. Тем не менее, прежде чем этот метод начнет действовать, вы должны убедиться, что активировали все необходимые виды ориентации внутри самого проекта. Для этого перейдите в Xcode к свойствам целевого проекта, откройте вкладку General (Общие), а в ней найдите раздел Device Orientation (Ориентация устройства). Затем активизируйте все возможные виды ориентации (рис. 3.2). Обсуждение. 3.1. Размещение компонентов пользовательского интерфейса в центре экрана. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.2. Активизируем в Xcode все виды ориентации, поддерживаемые для целевого проекта

Теперь, если запустить это приложение на устройстве или эмуляторе, вы увидите на экране обычную кнопку. Сколько бы вы ни вращали устройство, кнопка никуда не сдвигается с центра экрана. Мы смогли достичь этого, не написав ни строки кода для настройки фрейма кнопки, а также без прослушивания каких-либо изменений ориентации и без корректирования положения кнопки. Фактически здесь были применены только возможности автоматической компоновки (рис. 3.3). Этот подход выигрышен по той простой причине, что наш код теперь будет работать на любом устройстве, независимо от его ориентации и разрешения экрана. Напротив, если бы мы программировали фрейм для компонентов пользовательского интерфейса, то пришлось бы создавать отдельные фреймы для каждого целевого устройства во всех интересующих нас ориентациях, поскольку на разных устройствах с iOS могут использоваться экраны с довольно несхожими разрешениями. В частности, приложение, написанное в этом разделе, будет отлично работать и на iPad, и на iPhone, причем кнопка будет находиться в центре экрана независимо от ориентации устройства и разрешения его экрана.

Обсуждение. 3.1. Размещение компонентов пользовательского интерфейса в центре экрана. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.3. Кнопка остается в центре экрана при любой ориентации

См. также.

Разделы 3.0 и 3.2.

3.2. Определение горизонтальных и вертикальных ограничений на языке визуального форматирования.

Постановка задачи.

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

Решение.

В строке форматирования ограничения пользуйтесь указателем ориентации H:, чтобы задать выравнивание по горизонтали, и указателем V: для выравнивания по вертикали.

Обсуждение.

Я не буду утверждать, что язык визуального форматирования прост для понимания, — напротив, он довольно запутан. Поэтому приведу несколько примеров работы с ним, которые, надеюсь, прояснят ситуацию. Во всех этих примерах мы будем изменять горизонтальное выравнивание кнопки на экране.

1. Кнопка должна находиться на расстоянии 100 точек от каждого из краев ее вышестоящего вида:

H:|-100-[_button]-100-|

2. Кнопка должна находиться на расстоянии 100 точек или менее от левого края вышестоящего вида. Кроме того, ее ширина должна быть не меньше 50 точек, а расстояние между кнопкой и правым краем вышестоящего вида должно составлять 100 точек или менее:

H:|-(<=100)-[_button(>=50)]-(<=100)-|

3. Кнопка должна находиться на стандартном расстоянии от левого края вышестоящего вида (стандартные расстояния определяются Apple) и иметь ширину не менее 100, но не более 200 точек:

H:|-[_button(>=100,<=200)]

Как видите, может понадобиться некоторое время, чтобы привыкнуть к правилам форматирования. Но, как только вы усвоите основы этого процесса, он постепенно начнет укладываться у вас в голове. Аналогичные правила применяются и к выравниванию по вертикали, при котором используется указатель ориентации V:, например:

V:[_button]-(>=100)-|

При таком ограничении кнопка «прилипнет» к верхнему краю вышестоящего вида (не забывайте, что это ограничение действует по вертикали, так как начинается с V) и будет находиться на расстоянии не менее 100 точек от его нижнего края.

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

Обсуждение. 3.2. Определение горизонтальных и вертикальных ограничений на языке визуального форматирования. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.4. Интерфейс, который мы хотим получить, опираясь на наши ограничения и пользуясь языком визуального форматирования

Чтобы дизайнерам было проще принимать решения, а сами приложения выглядели более единообразно, Apple регламентирует стандартные расстояния (пробелы), которые следует оставлять между компонентами пользовательского интерфейса. Эти стандарты описаны в документе iOS Human Interface Guidelines.

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

• Поле для адреса электронной почты имеет стандартное расстояние по вертикали до верхней границы вида.

• Поле для подтверждения адреса электронной почты имеет стандартное расстояние по вертикали до поля с адресом электронной почты.

• Кнопка Register (Зарегистрировать) имеет стандартное расстояние по вертикали до поля для подтверждения адреса электронной почты.

• Все компоненты центрированы по горизонтали относительно родительского (вышестоящего) вида.

• Поля для адреса электронной почты и подтверждения этого адреса имеют стандартное расстояние по горизонтали от левого и правого краев вышестоящего вида.

• Ширина кнопки является фиксированной и составляет 128 точек.

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

/* Ограничения для поля с адресом электронной почты */

NSString *const kEmailTextFieldHorizontal = @"H:|-[_textFieldEmail]-|";

NSString *const kEmailTextFieldVertical = @"V:|-[_textFieldEmail]";

/* Ограничения для поля, в котором подтверждается адрес электронной почты */

NSString *const kConfirmEmailHorizontal = @"H:|-[_textFieldConfirmEmail]-|";

NSString *const kConfirmEmailVertical =

@"V:[_textFieldEmail]-[_textFieldConfirmEmail]";

/* Ограничение для регистрационной кнопки */

NSString *const kRegisterVertical =

@"V:[_textFieldConfirmEmail]-[_registerButton]";

Здесь мы видим, что оба текстовых поля сопровождаются применяемыми к ним по горизонтали и вертикали ограничениями, описанными на языке визуального форматирования. Кнопка регистрации, в свою очередь, имеет только ограничение по вертикали, также описанное на языке визуального форматирования. Почему? Оказывается, что на языке визуального форматирования невозможно выразить центрирование компонента пользовательского интерфейса по горизонтали. Для решения этой задачи воспользуемся приемом, изученным в разделе 3.1. Но пусть это вас не смущает — все равно стоит пользоваться языком визуального форматирования и наслаждаться его потенциалом. Да, он несовершенен, но это не повод от него отказываться.

Теперь определим компоненты пользовательского интерфейса как закрытые (приватные) свойства в файле реализации контроллера вида:

@interface ViewController ()

@property (nonatomic, strong) UITextField *textFieldEmail;

@property (nonatomic, strong) UITextField *textFieldConfirmEmail;

@property (nonatomic, strong) UIButton *registerButton;

@end

@implementation ViewController

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

Что дальше? Теперь нужно сконструировать сами компоненты пользовательского интерфейса в файле реализации контроллера вида. Итак, напишем два удобных метода, которые нам в этом помогут. Опять же не забывайте: мы не собираемся здесь задавать фреймы этих компонентов. Позже нам в этом поможет автоматическая компоновка:

— (UITextField *) textFieldWithPlaceholder:(NSString *)paramPlaceholder{

UITextField *result = [[UITextField alloc] init];

result.translatesAutoresizingMaskIntoConstraints = NO;

result.borderStyle = UITextBorderStyleRoundedRect;

result.placeholder = paramPlaceholder;

return result;

}

— (void) constructUIComponents{

self.textFieldEmail =

[self textFieldWithPlaceholder:@"Email"];

self.textFieldConfirmEmail =

[self textFieldWithPlaceholder:@"Confirm Email"];

self.registerButton = [UIButton buttonWithType: UIButtonTypeSystem];

self.registerButton.translatesAutoresizingMaskIntoConstraints = NO;

[self.registerButton setTitle:@"Register" forState: UIControlStateNormal];

}

Метод textFieldWithPlaceholder: просто создает текстовые поля, содержащие заданный подстановочный текст, а метод constructUIComponents, в свою очередь, создает два текстовых поля, пользуясь вышеупомянутым методом и кнопкой. Вы, вероятно, заметили, что мы присвоили свойству translatesAutoresizingMaskIntoConstraints всех наших компонентов пользовательского интерфейса значение NO. Так мы помогаем UIKit не перепутать маски автоматической подгонки размеров с ограничениями автоматической компоновки. Как вы знаете, можно задавать маски автоматической подгонки размеров для компонентов пользовательского интерфейса и контроллеров видов как в коде, так и в конструкторе интерфейсов. Об этом мы говорили в главе 1. Устанавливая здесь значение NO, мы гарантируем, что UIKit ничего не перепутает и не будет автоматически преобразовывать маски автоматической подгонки размера в ограничения автоматической компоновки. Эту функцию необходимо задавать, если вы смешиваете свойства автоматической компоновки компонентов с ограничениями макета. Как правило, следует устанавливать это значение у всех компонентов пользовательского интерфейса в NO всякий раз, когда вы работаете с ограничениями автоматической компоновки. Исключение составляют случаи, в которых вы специально приказываете UIKit преобразовать маски автоматической подгонки размеров в ограничения автоматической компоновки.

Мы создаем компоненты пользовательского интерфейса, но вполне очевидно, что методу viewDidLoad контроллера вида необходимо добавить к виду все три компонента пользовательского интерфейса. Почему бы не написать еще один небольшой метод, который будет заниматься именно этим?

— (void) addUIComponentsToView:(UIView *)paramView{

[paramView addSubview: self.textFieldEmail];

[paramView addSubview: self.textFieldConfirmEmail];

[paramView addSubview: self.registerButton];

}

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

— (NSArray *) emailTextFieldConstraints{

NSMutableArray *result = [[NSMutableArray alloc] init];

NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_textFieldEmail);

[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kEmailTextFieldHorizontal

options:0

metrics: nil

views: viewsDictionary]

];

[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kEmailTextFieldVertical

options:0

metrics: nil

views: viewsDictionary]

];

return [NSArray arrayWithArray: result];

}

— (NSArray *) confirmEmailTextFieldConstraints{

NSMutableArray *result = [[NSMutableArray alloc] init];

NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_textFieldConfirmEmail, _textFieldEmail);

[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kConfirmEmailHorizontal

options:0

metrics: nil

views: viewsDictionary]

];

[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kConfirmEmailVertical

options:0

metrics: nil

views: viewsDictionary]

];

return [NSArray arrayWithArray: result];

}

— (NSArray *) registerButtonConstraints{

NSMutableArray *result = [[NSMutableArray alloc] init];

NSDictionary *viewsDictionary =

NSDictionaryOfVariableBindings(_registerButton, _textFieldConfirmEmail);

[result addObject:

[NSLayoutConstraint constraintWithItem: self.registerButton

attribute: NSLayoutAttributeCenterX

relatedBy: NSLayoutRelationEqual

toItem: self.view

attribute: NSLayoutAttributeCenterX

multiplier:1.0f

constant:0.0f]

];

[result addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kRegisterVertical

options:0

metrics: nil

views: viewsDictionary]

];

return [NSArray arrayWithArray: result];

}

— (NSArray *)constraints{

NSMutableArray *result = [[NSMutableArray alloc] init];

[result addObjectsFromArray: [self emailTextFieldConstraints]];

[result addObjectsFromArray: [self confirmEmailTextFieldConstraints]];

[result addObjectsFromArray: [self registerButtonConstraints]];

return [NSArray arrayWithArray: result];

}

Фактически здесь мы имеем метод экземпляра constraints, относящийся к контроллеру вида; этот метод собирает ограничения от всех трех компонентов пользовательского интерфейса, а потом возвращает их все как один большой массив. Теперь переходим к основной части контроллера — методу viewDidLoad:

— (void)viewDidLoad{

[super viewDidLoad];

[self constructUIComponents];

[self addUIComponentsToView: self.view];

[self.view addConstraints: [self constraints]];

}

Этот метод просто собирает пользовательский интерфейс, добавляя сам к себе все компоненты пользовательского интерфейса и связанные с ними ограничения. При этом он использует методы, написанные нами ранее. Отлично, но что мы увидим на экране, когда запустим эту программу? Мы уже видели, как этот интерфейс выглядит на устройстве, работающем в книжной ориентации (см. рис. 3.4). А теперь повернем устройство и посмотрим, что получится при альбомной ориентации (рис. 3.5).

Обсуждение. 3.2. Определение горизонтальных и вертикальных ограничений на языке визуального форматирования. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.5. Ограничения функционируют в альбомном режиме не хуже, чем в книжном

См. также.

Разделы 3.0 и 3.1.

3.3. Применение ограничений при работе с перекрестными видами.

Постановка задачи.

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

Решение.

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

Обсуждение.

Прежде чем углубляться в детали, разберемся, в чем же заключаются ограничения перекрестных видов. Мне кажется, что суть проблемы удобнее изобразить на картинке, а не описывать словами, — предлагаю вашему вниманию рис. 3.6.

Обсуждение. 3.3. Применение ограничений при работе с перекрестными видами. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.6. Важные ограничения, налагаемые перекрестными видами на две кнопки

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

• Есть основной вид с контроллером, в этом виде расположены еще два серых вида. Оба они должны отстоять от левой и правой границ вида с контроллером на стандартные расстояния. В частности, должно сохраняться стандартное расстояние между верхним серым видом и верхней границей вышестоящего вида. Между двумя серыми видами по вертикали также должно сохраняться стандартное пространство.

• Нужна кнопка, которая будет вертикально центрирована относительно обоих серых видов.

• Кнопка, расположенная в верхнем сером виде, слева должна быть удалена от края своего вышестоящего вида на стандартное расстояние.

• Левая сторона кнопки, находящейся в нижнем сером виде, должна быть выровнена по правой стороне той кнопки, что находится в верхнем сером виде. Это и есть ограничение для перекрестных видов, которое интересует нас в данном разделе.

• Серые виды должны автоматически изменять размер по мере того, как меняется ориентация вида с контроллером.

• Высота обоих серых видов должна составлять по 100 точек.

Итак, начнем. Чтобы выполнить все перечисленные задачи, вначале обратимся к методу viewDidLoad контроллера вида. Всегда стоит продумывать максимально чистый способ объединения методов. Конечно, в данном примере мы оперируем довольно большим количеством ограничений и видов. Как же нам не захламлять метод viewDidLoad контроллера вида? Вот так:

— (void)viewDidLoad{

[super viewDidLoad];

[self createGrayViews];

[self createButtons];

[self applyConstraintsToTopGrayView];

[self applyConstraintsToButtonOnTopGrayView];

[self applyConstraintsToBottomGrayView];

[self applyConstraintsToButtonOnBottomGrayView];

}

Мы просто распределили стоящие перед нами задачи по разным методам, которые вскоре реализуем. Продолжим — определим виды в файле реализации контроллера вида как расширение интерфейса:

#import «ViewController.h»

@interface ViewController ()

@property (nonatomic, strong) UIView *topGrayView;

@property (nonatomic, strong) UIButton *topButton;

@property (nonatomic, strong) UIView *bottomGrayView;

@property (nonatomic, strong) UIButton *bottomButton;

@end

@implementation ViewController

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

Далее следует реализовать метод createGrayViews. Как понятно из названия, этот метод отвечает за создание серых видов:

— (UIView *) newGrayView{

UIView *result = [[UIView alloc] init];

result.backgroundColor = [UIColor lightGrayColor];

result.translatesAutoresizingMaskIntoConstraints = NO;

[self.view addSubview: result];

return result;

}

— (void) createGrayViews{

self.topGrayView = [self newGrayView];

self.bottomGrayView = [self newGrayView];

}

Пока несложно? Оба серых вида добавляются к контроллеру нашего вида. Отлично. Что дальше? Теперь нужно реализовать метод createButtons, поскольку он вызывается в методе viewDidLoad контроллера вида. Этот метод должен просто создать кнопки и поместить каждую в ассоциированном с ней сером виде:

— (UIButton *) newButtonPlacedOnView:(UIView *)paramView{

UIButton *result = [UIButton buttonWithType: UIButtonTypeSystem];

result.translatesAutoresizingMaskIntoConstraints = NO;

[result setTitle:@"Button" forState: UIControlStateNormal];

[paramView addSubview: result];

return result;

}

— (void) createButtons{

self.topButton = [self newButtonPlacedOnView: self.topGrayView];

self.bottomButton = [self newButtonPlacedOnView: self.bottomGrayView];

}

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

• верхний вид должен находиться на стандартном расстоянии от вида с контроллером по левому и верхнему краю;

• высота этого серого вида должна составлять 100 точек.

— (void) applyConstraintsToTopGrayView{

NSDictionary *views =

NSDictionaryOfVariableBindings(_topGrayView);

NSMutableArray *constraints = [[NSMutableArray alloc] init];

NSString *const kHConstraint = @"H:|-[_topGrayView]-|";

NSString *const kVConstraint = @"V:|-[_topGrayView(==100)]";

/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];

/* Вертикальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kVConstraint

options:0

metrics: nil

views: views]

];

[self.topGrayView.superview addConstraints: constraints];

}

Здесь следует остановиться на том, как создается вертикальное ограничение верхнего серого вида. Как видите, мы задаем высоту верхнего вида равной 100 точкам и записываем эту информацию в формате (==100). Среда времени исполнения интерпретирует это значение именно как высоту, поскольку здесь есть указатель V:. Он сообщает среде времени исполнения о следующем: те числа, которые мы сообщаем системе, как-то связаны с высотой и вертикальным выравниванием целевого вида, а не с его шириной и горизонтальным выравниванием.

Далее займемся установкой ограничений для кнопки, находящейся в верхнем сером виде. Это делается с помощью метода applyConstraintsToButtonOnTopGrayView. Кнопка должна будет соответствовать перечисленным далее ограничениям:

• она должна быть вертикально центрирована в верхнем сером виде;

• она должна быть удалена на стандартное расстояние от левого и верхнего края этого серого вида.

У нее не должно быть жестко заданных высоты и ширины; эти значения будут зависеть от содержимого кнопки, в данном случае — от текста Button, который мы решили на ней написать:

— (void) applyConstraintsToButtonOnTopGrayView{

NSDictionary *views = NSDictionaryOfVariableBindings(_topButton);

NSMutableArray *constraints = [[NSMutableArray alloc] init];

NSString *const kHConstraint = @"H:|-[_topButton]";

/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];

/* Вертикальные ограничения */

[constraints addObject:

[NSLayoutConstraint constraintWithItem: self.topButton

attribute: NSLayoutAttributeCenterY

relatedBy: NSLayoutRelationEqual

toItem: self.topGrayView

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f]

];

[self.topButton.superview addConstraints: constraints];

}

Итак, работа с верхним серым видом и находящейся в нем кнопкой завершена. Переходим к нижнему серому виду и его кнопке. Сейчас начнем работать с методом ConstraintsToBottomGrayView. Он будет задавать ограничения для нижнего серого вида. Просто напомню, что для этого вида нам требуется создать следующие ограничения:

• вид удален на стандартное расстояние от верхнего и левого края вышестоящего вида с контроллером;

• вид удален на стандартное расстояние от нижней границы верхнего серого вида;

• высота нижнего серого вида составляет 100 точек.

— (void) applyConstraintsToBottomGrayView{

NSDictionary *views =

NSDictionaryOfVariableBindings(_topGrayView,

_bottomGrayView);

NSMutableArray *constraints = [[NSMutableArray alloc] init];

NSString *const kHConstraint = @"H:|-[_bottomGrayView]-|";

NSString *const kVConstraint =

@"V:|-[_topGrayView]-[_bottomGrayView(==100)]";

/* Горизонтальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];

/* Вертикальные ограничения */

[constraints addObjectsFromArray:

[NSLayoutConstraint constraintsWithVisualFormat: kVConstraint

options:0

metrics: nil

views: views]

];

[self.bottomGrayView.superview addConstraints: constraints];

}

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

Следующий и, пожалуй, последний компонент пользовательского интерфейса, для которого мы собираемся написать ограничения, — это кнопка, расположенная в нижнем сером виде. Метод, который будет заниматься ее ограничениями, называется applyConstraintsToButtonOnBottomGrayView. Перед тем как его реализовать, обсудим требования, которым должны соответствовать ограничения для нижней кнопки:

• кнопка должна быть вертикально центрирована в нижнем сером виде;

• ее левый край должен быть выровнен по правому краю кнопки, находящейся в верхнем сером виде;

• с ней не должны применяться строго определенные значения высоты и ширины; ее высота и ширина должны зависеть от содержимого — в данном случае от текста Button, который мы на ней записываем.

— (void) applyConstraintsToButtonOnBottomGrayView{

NSDictionary *views = NSDictionaryOfVariableBindings(_topButton,

_bottomButton);

NSString *const kHConstraint = @"H:[_topButton][_bottomButton]";

/* Горизонтальные ограничения */

[self.bottomGrayView.superview addConstraints:

[NSLayoutConstraint constraintsWithVisualFormat: kHConstraint

options:0

metrics: nil

views: views]

];

/* Вертикальные ограничения */

[self.bottomButton.superview addConstraint:

[NSLayoutConstraint constraintWithItem: self.bottomButton

attribute: NSLayoutAttributeCenterY

relatedBy: NSLayoutRelationEqual

toItem: self.bottomGrayView

attribute: NSLayoutAttributeCenterY

multiplier:1.0f

constant:0.0f]

];

}

Наконец, мы должны удостовериться в том, что контроллер вида сообщает среде времени исполнения, что он может обрабатывать любые варианты ориентации. Ведь именно этот аспект наиболее сильно интересовал нас в данном разделе. Поэтому мы переопределим метод supportedInterfaceOrientations в виде UIViewController:

— (NSUInteger) supportedInterfaceOrientations{

return UIInterfaceOrientationMaskAll;

}

Итак, работа с этим контроллером вида завершена. Запустим приложение и посмотрим, как оно работает при книжной ориентации (рис. 3.7).

Обсуждение. 3.3. Применение ограничений при работе с перекрестными видами. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.7. Приложение отображает компоненты пользовательского интерфейса в книжной ориентации согласно требованиям, которые мы предъявили

А теперь момент истины! Будет ли оно работать в альбомном режиме? Попробуем (рис. 3.8).

Обсуждение. 3.3. Применение ограничений при работе с перекрестными видами. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.8. Как и ожидалось, тот же самый код отлично работает и при альбомной ориентации экрана

Отлично! Все получилось.

См. также.

Раздел 3.0.

3.4. Конфигурирование ограничений автоматической компоновки в конструкторе интерфейсов.

Постановка задачи.

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

Решение.

Выполните следующие шаги.

1. Откройте в конструкторе интерфейсов файл XIB или файл раскадровки, который вы собираетесь редактировать.

2. Убедитесь, что в конструкторе интерфейсов вы выбрали объект вида, в котором собираетесь активизировать автоматическую компоновку. Просто щелкните на этом объекте.

3. Щелкните на элементе меню View — Utilities — Show File Inspector (Вид — Утилиты — Показать инспектор файлов).

4. Убедитесь, что в элементе File Inspector (Инспектор файлов) в разделе Interface Builder Document (Документ конструктора интерфейсов) установлен флажок Use Autolayout (Использовать автоматическую компоновку) (рис. 3.9).

Решение. 3.4. Конфигурирование ограничений автоматической компоновки в конструкторе интерфейсов. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.9. Активизируем автоматическую компоновку в конструкторе интерфейсов

Обсуждение.

Конструктор интерфейсов значительно упрощает для программиста создание ограничений, причем наше участие в этом сводится к минимуму. До того как в iOS появилась возможность автоматической компоновки, приходилось, как правило, пользоваться специальными ориентировочными панелями (guideline bars). Эти панели появлялись на экране, пока вы перемещали компоненты пользовательского интерфейса. Ориентировочные панели были связаны с масками для автоматической подгонки размеров, которые вы могли создавать и в коде, точно так же, как ограничения. Но после того, как в конструкторе интерфейсов будет установлен флажок Use Autolayout (Использовать автоматическую компоновку), ориентировочные панели приобретут несколько иное значение. Теперь они сообщают о тех ограничениях, которые создает для вас в фоновом режиме сам конструктор интерфейсов.

Немного поэкспериментируем. Создадим в Xcode приложение с одним видом (Single View Application). Таким образом, будет создано приложение, содержащее всего один контроллер вида. Этот контроллер вида будет относиться к классу ViewController, а. xib-файл для него будет называться ViewController.xib. Просто щелкните на этом файле, чтобы конструктор интерфейсов открыл его. Убедитесь, что в инспекторе файлов установлен флажок Use Autolayout (Использовать автоматическую компоновку) так, как описано в подразделе «Решение» этого раздела.

Теперь просто найдите в библиотеке объектов кнопку (Button) и перетащите ее в центр экрана. Дождитесь, пока в конструкторе интерфейсов появятся ориентировочные панели, по которым будет понятно, что центр кнопки соответствует центру экрана. В меню Edit (Правка) установите флажок Show Document Outline (Показать структуру документа). Если у вас в конструкторе интерфейсов уже открыт раздел Document Outline (Структура документа), то вместо Show Document Outline (Показать структуру документа) на этом месте будет отображаться надпись Hide Document Outline (Скрыть структуру документа) — в таком случае ничего делать не надо. Теперь найдите в разделе Document Outline (Структура документа) новый подраздел, отмеченный голубым цветом. Он был создан специально для вас и называется Constraints (Ограничения). Раскройте ограничения, созданные конструктором интерфейсов для этой кнопки. То, что вы теперь увидите, должно напоминать рис. 3.10.

Обсуждение. 3.4. Конфигурирование ограничений автоматической компоновки в конструкторе интерфейсов. ГлаваЗ. Автоматическая компоновка и язык визуального форматирования. iOS. Приемы программирования.

Рис. 3.10. Конструктор интерфейсов создал ограничения компоновки

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

См. также.

Раздел 3.0.

Глава 4. Создание и использование табличных видов.

4.0. Введение.

Табличный вид — это обычный вид с прокручиваемым контентом, который разделен на секции. Каждая такая секция, в свою очередь, подразделяется на строки. Каждая строка (Row) является экземпляром класса UITableViewCell. Вы можете создавать собственные варианты строк в табличном виде, делая подклассы этого класса.

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

Табличный вид можно наполнить данными, используя источник данных табличного вида. Вы можете получать различные события и управлять оформлением табличных видов с помощью объекта-делегата табличного вида. Источник данных для табличного вида определяется в протоколе UITableViewDataSource, а делегат табличного вида — в протоколе UITableViewDelegate.

Хотя экземпляр UITableView является подклассом от UIScrollView, табличные виды можно прокручивать только по вертикали. Это скорее благо, чем ограничение. В данной главе мы обсудим различные способы создания табличных видов, их настройки и управления ими.

Табличные виды можно использовать двумя способами:

• с помощью класса UITableViewController. Этот класс напоминает UIViewController (см. раздел 1.9) в том, что фактически это контроллер вида, но в нем отображается не обычный вид, а таблица. Красота этого класса заключается в том, что каждый его экземпляр уже соответствует протоколам UITableViewDelegate и UITableViewDataSource. Итак, по умолчанию контроллер табличного вида становится источником данных и одновременно делегатом того табличного вида, которым он управляет. Таким образом, чтобы реализовать, например, источник данных для табличного вида, вам всего лишь потребуется реализовать контроллер для табличного вида, а не устанавливать вручную контроллер вида в качестве источника данных для табличного вида;

• вручную инстанцировав класс UITableView.

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

Рассмотрим пример создания табличного вида в приложении. Примеры контроллеров табличных видов будут подробно изучены в разделе 4.9, а пока мы просто займемся созданием таких видов в коде и будем добавлять их к имеющемуся контроллеру вида.

Класс UITableView инстанцируется с помощью метода initWithFrame: style:. Далее перечислены параметры, которые мы должны передать этому методу, а также значения этих параметров.

initWithFrame — это параметр типа CGRect. Он указывает, как именно должен быть расположен табличный вид в вышестоящем виде. Если вы хотите, чтобы таблица просто полностью накрывала вышестоящий вид, передайте этому параметру значение свойства bounds вида с контроллером.

style — это параметр типа UITableViewStyle, определяемый следующим образом:

typedef NS_ENUM(NSInteger, UITableViewStyle) {

UITableViewStylePlain,

UITableViewStyleGrouped

};

На рис. 4.1 показана разница между обычным и сгруппированным табличными видами.

4.0. Введение. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.1. Табличные виды различных типов

Мы заполняем табличный вид информацией, используя его источник данных, как будет показано в разделе 4.1. Табличные виды также обладают делегатами. Делегаты получают различные события от табличного вида. Объекты делегатов должны соответствовать протоколу UITableViewDelegate. Далее перечислены отдельные методы этого протокола, которые необходимо знать.

• tableView: viewForHeaderInSection: — вызывается в делегате, когда табличному виду требуется отобразить заголовочный вид раздела. Каждый раздел табличного вида может содержать верхний колонтитул, некоторое количество ячеек и нижний колонтитул. В этой главе мы подробно обсудим все эти участки таблицы. Верхний и нижний колонтитул — это обычные экземпляры UIView. Данный метод является необязательным, но если вы хотите сконфигурировать заголовок для разделов вашего табличного вида, то пользуйтесь этим методом, чтобы создать экземпляр вида и передать его обратно в качестве возвращаемого значения. О верхних и нижних колонтитулах табличных видов подробнее рассказано в разделе 4.5.

• tableView: viewForFooterInSection: — делегатный метод, аналогичный tableView: viewForHeaderInSection:, но он возвращает вид с нижним колонтитулом таблицы. Как и заголовок, нижний колонтитул таблицы не является обязательным, но если он вам нужен, то его следует создавать здесь. Подробнее о верхних и нижних колонтитулах табличных видов рассказано в разделе 4.5.

• tableView: didEndDisplayingCell: forRowAtIndexPath: — вызывается в объекте-делегате, когда в ходе прокрутки таблицы ячейка уходит с экрана. Этот метод действительно очень удобен для вызова в делегате, так как вы можете удалять объекты и выбрасывать их из памяти, если эти объекты ассоциированы с ячейкой, которая ушла с экрана, а вы полагаете, что связанные с ней объекты вам больше не понадобятся.

• tableView: willDisplayCell: forRowAtIndexPath: — этот метод вызывается в делегате табличного вида всякий раз, когда ячейка вот-вот отобразится на экране.

Чтобы задать делегат для табличного вида, просто укажите в качестве значения свойства delegate экземпляра UITableView такой объект, который соответствует протоколу UITableViewDelegate. Если табличный вид является частью контроллера вида, то можно просто сделать этот контроллер делегатом вашего табличного вида, вот так:

#import «ViewController.h»

@interface ViewController () <UITableViewDelegate>

@property (nonatomic, strong) UITableView *myTableView;

@end

@implementation ViewController

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];

self.myTableView.delegate = self;

[self.view addSubview: self.myTableView];

}

@end

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

Объект-делегат обязан отвечать на сообщения, помеченные протоколом UITableViewDelegate как @required. Отвечать на другие сообщения не обязательно, но делегат должен отвечать на все сообщения, которые, по вашему замыслу, будут изменять табличный вид.

Сообщения, отправляемые объекту-делегату табличного вида, несут с собой параметр, который сообщает делегату, какой именно табличный вид инициировал данное событие в своем делегате. Это очень важно отметить, так как в определенных обстоятельствах вы можете разместить в одном объекте (как правило, в виде) более одной таблицы. Поэтому настоятельно рекомендую принимать соответствующие решения с учетом того, какой именно табличный вид послал конкретное сообщение объекту-делегату:

— (CGFloat) tableView:(UITableView *)tableView

heightForRowAtIndexPath:(NSIndexPath *)indexPath{

if ([tableView isEqual: self.myTableView]){

return 100.0f;

}

return 40.0f;

}

}

Расположение ячейки в табличном виде представляется индексным путем этой ячейки. Индексный путь — это комбинация данных о разделе и индекса строки. В данном случае индекс раздела имеет нулевую базу и указывает, к каким группе или разделу относится каждая ячейка. Индекс ячейки также имеет нулевую базу и означает положение данной ячейки в ее разделе.

4.1. Наполнение табличного вида данными.

Постановка задачи.

Требуется наполнить табличный вид данными.

Решение.

Необходимо создать объект, соответствующий протоколу UITableViewDataSource, и присвоить этот объект экземпляру табличного вида. Затем, отвечая на сообщения источника данных, предоставьте информацию для вашего вида. Продолжим данный пример и объявим. h-файл контроллера нашего вида. Позже в коде для этого вида будет создана таблица:

#import «ViewController.h»

static NSString *TableViewCellIdentifier = @"MyCells";

@interface ViewController () <UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@end

Экземпляр TableViewCellIdentifier содержит идентификаторы ячеек в виде статической строковой переменной. Как вы вскоре узнаете, каждая ячейка может иметь идентификатор, и это очень помогает при повторном использовании ячеек. Пока считайте эту переменную просто уникальным идентификатором всех ячеек табличного вида — на данном этапе этого достаточно.

В методе viewDidLoad контроллера вида создадим табличный вид и присвоим ему контроллер вида в качестве источника данных:

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStylePlain];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: TableViewCellIdentifier];

self.myTableView.dataSource = self;

/* Убеждаемся, что табличный вид правильно масштабируется. */

self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

[self.view addSubview: self.myTableView];

}

В этом фрагменте кода все элементарно, кроме метода registerClass: forCellReuseIdentifier:, который мы вызываем в экземпляре табличного вида. Что же делает этот метод? Параметр registerClass этого метода просто принимает имя класса, соответствующее типу объекта, который вы хотите загружать в табличном виде при отображении каждой ячейки. Все ячейки внутри табличного вида должны быть прямыми или непрямыми потомками класса UITableViewCell. Сам этот класс предоставляет программистам довольно широкий функционал. Но при желании этот класс можно и расширить — достаточно произвести от него подкласс, добавив к новому классу требуемый функционал. Итак, возвращаемся к параметру registerClass вышеупомянутого метода. Вам потребуется сообщить имя класса ячеек этому параметру, а потом передать идентификатор параметру forCellReuseIdentifier. Вот по какой причине мы ассоциируем классы табличного вида с идентификаторами: когда позже вы заполняете табличный вид данными, можете просто передать тот же самый идентификатор методу dequeueReusableCellWithIdentifier: forIndexPath: табличного вида, после чего приказать табличному виду инстанцировать ячейку таблицы, если в наличии нет ячеек, доступных для повторного использования. Все это просто отлично, так как в предыдущих версиях iOS SDK программистам приходилось инстанцировать эти ячейки самостоятельно, если из табличного вида не удавалось добыть уже готовый код, пригодный для повторного использования.

Теперь необходимо убедиться в том, что наш табличный вид реагирует на методы протокола UITableViewDataSource, помеченные как @required (обязательные). Нажмите на клавиатуре комбинацию клавиш Command+Shift+O, введите в диалоговое окно имя этого протокола, затем нажмите клавишу Enter. В результате вы увидите обязательные методы данного протокола.

Класс UITableView определяет свойство под названием dataSource. Это нетипизированный объект, который должен подчиняться протоколу UITableViewDataSource. Всякий раз, когда табличный вид обновляется и перезагружается с помощью метода reloadData, табличный вид будет вызывать в своем источнике данных различные методы, чтобы получить информацию о тех данных, которыми вы хотите заполнить таблицу. Источник данных табличного вида может реализовывать три важных метода, два из которых являются обязательными для любого источника данных:

• numberOfSectionsInTableView: — позволяет источнику данных информировать табличный вид о количестве разделов, которые должны быть загружены в таблицу;

• tableView: numberOfRowsInSection: — сообщает контроллеру вида, сколько ячеек или строк следует загрузить в каждый раздел. Номер раздела передается источнику данных в параметре numberOfRowsInSection. Реализация этого метода является обязательной для объекта источника данных;

• tableView: cellForRowAtIndexPath: — отвечает за возвращение экземпляров класса UITableViewCell как строк таблицы, которыми должен заполняться табличный вид. Реализация этого метода обязательна для объекта источника данных.

Итак, продолжим и реализуем эти методы в контроллере вида один за другим. Сначала сообщим табличному виду, что мы хотим отобразить три раздела:

— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{

if ([tableView isEqual: self.myTableView]){

return 3;

}

return 0;

}

Далее сообщим табличному виду, сколько строк хотим в нем отобразить для каждого раздела:

— (NSInteger)tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

if ([tableView isEqual: self.myTableView]){

switch (section){

case 0:{

return 3;

break;

}

case 1:{

return 5;

break;

}

case 2:{

return 8;

break;

}

}

}

return 0;

}

Итак, на данный момент мы приказали табличному виду отобразить три раздела. В первом разделе три строки, во втором — пять, в третьем — восемь. Что дальше? Нужно вернуть табличному виду экземпляры UITableViewCell — тех ячеек, которые мы хотим отобразить в таблице:

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *result = nil;

if ([tableView isEqual: self.myTableView]){

cell = [tableView

dequeueReusableCellWithIdentifier: TableViewCellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = [NSString stringWithFormat:

@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];

}

return cell;

}

Теперь, если запустить приложение в эмуляторе iPhone, мы увидим результат работы (рис. 4.2).

Решение. 4.1. Наполнение табличного вида данными. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.2. Обычный табличный вид с тремя разделами

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

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

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

4.2. Использование дополнительных элементов в ячейке табличного вида.

Постановка задачи.

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

Решение.

Используйте свойство accessoryType класса UITableViewCell. Экземпляры этого класса вы предоставляете табличному виду в объекте его источника данных:

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell* result = nil;

if ([tableView isEqual: self.myTableView]){

result = [tableView

dequeueReusableCellWithIdentifier: MyCellIdentifier

forIndexPath: indexPath];

result.textLabel.text =

[NSString stringWithFormat:@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];

result.accessoryType = UITableViewCellAccessoryDetailDisclosureButton;

}

return result;

}

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 10;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: MyCellIdentifier];

self.myTableView.dataSource = self;

self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

[self.view addSubview: self.myTableView];

}

Обсуждение.

Можно присваивать любые значения, определенные в перечне UITableViewCellAccessoryType, свойству accessoryType экземпляра класса UITableViewCell. Среди полезных дополнительных элементов следует особо отметить индикатор подробного описания и кнопку детализации[1]. Оба этих элемента содержат угловую скобку, подсказывающую пользователю, что если прикоснуться пальцем к соответствующей ячейке таблицы, то откроется новый вид или контроллер вида. Проще говоря, пользователь перейдет на новый экран с более подробной информацией об актуальном селекторе. Разница между двумя этими элементами заключается с том, что индикатор подробного описания не инициирует никакого события, а вот кнопка детализации при нажатии запускает событие, направляемое к делегату. Иными словами, эффект от нажатия кнопки не равен эффекту от нажатия самой ячейки. Следовательно, кнопка детализации позволяет пользователю осуществлять два разных, но связанных действия применительно к одной и той же строке.

На рис. 4.3 показаны два этих дополнительных элемента в табличном виде. В первой строке мы видим индикатор подробного описания, а во второй — кнопку детализации.

Обсуждение. 4.2. Использование дополнительных элементов в ячейке табличного вида. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.3. Две ячейки табличного вида с различными дополнительными элементами

Если прикоснуться к любой кнопке детализации, присвоенной ячейке табличного вида, то сразу становится очевидно, что это, в сущности, самостоятельная кнопка. А теперь внимание — вопрос! Как табличный вид узнает, что пользователь нажал такую кнопку?

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

— (void) tableView:(UITableView *)tableView

accessoryButtonTappedForRowWithIndexPath:(NSIndexPath *)indexPath{

/* Делаем что-либо при нажатии дополнительной кнопки. */

NSLog(@"Accessory button is tapped for cell at index path = %@",

indexPath);

UITableViewCell *ownerCell = [tableView cellForRowAtIndexPath: indexPath];

NSLog(@"Cell Title = %@", ownerCell.textLabel.text);

}

Данный код ищет ячейку табличного вида, в которой была нажата кнопка детализации, и выводит в окне консоли содержимое текстовой метки данной ячейки. Напоминаю: чтобы отобразить окно консоли в Xcode, нужно выполнить команду Run\Console (Запуск\Консоль).

4.3. Создание специальных дополнительных элементов в ячейке табличного вида.

Постановка задачи.

Дополнительных элементов, предоставляемых в iOS, недостаточно для решения задачи, и вы хотели бы создать собственные дополнительные элементы.

Решение.

Присвойте экземпляр класса UIView свойству accessoryView любого экземпляра класса UITableViewCell:

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell* cell = nil;

cell = [tableView dequeueReusableCellWithIdentifier: MyCellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = [NSString stringWithFormat:@"Section %ld, Cell %ld",

(long)indexPath.section,

(long)indexPath.row];

UIButton *button = [UIButton buttonWithType: UIButtonTypeSystem];

button.frame = CGRectMake(0.0f, 0.0f, 150.0f, 25.0f);

[button setTitle:@"Expand"

forState: UIControlStateNormal];

[button addTarget: self

action:@selector(performExpand:)

forControlEvents: UIControlEventTouchUpInside];

cell.accessoryView = button;

return cell;

}

Как видите, в этом коде используется метод performExpand:. Он играет роль селектора для каждой кнопки. Вот определение данного метода:

— (void) performExpand:(id)paramSender{

/* Обрабатываем событие нажатия кнопки */

}

В данном примере кода специальная создаваемая нами кнопка присваивается дополнительному виду в каждой строке выбранной таблицы. Результат показан на рис. 4.4.

Решение. 4.3. Создание специальных дополнительных элементов в ячейке табличного вида. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.4. Ячейки табличного вида со специальными дополнительными видами

Обсуждение.

Объект типа UITableViewCell содержит свойство accessoryView. Это тот вид, которому вы можете присвоить значение, если вас не вполне устраивают встроенные в SDK iOS дополнительные виды для табличных ячеек. После того как задано это свойство, Cocoa Touch будет игнорировать значение свойства accessoryType и станет использовать вид, присвоенный свойству accessoryView, в качестве дополнительного элемента, который отображается в ячейке таблицы.

В коде, приведенном в подразделе «Решение» данного раздела, мы создаем кнопки для всех ячеек, находящихся в табличном виде. При нажатии кнопки в любой ячейке вызывается метод performExpand:. И если вы думаете примерно так же, как я, то вы уже стали задаваться вопросом: как же определить, к какой именно ячейке относится кнопка-отправитель? Итак, теперь нам нужно как-то связать кнопки с теми ячейками, к которым они относятся.

Один из способов разрешения этой ситуации связан с использованием свойства tag экземпляра кнопки. Это свойство-метка представляет собой обычное целое число, которое, как правило, используется для ассоциирования вида с другим объектом. Например, если вы хотите ассоциировать кнопку с третьей ячейкой в вашем табличном виде, то следует задать для свойства-метки этой кнопки значение 3. Но здесь возникает проблема: в табличных видах есть разделы, и каждый раздел может содержать n ячеек. Следовательно, нам требуется возможность определить и раздел таблицы, и ячейку, которая владеет нашей кнопкой. А поскольку значением свойства-метки может быть только одно целое число, эта задача существенно усложняется. Поэтому мы можем отказаться от метки и вместо работы с ней запрашивать вышестоящий вид о дополнительном виде, рекурсивно проходя вверх по цепочке видов, пока не найдем ячейку типа UITableViewCell, вот так:

— (UIView *) superviewOfType:(Class)paramSuperviewClass

forView:(UIView *)paramView{

if (paramView.superview!= nil){

if ([paramView.superview isKindOfClass: paramSuperviewClass]){

return paramView.superview;

} else {

return [self superviewOfType: paramSuperviewClass

forView: paramView.superview];

}

}

return nil;

}

— (void) performExpand:(UIButton *)paramSender{

/* Обрабатываем событие нажатия кнопки */

__unused UITableViewCell *parentCell =

(UITableViewCell *)[self superviewOfType: [UITableViewCell class]

forView: paramSender];

/* Теперь, если желаете, можете еще что-нибудь сделать с ячейкой */

}

Здесь мы используем простой рекурсивный метод, принимающий вид (в данном случае нашу кнопку) и имя класса (в данном случае UITableViewCell), а затем просматриваем иерархию вида, являющегося вышестоящим для данного, чтобы найти вышестоящий вид, относящийся к интересующему нас классу. Итак, он начинает работу с вида, являющегося вышестоящим для заданного, и если этот вышестоящий вид не относится к требуемому типу, то просматривает и его вышестоящий вид, и так до тех пор, пока не найдет один из вышестоящих видов, относящийся к требуемому классу. Как видите, в качестве первого параметра метода superviewOfType: forView: мы используем структуру Class. В этом типе данных может содержаться имя любого класса из языка Objective-C, и это весьма кстати, если вы ищете или запрашиваете у программиста конкретные имена классов.

4.4. Обеспечение удаления смахиванием в ячейках табличных видов.

Постановка задачи.

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

Решение.

Реализуйте в делегате табличного вида селектор tableView: editingStyleForRowAtIndexPath:, а в источнике данных табличного вида — селектор tableView: commitEditingStyle: forRowAtIndexPath::

— (UITableViewCellEditingStyle)tableView:(UITableView *)tableView

editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath{

return UITableViewCellEditingStyleDelete;

}

— (void) setEditing:(BOOL)editing

animated:(BOOL)animated{

[super setEditing: editing

animated: animated];

[self.myTableView setEditing: editing

animated: animated];

}

— (void) tableView:(UITableView *)tableView

commitEditingStyle:(UITableViewCellEditingStyle)editingStyle

forRowAtIndexPath:(NSIndexPath *)indexPath{

if (editingStyle == UITableViewCellEditingStyleDelete){

/* Сначала удаляем этот объект из источника данных */

[self.allRows removeObjectAtIndex: indexPath.row];

/* Потом удаляем ассоциированную с ним ячейку из табличного вида */

[tableView deleteRowsAtIndexPaths:@[indexPath]

withRowAnimation: UITableViewRowAnimationLeft];

}

}

Метод tableView: editingStyleForRowAtIndexPath: позволяет выполнять операции удаления. Он вызывается табличным видом, а его возвращаемое значение определяет, какие операции пользователь может делать в табличном виде (вставлять информацию, удалять информацию и т. д.). Метод tableView: commitEditingStyle: forRowAtIndexPath: выполняет затребованную пользователем операцию удаления. Второй из указанных методов определяется в делегате, но его функционал несколько перегружен: этот метод применяется не только для удаления данных, но и для удаления строк из таблицы.

Обсуждение.

Табличный вид реагирует на жест смахивания (Swipe), отображая кнопку в правой части затронутой строки (рис. 4.5). Как видите, табличный вид не находится в режиме редактирования, но эта кнопка позволяет пользователю удалить строку.

Обсуждение. 4.4. Обеспечение удаления смахиванием в ячейках табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.5. Кнопка для удаления, появляющаяся в ячейке табличного вида

Такой режим активизируется путем реализации метода tableView: editingStyleForRowAtIndexPath: (определяемого в протоколе UITableViewDelegate), чье возвращаемое значение указывает, будут ли в таблице разрешаться операции вставки, или удаления, или обе эти операции, или ни одна из них. Реализуя метод tableView: commitEditingStyle: forRowAtIndexPath: в источнике данных табличного вида, можно также получать уведомление о том, какую операцию выполнил пользователь, вставку или удаление.

Второй параметр метода deleteRowsAtIndexPaths: withRowAnimation: позволяет указывать метод анимации, который будет выполняться при удалении строк из табличного вида. В примере мы задали, что удаляемые строки будут уходить с экрана в направлении справа налево.

4.5. Создание верхних и нижних колонтитулов в табличных видах.

Постановка задачи.

Необходимо создать в таблице верхний и/или нижний колонтитул.

Решение.

Создайте вид (это может быть подпись, вид с изображением или любой другой класс, прямо или опосредованно производимый от UIView) и присвойте этот вид верхнему и/или нижнему колонтитулу табличного раздела. Кроме того, как вы вскоре увидите, для верхнего или нижнего колонтитулов можно выделять конкретное количество точек.

Обсуждение.

Табличный вид может иметь несколько верхних и нижних колонтитулов. У каждого раздела табличного вида может быть свой верхний и нижний колонтитул, так что если у вас в табличном виде три раздела, то в нем может быть максимум три верхних и три нижних колонтитула. Вы не обязаны создавать верхние и нижние колонтитулы в каком-либо из разделов и сами решаете, сообщать или нет табличному виду, что в определенном его разделе будут верхний и нижний колонтитулы. Эти виды-колонтитулы передаются табличному виду через его делегат — если вы решите их сделать. Верхние и нижние колонтитулы становятся частью табличного вида. Это означает, что, когда содержимое таблицы прокручивается, одновременно с ним прокручиваются и колонтитулы табличных разделов. Рассмотрим примеры верхнего и нижнего колонтитулов в табличном виде (рис. 4.6).

Обсуждение. 4.5. Создание верхних и нижних колонтитулов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.6. Нижний колонтитул в верхнем разделе и верхний колонтитул Shortcuts (Быстрый доступ) в последнем разделе табличного вида

Как видите, в верхнем разделе (там, где находятся элементы Check Spelling (Проверка правописания) и Enable Caps Lock (Зафиксировать верхний регистр)) в нижнем колонтитуле написано: Double tapping the space bar will insert a period followed by a space (Двойное нажатие клавиши пробела вставляет точку, за которой следует пробел). Это нижний колонтитул верхнего раздела рассматриваемого вида. Причина, по которой этот фрагмент находится именно в нижнем, а не в верхнем колонтитуле, в том, что он прикреплен к нижней, а не к верхней части раздела. В последнем разделе данной таблицы также есть верхний колонтитул, на котором написано Shortcuts (Быстрый доступ). Здесь, наоборот, колонтитул является верхним, а не нижним, так как он прикреплен к верхней части раздела.

Для указания высоты верхнего и нижнего колонтитулов в разделе табличного вида применяются методы, определяемые в протоколе UITableViewDataSource. Чтобы задать сам вид, который будет соответствовать верхнему/нижнему колонтитулу в разделе табличного вида, нужно использовать методы, определяемые в протоколе UITableViewDelegate.

Идем дальше. Создадим простое приложение, внутри которого будет табличный вид. Потом сделаем две метки типа UILabel, одна будет играть роль верхнего колонтитула, а другая — нижнего в единственном разделе нашего табличного вида. Этот раздел будет заполнен всего тремя ячейками. В верхнем колонтитуле мы напишем Section 1 Header (Верхний колонтитул раздела 1), а в нижнем — Section 1 Footer (Нижний колонтитул раздела 1). Начнем с файла реализации контроллера вида, где определим табличный вид:

#import «ViewController.h»

static NSString *CellIdentifier = @"CellIdentifier";

@interface ViewController () <UITableViewDelegate, UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@end

@implementation ViewController

После этого создадим сгруппированный табличный вид и загрузим в него три ячейки:

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = nil;

cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = [[NSString alloc] initWithFormat:@"Cell %ld",

(long)indexPath.row];

return cell;

}

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 3;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStyleGrouped];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

self.myTableView.dataSource = self;

self.myTableView.delegate = self;

self.myTableView.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

[self.view addSubview: self.myTableView];

}

И тут начинается самое интересное. Мы можем воспользоваться двумя важными методами (определяемыми в протоколе UITableViewDelegate), чтобы сделать метку и для верхнего и для нижнего колонтитула того раздела, который мы загрузили в табличный вид. Вот эти методы:

• tableView: viewForHeaderInSection: — ожидает возвращаемого значения типа UIView. Вид, возвращаемый этим методом, отобразится как верхний колонтитул раздела и будет указан в параметре viewForHeaderInSection;

• tableView: viewForFooterInSection: — ожидает возвращаемого значения типа UIView. Вид, возвращаемый этим методом, отобразится как нижний колонтитул раздела и будет указан в параметре viewForFooterInSection.

Теперь наша задача заключается в том, чтобы реализовать эти методы и вернуть экземпляр UILabel. На метке верхнего колонтитула мы укажем текст Section 1 Header (Верхний колонтитул раздела 1), а на метке нижнего — Section 1 Footer (Нижний колонтитул раздела 1), как и планировали:

— (UILabel *) newLabelWithTitle:(NSString *)paramTitle{

UILabel *label = [[UILabel alloc] initWithFrame: CGRectZero];

label.text = paramTitle;

label.backgroundColor = [UIColor clearColor];

[label sizeToFit];

return label;

}

— (UIView *) tableView:(UITableView *)tableView

viewForHeaderInSection:(NSInteger)section{

if (section == 0){

return [self newLabelWithTitle:@"Section 1 Header"];

}

return nil;

}

— (UIView *) tableView:(UITableView *)tableView

viewForFooterInSection:(NSInteger)section{

if (section == 0){

return [self newLabelWithTitle:@"Section 1 Footer"];

}

return nil;

}

Если теперь запустить приложение в эмуляторе, получится такая картинка, как на рис. 4.7.

Обсуждение. 4.5. Создание верхних и нижних колонтитулов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.7. Метки для верхнего и нижнего колонтитулов табличного вида, выровненные неправильно

Причина такого неправильного выравнивания в том, что родительский вид не знает высоты видов-меток. Для указания высоты видов верхнего и нижнего колонтитулов следует использовать два следующих метода, определяемых в протоколе UITableViewDelegate:

• tableView: heightForHeaderInSection: — возвращаемое значение данного метода относится к типу CGFloat. Оно указывает высоту верхнего колонтитула раздела табличного вида. Индекс раздела передается в параметре heightForHeaderInSection;

• tableView: heightForFooterInSection: — возвращаемое значение данного метода относится к типу CGFloat. Оно указывает высоту нижнего колонтитула раздела табличного вида. Индекс раздела передается в параметре heightForHeaderInSection.

— (CGFloat) tableView:(UITableView *)tableView

heightForHeaderInSection:(NSInteger)section{

if (section == 0){

return 30.0f;

}

return 0.0f;

}

— (CGFloat) tableView:(UITableView *)tableView

heightForFooterInSection:(NSInteger)section{

if (section == 0){

return 30.0f;

}

return 0.0f;

}

Запустив это приложение, вы увидите, что теперь метки верхнего и нижнего колонтитулов имеют фиксированную высоту. Но в написанном нами коде все еще остается какая-то ошибка — дело в левом поле меток верхнего и нижнего колонтитулов. В этом можно убедиться, взглянув на рис. 4.8.

Обсуждение. 4.5. Создание верхних и нижних колонтитулов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.8. Левые поля меток в верхнем и нижнем колонтитулах — неправильные

Причина заключается в том, что по умолчанию табличный вид размещает верхний и нижний колонтитулы в точке с координатой 0.0f по оси Х. Можно подумать, что эта проблема решается изменением контуров меток верхнего и нижнего колонтитулов, но, к сожалению, это мнение ошибочно. Проблема решается созданием универсального вида UIView, где и размещаются метки для верхнего и нижнего колонтитулов. Возвратите в качестве верхнего/нижнего колонтитула такой универсальный вид, но измените положение меток по оси Х в этом виде.

Теперь изменим реализацию методов tableView: viewForHeaderInSection: и tableView: viewForFooterInSection::

— (UIView *) tableView:(UITableView *)tableView

viewForHeaderInSection:(NSInteger)section{

UIView *header = nil;

if (section == 0){

UILabel *label = [self newLabelWithTitle:@"Section 1 Header"];

/* Перемещаем метку на 10 точек вправо. */

label.frame = CGRectMake(label.frame.origin.x + 10.0f,

5.0f, /* Опускаемся на 5 точек вниз

по оси y. */

label.frame.size.width,

label.frame.size.height);

/* Делаем ширину содержащего вида на 10 точек больше,

чем ширина метки, так как для метки требуется

10 дополнительных точек ширины в левом поле. */

CGRect resultFrame = CGRectMake(0.0f,

0.0f,

label.frame.size.width + 10.0f,

label.frame.size.height);

header = [[UIView alloc] initWithFrame: resultFrame];

[header addSubview: label];

}

return header;

}

— (UIView *) tableView:(UITableView *)tableView

viewForFooterInSection:(NSInteger)section{

UIView *footer = nil;

if (section == 0){

UILabel *label = [[UILabel alloc] initWithFrame: CGRectZero];

/* Перемещаем метку на 10 точек вправо. */

label.frame = CGRectMake(label.frame.origin.x + 10.0f,

5.0f, /* Опускаемся на 5 точек вниз по оси y*/

label.frame.size.width,

label.frame.size.height);

/* Делаем ширину содержащего вида на 10 точек больше,

чем ширина метки, так как для метки требуется

10 дополнительных точек ширины в левом поле. */

CGRect resultFrame = CGRectMake(0.0f,

0.0f,

label.frame.size.width + 10.0f,

label.frame.size.height);

footer = [[UIView alloc] initWithFrame: resultFrame];

[footer addSubview: label];

}

return footer;

}

Теперь, запустив приложение, вы получите примерно такой результат, как на рис. 4.9.

Обсуждение. 4.5. Создание верхних и нижних колонтитулов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.9. В табличном виде отображаются метки верхнего и нижнего колонтитулов

Пользуясь изученными здесь методами, вы также можете размещать изображения в верхнем и нижнем колонтитулах табличных видов. Экземпляры класса UIImageView являются производными от класса UIView, поэтому вы легко можете ставить картинки в виды для изображений и возвращать их как верхние/нижние колонтитулы табличного вида. Если вы не собираетесь помещать в верхних и нижних колонтитулах табличных видов ничего, кроме текста, то можете пользоваться двумя удобными методами, определяемыми в протоколе UITableViewDataSource. Эти методы избавят вас от массы проблем. Чтобы не создавать собственные метки и не возвращать их как верхние/нижние колонтитулы табличного вида, просто пользуйтесь следующими методами:

• tableView: titleForHeaderInSection: — возвращаемое значение этого метода относится к типу NSString. Табличный вид будет автоматически помещать в метке строку, которая будет отображаться как верхний колонтитул раздела, указываемый в параметре titleForHeaderInSection;

• tableView: titleForFooterInSection: — возвращаемое значение этого метода относится к типу NSString. Табличный вид будет автоматически помещать в метке строку, которая будет отображаться как нижний колонтитул раздела, указываемый в параметре titleForFooterInSection.

Итак, чтобы упростить код приложения, избавимся от реализаций методов tableView: viewForHeaderInSection: и tableView: viewForFooterInSection:, заменив их реализациями методов tableView: titleForHeaderInSection: и tableView: titleForFooterInSection::

— (NSString *) tableView:(UITableView *)tableView

titleForHeaderInSection:(NSInteger)section{

if (section == 0){

return @"Section 1 Header";

}

return nil;

}

— (NSString *) tableView:(UITableView *)tableView

titleForFooterInSection:(NSInteger)section{

if (section == 0){

return @"Section 1 Footer";

}

return nil;

}

Теперь запустите ваше приложение в эмуляторе iPhone. Вы увидите, что табличный вид автоматически создал для верхнего колонтитула метку, выровненную по левому краю, а для нижнего колонтитула — метку, выровненную по центру, и поместил их в единственном разделе табличного вида. В iOS 7 по умолчанию верхний и нижний колонтитулы выравниваются по левому краю. В более ранних версиях iOS верхний колонтитул выравнивался по левому краю, а нижний — по центру. В любой версии выравнивание этих меток может задаваться табличным видом (рис. 4.10).

Обсуждение. 4.5. Создание верхних и нижних колонтитулов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.10. Табличный вид, в верхнем и нижнем колонтитулах которого отображается текст

4.6. Отображение контекстных меню в ячейках табличных видов.

Постановка задачи.

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

Решение.

Реализуйте следующие три метода протокола UITableViewDelegate в объекте-делегате вашего табличного вида.

• tableView: shouldShowMenuForRowAtIndexPath: — возвращаемое значение данного вида относится к типу BOOL. Если вернуть от этого метода значение YES, то система iOS отобразит для ячейки табличного вида контекстное меню. Индекс этой ячейки будет передан вам в параметре shouldShowMenuForRowAtIndexPath.

• tableView: canPerformAction: forRowAtIndexPath: withSender: — возвращаемое значение данного метода также относится к типу BOOL. Как только вы позволите iOS отображать контекстное меню для ячейки табличного вида, iOS вызовет этот метод несколько раз и сообщит вам селектор действия. После этого вы сможете решить, следует ли отображать это действие в командах контекстного меню. Итак, если iOS спрашивает вас, хотите ли вы отобразить для пользователя меню Copy (Копировать), то рассматриваемый метод будет вызван в объекте-делегате вашего табличного вида и параметр canPerformAction данного метода будет равен @selector(copy:). Подробнее этот вопрос рассматривается в подразделе «Обсуждение» данного раздела.

• tableView: performAction: forRowAtIndexPath: withSender: — как только вы разрешите отобразить определенное действие в списке вариантов контекстного меню ячейки табличного вида, возникает такая ситуация: когда пользователь выбирает это действие в меню, данный метод вызывается в объекте-делегате вашего табличного вида. Здесь нужно сделать все необходимое, чтобы удовлетворить пользовательский запрос. Например, если пользователь выбрал меню Copy (Копировать), то вы должны применить буфер обмена (Pasteboard), куда помещается содержимое из ячейки табличного вида.

Обсуждение.

Табличный вид может дать системе iOS ответ «да» или «нет», позволив или не позволив отобразить доступные системные элементы меню для данной табличной ячейки. iOS пытается вывести контекстное меню для табличной ячейки, когда пользователь удерживает эту ячейку пальцем в течение определенного временного промежутка — обычно примерно 1 с. Затем iOS пытается узнать табличный вид, одна из ячеек которого инициировала появление контекстного меню на экране. Если табличный вид ответит, то iOS сообщит ему, какие команды можно отобразить в контекстном меню, а табличный вид сможет утвердительно или отрицательно отреагировать на каждый из этих вариантов. Например, если доступны пять вариантов (элементов) и табличный вид отвечает «да» на два из них, то будут отображены только два этих элемента.

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

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

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return 3;

}

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = nil;

cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = [[NSString alloc]

initWithFormat:@"Section %ld Cell %ld",

(long)indexPath.section,

(long)indexPath.row];

return cell;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView = [[UITableView alloc]

initWithFrame: self.view.bounds

style: UITableViewStylePlain];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

self.myTableView.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.myTableView.dataSource = self;

self.myTableView.delegate = self;

[self.view addSubview: self.myTableView];

}

Теперь реализуем три упомянутых ранее метода, определенных в протоколе UITableViewDelegate, и просто преобразуем доступные действия (типа SEL) в строку, после чего выведем доступные результаты на консоль:

— (BOOL) tableView:(UITableView *)tableView

shouldShowMenuForRowAtIndexPath:(NSIndexPath *)indexPath{

/* Разрешаем отображение контекстного меню для каждой ячейки */

return YES;

}

— (BOOL) tableView:(UITableView *)tableView

canPerformAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

NSLog(@"%@", NSStringFromSelector(action));

/* Пока разрешим любые действия. */

return YES;

}

— (void) tableView:(UITableView *)tableView

performAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

/* Пока оставим пустым. */

}

А теперь запустим приложение в эмуляторе или на устройстве. После этого мы увидим, что в табличный вид загружены три ячейки. Удерживайте на ячейке палец (если работаете с устройством) или указатель мыши (если с эмулятором) и смотрите, какая информация появляется в окне консоли:

cut:

copy:

select:

selectAll:

paste:

delete:

_promptForReplace:

_showTextStyleOptions:

_define:

_addShortcut:

_accessibilitySpeak:

_accessibilitySpeakLanguageSelection:

_accessibilityPauseSpeaking:

makeTextWritingDirectionRightToLeft:

makeTextWritingDirectionLeftToRight:

Все это действия, которые система iOS позволяет вывести на экран для пользователя, если такие действия вам понадобятся. Допустим, вы хотите разрешить пользователям операцию копирования (Copy). Для этого перед отображением команды просто найдите в методе tableView: canPerformAction: forRowAtIndexPath: withSender:, на какое действие запрашивает у вас разрешение система iOS, а потом верните значение YES или NO:

— (BOOL) tableView:(UITableView *)tableView

canPerformAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

if (action == @selector(copy:)){

return YES;

}

return NO;

}

На следующем этапе перехватываем информацию о том, какой именно элемент был выбран пользователем в контекстном меню. В зависимости от того, что выяснится, мы можем совершить нужное действие. Например, если пользователь выберет в контекстном меню команду Copy (Копировать) (рис. 4.11), мы воспользуемся UIPasteBoard, чтобы скопировать эту ячейку в компоновочный буфер и иметь возможность применять ее позже:

— (void) tableView:(UITableView *)tableView

performAction:(SEL)action

forRowAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

if (action == @selector(copy:)){

UITableViewCell *cell = [tableView cellForRowAtIndexPath: indexPath];

UIPasteboard *pasteBoard = [UIPasteboard generalPasteboard];

[pasteBoard setString: cell.textLabel.text];

}

}

Обсуждение. 4.6. Отображение контекстных меню в ячейках табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.11. Команда Copy (Копировать), отображенная в контекстном меню ячейки табличного вида

4.7. Перемещение ячеек и разделов в табличных видах.

Постановка задачи.

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

Решение.

Используйте метод moveSection: toSection: табличного вида, чтобы переместить раздел на новое место. Кроме того, можно применять метод moveRowAtIndexPath: toIndexPath:, чтобы перемещать ячейку табличного вида на новое место с того места, которое она сейчас занимает.

Обсуждение.

Процесс перемещения разделов и ячеек таблицы отличается от их замены. Рассмотрим пример, помогающий лучше понять эту разницу. Допустим, у нас есть табличный вид с тремя разделами, A, B и C. Если передвинуть раздел A к разделу C, то табличный вид заметит это и переместит раздел B туда, где до этого находился раздел A. Но если раздел B будет перемещен на место раздела C, то табличному виду вообще не придется перемещать раздел A, так как он находится «выше» двух перемещаемых разделов и не участвует в передвижениях B и C. В данном случае раздел B попадет на место раздела C, а раздел C — на место раздела B. Такая же логика применяется в табличных видах при перемещении ячеек.

Для демонстрации таких взаимодействий создадим табличный вид и загрузим в него три раздела, в каждом из которых есть три собственные ячейки. Начнем с файла реализации контроллера вида:

#import «ViewController.h»

static NSString *CellIdentifier = @"CellIdentifier";

@interface ViewController () <UITableViewDelegate, UITableViewDataSource>

@property (nonatomic, strong) UITableView *myTableView;

@property (nonatomic, strong) NSMutableArray *arrayOfSections;

@end

Контроллер вида становится источником данных для табличного вида. В табличном виде есть разделы, а в каждом разделе — ячейки. Мы, в сущности, работаем с массивом массивов: массив первого порядка содержит разделы, а каждый раздел, в свою очередь, является массивом, содержащим ячейки. Отвечать за этот функционал будет элемент arrayOfSections, определяемый в заголовочном файле контроллера вида. Итак, заполним этот массив:

— (NSMutableArray *) newSectionWithIndex:(NSUInteger)paramIndex

withCellCount:(NSUInteger)paramCellCount{

NSMutableArray *result = [[NSMutableArray alloc] init];

NSUInteger counter = 0;

for (counter = 0;

counter < paramCellCount;

counter++){

[result addObject: [[NSString alloc] initWithFormat:@"Section %lu

Cell %lu",

(unsigned long)paramIndex,

(unsigned long)counter+1]];

}

return result;

}

— (NSMutableArray *) arrayOfSections{

if (_arrayOfSections == nil){

NSMutableArray *section1 = [self newSectionWithIndex:1

cellCount:3];

NSMutableArray *section2 = [self newSectionWithIndex:2

cellCount:3];

NSMutableArray *section3 = [self newSectionWithIndex:3

cellCount:3];

_arrayOfSections = [[NSMutableArray alloc] initWithArray:@[

section1,

section2,

section3

]

];

}

return _arrayOfSections;

}

Затем мы инстанцируем табличный вид и реализуем необходимые методы в протоколе UITableViewDataSource, чтобы заполнить табличный вид данными:

— (NSInteger) numberOfSectionsInTableView:(UITableView *)tableView{

return self.arrayOfSections.count;

}

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

NSMutableArray *sectionArray = self.arrayOfSections[section];

return sectionArray.count;

}

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = nil;

cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

NSMutableArray *sectionArray = self.arrayOfSections[indexPath.section];

cell.textLabel.text = sectionArray[indexPath.row];

return cell;

}

— (void)viewDidLoad{

[super viewDidLoad];

self.myTableView =

[[UITableView alloc] initWithFrame: self.view.bounds

style: UITableViewStyleGrouped];

[self.myTableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

self.myTableView.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.myTableView.delegate = self;

self.myTableView.dataSource = self;

[self.view addSubview: self.myTableView];

}

Теперь посмотрим, что получается. Сначала проверим, как разделы перемещаются на новое место. Напишем метод, который будет перемещать раздел 1 на место раздела 3:

— (void) moveSection1ToSection3{

NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

[self.arrayOfSections removeObject: section1];

[self.arrayOfSections addObject: section1];

[self.myTableView moveSection:0

toSection:2];

}

Оставляю на ваш выбор окончательное решение о том, как инициировать этот метод, ведь на данный момент у нас в пользовательском интерфейсе нет специальной кнопки для этой цели. Можно просто создать навигационный контроллер и разместить на нем навигационную кнопку, которая и будет запускать данный метод.

Как только вы запустите приложение в обычном режиме, на экране появятся разделы с 1-го по 3-й (рис. 4.12).

Обсуждение. 4.7. Перемещение ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.12. Табличный вид с тремя разделами, в каждом из которых находятся по три ячейки

После запуска метода moveSection1ToSection3 вы увидите, что раздел 1 переходит на место раздела 3, раздел 3 переходит на место, ранее занятое разделом 2, и, наконец, раздел 2 перемещается на то место, где раньше находился раздел 1 (рис. 4.13).

Обсуждение. 4.7. Перемещение ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.13. Раздел 1 перешел на место раздела 3, после чего последовательно переместились и другие разделы

Перемещение ячеек очень напоминает перемещение разделов. Для этого нужно просто пользоваться методом moveRowAtIndexPath: toIndexPath:. Не забывайте, что ячейка может перемещаться либо в пределах одного раздела, либо из одного раздела в другой. Начнем с простого — переместим ячейку 1 из 1-го раздела на место ячейки 2 того же раздела и посмотрим, что получится:

— (void) moveCell1InSection1ToCell2InSection1{

NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

NSString *cell1InSection1 = [section1 objectAtIndex:0];

[section1 removeObject: cell1InSection1];

[section1 insertObject: cell1InSection1

atIndex:1];

NSIndexPath *sourceIndexPath = [NSIndexPath indexPathForRow:0

inSection:0];

NSIndexPath *destinationIndexPath = [NSIndexPath indexPathForRow:1

inSection:0];

[self.myTableView moveRowAtIndexPath: sourceIndexPath

toIndexPath: destinationIndexPath];

}

Что же происходит в этом коде? Нам нужно гарантировать, что в источнике данных содержится корректная информация, которая отобразится в табличном виде по окончании всех перестановок. Поэтому сначала убираем ячейку 1 в разделе 1. В результате ячейка 2 переходит на место, освобожденное ячейкой 1, а ячейка 3 — на место, ранее занятое ячейкой 2. В массиве остается всего 2 ячейки. Потом мы вставляем ячейку 1 в индекс 1 (второй объект) массива. Таким образом, в массиве будут содержаться ячейка 2, ячейка 1, а потом ячейка 3. И вот теперь мы на самом деле переместили ячейки в табличном виде.

Теперь немного усложним задачу. Попробуем переместить ячейку 2 из раздела 1 на место ячейки 1 из раздела 2:

— (void) moveCell2InSection1ToCell1InSection2{

NSMutableArray *section1 = [self.arrayOfSections objectAtIndex:0];

NSMutableArray *section2 = [self.arrayOfSections objectAtIndex:1];

NSString *cell2InSection1 = [section1 objectAtIndex:1];

[section1 removeObject: cell2InSection1];

[section2 insertObject: cell2InSection1

atIndex:0];

NSIndexPath *sourceIndexPath = [NSIndexPath indexPathForRow:1

inSection:0];

NSIndexPath *destinationIndexPath = [NSIndexPath indexPathForRow:0

inSection:1];

[self.myTableView moveRowAtIndexPath: sourceIndexPath

toIndexPath: destinationIndexPath];

}

Результаты перехода показаны на рис. 4.14.

Обсуждение. 4.7. Перемещение ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.14. Ячейка 2 из раздела 1 перемещена на место ячейки 1 из раздела 2

4.8. Удаление ячеек и разделов в табличных видах.

Постановка задачи.

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

Решение.

Для удаления разделов из табличного вида выполните следующие шаги.

1. Сначала удалите раздел (-ы) в источнике данных независимо от того, с какой именно моделью данных вы работаете — Core Data или словарь/массив.

2. Примените к табличному виду метод экземпляра deleteSections: withRowAnimation:, относящийся к UITableView. Первый параметр, который нужно передать данному методу, имеет тип NSIndexSet. Этот объект можно инстанцировать с помощью метода класса indexSetWithIndex:, относящегося к классу NSIndexSet, где указываемый индекс — это беззнаковое целое число. Применяя такой подход, вы можете удалять только один раздел за раз. Если вы собираетесь удалить за раз более одного раздела, пользуйтесь методом класса indexSetWithIndexesInRange:, также относящимся к классу NSIndexSet, чтобы создать индексное множество с указанием диапазона. Это индексное множество передается описанному ранее методу экземпляра, относящемуся к UITableView.

Если вы хотите удалить ячейки в табличном виде, выполните следующие шаги.

1. Сначала удалите ячейку (ячейки) из источника данных. Здесь также не имеет значения, работаете ли вы с Core Data, обычным словарем, массивом или чем-то еще. Самое важное в данном случае — удалить из источника данных те объекты, которые соответствуют ячейкам табличного вида.

2. Теперь для удаления самих ячеек, соответствующих объектам данных, примените метод экземпляра deleteRowsAtIndexPaths: withRowAnimation:, относящийся к табличному виду. Первый параметр, который необходимо передать данному методу, — это массив типа NSArray. Данный массив должен содержать объекты типа NSIndexPath, и каждый индексный путь представляет одну ячейку в табличном виде. В каждом индексном пути содержится указание на раздел и на строку табличного вида. Этот путь составляется с помощью метода класса indexPathForRow: inSection:, относящегося к классу NSIndexPath.

Обсуждение.

В коде вашего пользовательского интерфейса вам может понадобиться удалять ячейки и/или разделы. Например, у вас может иметься переключатель (типа UISwitch, см. раздел 1.2). Когда пользователь нажимает переключатель, вам, возможно, требуется добавить в табличный вид несколько строк. После того как пользователь вернет переключатель в исходное положение, вам, вероятно, потребуется вновь убрать эти строки с экрана. Но такие операции удаления не всегда ограничиваются ячейками (строками) табличного вида. Иногда из табличного вида требуется одновременно удалить целый раздел (или несколько разделов). Ключевой аспект при удалении разделов и ячеек из табличных видов состоит в том, что сначала из источника данных удаляется информация, соответствующая этим элементам (ячейкам или разделам), а потом вызываются соответствующие методы удаления, применяемые к табличному виду. После того как метод удаления завершит работу, табличный вид снова будет ссылаться на свой объект из источника данных. Если же после операции удаления количество ячеек/разделов в источнике данных не совпадет с количеством ячеек/разделов в табличном виде, приложение аварийно завершится. Но не волнуйтесь — даже если вы и допустите такую ошибку, то отладочное сообщение, которое появится на консоли, будет достаточно подробным для того, чтобы вы могли подправить код.

Рассмотрим, как удалять разделы из табличного вида. В данном разделе мы отобразим табличный вид в контроллере вида, который, в свою очередь, будет находиться в навигационном контроллере. Внутри табличного вида будет два раздела: один для нечетных чисел, другой — для четных. В табличном виде в разделе с нечетными числами мы отобразим только 1, 3, 5 и 7, а в разделе с четными — 0, 2, 4 и 6. В первом упражнении мы собираемся создать на навигационной панели специальную кнопку, которая будет удалять раздел с нечетными числами. На рис. 4.15 показано, какой результат мы хотим получить.

Обсуждение. 4.8. Удаление ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.15. Пользовательский интерфейс для отображения двух разделов табличного вида; в интерфейсе есть кнопка, удаляющая раздел Odd Numbers (Нечетные числа)

Начнем с главного. Определим контроллер вида:

#import <UIKit/UIKit.h>

static NSString *CellIdentifier = @"NumbersCellIdentifier";

@interface ViewController: UIViewController <UITableViewDelegate,

UITableViewDataSource>

@property (nonatomic, strong) UITableView *tableViewNumbers;

@property (nonatomic, strong) NSMutableDictionary *dictionaryOfNumbers;

@property (nonatomic, strong) UIBarButtonItem *barButtonAction;

@end

Свойство tableViewNumbers соответствует нашему табличному виду. Свойство barButtonAction соответствует кнопке для удаления, которая будет отображаться на навигационной панели. И последнее, но немаловажное свойство dictionaryOfNumbers — это источник данных для табличного вида. В данном словаре мы поместим два значения типа NSMutableArray, которые будут содержать числа типа NSNumber. Это изменяемые массивы, позже в данной главе мы сможем удалять их отдельно от массивов, содержащихся в словаре. Ключи для этих массивов мы будем хранить как статические значения в файле реализации контроллера вида. По этой причине позже просто сможем извлечь массивы из словаря, пользуясь статическими ключами. (Если бы ключи не были статическими, то для нахождения массивов в словаре пришлось бы выполнять сравнение строк. А эта операция требует больше времени, чем обычное ассоциирование объекта со статическим ключом, не изменяющимся на протяжении всего существования контроллера вида.) Теперь синтезируем наши свойства и определим статические строковые ключи для массивов, находящихся в словаре источника данных:

static NSString *SectionOddNumbers = @"Odd Numbers";

static NSString *SectionEvenNumbers = @"Even Numbers";

@implementation ViewController

Теперь, перед тем как создать табличный вид, необходимо заполнить информацией словарь источника данных. Вот простой метод, который автоматически заполнит словарь:

— (NSMutableDictionary *) dictionaryOfNumbers{

if (_dictionaryOfNumbers == nil){

NSMutableArray *arrayOfEvenNumbers =

[[NSMutableArray alloc] initWithArray:@[

@0,

@2,

@4,

@6,

]];

NSMutableArray *arrayOfOddNumbers =

[[NSMutableArray alloc] initWithArray:@[

@1,

@3,

@5,

@7,

]];

_dictionaryOfNumbers =

[[NSMutableDictionary alloc]

initWithDictionary:@{

SectionEvenNumbers: arrayOfEvenNumbers,

SectionOddNumbers: arrayOfOddNumbers,

}];

}

return _dictionaryOfNumbers;

}

Пока все нормально? Как видите, у нас два массива, в каждом из которых содержатся некоторые числа (в одном нечетные, в другом — четные). Мы ассоциируем массивы с ключами SectionEvenNumbers и SectionOddNumbers, которые ранее определили в файле реализации контроллера вида. Теперь инстанцируем табличный вид:

— (void)viewDidLoad

{

[super viewDidLoad];

self.barButtonAction =

[[UIBarButtonItem alloc]

initWithTitle:@"Delete Odd Numbers"

style: UIBarButtonItemStylePlain

target: self

action:@selector(deleteOddNumbersSection:)];

[self.navigationItem setRightBarButtonItem: self.barButtonAction

animated: NO];

self.tableViewNumbers = [[UITableView alloc]

initWithFrame: self.view.frame

style: UITableViewStyleGrouped];

self.tableViewNumbers.autoresizingMask = UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.tableViewNumbers.delegate = self;

self.tableViewNumbers.dataSource = self;

[self.view addSubview: self.tableViewNumbers];

}

Далее нужно заполнить табличный вид информацией внутри словаря источника с данными:

— (NSInteger) numberOfSectionsInTableView:(UITableView *)tableView{

return self.dictionaryOfNumbers.allKeys.count;

}

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

NSString *sectionNameInDictionary =

self.dictionaryOfNumbers.allKeys[section];

NSArray *sectionArray = self.dictionaryOfNumbers[sectionNameInDictionary];

return sectionArray.count;

}

— (UITableViewCell *) tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = nil;

cell = [tableView dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

NSString *sectionNameInDictionary =

self.dictionaryOfNumbers.allKeys[indexPath.section];

NSArray *sectionArray = self.dictionaryOfNumbers[sectionNameInDictionary];

NSNumber *number = sectionArray[indexPath.row];

cell.textLabel.text = [NSString stringWithFormat:@"%lu",

(unsigned long)[number unsignedIntegerValue]];

return cell;

}

— (NSString *) tableView:(UITableView *)tableView

titleForHeaderInSection:(NSInteger)section{

return self.dictionaryOfNumbers.allKeys[section];

}

Навигационная кнопка связана с селектором deleteOddNumbersSection:. Этот метод нам сейчас предстоит запрограммировать. Цель метода, как видно из его названия[2], — найти раздел, соответствующий всем нечетным числам в источнике данных, найти табличный вид, а потом удалить искомый раздел и из таблицы, и из источника данных. Вот как это делается:

— (void) deleteOddNumbersSection:(id)paramSender{

/* Сначала удаляем раздел из источника данных. */

NSString *key = SectionOddNumbers;

NSInteger indexForKey = [[self.dictionaryOfNumbers allKeys]

indexOfObject: key];

if (indexForKey == NSNotFound){

NSLog(@"Could not find the section in the data source.");

return;

}

[self.dictionaryOfNumbers removeObjectForKey: key];

/* Затем удаляем раздел из табличного вида. */

NSIndexSet *sectionToDelete = [NSIndexSet indexSetWithIndex: indexForKey];

[self.tableViewNumbers deleteSections: sectionToDelete

withRowAnimation: UITableViewRowAnimationAutomatic];

/* Наконец, убираем с навигационной панели кнопку,

так как она нам больше не понадобится. */

[self.navigationItem setRightBarButtonItem: nil animated: YES];

}

Все довольно просто. Теперь, когда пользователь нажмет кнопку на навигационной панели, раздел Odd Numbers (Нечетные числа) исчезнет из табличного вида. Как видите, в процессе удаления раздела табличный вид анимируется. Это происходит потому, что мы передали анимационный тип UITableViewRowAnimationAutomatic параметру withRowAnimation: метода deleteSections: withRowAnimation: табличного вида. Теперь запустите приложение в эмуляторе iOS и выполните Debug — Toggle Slow Animations (Отладка — Включить медленную анимацию). Потом попробуйте нажать кнопку на навигационной панели и посмотрите, что происходит. Как видите, удаление сопровождается медленной анимацией (движением). Красиво, правда? Когда удаление завершится, приложение будет выглядеть, как на рис. 4.16.

Обсуждение. 4.8. Удаление ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.16. Раздел, содержащий нечетные числа, удален из табличного вида

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

— (void)viewDidLoad {

[super viewDidLoad];

self.barButtonAction =

[[UIBarButtonItem alloc]

initWithTitle:@"Delete Numbers > 2"

style: UIBarButtonItemStylePlain

target: self

action:@selector(deleteNumbersGreaterThan2:)];

[self.navigationItem setRightBarButtonItem: self.barButtonAction

animated: NO];

self.tableViewNumbers = [[UITableView alloc]

initWithFrame: self.view.frame

style: UITableViewStyleGrouped];

self.tableViewNumbers.autoresizingMask =

UIViewAutoresizingFlexibleWidth |

UIViewAutoresizingFlexibleHeight;

self.tableViewNumbers.delegate = self;

self.tableViewNumbers.dataSource = self;

[self.view addSubview: self.tableViewNumbers];

}

На рис. 4.17 показано, как выглядит приложение при запуске в эмуляторе iPhone.

Обсуждение. 4.8. Удаление ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.17. Кнопка, удаляющая все ячейки с числами больше 2

Теперь кнопка навигационной панели связана с селектором deleteNumbersGreaterThan2:. Селектор — это метод, реализованный в контроллере вида. Но прежде, чем перейти к его программированию, определим, что этот метод должен сделать.

1. Найти оба массива с нечетными и четными числами в источнике данных и собрать индексные пути (типа NSIndexPath) чисел больше 2. Позже мы будем пользоваться этими индексными путями для удаления соответствующих ячеек в табличном виде.

2. Удалить все числа больше 2 из источника данных — как из словаря для нечетных чисел, так и из словаря для четных.

3. Удалить из табличного вида соответствующие ячейки. Индексные пути к этим ячейкам мы собрали на первом этапе.

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

— (void) deleteNumbersGreaterThan2:(id)paramSender{

NSMutableArray *arrayOfIndexPathsToDelete =

[[NSMutableArray alloc] init];

NSMutableArray *arrayOfNumberObjectsToDelete =

[[NSMutableArray alloc] init];

/* Шаг 1: собираем объекты, которые мы хотим удалить из

источника данных, а также их индексные пути. */

__block NSUInteger keyIndex = 0;

[self.dictionaryOfNumbers enumerateKeysAndObjectsUsingBlock:

^(NSString *key, NSMutableArray *object, BOOL *stop) {

[object enumerateObjectsUsingBlock:

^(NSNumber *number, NSUInteger numberIndex, BOOL *stop) {

if ([number unsignedIntegerValue] > 2){

NSIndexPath *indexPath =

[NSIndexPath indexPathForRow: numberIndex

inSection: keyIndex];

[arrayOfIndexPathsToDelete addObject: indexPath];

[arrayOfNumberObjectsToDelete addObject: number];

}

}];

keyIndex++;

}];

/* Шаг 2: удаляем объекты из источника данных. */

if ([arrayOfNumberObjectsToDelete count] > 0){

NSMutableArray *arrayOfOddNumbers =

self.dictionaryOfNumbers[SectionOddNumbers];

NSMutableArray *arrayOfEvenNumbers =

self.dictionaryOfNumbers[SectionEvenNumbers];

[arrayOfNumberObjectsToDelete enumerateObjectsUsingBlock:

^(NSNumber *numberToDelete, NSUInteger idx, BOOL *stop) {

if ([arrayOfOddNumbers indexOfObject: numberToDelete]

!= NSNotFound){

[arrayOfOddNumbers removeObject: numberToDelete];

}

if ([arrayOfEvenNumbers indexOfObject: numberToDelete]

!= NSNotFound){

[arrayOfEvenNumbers removeObject: numberToDelete];

}

}];

}

/* Шаг 3: удаляем все ячейки, соответствующие объектам. */

[self.tableViewNumbers

deleteRowsAtIndexPaths: arrayOfIndexPathsToDelete

withRowAnimation: UITableViewRowAnimationAutomatic];

[self.navigationItem setRightBarButtonItem: nil animated: YES];

}

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

Обсуждение. 4.8. Удаление ячеек и разделов в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.18. Мы удалили все ячейки, в которых содержались числа больше 2

См. также.

Раздел 1.2.

4.9. Использование UITableViewController для удобства при создании табличных видов.

Постановка задачи.

Требуется возможность быстро создавать табличные виды.

Решение.

Используйте контроллер вида UITableViewController, который по умолчанию предоставляется с табличным контроллером вида.

Обсуждение.

В инструментарии iOS SDK есть очень удобный класс UITableViewController, который предоставляется с заранее заготовленным экземпляром табличного вида. Чтобы пользоваться всеми его преимуществами, всего лишь потребуется создать новый класс, наследующий от указанного. Здесь я подробно опишу все этапы создания нового проекта Xcode, использующего табличный контроллер вида.

1. На панели меню Xcode выберите File-New-Project (Файл-Новый-Проект).

2. Убедитесь, что в левой части экрана выбрана категория iOS. Затем перейдите в подкатегорию Application (Приложение). В правой части экрана выберите шаблон Empty Application (Пустое приложение), а потом нажмите кнопку Next (Далее) (рис. 4.19).

Обсуждение. 4.9. Использование UITableViewController для удобства при создании табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

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

3. На следующем экране просто выберите название для вашего проекта. Кроме того, убедитесь, что вся информация у вас на экране, кроме Organization Name (Название организации) и Company Identifier (Идентификатор компании), в точности соответствует той, что приведена на рис. 4.20. Как только все будет готово, нажмите кнопку Next (Далее).

Обсуждение. 4.9. Использование UITableViewController для удобства при создании табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.20. Конфигурирование нового пустого приложения в Xcode

4. На следующем экране вам будет предложено сохранить приложение на диске. Просто сохраните приложение в месте, которое кажется вам целесообразным, и нажмите кнопку Create (Создать).

5. В Xcode выберите меню File-New-File (Файл-Новый-Файл).

6. Убедитесь, что в левой части диалогового окна категория iOS выбрана в качестве основной и при этом также выбрана подкатегория Cocoa Touch. Далее в правой части диалогового окна выберите класс Objective-C (рис. 4.21).

Обсуждение. 4.9. Использование UITableViewController для удобства при создании табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.21. Создание нового класса для табличного вида с контроллером

7. На следующем экране вам будет предложено выбрать суперкласс для нового класса. Это очень важный этап. Убедитесь, что в качестве суперкласса задан UITableViewController. Удостоверьтесь, что все остальные настройки у вас точно такие же, как и у меня на рис. 4.22. Когда все будет готово, нажмите кнопку Next (Далее).

Обсуждение. 4.9. Использование UITableViewController для удобства при создании табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.22. Задаем суперкласс для нового объекта, который станет контроллером табличного вида

8. На следующем экране вы сможете сохранить табличный контроллер вида в проекте. Сохраните его как класс ViewController и нажмите кнопку Create (Создать).

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

#import «AppDelegate.h»

#import «ViewController.h»

@implementation AppDelegate

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

ViewController *controller = [[ViewController alloc]

initWithStyle: UITableViewStylePlain];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.rootViewController = controller;

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Теперь, если вы попытаетесь скомпилировать проект, компилятор выдаст вам следующие предупреждения[3]:

ViewController.m:47:2: Potentially incomplete method implementation.

ViewController.m:54:2: Incomplete method implementation.

Итак, необходимо иметь в виду, что компилятор выдает определенные предупреждения, об устранении которых придется позаботиться в файле реализации контроллера вида. Открыв этот файл, вы увидите, что Apple вставила в шаблон класса табличного контроллера вида макрокоманды #warning — инструкции для компилятора (именно они приводят к тому, что на экран выводятся показанные ранее предупреждения). Одно из предупреждений находится в методе numberOfSectionsInTableView:, другое — в методе tableView: numberOfRowsInSection:. Мы видим на экране предупреждения, потому что не запрограммировали логику для этих методов. Минимальная информация, необходимая табличному контроллеру вида, — это количество разделов для отображения, количество строк для отображения, а также объект ячейки, который должен отображаться в каждой из строк. Мы не видим никаких предупреждений, связанных с отсутствием реализации объекта ячейки, но только потому, что Apple по умолчанию предоставляет формальную реализацию этого метода, создающую за вас пустые ячейки.

По умолчанию контроллер табличного вида является источником данных и делегатом табличного вида. Вам не придется отдельно указывать источник данных и делегат для этого табличного вида.

Перейдем к файлу реализации табличного контроллера вида и убедимся, что у нас есть массив строк (просто для примера), которыми мы можем заполнить табличный вид:

#import «ViewController.h»

static NSString *CellIdentifier = @"Cell";

@interface ViewController ()

@property (nonatomic, strong) NSArray *allItems;

@end

@implementation ViewController

— (id)initWithStyle:(UITableViewStyle)style

{

self = [super initWithStyle: style];

if (self) {

// Специальная инициализация

self.allItems = @[

@"Anthony Robbins",

@"Steven Paul Jobs",

@"Paul Gilbert",

@"Yngwie Malmsteen"

];

[self.tableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

}

return self;

}

— (void) viewDidLoad{

[super viewDidLoad];

}

— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{

return 1;

}

— (NSInteger)tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return self.allItems.count;

}

— (UITableViewCell *)tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = [tableView

dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = self.allItems[indexPath.row];

return cell;

}

@end

Теперь, запустив приложение, мы увидим результат, напоминающий рис. 4.23.

Обсуждение. 4.9. Использование UITableViewController для удобства при создании табличных видов. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.23. Строки правильно отображаются в табличном виде

Вот практически и все, что следует знать о табличных контроллерах видов. Еще раз напомню, что табличный контроллер вида одновременно является и источником данных, и делегатом табличного вида. Итак, теперь вы можете реализовать методы протокола UITableViewDataSource, а также методы протокола UITableViewDelegate прямо в файле реализации табличного контроллера вида.

См. также.

Раздел 4.1.

4.10. Отображение элемента управления, предназначенного для обновления информации в табличных видах.

Постановка задачи.

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

Постановка задачи. 4.10. Отображение элемента управления, предназначенного для обновления информации в табличных видах. Глава 4. Создание и использование табличных видов. iOS. Приемы программирования.

Рис. 4.24. Элемент управления для обновления информации, расположенный над табличным видом

Решение.

Создайте табличный контроллер вида (так, как описано в разделе 4.9) и задайте в качестве значения его свойства refreshControl новый экземпляр класса UIRefreshControl, как показано далее:

— (id)initWithStyle:(UITableViewStyle)style{

self = [super initWithStyle: style];

if (self) {

[self.tableView registerClass: [UITableViewCell class]

forCellReuseIdentifier: CellIdentifier];

self.allTimes = [NSMutableArray arrayWithObject: [NSDate date]];

/* Создаем элемент управления для обновления информации */

self.refreshControl = [[UIRefreshControl alloc] init];

self.refreshControl = self.refreshControl;

[self.refreshControl addTarget: self

action:@selector(handleRefresh:)

forControlEvents: UIControlEventValueChanged];

}

return self;

}

Обсуждение.

Элементы управления для обновления информации — это простые визуальные индикаторы, располагающиеся над табличным видом и сообщающие пользователю, что какая-то информация в таблице сейчас обновится. Например, чтобы обновить содержимое почтового ящика в приложении Mail в версиях старше iOS 6, вам приходилось нажимать на специальную кнопку Refresh (Обновить). В новой iOS 7 вы можете просто потянуть список ваших писем вниз, как если бы хотели ознакомиться с какими-то письмами из верхней части списка, которые пока не успели прочитать. Как только iOS зафиксирует такой жест, система инициирует обновление. Круто, правда? Это нововведение впервые появилось в Twitter-клиенте для iPhone, большое спасибо за это его разработчикам. Apple по достоинству оценила всю элегантность и логичность этой возможности обновления видов, поэтому в SDK был добавлен специальный компонент для реализации такой функции. Класс, соответствующий этому компоненту, называется UIRefreshControl.

Чтобы создать новый экземпляр этого класса, достаточно просто вызвать его метод init. Сделав это, добавьте экземпляр к табличному контроллеру вида, как описано в подразделе «Решение» данного раздела.

Итак, вы хотите знать, когда пользователь инициирует обновление информации в табличном виде. Для этого просто вызовите метод экземпляра addTarget: action: forControlEvents: обновляющего элемента и передайте ему целевой объект вместе с селектором этого объекта — остальное система сделает за вас. Передайте событие UIControlEventValueChanged параметру forControlEvents этого метода.

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

#import «ViewController.h»

static NSString *CellIdentifier = @"Cell";

@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *allTimes;

@property (nonatomic, strong) UIRefreshControl *refreshControl;

@end

@implementation ViewController

Свойство allTimes — это обычный изменяемый массив, который будет содержать все экземпляры NSDate в момент, когда завершится обновление таблицы. Мы уже рассмотрели инициализацию табличного контроллера вида в подразделе «Решение» данного раздела, поэтому я не буду вновь писать об этом. Но, как вы помните, мы прикрепили событие UIControlEventValueChanged обновляющего элемента управления к методу handleRefresh:. В этом методе мы всего лишь собираемся добавить к массиву дату и время, после чего обновить табличный вид:

— (void) handleRefresh:(id)paramSender{

/* Оставляем небольшую задержку между высвобождением обновляющего элемента

управления и самим моментом обновления. Так весь процесс выглядит

в интерфейсе более плавно, чем при использовании обычной анимации */

int64_t delayInSeconds = 1.0f;

dispatch_time_t popTime =

dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);

dispatch_after(popTime, dispatch_get_main_queue(), ^(void){

/* Добавляем актуальную дату к имеющемуся списку дат;

Таким образом, при обновлении табличного вида новый информационный

элемент на экране будет находиться над старым и пользователь увидит

разницу во времени до и после обновления */

[self.allTimes addObject: [NSDate date]];

[self.refreshControl endRefreshing];

NSIndexPath *indexPathOfNewRow =

[NSIndexPath indexPathForRow: self.allTimes.count-1 inSection:0];

[self.tableView

insertRowsAtIndexPaths:@[indexPathOfNewRow]

withRowAnimation: UITableViewRowAnimationAutomatic];

});

}

Последний важный момент: мы записываем дату в табличный вид посредством методов делегата и источника данных табличного вида:

— (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{

return 1;

}

— (NSInteger) tableView:(UITableView *)tableView

numberOfRowsInSection:(NSInteger)section{

return self.allTimes.count;

}

— (UITableViewCell *)tableView:(UITableView *)tableView

cellForRowAtIndexPath:(NSIndexPath *)indexPath{

UITableViewCell *cell = [tableView

dequeueReusableCellWithIdentifier: CellIdentifier

forIndexPath: indexPath];

cell.textLabel.text = [NSString stringWithFormat:@"%@",

self.allTimes[indexPath.row]];

return cell;

}

Опробуйте в эмуляторе или на устройстве то, что у нас получилось. Открыв приложение, вы сразу заметите только одно значение даты и времени в списке. Но если потянуть таблицу вниз, то постепенно перед вами будут открываться новые элементы (см. рис. 4.24).

См. также.

Раздел 4.9.

Глава 5. Выстраивание сложных макетов с помощью сборных видов.

5.0. Введение.

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

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

Именно поэтому в 6-й версии iOS компания Apple впервые внедрила сборные виды. Сборный вид можно сравнить с сильно усовершенствованным прокручиваемым видом. У него есть источник данных и делегат, как и у табличного вида. Но он обладает одним свойством, делающим его совершенно несхожим с табличным или прокручиваемым видами. Речь идет о макетном объекте.

В сущности, макетный объект вычисляет, где должен быть размещен каждый элемент, входящий в состав сборного вида. Однако Apple немного усложнила такую работу, внедрив конкретный класс для работы со сборными видами, причем этот класс нельзя инстанцировать напрямую. Вместо этого придется инстанцировать подкласс от этого класса, называемый UICollectionViewFlowLayout.

Этот подкласс обеспечивает последовательную компоновку, при которой ячейки из сборного вида распределяются на экране по секциям. Каждая секция — это группа ячеек сборного вида, так же как в табличном виде. Однако в сборном виде любая секция может компоноваться на экране разными способами, не обязательно вертикально. Например, у вас может быть три прямоугольника, в каждом из которых содержится своя маленькая таблица (рис. 5.1).

5.0. Введение. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.1. Типичный макет с последовательной компоновкой в сборном виде

Как правило, секции располагаются на экране в виде таблиц, то есть образуя строки и столбцы. Именно эта задача решается с помощью класса последовательной компоновки. Если вы хотите добиться еще большей свободы действий при компоновке, то попробуйте изменить свойства класса последовательной компоновки. А если желаете сделать нечто, значительно отличающееся от стандартных возможностей последовательной компоновки, создайте для этого собственный класс. Например, такой специальный класс вам потребуется для создания сборного вида, который показан на рис. 5.2. Далее приведен специальный класс компоновки, располагающий соответствующие ячейки совсем не по табличному принципу.

5.0. Введение. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.2. Специальный вариант компоновки для сборного вида

5.1. Создание сборных видов.

Постановка задачи.

Требуется отобразить на экране сборный вид.

Решение.

Либо воспользуйтесь экземпляром UICollectionView, который в таком случае нужно сделать дочерним видом одного из видов вашего приложения (если хотите создать полноэкранный сборный вид), либо примените класс UICollectionViewController.

Обсуждение.

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

Сначала рассмотрим вариант с полноэкранным видом.

1. Откройте Xcode.

2. В меню File (Файл) выберите New (Новый), а затем Project (Проект).

3. Слева в качестве основной категории выберите iOS, а под ней — Application (Приложение). В правой части экрана выберите Empty Application (Пустое приложение), после чего нажмите кнопку Next (Далее).

4. На следующем экране введите информацию о вашем проекте и убедитесь, что установлен флажок Use Automatic Reference Counting (Использовать автоматический подсчет ссылок) (рис. 5.3). Как только введете все необходимые значения, нажмите кнопку Next (Далее).

Обсуждение. 5.1. Создание сборных видов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.3. Создание нового проекта Пустое приложение (Empty Application) для сборного вида

5. После этого вам будет предложено сохранить проект на диске. Выберите подходящее для этого место и нажмите кнопку Create (Создать).

6. Теперь, когда проект подготовлен, создайте в нем новый класс и назовите его ViewController. Этот класс должен наследовать от UICollectionViewController. Вам не понадобится. xib-файл для этого контроллера вида, поэтому откажитесь от этой возможности (рис. 5.4).

Обсуждение. 5.1. Создание сборных видов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.4. Добавляем в проект новый класс сборного вида

7. Найдите в проекте файл AppDelegate.m (это файл реализации делегата приложения) и откройте его, после чего создайте экземпляр сборного вида, а затем сделайте этот сборный вид корневым контроллером вида вашего приложения, как показано здесь:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

/* Инстанцируем контроллер сборного вида с нулевым макетным объектом.

Примечание: в результате программа выдаст исключение, но позже мы

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

видам */

ViewController *viewController = [[ViewController alloc]

initWithCollectionViewLayout: nil];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

/* Устанавливаем сборный вид в качестве корневого для нашего окна */

self.window.rootViewController = viewController;

[self.window makeKeyAndVisible];

return YES;

}

Как только вы запустите ваше приложение, оно аварийно завершится и выдаст сообщение о том, что вы указали нулевой макетный объект для вашего сборного вида. И здесь среда времени исполнения действует совершенно правильно. Так делать нельзя. Но мы просто пока не обсудили, как инстанцировать макетные объекты и передавать их в сборные виды. Поэтому пока оставим все как есть. Далее в этой главе мы подробнее поговорим о макетных объектах сборных видов.

Итак, мы уже научились создавать контроллер сборного вида, и это хорошо, если вы хотите, чтобы такой вид при отображении занимал на устройстве весь экран. Однако если вы разрабатываете специальный компонент, входящий в состав другого, более крупного вида, то попробуйте просто инстанцировать объект типа UICollectionView, воспользовавшись его выделенным инициализатором — методом initWithFrame: collectionViewLayout:.

Чтобы это сделать, требуется просто инстанцировать сборный вид, воспользовавшись указанным инициализатором. После инициализации вы сможете добавить сборный вид в качестве дочернего к другому виду. Например, если вы хотите добавить его к вашему виду контроллера вида, просто вызовите метод addSubview: этого вида с контроллером и передайте экземпляр вашего сборного вида этому методу в качестве параметра. Кроме того, нужно убедиться, что в качестве значений свойств delegate и dataSource сборного вида заданы валидные объекты, соответствующие протоколам UICollectionViewDelegate и UICollectionViewDataSource. Выполнить остальные операции не составляет труда. Далее в этой главе описаны все приемы, используемые для наполнения сборного вида информацией из источника данных и реагирования на события с помощью объекта-делегата.

См. также.

Раздел 5.0.

5.2. Присваивание источника данных сборному виду.

Постановка задачи.

Требуется предоставить для сборного вида данные, которые будут выводиться на экран.

Решение.

Присвойте сборному виду источник данных, воспользовавшись свойством dataSource класса UICollectionView. Источник данных должен быть объектом, который соответствует протоколу UICollectionViewDataSource. Кроме того, само собой разумеется, что объект источника данных обязательно должен реализовывать методы и свойства этого протокола, относящиеся к категории required.

Обсуждение.

Источник данных сборного вида, как и источник данных табличного вида, отвечает за предоставление сборному виду достаточного для отображения на экране количества информации. Способ отображения данных на экране не входит в компетенцию источника данных — это задача макета. Ячейки, отображаемые макетным объектом в сборном виде, в итоге будут предоставляться источником данных сборного вида.

Вот методы протокола UICollectionViewDataSource, которые обязательно требуется реализовать в вашем источнике данных.

• collectionView: numberOfItemsInSection: — этот метод возвращает объект NSInteger, сообщающий сборному виду количество элементов, которые должны быть отображены в заданной секции. Задаваемая секция сообщается данному методу как целое число, представляющее собой индекс с нулевым основанием для данной секции. Именно так происходит и при работе с табличными видами.

• collectionView: cellForItemAtIndexPath: — ваша реализация этого метода должна возвращать экземпляр UICollectionViewCell, соответствующий ячейке, к которой ведет указанный индексный путь. Класс UICollectionViewCell наследует от UICollectionReusableView. Фактически любая доступная для повторного использования ячейка, передаваемая сборному виду для отображения, должна прямо или косвенно наследовать от UICollectionReusableView, о чем мы подробно поговорим в этой главе. Индексный путь указывается в параметре cellForItemAtIndexPath этого метода. Вы можете запросить индексы section и row этого элемента из индексного пути.

Перейдем к файлу реализации контроллера сборного вида (ViewController.m). Этот контроллер мы создали в разделе 5.1. Реализуем в данном файле рассмотренные ранее методы источника данных сборного вида:

#import «ViewController.h»

@implementation ViewController

/* Пока мы не собираемся возвращать никаких секций */

— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

return 0;

}

/* Мы пока не знаем, как возвращать секции в сборный вид, поэтому для начала возвратим здесь nil */

— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{

return nil;

}

@end

На данном этапе этот код можно считать полным. Но, как было указано в разделе 5.1, при попытке его запустить приложение аварийно завершится. Дело в том, что делегат приложения устанавливает макетный объект сборного вида в значение nil. Эта проблема никуда не исчезла, мы собираемся устранить ее в разделе 5.3.

См. также.

Разделы 5.0 и 5.1.

5.3. Обеспечение последовательной компоновки в сборном виде.

Постановка задачи.

Требуется, чтобы ваш сборный вид был скомпонован как таблица (сетка), чтобы его содержимое отображалось примерно так же, как на рис. 5.1.

Решение.

Создайте экземпляр класса UICollectionViewFlowLayout, инстанцируйте контроллер сборного вида с помощью выделенного метода-инициализатора initWithCollectionViewLayout: из класса UICollectionViewController, а затем передайте этому методу ваш макетный объект.

Обсуждение.

Макет для последовательной компоновки очень легко инстанцировать. Но прежде, чем можно будет передать его сборному виду, он должен быть сконфигурирован. Здесь мы обсудим различные свойства экземпляра класса UICollectionViewFlowLayout и поговорим о том, как их можно корректировать. Кроме того, нас интересует, как эти свойства влияют на отображение ячеек сборного вида на экране.

• minimumLineSpacing — значение с плавающей точкой, сообщающее макету с последовательной компоновкой минимальное количество точек, которые необходимо зарезервировать между рядами. Макетный объект может выделить и больше пространства, чтобы компоновка выглядела красиво, но меньше выделить не может. Если ваш сборный вид слишком мал и в него не помещаются все элементы, они будут обрезаться, как и любые другие виды в iOS SDK.

• minimumInteritemSpacing — значение с плавающей точкой, сообщающее макету с последовательной компоновкой минимальное количество точек, которые необходимо зарезервировать между ячейками в одной строке. Опять же это минимальное количество точек, и макет может увеличить это количество в зависимости от размера сборного вида.

• itemSize — величина CGSize, соответствующая размеру каждой ячейки в сборном виде.

• scrollDirection — значение типа UICollectionViewScrollDirection, сообщающее макету с последовательной компоновкой, как должно прокручиваться содержимое сборного вида. Содержимое может прокручиваться либо по горизонтали, либо по вертикали, но не в обоих направлениях одновременно. По умолчанию это свойство имеет значение UICollectionViewScrollDirectionVertical, но вы можете изменить его на UICollectionViewScrollDirectionHorizontal.

• sectionInset — значение типа UIEdgeInsets, задающее размер полей вокруг каждой секции. В принципе, поля — это пространство, которое не относится ни к одной из ячеек. Для создания таких отступов можно воспользоваться функцией UIEdgeInsetsMake. У каждого поля есть верхний, нижний, правый и левый край, все они обозначаются числами с плавающей точкой. Не волнуйтесь, если это объяснение кажется путаным — вскоре все встанет на свои места.

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

#import «AppDelegate.h»

#import «ViewController.h»

@implementation AppDelegate

— (UICollectionViewFlowLayout *) flowLayout{

UICollectionViewFlowLayout *flowLayout =

[[UICollectionViewFlowLayout alloc] init];

flowLayout.minimumLineSpacing = 20.0f;

flowLayout.minimumInteritemSpacing = 10.0f;

flowLayout.itemSize = CGSizeMake(80.0f, 120.0f);

flowLayout.scrollDirection = UICollectionViewScrollDirectionVertical;

flowLayout.sectionInset = UIEdgeInsetsMake(10.0f, 20.0f, 10.0f, 20.0f);

return flowLayout;

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

/* Инстанцируем контроллер сборного вида с валидным макетом

для последовательной компоновки */

ViewController *viewController =

[[ViewController alloc]

initWithCollectionViewLayout: [self flowLayout]];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

/* Задаем сборный вид в качестве корневого контроллера вида окна */

self.window.rootViewController = viewController;

[self.window makeKeyAndVisible];

return YES;

}

Реализация контроллера сборного вида остается такой же, как в разделе 5.2. Если сейчас запустить приложение, то вы увидите просто черный экран, так как в стандартной реализации контроллера сборного вида фон вида даже не заменяется на белый. Пока нас это устраивает. Как минимум приложение уже не завершается аварийно, поскольку у нас уже есть объекты макета.

См. также.

Разделы 5.1 и 5.2.

5.4. Наполнение сборного вида простейшим содержимым.

Постановка задачи.

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

Решение.

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

Обсуждение.

В данном разделе я исхожу из того, что вы уже проработали разделы 5.1–5.3 и выполнили базовую настройку проекта.

Будем работать по порядку. Начнем с самого простого и самого быстрого способа создания ячеек. Инстанцируем объекты типа UICollectionViewCell и занесем их в сборный вид в нашем источнике данных. У класса UICollectionViewCell есть свойство вида с содержимым, называемое contentView, куда вы можете добавлять для отображения собственные виды. Кроме того, можете задавать и многие другие свойства ячейки, например цвет фона. Именно цветом фона мы и займемся в этом примере. Но перед тем, как начать, опишем, чего мы собираемся добиться в данном разделе, подробно объясним стоящие перед нами требования.

Мы собираемся запрограммировать сборный вид с последовательной компоновкой, в котором будут отображаться три секции. В каждой из секций будет находиться от 20 до 40 ячеек, причем в первой секции все ячейки красные, во второй — зеленые, в третьей — синие (рис. 5.5).

Обсуждение. 5.4. Наполнение сборного вида простейшим содержимым. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.5. Простой сборный вид с последовательной компоновкой, в котором отображаются три секции с ячейками разных цветов

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

/* У нас будет три секции, и для каждой из них мы определим свой цвет ячеек. Для представления цвета используются самые обычные экземпляры UIColor, которые мы позже применим к каждой из ячеек в соответствующих секциях */

— (NSArray *) allSectionColors{

static NSArray *allSectionColors = nil;

if (allSectionColors == nil){

allSectionColors = @[

[UIColor redColor],

[UIColor greenColor],

[UIColor blueColor],

];

}

return allSectionColors;

}

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

В более ранних версиях iOS приходилось вручную создавать ячейки, если табличному виду не удавалось найти готовые ячейки для повторного использования (сборные виды в ранних версиях iOS отсутствовали). Однако с появлением новых API Apple выполнила очень интересную работу, связанную с многократно используемыми ячейками. Компания предоставила новые API как для табличных, так и для сборных видов. Поэтому вы можете зарегистрировать вызов и с табличным видом, и со сборным видом. Если же вам приходится конфигурировать новую ячейку, то вы просто требуете от табличного или сборного вида новую ячейку нужного рода. Если такая ячейка имеется в очереди многократного использования, то она (ячейка) будет вам предоставлена. Если нет — то табличный или сборный вид автоматически создаст такую ячейку. Этот механизм называется регистрацией многоразовой ячейки, он реализуется двумя способами:

• регистрацией ячейки с использованием имени класса;

• регистрацией ячейки с использованием. xib-файла.

Оба этих способа регистрации многоразовых ячеек вполне хороши и отлично работают со сборными видами. Чтобы зарегистрировать новую ячейку для сборного вида, воспользовавшись ее именем класса, применяется метод registerClass: forCellWithReuseIdentifier: класса UICollectionView, где идентификатор — обычная строка, которую вы сообщаете сборному виду. При попытке получить многоразовые ячейки вы запрашиваете у сборного вида ячейку с заданным идентификатором. Чтобы зарегистрировать со сборным видом. xib-файл, необходимо использовать метод экземпляра registerNib: forCellWithReuseIdentifier: сборного вида. Идентификатор этого метода также вполне функционален, об этом рассказано ранее в данном абзаце.

Nib-файл — это объект типа UINib, с ним мы подробнее познакомимся далее в этой главе.

— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{

self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем со сборным видом ячейку для ее удобного получения */

[self.collectionView registerClass: [UICollectionViewCell class]

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];

}

return self;

}

Как видите, в качестве идентификатора для ячеек мы используем константное значение kCollectionViewCellIdentifier. Необходимо определить его в контроллере вида:

#import «ViewController.h»

static NSString *kCollectionViewCellIdentifier = @"Cells";

@implementation ViewController

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

— (NSInteger)numberOfSectionsInCollectionView

:(UICollectionView *)collectionView{

return [self allSectionColors].count;

}

Одно из требований, предъявляемых к нашему приложению, такое: каждая секция должна содержать не менее 20, но не более 40 ячеек. Эту задачу можно решить с помощью функции arc4random_uniform(x). Она возвращает положительные целые числа в диапазоне от 0 до x, где x — параметр, который вы сообщаете этой функции. Следовательно, если требуется сгенерировать число в диапазоне от 20 до 40, всего лишь нужно прибавить 20 к возвращаемому значению этой функции, а значение x также сделать равным 20. Зная это, реализуем метод collectionView: numberOfItemsInSection: из источника данных сборного вида:

— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

/* Генерируем от 20 до 40 ячеек для заполнения каждой секции */

return 20 + arc4random_uniform(21);

}

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

— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{

UICollectionViewCell *cell =

[collectionView

dequeueReusableCellWithReuseIdentifier: kCollectionViewCellIdentifier

forIndexPath: indexPath];

cell.backgroundColor = [self allSectionColors][indexPath.section];

return cell;

}

Индексные пути просто содержат номер секции и номер строки. Поэтому индексный путь 0, 1 указывает, что речь идет о второй строке первой секции, поскольку индексы имеют нулевое основание. Если же мы захотим указать пятую строку десятой секции, то обозначим индексный путь как 9, 4. Индексные пути очень широко используются при работе с табличными и сборными видами, так как органично подходят для описания секций, каждая из которых наполнена ячейками. Делегаты и источники данных для табличных и сборных видов при работе указывают целевую ячейку именно по ее индексному пути. Например, если пользователь нажмет ячейку в сборном виде, то вы получите его индексный путь. С помощью этого индексного пути вы также сможете просмотреть базовую структуру данных конкретной ячейки (речь идет о данных, которые использовались в вашем классе для создания этой ячейки).

Как видите, здесь используется метод экземпляра dequeueReusableCellWithReuseIdentifier: forIndexPath:, относящийся к сборному виду. Этот метод применяется для извлечения многоразовых ячеек из очереди. Этот метод ожидает получения двух параметров: идентификатора ячейки, которую вы ранее зарегистрировали с этим сборным видом, а также индексного пути, по которому должна быть отображена ячейка. Индексный путь вы получаете в том же самом методе collectionView: cellForItemAtIndexPath: в качестве параметра, поэтому остается всего лишь сообщить идентификатор ячейки.

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

Итак, остался последний шаг перед завершением данного примера. Сделаем фон сборного вида белым, чтобы он выглядел немного лучше, чем со стандартным черным фоном. Реализуйте метод viewDidLoad контроллера сборного вида и задайте фоновый цвет для данного вида прямо в этом методе:

— (void) viewDidLoad{

[super viewDidLoad];

self.collectionView.backgroundColor = [UIColor whiteColor];

}

Экземпляр UICollectionViewController имеет вид типа UIView, к которому можно получить доступ по его свойству view. Не путайте этот вид со свойством collectionView вашего контроллера, соответствующим той сущности, в которой располагается сам сборный вид.

Красота решения, предложенного в данном разделе, заключается в том, что оно отлично работает и на iPad, и на iPhone. На рис. 5.5 показано, как результат выглядит на iPad, на рис. 5.6 — как на iPhone.

Обсуждение. 5.4. Наполнение сборного вида простейшим содержимым. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.6. Простой сборный вид, изображенный в эмуляторе iPhone

См. также.

Разделы 5.1–5.3.

5.5. Заполнение сборных видов специальными ячейками с помощью XIB-файлов.

Постановка задачи.

Требуется сконфигурировать ячейки сборного вида в конструкторе интерфейса и заполнить ими сборный вид для последующего отображения.

Решение.

Выполните следующие шаги.

1. Создайте подкласс UICollectionViewCell и назовите его (в данном примере мы будем использовать имя CollectionViewCell).

2. Создайте пустой. xib-файл и назовите его MyCollectionViewCell.xib.

3. Поместите в конструктор интерфейса ячейку сборного вида (ее вы найдете в библиотеке объектов). Она должна оказаться в вашем пустом. xib-файле (рис. 5.7). В конструкторе интерфейсов измените имя объекта-ячейки на MyCollectionViewCell (рис. 5.8). Поскольку вы устанавливаете такую ассоциацию, когда загружаете. xib-файл программно, специальный класс MyCollectionViewCell будет автоматически попадать в память. Волшебство, да и только!

Решение. 5.5. Заполнение сборных видов специальными ячейками с помощью XIB-файлов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.7. Объект пользовательского интерфейса «ячейка сборного вида» в библиотеке объектов конструктора интерфейса

Решение. 5.5. Заполнение сборных видов специальными ячейками с помощью XIB-файлов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.8. Присваивание специального класса. xib-файлу ячейке специального сборного вида

4. Оформите ячейку в конструкторе интерфейса. Необходимо гарантировать, что для каждого компонента пользовательского интерфейса, который вы помещаете в ячейку, создается также ассоциированный с ней объект IBOutlet, расположенный либо в заголовочном файле, либо в файле реализации вашего класса (MyCollectionViewCell).

5. Зарегистрируйте с вашим сборным видом. nib-файл, воспользовавшись для этого методом экземпляра registerNib: forCellWithReuseIdentifier: сборного вида. Чтобы загрузить. nib-файл в память, используется метод класса nibWithNibName: bundle:, относящийся к классу UINib. Об этом методе мы вскоре поговорим.

Обсуждение.

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

1. Откройте File — New — File (Файл — Новый — Файл).

2. В левой части экрана в категории iOS выберите запись User Interface (Пользовательский интерфейс), а в правой части — вариант Empty (Пустой).

3. Теперь система запросит у вас семейство устройств, к которому относится данный. xib-файл. Здесь просто выберите iPhone.

4. Далее вам будет предложено сохранить. xib-файл на диск. Сохраните его под именем MyCollectionViewCell.xib.

Кроме того, потребуется создать класс, который вы сможете связать с содержимым. xib-файла. Этот класс мы назовем MyCollectionViewCell, он будет наследовать от UICollectionViewCell. Чтобы его создать, выполните следующие шаги.

1. Откройте File-New-File (Файл-Новый-Файл).

2. В диалоговом окне для создания нового файла в категории iOS выберите вариант Cocoa Touch. В правой части экрана выберите Objective-C class (Класс Objective-C).

3. Назовите класс MyCollectionViewCell и выберите UICollectionViewCell в качестве его класса-предка.

4. Когда вам будет предложено сохранить файл на диске, так и сделайте.

Теперь нужно ассоциировать созданный класс с. xib-файлом. Для этого выполните следующие шаги.

1. Откройте файл MyCollectionViewCell.xib в конструкторе интерфейса. В библиотеке объектов просто найдите объект Collection View Cell (Ячейка сборного вида) и поместите ее в. xib-файл. По умолчанию эта ячейка будет очень маленькой (50 × 50 точек) и будет иметь черный фон.

2. Явно выберите эту ячейку в вашем. xib-файле, щелкнув на ней. Откройте инспектор идентичности (Identity Inspector) в конструкторе интерфейса и измените значение поля Class (Класс) на MyCollectionViewCell, как было показано на рис. 5.8.

Далее следует добавить в ячейку нужные компоненты пользовательского интерфейса. Позже при заполнении сборного вида информацией значения этих компонентов можно будет изменить. Для данного примера лучше всего подойдет вид с изображением. Поэтому, когда у вас в конструкторе интерфейса открыт файл MyCollectionViewCell.xib, поместите в него экземпляр UIImageView. Подключите этот вид с изображением к заголовочному файлу вашей ячейки (MyCollectionViewCell.h) и назовите его imageViewBackgroundImage, чтобы заголовочный файл ячейки выглядел примерно так:

#import <UIKit/UIKit.h>

@interface MyCollectionViewCell: UICollectionViewCell

@property (weak, nonatomic) IBOutlet UIImageView *imageViewBackgroundImage;

@end

Мы собираемся заполнить этот вид разными изображениями. В этом разделе я создал для работы три простых изображения, каждое размером 50 × 50 точек. Вы можете пользоваться любыми другими картинками на ваш выбор — просто поищите их в Интернете. Когда найдете понравившиеся вам картинки, добавьте их в свой проект. Убедитесь, что изображения называются 1.png, 2.png и 3.png и что их увеличенные вдвое аналоги для сетчатого дисплея называются 1@2x.png, 2@2x.png и 3@2x.png.

В данном примере мы собираемся отобразить примерно такой же пользовательский интерфейс, как на рис. 5.5. Но мы будем задавать для ячеек не цвета, а фоновые изображения, причем случайные. Поэтому целесообразно использовать в качестве основы для данного примера тот код, который мы написали в разделе 5.4, так как результат будет очень похожим.

Первое изменение, которое предстоит внести, заключается в написании метода, с помощью которого мы будем возвращать случайное изображение. Как было объяснено ранее, у нас есть массив изображений. После инстанцирования массива нам понадобится удобный небольшой метод, который будет выбирать из массива случайное изображение:

— (NSArray *) allImages{

static NSArray *AllSectionImages = nil;

if (AllSectionImages == nil){

AllSectionImages = @[

[UIImage imageNamed:@"1"],

[UIImage imageNamed:@"2"],

[UIImage imageNamed:@"3"]

];

}

return AllSectionImages;

}

— (UIImage *) randomImage{

return [self allImages][arc4random_uniform([self allImages].count)];

}

Далее потребуется переопределить выделенный метод-инициализатор контроллера сборного вида, чтобы зарегистрировать. nib-файл MyCollectionViewCell с этим сборным видом:

— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{

self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем nib-файл со сборным видом для удобства получения информации */

UINib *nib = [UINib nibWithNibName:

NSStringFromClass([MyCollectionViewCell class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: nib

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];

}

return self;

}

В ответ на запрос о том, сколько у нас секций, также возвратим случайное число в диапазоне от 3 до 6. Это требование не является обязательным — мы вполне могли бы обойтись и одной секцией, но если их будет больше, это точно не помешает. Кроме того, в каждой секции должно быть от 10 до 15 ячеек:

— (NSInteger)numberOfSectionsInCollectionView

:(UICollectionView *)collectionView{

/* От 3 до 6 секций */

return 3 + arc4random_uniform(4);

}

— (NSInteger)collectionView:(UICollectionView *)collectionView

numberOfItemsInSection:(NSInteger)section{

/* В каждой секции — от 10 до 15 ячеек */

return 10 + arc4random_uniform(6);

}

Наконец, запросим у сборного вида ячейки, а затем сконфигурируем их со случайными фоновыми изображениями:

— (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView

cellForItemAtIndexPath:(NSIndexPath *)indexPath{

MyCollectionViewCell *cell =

[collectionView

dequeueReusableCellWithReuseIdentifier: kCollectionViewCellIdentifier

forIndexPath: indexPath];

cell.imageViewBackgroundImage.image = [self randomImage];

cell.imageViewBackgroundImage.contentMode = UIViewContentModeScaleAspectFit;

return cell;

}

Как видите, мы используем специальный класс MyCollectionViewCell в контроллере сборного вида. Чтобы программа успешно скомпилировалась, необходимо включить заголовочный файл ячейки в реализацию контроллера вида, вот так:

#import «ViewController.h»

#import «MyCollectionViewCell.h»

Запустив приложение, вы увидите примерно такую картинку, как на рис. 5.9. Разумеется, если вы используете в примере другие изображения, она будет другой, но у меня тут показаны нотки.

Обсуждение. 5.5. Заполнение сборных видов специальными ячейками с помощью XIB-файлов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.9. Сборный вид со специальными ячейками, загруженными из. nib-файла

См. также.

Раздел 5.4.

5.6. Обработка событий в сборных видах.

Постановка задачи.

Необходимо обрабатывать события, происходящие в сборных видах, например касания.

Решение.

Присвойте делегат сборному виду. В других случаях не придется делать даже этого. Порой достаточно просто слушать интересующие вас события в классах ячеек и обрабатывать их прямо в этих классах.

Обсуждение.

У сборных видов есть свойства delegate, которые должны соответствовать протоколу UICollectionViewDelegate. Делегатный объект, создаваемый с их помощью, будет получать различные делегатные вызовы от сборного вида, сообщающего делегату о различных событиях, например о том, что элемент был подсвечен или выделен. Необходимо различать подсвеченное и выделенное состояние ячейки сборного вида. Когда пользователь нажимает пальцем на ячейку сборного вида, но не поднимает палец сразу после этого, ячейка под пальцем становится подсвеченной. Когда пользователь нажимает на ячейку, а затем сразу поднимает палец (это означает, что он хочет совершить с ячейкой какое-то действие), данная ячейка становится выделенной.

Ячейки сборных видов, относящиеся к типу UICollectionViewCell, имеют два очень полезных свойства — highlighted и selected.

Если вы хотите всего лишь изменить визуальное оформление вашей ячейки, когда она выделена, то задача тем более упрощается, поскольку ячейки типа UICollectionViewCell предоставляют свойство selectedBackgroundView типа UIView. В качестве значения этого свойства можно задать любой валидный вид. Затем этот вид отобразится на экране, как только ячейка будет выделена. Продемонстрируем эти возможности на основе кода, который мы написали в разделе 5.5. Как вы помните, там мы создали специальную ячейку, одно из свойств которой (imageViewBackgroundImage) снабжало ее фоновым изображением. Изображение заполняло весь фон ячейки. В этот вид с изображением мы загружали специально подобранные картинки. Теперь мы собираемся залить фон ячейки голубым цветом, как только она будет выделена. Поскольку вид с изображением находится поверх всех остальных компонентов сборного вида, перед заданием фонового цвета нам придется гарантировать, что этот вид с изображением будет прозрачным. Для этого оттенок фона вида с изображением нужно изменить на проницаемый. Дело в том, что по умолчанию фон у вида с изображением непрозрачный, поэтому если расположить такой вид поверх другого вида, имеющего фоновый цвет, то этот фоновый цвет, естественно, виден не будет. Соответственно, чтобы оставался виден фоновый цвет того вида, который является вышестоящим для вида с изображением, фон самого вида с изображением должен быть прозрачным. Итак, начнем:

#import «MyCollectionViewCell.h»

@implementation MyCollectionViewCell

— (void) awakeFromNib{

[super awakeFromNib];

self.imageViewBackgroundImage.backgroundColor = [UIColor clearColor];

self.selectedBackgroundView = [[UIView alloc] initWithFrame: self.bounds];

self.selectedBackgroundView.backgroundColor = [UIColor blueColor];

}

@end

Вот и все! Теперь если нажать любую ячейку в вашей программе, она сразу приобретет голубой цвет фона.

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

Протокол UICollectionViewDelegateFlowLayout, как и рассмотренный нами в главе 4 протокол UITableViewDelegate, позволяет сообщать информацию о ваших элементах — например, значения их высоты и ширины, — а потом передавать эти значения макету с последовательной компоновкой. Можно сразу предоставить для всех элементов такого макета обобщенное значение размера, тогда они получатся одинаковыми. Другой вариант — реагировать на соответствующие сообщения, которые вы будете получать от протокола делегата макета с последовательной компоновкой. В этих сообщениях программа будет запрашивать у вас значения размеров для тех или иных ячеек в макете.

• collectionView: didHighlightItemAtIndexPath: — вызывается в делегате, когда ячейка подсвечивается.

• collectionView: didUnhighlightItemAtIndexPath: — вызывается в делегате, когда ячейка выходит из подсвеченного состояния. Этот метод срабатывает, когда пользователь успешно завершает событие касания (попадает пальцем по нужному элементу, а потом поднимает палец, совершая, таким образом, жест касания). В другом случае этот метод срабатывает, когда пользователь отменяет сделанное ранее выделение, выводя палец за пределы ячейки.

• collectionView: didSelectItemAtIndexPath: — этот метод вызывается в делегатном объекте, когда конкретная ячейка становится выделенной. Ячейка всегда является подсвеченной, перед тем как стать выделенной.

• collectionView: didDeselectItemAtIndexPath: — вызывается в делегате, когда ячейка выходит из выделенного состояния.

Итак, напишем приложение в соответствии с изложенными выше требованиями. Мы хотим, чтобы ячейка «развоплощалась», а потом вновь «вырисовывалась» на экране, когда ее выделяют. В экземпляре UICollectionViewController реализуем метод collectionView: didSelectItemAtIndexPath:, вот так:

#import «ViewController.h»

#import «MyCollectionViewCell.h»

static NSString *kCollectionViewCellIdentifier = @"Cells";

@implementation ViewController

— (void) collectionView:(UICollectionView *)collectionView

didSelectItemAtIndexPath:(NSIndexPath *)indexPath{

UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];

const NSTimeInterval kAnimationDuration = 0.20;

[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.alpha = 0.0f;

} completion: ^(BOOL finished) {

[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.alpha = 1.0f;

}];

}];

}

Мы пишем этот код в контроллере сборного вида, который по умолчанию выбирается системой и в качестве источника данных, и в качестве делегата этого сборного вида. Он соответствует протоколам UICollectionViewDataSource и UICollectionViewDelegate. Следовательно, вы просто можете реализовать любой метод делегата или источника данных прямо в файле реализации вашего контроллера сборного вида.

В примере выше мы используем анимацию, но это не самое подходящее место, чтобы объяснять принципы работы анимации. Если вы хотите подробнее изучить, как в iOS создается простая анимация, обратитесь к главе 17 этой книги.

Итак, тут все было просто. Рассмотрим другой пример. Допустим, когда ячейка подсвечивается, мы хотим сделать ее вдвое крупнее обычного ее размера, а при выходе этой ячейки из подсвеченного состояния вернуть ей исходный размер. Таким образом, когда пользователь прикасается пальцем к ячейке (но еще не поднимает палец), ячейка увеличивается вдвое, а когда пользователь убирает палец — вновь уменьшается, тоже вдвое. Для этого нам потребуется реализовать в контроллере сборного вида методы collectionView: didHighlightItemAtIndexPath: и collectionView: didUnhighlightItemAtIndexPath: из протокола UICollectionViewDelegate. Как вы помните, контроллеры сборных видов по умолчанию соответствуют протоколам UICollectionViewDelegate и UICollectionViewDataSource:

#import «ViewController.h»

#import «MyCollectionViewCell.h»

static NSString *kCollectionViewCellIdentifier = @"Cells";

const NSTimeInterval kAnimationDuration = 0.20;

@implementation ViewController

— (void) collectionView:(UICollectionView *)collectionView

didHighlightItemAtIndexPath:(NSIndexPath *)indexPath{

UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];

[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.transform = CGAffineTransformMakeScale(2.0f, 2.0f);

}];

}

— (void) collectionView:(UICollectionView *)collectionView

didUnhighlightItemAtIndexPath:(NSIndexPath *)indexPath{

UICollectionViewCell *selectedCell =

[collectionView cellForItemAtIndexPath: indexPath];

[UIView animateWithDuration: kAnimationDuration animations: ^{

selectedCell.transform = CGAffineTransformMakeScale(1.0f, 1.0f);

}];

}

Как видите, мы используем функцию CGAffineTransformMakeScale из фреймворка Core Graphics для создания аффинного преобразования, а потом присваиваем это преобразование самой ячейке. Достигается нужный эффект: сначала ячейка увеличивается вдвое, а потом уменьшается до исходного размера. Эта функция подробнее описана в разделе 17.12.

См. также.

Разделы 5.2, 5.3, 5.5, 17.12.

5.7. Создание верхних и нижних колонтитулов в макете с последовательной компоновкой.

Постановка задачи.

Требуется создать в сборном виде отдельные виды для верхнего и нижнего колонтитулов, так же как в табличном виде. При этом используется последовательная компоновка.

Решение.

Выполните следующие шаги.

1. Создайте по файлу. xib для верхнего и для нижнего колонтитулов.

2. Найдите в библиотеке объектов конструктора интерфейса по одному объекту Collection Reusable View и перетащите их в ваши. xib-файлы. Убедитесь, что эти многоразовые сборные виды являются единственными видами в своих. xib-файлах. Таким образом, многоразовый сборный вид становится корневым видом вашего. xib-файла. Именно так создаются колонтитулы в сборных видах.

3. Если вы хотите более полно контролировать поведение. xib-файлов, создайте класс Objective-C и ассоциируйте с ним корневой вид вашего. xib-файла. Таким образом, всякий раз, когда iOS будет загружать с диска содержимое. xib-файла, ассоциированный с ним класс также будет загружаться в память и вы будете получать доступ к иерархии видов в. xib-файле.

4. Инстанцируйте метод экземпляра registerNib: forSupplementaryViewOfKind: withReuseIdentifier: сборного вида и зарегистрируйте ваши nib-файлы для разновидностей видов UICollectionElementKindSectionHeader и UICollectionElementKindSectionFooter.

5. Чтобы правильно оформить виды верхних и нижних колонтитулов перед тем, как они будут отображены, реализуйте метод collectionView: viewForSupplementaryElementOfKind: atIndexPath: источника данных сборного вида, а в этом методе запустите другой метод сборного вида, dequeueReusableSupplementaryViewOfKind: withReuseIdentifier: forIndexPath:, чтобы извлечь из очереди многоразовый вид верхнего или нижнего колонтитула.

6. Наконец, необходимо убедиться, что размер видов для верхних и нижних колонтитулов задается путем присваивания соответствующих значений свойствам headerReferenceSize и footerReferenceSize макетного объекта, отвечающего за последовательную компоновку.

Обсуждение.

Итак, теперь нам требуется создать. xib-файлы для специальных верхних и нижних колонтитулов. Назовем их Header.xib и Footer.xib. Мы создаем их по тому же принципу, который описан в разделе 5.5, поэтому я не буду вновь повторять здесь этот материал. Убедитесь в том, что и для верхнего и для нижнего колонтитула у вас есть по одному классу Objective-C. Назовите их соответственно Header и Footer. Необходимо гарантировать, что оба этих класса наследуют от UICollectionReusableView. Закончив с этим, сконфигурируйте в конструкторе интерфейса подпись и кнопку, затем перетащите подпись в файл Header, а кнопку — в файл Footer. Свяжите их с вашими классами так, как показано на рис. 5.10 и 5.11.

Обсуждение. 5.7. Создание верхних и нижних колонтитулов в макете с последовательной компоновкой. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.10. Конфигурирование ячейки верхнего колонтитула для сборного вида в конструкторе интерфейса

Обсуждение. 5.7. Создание верхних и нижних колонтитулов в макете с последовательной компоновкой. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.11. Конфигурирование ячейки нижнего колонтитула для сборного вида в конструкторе интерфейса

Я связал подпись из верхнего колонтитула с классом Header с помощью свойства аутлета[4] в файле Header.h. Назовем аутлет просто label:

#import <UIKit/UIKit.h>

@interface Header: UICollectionReusableView

@property (weak, nonatomic) IBOutlet UILabel *label;

@end

То же самое я делаю и в нижнем колонтитуле, связав кнопку из файла Footer.xib с аутлетом из файла Footer.h и назвав аутлет button:

#import <UIKit/UIKit.h>

@interface Footer: UICollectionReusableView

@property (weak, nonatomic) IBOutlet UIButton *button;

@end

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

#import «ViewController.h»

#import «MyCollectionViewCell.h»

#import «Header.h»

#import «Footer.h»

static NSString *kCollectionViewCellIdentifier = @"Cells";

static NSString *kCollectionViewHeaderIdentifier = @"Headers";

static NSString *kCollectionViewFooterIdentifier = @"Footers";

@implementation ViewController

Далее в методе-инициализаторе сборного вида зарегистрируем ячейку сборного вида, ячейку верхнего колонтитула и ячейку нижнего колонтитула. Для этого воспользуемся nib-файлами, которые мы загружаем в память:

— (instancetype) initWithCollectionViewLayout:(UICollectionViewLayout *)layout{

self = [super initWithCollectionViewLayout: layout];

if (self!= nil){

/* Регистрируем nib-файл со сборным видом для удобного получения */

UINib *nib = [UINib nibWithNibName:

NSStringFromClass([MyCollectionViewCell class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: nib

forCellWithReuseIdentifier: kCollectionViewCellIdentifier];

/* Регистрируем nib-файл верхнего колонтитула */

UINib *headerNib = [UINib

nibWithNibName: NSStringFromClass([Header class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: headerNib

forSupplementaryViewOfKind: UICollectionElementKindSectionHeader

withReuseIdentifier: kCollectionViewHeaderIdentifier];

/* Регистрируем nib-файл нижнего колонтитула */

UINib *footerNib = [UINib

nibWithNibName: NSStringFromClass([Footer class])

bundle: [NSBundle mainBundle]];

[self.collectionView registerNib: footerNib

forSupplementaryViewOfKind: UICollectionElementKindSectionFooter

withReuseIdentifier: kCollectionViewFooterIdentifier];

}

return self;

}

Переходим к реализации метода collectionView: viewForSupplemen taryElementOfKind: atIndexPath: сборного вида. Этот метод нужен нам для конфигурирования верхних и нижних колонтитулов и предоставления их обратно сборному виду:

— (UICollectionReusableView *)collectionView:(UICollectionView *)collectionView

viewForSupplementaryElementOfKind:(NSString *)kind

atIndexPath:(NSIndexPath *)indexPath{

NSString *reuseIdentifier = kCollectionViewHeaderIdentifier;

if ([kind isEqualToString: UICollectionElementKindSectionFooter]){

reuseIdentifier = kCollectionViewFooterIdentifier;

}

UICollectionReusableView *view =

[collectionView dequeueReusableSupplementaryViewOfKind: kind

withReuseIdentifier: reuseIdentifier

forIndexPath: indexPath];

if ([kind isEqualToString: UICollectionElementKindSectionHeader]){

Header *header = (Header *)view;

header.label.text = [NSString stringWithFormat:@"Section Header %lu",

(unsigned long)indexPath.section + 1];

}

else if ([kind isEqualToString: UICollectionElementKindSectionFooter]){

Footer *footer = (Footer *)view;

NSString *title = [NSString stringWithFormat:@"Section Footer %lu",

(unsigned long)indexPath.section + 1];

[footer.button setTitle: title forState: UIControlStateNormal];

}

return view;

}

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

— (UICollectionViewFlowLayout *) flowLayout{

UICollectionViewFlowLayout *flowLayout =

[[UICollectionViewFlowLayout alloc] init];

flowLayout.minimumLineSpacing = 20.0f;

flowLayout.minimumInteritemSpacing = 10.0f;

flowLayout.itemSize = CGSizeMake(80.0f, 120.0f);

flowLayout.scrollDirection = UICollectionViewScrollDirectionVertical;

flowLayout.sectionInset = UIEdgeInsetsMake(10.0f, 20.0f, 10.0f, 20.0f);

/* Задаем базовый размер для видов с верхними и нижними колонтитулами */

flowLayout.headerReferenceSize = CGSizeMake(300.0f, 50.0f);

flowLayout.footerReferenceSize = CGSizeMake(300.0f, 50.0f);

return flowLayout;

}

Итак, все готово! Если вы теперь запустите приложение в эмуляторе iPad, то увидите примерно такой результат, как на рис. 5.12.

Обсуждение. 5.7. Создание верхних и нижних колонтитулов в макете с последовательной компоновкой. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.12. Верхние и нижние колонтитулы в сборном виде

См. также.

Разделы 5.2, 5.3, 5.5.

5.8. Добавление собственных вариантов взаимодействий к сборным видам.

Постановка задачи.

Вы хотели бы добавить к сборному виду собственные механизмы распознавания жестов, таких как щипок, чтобы реализовать собственные варианты поведений на базе уже имеющихся.

Решение.

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

Как только выполните описанную работу, добавьте ваш распознаватель жестов к сборному виду. Как вы помните, в экземпляре UICollectionViewController объект вашего сборного вида будет доступен через свойство контроллера collectionView, а не через свойство view.

Обсуждение.

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

Рассмотрим пример. В этом примере мы собираемся добавить к сборному виду возможность уменьшения и увеличения изображения (то есть его масштабирования). Этот пример будет выстроен на основе того, который мы подготовили в разделе 5.5. Итак, первым делом мы должны добавить распознаватель щипков в коллекцию распознавателей жестов, имеющихся в сборном виде. Мы сделаем это в методе viewDidLoad контроллера сборного вида:

— (void) viewDidLoad{

[super viewDidLoad];

self.collectionView.backgroundColor = [UIColor whiteColor];

UIPinchGestureRecognizer *pinch = [[UIPinchGestureRecognizer alloc]

initWithTarget: self

action:@selector(handlePinches:)];

for (UIGestureRecognizer *recognizer in

self.collectionView.gestureRecognizers){

if ([recognizer isKindOfClass: [pinch class]]){

[recognizer requireGestureRecognizerToFail: pinch];

}

}

[self.collectionView addGestureRecognizer: pinch];

}

Настраиваем распознаватель жестов щипка для вызова метода handlePinches: контроллера вида. Сейчас мы напишем этот метод:

— (void) handlePinches:(UIPinchGestureRecognizer *)paramSender{

CGSize DefaultLayoutItemSize = CGSizeMake(80.0f, 120.0f);

UICollectionViewFlowLayout *layout =

(UICollectionViewFlowLayout *)self.collectionView.collectionViewLayout;

layout.itemSize =

CGSizeMake(DefaultLayoutItemSize.width * paramSender.scale,

DefaultLayoutItemSize.height * paramSender.scale);

[layout invalidateLayout];

}

В этом коде есть две очень важные детали.

1. Предполагается, что по умолчанию размер элемента в макете последовательной компоновки сборного вида имеет ширину 80 точек и высоту 120 точек. Именно так мы создали макет с последовательной компоновкой для сборного вида в разделе 5.3. Затем мы берем коэффициент масштабирования, полученный от распознавателя жестов щипка, и умножаем на него размер элементов из сборного вида. В результате эти экранные элементы могут уменьшиться или увеличиться в зависимости от того, как именно пользователь масштабирует экран.

2. После того как был изменен размер элемента, применяемый по умолчанию в макете с последовательной компоновкой, макет необходимо обновить. В табличных видах мы обновляли либо нужные секции таблицы, либо всю таблицу, но в данном случае обновляем или упраздняем макет, прикрепленный к сборному виду. Это делается, чтобы сборный вид полностью «перерисовал» себя после изменения макета. Поскольку сборный вид в каждый момент времени может содержать всего один макетный объект, при упразднении такого макетного объекта потребуется перезагрузить весь сборный вид. Если бы мы могли иметь отдельный макет для каждой секции, то могли бы перезагружать только те секции, которые связаны с данным макетом. Но, имея такой код, как сейчас, при упразднении макетного объекта придется перерисовывать весь сборный вид.

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

См. также.

Разделы 5.3 и 5.5.

5.9. Представление контекстных меню в ячейках сборных видов.

Постановка задачи.

Если пользователь нажимает на один из экранных элементов в вашем сборном виде и удерживает на нем палец, требуется вывести контекстное меню. С помощью команд из этого меню элемент можно будет скопировать, переместить и т. д.

Решение.

Контекстные меню по умолчанию встроены в сборные виды. Чтобы активизировать их, потребуется всего лишь реализовать следующие методы из протокола UICollectionViewDelegate.

• collectionView: shouldShowMenuForItemAtIndexPath: — среда времени исполнения передает этому методу индексный путь к элементу. Метод возвращает логическое значение, указывающее дальнейшее действие: должен этот элемент открывать контекстное меню или нет.

• collectionView: canPerformAction: forItemAtIndexPath: withSender: — среда времени исполнения передает этому методу селектор типа SEL. Можно проверить селектор (обычно для этого он преобразуется в строку, которая затем сравнивается со строкой, представляющей действие) и определить, хотите ли вы, чтобы указанное действие произошло. Возвратите YES, чтобы разрешить такое действие, либо NO, чтобы подавить его. Не забывайте, что вы всегда можете преобразовать селектор в строку, воспользовавшись методом NSStringFromSelector. Типичные примеры селекторов — copy: или paste: для команд контекстного меню Копировать или Вставить соответственно.

• collectionView: performAction: forItemAtIndexPath: withSender: — здесь выполняется действие, которое было с вашего разрешения отображено в сборном виде с помощью вышеупомянутых делегатных методов.

Обсуждение.

Не откладывая в долгий ящик, расширим код, написанный в разделе 5.5. Мы будем выводить в ячейках контекстное меню Copy (Копировать), если пользователь нажмет на ячейку и на некоторое время задержит на ней палец. Когда пользователь выбирает элемент в меню копирования, мы скопируем изображение из ячейки в буфер обмена. После этого пользователь сможет вставить это изображение в файлы из других программ, например из почтового приложения Mail.

Первым делом реализуем в делегате сборного вида метод collectionView: shouldShowMenuForItemAtIndexPath:. В данном примере мы работаем с контроллером сборного вида, который сам является и делегатом и источником данных. Поэтому фактически нам придется всего лишь реализовать вышеупомянутый метод в контроллере сборного вида, вот так:

— (BOOL) collectionView:(UICollectionView *)collectionView

shouldShowMenuForItemAtIndexPath:(NSIndexPath *)indexPath{

return YES;

}

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

— (BOOL) collectionView:(UICollectionView *)collectionView

canPerformAction:(SEL)action

forItemAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

if (action == @selector(copy:)){

return YES;

}

return NO;

}

Как видите, нам даже не требуется преобразовывать селектор в строку, чтобы сравнить его с такими строками, как copy:. Мы всего лишь используем оператор равенства, чтобы проверить, отвечает ли запрошенный селектор нашим ожиданиям. Если это так, возвращаем YES, в противном случае — NO.

Наконец, нам потребуется реализовать в делегате метод collectionView: performAction: forItemAtIndexPath: withSender:. С помощью этого метода мы узнаем, было ли вызвано действие копирования, а потом копируем изображение, взятое из ячейки, в буфер обмена. Пользователь сможет вставить из буфера изображение в файл из совершенно другого приложения:

— (void) collectionView:(UICollectionView *)collectionView

performAction:(SEL)action

forItemAtIndexPath:(NSIndexPath *)indexPath

withSender:(id)sender{

if (action == @selector(copy:)){

MyCollectionViewCell *cell = (MyCollectionViewCell *)[collectionView

cellForItemAtIndexPath: indexPath];

[[UIPasteboard generalPasteboard]

setImage: cell.imageViewBackgroundImage.image];

}

}

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

Обсуждение. 5.9. Представление контекстных меню в ячейках сборных видов. Глава 5. Выстраивание сложных макетов с помощью сборных видов. iOS. Приемы программирования.

Рис. 5.13. Элемент контекстного меню, отображаемый в ячейке сборного вида

См. также.

Раздел 5.5.

Глава 6. Раскадровки.

6.0. Введение.

Программисты iOS уже привыкли работать с контроллерами видов. Мы умеем пользоваться навигационными контроллерами, чтобы выводить на экран и убирать с него контроллеры видов. Но Apple полагает, что такие задачи можно решать и проще, и поэтому в системе появились раскадровки. Раскадровки — это новый способ определения связей между экранами вашего приложения. Например, если в вашем приложении 20 уникальных контроллеров видов, вы написали эти контроллеры год назад, а сейчас снова изучаете исходный код, то вам придется снова распутывать все замысловатые соединения между контроллерами видов. Вы будете пытаться запомнить, какой именно контроллер вида поднимается вверх по стеку, когда пользователь совершает то или иное действие. Это может быть очень сложно, особенно если вы не слишком подробно документировали код. И вот тут вам поможет раскадровка. Раскадровка позволяет просматривать или создавать сразу весь пользовательский интерфейс приложения, а также выстраивать связи между контроллерами видов на одном экране. Да, все настолько просто.

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

При работе с раскадровками каждый экран, наполненный значимым содержимым, называется сценой. Отношение между сценой и раскадровкой в iPhone можно сравнить с отношением вида к контроллеру вида. Весь контент сцены отображается на экране одновременно, соответственно, и пользователь воспринимает эту информацию одновременно. На iPad пользователь одновременно может просматривать более одной сцены, так как у планшета довольно большой экран.

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

6.1. Добавление в раскадровку навигационного контроллера.

Постановка задачи.

Требуется возможность управлять несколькими котроллерами видов в приложении, построенном на основе раскадровки.

Решение.

Задайте навигационный контроллер как исходный контроллер вида в файле раскадровки.

Обсуждение.

Если вы создали в Xcode новое универсальное приложение, воспользовавшись шаблоном Single View Application (Приложение с единственным видом), то у вас будет два файла раскадровок: Main_iPhone.storyboard и Main_iPad.storyboard. Если просмотреть их в конструкторе интерфейса, то легко заметить, что контроллер вида применяется в них в качестве корневого контроллера. На рис. 6.1 показано содержимое простого готового файла раскадровки для iPhone.

Обсуждение. 6.1. Добавление в раскадровку навигационного контроллера. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.1. Контроллер вида в качестве корневого элемента файла раскадровки

Чтобы заменить корневой контроллер вида в файле раскадровки на навигационный контроллер, выполните следующие шаги.

1. Выберите контроллер вида на холсте раскадровки.

2. В меню Edit (Правка) выберите команду Embed in (Встроить), а затем Navigation Controller (Навигационный контроллер) (рис. 6.2).

Обсуждение. 6.1. Добавление в раскадровку навигационного контроллера. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.2. Активизация контроллера вида в навигационном контроллере

Как только справитесь с этим, вы заметите, что контроллер вида в раскадровке превратился в навигационный контроллер (рис. 6.3).

Обсуждение. 6.1. Добавление в раскадровку навигационного контроллера. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.3. Навигационный контроллер теперь является корневым контроллером раскадровки

См. также.

Раздел 6.0.

6.2. Передача данных с одного экрана на другой.

Постановка задачи.

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

Решение.

Воспользуйтесь сегвеями, обеспечивающими плавные переходы.

Обсуждение.

Сегвей — это объект, напоминающий любые другие объекты языка Objective-C. Чтобы выполнить переход от одной сцены к другой, среда времени исполнения раскадровки создает объект-сегвей именно для этой цели[5]. Сегвей — это экземпляр класса UIStoryboardSegue. Чтобы начался переход, текущий контроллер вида (этот вид уходит с экрана по завершении плавного перехода) получает сообщение prepareForSegue: sender:, где в качестве параметра prepareForSegue будет использован объект типа UIStoryboardSegue. Если вы хотите передать какие-либо данные от актуального контроллера вида к контроллеру того вида, который вот-вот появится на экране, это нужно делать в методе prepareForSegue: sender:.

Для полноценной работы с этим разделом нужно выполнить инструкции из раздела 6.1, где в раскадровке создаются два контроллера видов внутри навигационного контроллера.

Рассмотрим прикладной пример с использованием сегвеев. В этом разделе мы собираемся отобразить на экране примерно такой контроллер вида, как показан на рис. 6.4.

Обсуждение. 6.2. Передача данных с одного экрана на другой. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.4. Первый контроллер вида в нашем приложении; на контроллере вида есть текстовое поле и кнопка

Та информация, которую пользователь внесет в текстовое поле, будет передана второму контроллеру вида посредством сегвея и задана в качестве заголовка этого контроллера вида. Холст второго контроллера вида будет пуст. Итак, воспользуйтесь приемами, изученными в разделе 6.1, и поместите первый контроллер вида в навигационный контроллер. Теперь возьмите в библиотеке объектов другой контроллер вида, поместите его в раскадровку, а также разместите в первом контроллере вида кнопку и текстовое поле. Вы заметите, что положение текстового поля и кнопки получается примерно таким, как на рис. 6.4, но такое сходство не является обязательным. Можете расположить элементы как хотите. Теперь, удерживая нажатой клавишу Ctrl, наведите указатель на экранную кнопку и нажмите и не отпускайте кнопку мыши. На экране появится линия. Перетащите ее на второй контроллер вида (рис. 6.5). Откроется диалоговое окно, в нем выберите элемент Push. Сделав это, вы устанавливаете связь между кнопкой и вторым контроллером вида. Когда кнопка нажимается, контроллер вида оказывается на верхней позиции в стеке навигационного контроллера.

Обсуждение. 6.2. Передача данных с одного экрана на другой. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.5. Создание связи между кнопкой и вторым контроллером вида; связь срабатывает при нажатии кнопки

В конструкторе интерфейса видно, что мы создали сегвей между первым и вторым контроллерами вида. Щелкните на сегвее в инспекторе атрибутов (Attribute Inspector), присвойте ему идентификатор pushSecondViewController (рис. 6.6).

Обсуждение. 6.2. Передача данных с одного экрана на другой. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.6. Присваивание идентификатора сегвею

Может возникнуть вопрос: а зачем вообще нужен этот идентификатор? Дело в том, что мы реализуем специальный метод контроллера вида, который сначала будет спрашивать, допустимо ли сейчас выполнить такой сегвей. В этом методе мы проверим текст, находящийся в текстовом поле, и, если это поле окажется пустым, не позволим пользователю перейти на следующий экран. Метод, который будет вызываться в контроллере вида, называется shouldPerformSegueWithIdentifier: sender:, он относится к классу UIViewController. Вы можете использовать значение типа NSString, записываемое в его параметр shouldPerformSegueWithIdentifier, чтобы получить идентификатор того сегвея, который собирается выполнить система. После этого вы будете должны возвратить значение YES, если планируемый сегвей вас устраивает, и NO — в противном случае. Если вернуть NO, то сегвей с заданным идентификатором выполнен не будет. Но блокировать переход, никак не дав знать об этом пользователю, — безусловно, порочная практика. Поэтому, если поле оказывается пустым, а пользователь пытается нажать кнопку и перейти на следующий экран, мы отобразим для него такое диалоговое окно, как на рис. 6.7.

Обсуждение. 6.2. Передача данных с одного экрана на другой. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.7. Пользователь не сможет перейти на следующий экран, пока не введет текст в следующее поле

Итак, наконец перейдем к реализации первого контроллера вида. Предполагаю, что вы уже соединили текстовое поле с контроллером вида (поле выступает в качестве аутлета для этого контроллера) и можете получить доступ к его свойству text, перед тем как произойдет сегвей:

#import «ViewController.h»

#import «SecondViewController.h»

@interface ViewController () <UITextFieldDelegate>

@property (weak, nonatomic) IBOutlet UITextField *textField;

@end

@implementation ViewController

— (void) viewDidLoad{

[super viewDidLoad];

self.title = @"First Screen";

}

— (BOOL) textFieldShouldReturn:(UITextField *)textField{

[textField resignFirstResponder];

return YES;

}

— (void) displayTextIsRequired{

UIAlertView *alert = [[UIAlertView alloc]

initWithTitle: nil

message:@"Please enter some text in the text field"

delegate: nil

cancelButtonTitle: nil

otherButtonTitles:@"OK", nil];

[alert show];

}

— (BOOL) shouldPerformSegueWithIdentifier:(NSString *)identifier

sender:(id)sender{

/* Проверяем, есть ли в текстовом поле какой-либо текст. Если текста

там нет, то отображаем пользователю соответствующее сообщение

и не позволяем перейти на следующий экран */

if ([identifier isEqualToString:@"pushSecondViewController"]){

if ([self.textField.text length] == 0){

[self displayTextIsRequired];

return NO;

}

};

return YES;

}

— (void) prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender{

if ([segue.identifier isEqualToString:@"pushSecondViewController"]){

SecondViewController *nextController =

segue.destinationViewController;

[nextController setText: self.textField.text];

}

}

@end

Метод prepareForSegue: sender: этого контроллера вида вызывает метод экземпляра setText:, относящийся к классу SecondViewController. Как понятно из названия, это класс второго контроллера вида. Мы просто реализуем этот метод следующим образом:

#import «SecondViewController.h»

@interface SecondViewController ()

@end

@implementation SecondViewController

— (void) setText:(NSString *)paramText{

self.title = paramText;

}

@end

Вот и все. Теперь, если вы запустите предложение и введете в текстовое поле текст, скажем, Hello, World! а потом нажмете кнопку, то увидите примерно такую картинку, как на рис. 6.8.

Обсуждение. 6.2. Передача данных с одного экрана на другой. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.8. Наш текст успешно отобразился в качестве заголовка второго контроллера вида

См. также.

Раздел 6.1.

6.3. Добавление в раскадровку контроллера с панелью вкладок.

Постановка задачи.

С помощью раскадровок требуется создать приложение, построенное на базе контроллера с панелью вкладок.

Решение.

Создайте в Xcode приложение с единственным видом и встройте первый контроллер вида в контроллер вида с панелью вкладок. Чтобы сделать это, выполните следующие шаги.

1. В конструкторе интерфейса выберите в раскадровке контроллер вида. В меню Editor (Редактор) выберите пункт Embed in (Встроить), а затем выберите Tab Bar Controller (Контроллер с панелью вкладок) (рис. 6.9).

Решение. 6.3. Добавление в раскадровку контроллера с панелью вкладок. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.9. Встраивание корневого контроллера вида в контроллер с панелью вкладок

2. Перейдите в библиотеку объектов контроллера интерфейсов, найдите там новый экземпляр контроллера вида и перетащите его в раскадровку.

3. Удерживая нажатой клавишу Ctrl, перетащите указатель мыши из контроллера с вкладками в созданный вами контроллер вида (рис. 6.10). Откроется диалоговое окно, в котором следует найти раздел Relationship Segues (Взаимосвязи через сегвеи) и выбрать в нем View Controller (Контроллер вида) (рис. 6.11).

Решение. 6.3. Добавление в раскадровку контроллера с панелью вкладок. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.10. Соединение контроллера вида с контроллером, имеющим панель вкладок

Решение. 6.3. Добавление в раскадровку контроллера с панелью вкладок. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.11. Ассоциирование контроллера вида с массивом контроллеров видов, находящихся в контроллере с панелью вкладок

Теперь запустите приложение в эмуляторе iOS. В нижней части экрана вы увидите два элемента (рис. 6.12). Каждый из этих элементов соответствует одному из ваших контроллеров вида. Если бы это контроллерное приложение с вкладками создавал я, то я поместил бы в каждой из вкладок по навигационному контроллеру. Если вы также хотите задействовать такую возможность, воспользуйтесь приемами, изученными в разделе 6.1, и встройте контроллеры видов в навигационные контроллеры (рис. 6.13).

Решение. 6.3. Добавление в раскадровку контроллера с панелью вкладок. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.12. Контроллеры вида успешно отображаются в контроллере с панелью вкладок

Решение. 6.3. Добавление в раскадровку контроллера с панелью вкладок. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.13. Встраивание ваших контроллеров видов в навигационные контроллеры, расположенные в контроллере панели вкладок

См. также.

Раздел 6.1.

6.4. Внедрение специальных переходов между сегвеями в раскадровке.

Постановка задачи.

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

Решение.

Создайте подкласс от UIStoryboardSegue и переопределите его метод perform в соответствии со стоящими перед вами задачами.

Обсуждение.

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

1. Создайте в Xcode проект, основанный на шаблоне Single View Application (Приложение с единственным видом).

2. В файле раскадровки создайте второй контроллер вида и поместите кнопку в центр первого контроллера вида. Удерживая нажатой клавишу Ctrl, перетащите указатель с экранной кнопки на второй контроллер вида. На этом этапе на экране откроется диалоговое окно, где система запросит информацию о типе перехода, который вы хотите ассоциировать с данным сегвеем. В этом диалоговом окне выберите вариант Custom (Специальный) (рис. 6.14).

Обсуждение. 6.4. Внедрение специальных переходов между сегвеями в раскадровке. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.14. Ассоциирование специального сегвея с действием, выполняемым кнопкой

3. Теперь выберите желаемый сегвей и в инспекторе атрибутов (Attribute Inspector) конструктора интерфейсов измените имя класса сегвея на MySegue (рис. 6.15). Этого класса пока не существует, но не волнуйтесь — мы напишем его уже в данном разделе.

Обсуждение. 6.4. Внедрение специальных переходов между сегвеями в раскадровке. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.15. Присваивание сегвею нашего собственного имени класса

4. Теперь создайте в Xcode новый класс Objective-C внутри вашего проекта, назовите этот класс MySegue (именно такое имя вы присвоили ему на предыдущем этапе) и убедитесь в том, что этот класс наследует от UIStoryboardSegue. Как только система создаст для вас этот класс, реализуйте его метод perform следующим образом:

#import «MySegue.h»

@implementation MySegue

— (void) perform{

UIViewController *source = self.sourceViewController;

UIViewController *destination = self.destinationViewController;

[UIView transitionFromView: source.view

toView: destination.view

duration:0.50f

options: UIViewAnimationOptionTransitionFlipFromTop

completion: ^(BOOL finished) {

NSLog(@"Transitioning is finished");

}];

}

@end

Вот и все. Теперь можете запустить приложение и убедиться в том, что при нажатии кнопки в первом контроллере вида запустится специальный сегвей, который, в свою очередь, отобразит на экране второй контроллер вида. В этом примере мы используем для реализации перехода метод класса transitionFromView: toView: duration: options: completion:, относящийся к классу UIView. Этот метод принимает довольно много параметров, которые описаны далее:

• transitionFromView — вид, с которого должен начинаться переход. В контексте нашего сегвея это вид с исходным контроллером вида;

• toView — это целевой вид, к которому должен привести переход. В нашем сегвее это вид с целевым контроллером вида;

• duration — длительность анимации в секундах;

• options — тип анимации, которую вы хотите выполнить. Это значение типа UIViewAnimationOptions. Если вы хотите просмотреть все параметры, доступные здесь, нажмите на клавиатуре Command+Shift+O, введите UIViewAnimationOptions, а потом нажмите клавишу Enter;

• completion — блок завершения, вызываемый сразу же по окончании перехода.

Прежде чем завершить этот раздел, необходимо упомянуть еще об одной важной вещи. Работа, которую вы выполняете (специальный переход), должна осуществляться в методе экземпляра perform специального класса сегвея. Это, в частности, означает, что вы не можете вывести в этом методе окно с предупреждением и отобразить его для пользователя (а также рассчитывать на то, что пользователь сможет нажать кнопку Yes или No в зависимости от своего решения и только потом выполнить переход). Это не сработает. Поэтому сначала подумайте, чего вы хотите добиться в вашем сегвее и является ли создание подкласса от UIStoryboardSegue наилучшим выходом из ситуации.

См. также.

Разделы 6.0 и 6.1.

6.5. Размещение изображений и других компонентов пользовательского интерфейса в раскадровках.

Постановка задачи.

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

Решение.

Воспользуйтесь библиотекой объектов из конструктора интерфейса и найдите в ней разные компоненты для пользовательского интерфейса. Когда будете готовы поместить их в файлы раскадровок, просто перетащите туда эти элементы. Затем вы сможете сконфигурировать эти компоненты в инспекторе атрибутов.

Обсуждение.

Допустим, вы хотите разместить в раскадровке несколько изображений. Находясь в конструкторе интерфейса, где уже должен быть открыт файл раскадровки, нажмите комбинацию клавиш Ctrl+Alt+Command+3 и таким образом перейдите в библиотеку объектов. Здесь найдите компонент Image View (Вид с изображением) (рис. 6.16) и перетащите его в основной вид с контроллером. Теперь одновременно нажмите на клавиатуре Alt+Command+4, чтобы открыть инспектор атрибутов. На этой панели вы сможете сконфигурировать вид с изображением. Чтобы поместить изображение в этот вид, просто добавьте изображение к вашему проекту. Пока вид с изображением остается выделенным, в инспекторе атрибутов задайте для этого вида свойство image (рис. 6.17).

Обсуждение. 6.5. Размещение изображений и других компонентов пользовательского интерфейса в раскадровках. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.16. Вид с изображением, служащий компонентом пользовательского интерфейса (так он выглядит в библиотеке объектов)

Обсуждение. 6.5. Размещение изображений и других компонентов пользовательского интерфейса в раскадровках. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.17. Установка свойства-изображения для вида с изображением в инспекторе атрибутов в конструкторе интерфейса

Периодически могут возникать ситуации, когда вы просто не можете найти в библиотеке объектов нужный компонент, но уверены, что он существует. Со мной это тоже случалось. В библиотеке объектов есть очень удобная строка для поиска, в которой вы можете написать имя интересующего вас компонента. Чтобы попасть в строку поиска, убедитесь, что вы уже открыли библиотеку объектов (для этого требуется нажать сочетание клавиш Ctrl+Alt+Command+3), а затем Command+Alt+L (рис. 6.18).

Обсуждение. 6.5. Размещение изображений и других компонентов пользовательского интерфейса в раскадровках. Глава 6. Раскадровки. iOS. Приемы программирования.

Рис. 6.18. Строка поиска в библиотеке объектов позволяет быстро найти интересующий объект

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

См. также.

Раздел 6.0.

Глава 7. Параллелизм.

7.0. Введение.

Параллелизм (конкурентное исполнение программ) возникает, когда одновременно выполняется несколько задач. Современные операционные системы позволяют параллельно выполнять задачи даже на одном процессоре. Такая возможность гарантируется, если выделить на каждую задачу строго определенный промежуток (квант) процессорного времени. Например, если за секунду требуется решить 10 задач и все они имеют одинаковый приоритет, то операционная система разделит 1000 мс на 10 и уделит решению каждой задачи 100 мс процессорного времени. Таким образом, все эти задачи решаются в течение одной секунды, и пользователю кажется, что это происходит параллельно.

При этом технологии развиваются, и теперь в нашем распоряжении есть процессоры с несколькими ядрами. Это означает, что один процессор действительно может решать несколько задач одновременно. Операционная система диспетчеризует задачи к процессору и дожидается, пока они будут выполнены. Вот так все просто!

Grand Central Dispatch (GCD) — это низкоуровневый API, написанный на языке С и работающий с блоковыми объектами. GCD отлично приспособлен для направления различных задач нескольким ядрам, так что программист может не задумываться о том, какое ядро решает какую задачу. Многоядерные устройства с операционной системой Mac OS X, в частности ноутбуки, имеются в свободном доступе уже довольно давно. А с появлением таких многоядерных устройств, как новый iPad, мы можем писать и интересные многопоточные приложения для системы iOS, рассчитанные на работу с несколькими ядрами.

Центральной составляющей GCD являются диспетчерские очереди. Диспетчерские очереди, как мы вскоре увидим, представляют собой пулы потоков, управляемые GCD в базовой операционной системе, будь то iOS или Mac OS X. Вы не будете работать с этими потоками напрямую. Вы будете иметь дело только с диспетчерскими очередями, распределяя задачи по этим очередям и приказывая очередям инициировать решение задач. GCD предлагает несколько режимов решения задач: синхронно, асинхронно, с определенной задержкой и т. д.

Чтобы приступить к использованию GCD в ваших приложениях, в проект не требуется импортировать каких-либо специальных библиотек. Apple уже встроила GCD в различные фреймворки, в частности в Core Foundation и Cocoa/Cocoa Touch. Все методы и типы данных, имеющиеся в GCD, начинаются с ключевого слова dispatch_. Например, dispatch_async позволяет направить задачу в очередь для асинхронного выполнения, а dispatch_after — выполнить блок кода после определенной задержки.

До того как появился GCD, программисту приходилось создавать собственные потоки для параллельного решения задач. Примерно такой поток разработчик iOS создаст для того, чтобы выполнить определенную операцию 1000 раз:

— (void) doCalculation{

/* Здесь происходят вычисления. */

}

— (void) calculationThreadEntry{

@autoreleasepool {

NSUInteger counter = 0;

while ([[NSThread currentThread] isCancelled] == NO){

[self doCalculation];

counter++;

if (counter >= 1000){

break;

}

}

}

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

/* Начинаем поток. */

[NSThread detachNewThreadSelector:@selector(calculationThreadEntry)

toTarget: self

withObject: nil];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Программист должен создать поток вручную, а потом придать ему требуемую структуру (точку входа, автоматически высвобождаемый пул и основной цикл потока). Когда мы пишем аналогичный код с помощью GCD, нам на самом деле приходится сделать не так уж много. Мы просто помещаем наш код в блоковый объект и направляем этот блок в GCD для выполнения. Где именно будет выполняться данный код — в главном потоке или в каком-нибудь другом, — зависит именно от нас. Вот пример:

dispatch_queue_t queue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

size_t numberOfIterations = 1000;

dispatch_async(queue, ^(void) {

dispatch_apply(numberOfIterations, queue, ^(size_t iteration){

/* Здесь выполняется операция. */

});

});

В этой главе будет рассказано обо всем, что нужно знать о GCD. Здесь вы научитесь писать современные многопоточные приложения для iOS и Mac OS X, помогающие достичь впечатляющей производительности на таких многоядерных устройствах, как iPad 2.

Мы довольно много будем работать с диспетчерскими очередями, поэтому необходимо досконально разобраться с теми концепциями, которые лежат в их основе. Диспетчерские очереди бывают трех типов.

Главная очередь — занимается выполнением всех задач из главного потока, и именно здесь Cocoa и Cocoa Touch требуют от программиста вызывать все методы, относящиеся к пользовательскому интерфейсу. Пользуйтесь функцией dispatch_get_main_queue, помогающей управлять главной очередью.

Параллельные очереди — это очереди, которые можно получать из GCD для выполнения синхронных или асинхронных задач. В нескольких параллельных очередях могут одновременно выполняться несколько задач, причем с завидной легкостью. Представляете, больше никакого управления потоками, ур-р-ра! Пользуйтесь функцией dispatch_get_global_queue, помогающей управлять параллельными очередями.

Последовательные очереди — всегда выполняют поставленные в них задачи по принципу «первым пришел — первым обслужен» (First In First Out, FIFO). При этом не имеет значения, являются эти задачи синхронными или асинхронными. Такой принцип работы означает, что последовательная очередь может выполнять в любой момент только один блок кода. Однако такие очереди не применяются в главном потоке, поэтому отлично подходят для решения задач, которые должны выполняться в строгом порядке и не блокировать при этом главный поток. Чтобы создать последовательную очередь, пользуйтесь функцией dispatch_queue_create.

Существуют два механизма отправки задач в диспетчерские очереди:

блочные объекты (см. раздел 7.1);

• функции C.

Блочные объекты позволяют наиболее эффективно использовать GCD и его огромный потенциал. Некоторые функции GCD были расширены таким образом, чтобы программист мог использовать функции C вместо блочных объектов. Однако в действительности лишь небольшое подмножество GCD-функций допускают замену объектов функциями C, поэтому перед дальнейшим изучением материала обязательно ознакомьтесь с разделом о блочных объектах (разделом 7.1).

Функции C, предоставляемые различным GCD-функциям, должны относиться к типу dispatch_function_t. Вот как этот тип определяется в библиотеках Apple:

typedef void (*dispatch_function_t)(void *);

Итак, если мы хотим, например, создать функцию под названием myGCDFunction, потребуется реализовать ее следующим образом:

void myGCDFunction(void * paramContext){

/* Вся работа выполняется здесь */

}

Параметр paramContext относится к контексту, который GCD позволяет передавать C-функциям при диспетчеризации задач к этим функциям. Вскоре мы подробно об этом поговорим.

Блочные объекты, передаваемые GCD-функциям, не всегда имеют одинаковую структуру. Некоторые должны принимать параметры, другие — нет, но ни один блочный объект, передаваемый GCD, не возвращает значения.

В любой момент в ходе жизненного цикла приложения вы можете одновременно задействовать несколько диспетчерских очередей. В системе есть только одна основная очередь, но вы сами можете создать сколько угодно последовательных диспетчерских очередей (конечно, в разумных пределах) для любых функций, которые, возможно, понадобится реализовать в вашем приложении. Кроме того, можно получить несколько параллельных очередей и направить им ваши задачи. Задачи можно передавать диспетчерским очередям двумя способами: как блоковые объекты и как функции языка C, о чем рассказано ранее.

Блоковые объекты — это пакеты с кодом, которые в Objective-C обычно имеют форму методов. Блоковые объекты вместе с GCD образуют гармоничную среду, в которой можно создавать высокопроизводительные многопоточные приложения для iOS и Mac OS X. Вы можете спросить: «А что же такого особенного в блоковых объектах и GCD?» Ответ прост: больше никаких потоков! Все, что от вас требуется, — поместить код в блоковые объекты и перепоручить GCD выполнение этого кода.

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

Блоковые объекты в Objective-C — это сущности, которые в среде программистов принято называть объектами первого класса. Это означает, что вы можете создавать код динамически, передавать блоковый объект методу в качестве параметра и возвращать блоковый объект от метода. Все это позволяет более уверенно выбирать, что вы хотите делать во время исполнения и изменять ход действия программы. В частности, GCD может выполнять блоковые объекты в отдельных потоках. Поскольку блоковые объекты являются объектами Objective-C, с ними можно обращаться как с любыми другими объектами.

Иногда блоковые объекты называются замкнутыми выражениями (Closures).

Создание блоковых объектов напоминает создание обычных функций языка C, как будет показано в разделе 7.1. Блоковые объекты могут возвращать значения и принимать параметры. Блоковые объекты можно определять как встраиваемые либо обрабатывать как отдельные блоки кода наподобие функций языка C. При создании встраиваемым способом область видимости переменных, доступных блоковым объектам, существенно отличается от аналогичной области видимости, если блоковый объект реализуется как отдельный блок кода.

GCD работает с блоковыми объектами. При выполнении задач с помощью GCD вы можете передавать блоковый объект, код которого будет выполняться синхронно или асинхронно в зависимости от того, какие методы используются в GCD. Следовательно, вы можете создать блоковый объект, который будет отвечать за загрузку данных по URL (универсальному идентификатору ресурса), передаваемому в качестве параметра. Такой отдельный блоковый объект можно синхронно или асинхронно использовать в различных местах приложения на ваш выбор. Не требуется делать блоковый объект синхронным или асинхронным по сути. Вы всего лишь будете вызывать его с помощью тех или иных методов, относящихся к GCD, — синхронных или асинхронных, — и блоковый объект будет просто работать.

Блоковые объекты — довольно новое явление для программистов, создающих приложения для iOS и Mac OS X. На самом деле блоковые объекты пока еще уступают по популярности потокам, поскольку их синтаксис несколько отличается от организации обычных методов Objective-C и более сложен. Тем не менее потенциал блоковых объектов огромен, и Apple довольно активно внедряет их в свои библиотеки. Такие дополнения уже можно заметить в некоторых классах, например NSMutableArray. Здесь программист может сортировать массив с помощью блокового объекта.

Эта глава целиком посвящена созданию и использованию блоковых объектов в приложениях для iOS и Mac OS X, использованию GCD для передачи задач операционной системе, а также работе с потоками и таймерами. Я хотел бы подчеркнуть, что единственный способ освоить синтаксис блоковых объектов — написать несколько таких объектов самостоятельно. Изучите код примеров, которые сопровождают эту главу, и попробуйте реализовать собственные блоковые объекты.

В данной главе будут рассмотрены базовые вопросы, связанные с блоковыми объектами, а потом мы обсудим некоторые более сложные темы. В частности, поговорим об интерфейсе Grand Central Dispatch, о потоках, таймерах, операциях и очередях операций. Вы усвоите все, что необходимо знать о блоковых объектах, а потом перейдете к материалу о GCD. По моему опыту, лучше всего изучать блоковые объекты на примерах, поэтому данная глава изобилует примерами. Обязательно опробуйте их в Xcode, чтобы по-настоящему усвоить синтаксис блоковых объектов.

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

В Cocoa выполняются операции трех типов:

блоковые операции — обеспечивают выполнение одного или нескольких блоковых объектов;

активизирующие операции — позволяют активизировать метод в другом, уже существующем объекте;

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

Как уже упоминалось ранее, управлять операциями можно с помощью очередей операций, относящихся к типу данных NSOperationQueue. После инстанцирования операции любого из упомянутых типов (блоковой, активизирующей или обычной) их можно добавить в очередь операций и перепоручить управление операцией самой очереди.

Объект операции может зависеть от других объектов операций. Можно приказать объекту операции дождаться, пока не выполнится одна или несколько иных операций, и только после этого приказать ему решить ассоциированную с ним задачу. Без применения зависимостей вы никак не сможете влиять на порядок выполнения операций. Так, если добавить операции в очередь в определенном порядке, это не гарантирует выполнения операций в том же порядке, несмотря на то что термин «очередь» это как бы подразумевает.

Работая с операциями и очередями операций, не следует забывать о нескольких важных вещах.

По умолчанию операция выполняется в том потоке, который ее начал с помощью их метода экземпляра start. Если вы хотите, чтобы операции выполнялись асинхронно, нужно использовать либо очередь операций, либо подкласс NSOperation и выделить новый поток в методе экземпляра main, относящегося к операции.

• Операция может дождаться окончания выполнения другой операции и только после этого начаться. Будьте осторожны и не создавайте взаимозависимых операций. Такая распространенная ошибка называется взаимоблокировкой, или клинчем (Deadlock). Иными словами, нельзя ставить операцию А в зависимость от операции B, если операция B уже зависит от операции A. В таком случае они обе будут ждать вечно, расходуя память и, возможно, вызывая зависание приложения.

• Операции можно отменять. Так, если вы создаете подклассы от NSOperation, чтобы делать собственные виды объектов операций, обязательно пользуйтесь методом экземпляра isCancelled. Он применяется, чтобы проверить, не была ли отменена определенная операция, прежде чем переходить к выполнению задачи, связанной с этой операцией. Например, если задача вашей операции — проверять доступность соединения с Интернетом раз в 20 с, то перед каждым запуском операции нужно вызвать метод экземпляра isCancelled, чтобы сначала убедиться, что операция не отменена, и только после этого пытаться проверять наличие соединения с Интернетом. Если на выполнение операции уходит более нескольких секунд (например, если это загрузка файла), то при выполнении задачи нужно также периодически проверять метод isCancelled.

• Объекты операций обязаны выполнять «уведомление наблюдателей об изменениях в свойствах наблюдаемого объекта» (KVO, Key-Value Observing) на различных ключевых путях, в частности isFinished, isReady и isExecuting. В одной из следующих глав мы обсудим механизм KVO, а также KVC — механизм для доступа к полям объекта по именам этих полей.

• Если вы планируете создавать подкласс от NSOperation и выполнять специальную реализацию для операции, вам следует создать собственный автоматически высвобождаемый пул в методе main, относящемся к операции. Данный метод вызывается из метода start. Эти вопросы мы подробнее рассмотрим далее в этой главе.

• Всегда сохраняйте ссылки на создаваемые вами объекты операций. Сама параллельная природа, присущая очередям операций, исключает возможность получения ссылки на операцию после того, как она добавлена в очередь.

Потоки и таймеры — это объекты, являющиеся подклассами от NSObject. Для порождения потока выполняется больше работы, чем для создания таймеров, а настройка цикла потока — более сложная задача, чем обычное слушание таймера, запускающего селектор. Когда приложение работает в операционной системе iOS, система создает для этого приложения как минимум один поток. Этот поток называется главным (Main Thread). Все потоки и таймеры должны добавляться в цикл исполнения (Run Loop). Цикл исполнения, как понятно из его названия, — это цикл, в ходе которого могут происходить разные события, например запуск таймера или выполнение потока. Обсуждение циклов исполнения выходит за рамки этой главы, но иногда я буду упоминать такой цикл.

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

Главный поток приложения — это тот поток, который обрабатывает события пользовательского интерфейса. Если вы выполняете в главном потоке долговременную задачу, то быстро станет заметно, что интерфейс перестает отвечать на запросы или реагирует медленно. Во избежание этого можно создавать отдельные потоки и/или таймеры, каждый из которых выполняет собственную задачу (даже если она сравнительно долговременная). Но при этом главный поток не будет блокироваться.

7.1. Создание блоковых объектов.

Постановка задачи.

Необходимо иметь возможность писать собственные блоковые объекты либо использовать блоковые объекты с классами из iOS SDK.

Решение.

Просто необходимо понимать базовую разницу между синтаксисом блоковых объектов и синтаксисом классических функций языка C. Эта разница рассматривается в подразделе «Обсуждение» данного раздела.

Обсуждение.

Блоковые объекты могут быть либо встраиваемыми, либо записываемыми как отдельные блоки кода. Начнем с объектов второго типа. Предположим, у нас есть метод языка Objective-C, принимающий два целочисленных значения типа NSInteger и возвращающий разницу двух этих значений в форме NSInteger. Разница получается в результате вычитания одного значения из другого:

— (NSInteger) subtract:(NSInteger)paramValue

from:(NSInteger)paramFrom{

return paramFrom — paramValue;

}

Очень просто, правда? Теперь преобразуем этот код Objective-C в классическую функцию языка C, обеспечивающую такую же функциональность. Это еще на шаг приблизит нас к пониманию синтаксиса блоковых объектов:

NSInteger subtract(NSInteger paramValue, NSInteger paramFrom){

return paramFrom — paramValue;

}

Как видите, синтаксис функции на C значительно отличается от синтаксиса аналогичной функции на языке Objective-C. Теперь рассмотрим, как можно написать ту же функцию в виде блокового объекта:

NSInteger (^subtract)(NSInteger, NSInteger) =

^(NSInteger paramValue, NSInteger paramFrom){

return paramFrom — paramValue;

};

Прежде чем перейти к детальному описанию синтаксиса блоковых объектов, приведу еще несколько примеров. Предположим, что у нас есть функция на языке C, принимающая параметр типа NSUInteger (беззнаковое целое число) и возвращающая строку типа NSString. Вот как данная функция реализуется на C:

NSString* intToString (NSUInteger paramInteger){

return [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

}

Чтобы научиться форматировать строки с применением системонезависимых указателей формата на языке Objective-C, ознакомьтесь с String Programming Guide in the iOS Developer Library (Руководство по программированию строк в библиотеке разработчика iOS). Адрес документа на сайте Apple: https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/Strings/Articles/formatSpecifiers.html.

Блоковый объект, эквивалентный данной функции языка C, показан в примере 7.1.

Пример 7.1. Образец блокового объекта, определенного в виде функции

NSString* (^intToString)(NSUInteger) = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

Простейший независимый блоковый объект — это блоковый объект, возвращающий void и не принимающий никаких параметров:

void (^simpleBlock)(void) = ^{

/* Здесь реализуется блоковый объект. */

};

Блоковые объекты инициируются точно так же, как и функции на языке C. Если у них есть какие-либо параметры, то вы передаете их так, как и в функции C. Любое возвращаемое значение можно получить точно так же, как и возвращаемое значение функции на языке C. Вот пример:

NSString* (^intToString)(NSUInteger) = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

— (void) callIntToString{

NSString *string = intToString(10);

NSLog(@"string = %@", string);

}

Метод callIntToString языка Objective-C вызывает блоковый объект intToString, передавая этому блоковому объекту в качестве единственного параметра значение 10 и помещая возвращаемое значение данного блокового объекта в локальную переменную string.

Теперь, когда мы знаем, как писать блоковые объекты в виде независимых блоков кода, рассмотрим передачу блоковых объектов как передачу параметров методам языка Objective-C. Чтобы понять смысл следующего примера, нужно прибегнуть к определенным абстракциям.

Предположим, у нас есть метод Objective-C, принимающий целое число и выполняющий над ним какое-либо преобразование. Такое преобразование может меняться в зависимости от того, что еще происходит в программе. Мы уже знаем, что у нас будет целое число в качестве ввода и строка в качестве вывода, но сам процесс преобразования поручим блоковому объекту — а этот объект может быть иным при каждом вызове метода. Следовательно, в качестве параметров данный метод будет принимать и целое число, которое необходимо преобразовать, и тот блок, который будет выполнять преобразование.

Для блокового объекта воспользуемся тем же блоковым объектом intToString, который мы реализовали в примере 7.1. Теперь нам нужен метод на языке Objective-C, который будет принимать в качестве параметра беззнаковое целое число, а в качестве еще одного параметра — блоковый объект. С беззнаковым целым в качестве параметра все просто, но как сообщить методу, что он должен принимать блоковый объект того же типа, к которому относится блоковый объект intToString? Сначала определяем псевдоним сигнатуры блокового объекта intToString (с помощью ключевого слова typedef) и таким образом сообщаем компилятору, какие параметры должен принимать блоковый объект:

typedef NSString* (^IntToStringConverter)(NSUInteger paramInteger);

Объявление typedef просто сообщает компилятору, что блоковые объекты, принимающие в качестве параметра целое число и возвращающие строку, можно представлять с помощью обычного идентификатора, называемого IntToStringConverter. Итак, пойдем дальше и напишем метод на Objective-C, который будет принимать в качестве параметров и целое число, и блоковый объект типа IntToStringConverter:

— (NSString *) convertIntToString-NSUInteger)paramInteger

usingBlockObject-IntToStringConverter)paramBlockObject{

return paramBlockObject(paramInteger);

}

Теперь требуется просто вызвать метод convertIntToString:, сопровождаемый объектом на наш выбор (пример 7.2).

Пример 7.2. Вызов блокового объекта в другом методе

— (void) doTheConversion{

NSString *result = [self convertIntToString:123

usingBlockObject: intToString];

NSLog(@"result = %@", result);

}

Теперь, когда мы немного разбираемся в независимых блоковых объектах, поговорим о встраиваемых блоковых объектах. В только что рассмотренном методе doTheConversion мы передавали методу convertIntToString: usingBlockObject: в качестве параметра блоковый объект intToString. Что если бы у нас не было в распоряжении готового блокового объекта, который можно было бы передать этому методу? На самом деле это не доставило бы нам никаких проблем. Как уже упоминалось, блоковые объекты — это функции первого класса и их можно создавать во время исполнения. Рассмотрим альтернативную реализацию метода doTheConversion (пример 7.3).

Пример 7.3. Блоковый объект, определенный в виде функции

— (void) doTheConversion{

IntToStringConverter inlineConverter = ^(NSUInteger paramInteger){

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

};

NSString *result = [self convertIntToString:123

usingBlockObject: inlineConverter];

NSLog(@"result = %@", result);

}

Сравните примеры 7.1 и 7.3. Я удалил имевшийся в первом варианте код, в котором мы формировали сигнатуру блокового объекта. Данная сигнатура состояла из имени и аргумента — (^intToString) (NSUInteger). Остальную часть блокового объекта я не трогаю, и теперь он становится анонимным объектом. Но это не означает, что я никак не могу сослаться на блоковый объект. С помощью знака равенства (=) я присваиваю блоковый объект типу и имени: IntToStringConverter inlineConverter. Теперь я могу воспользоваться типом данных, чтобы стимулировать правильную работу методов, а при самой операции передачи блокового объекта использовать его имя.

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

— (void) doTheConversion{

NSString *result =

[self convertIntToString:123

usingBlockObject: ^NSString *(NSUInteger paramInteger) {

NSString *result = [NSString stringWithFormat:@"%lu",

(unsigned long)paramInteger];

return result;

}];

NSLog(@"result = %@", result);

}

Сравните этот пример с примером 7.2. Оба метода используют блоковый объект с применением синтаксиса usingBlockObject. Но, в то время как при применении первого варианта мы ссылались по имени на предварительно определенный блоковый объект (intToString), во втором варианте блоковый объект создается на лету. В этом коде мы создали встраиваемый блоковый объект, который передается методу convertIntToString: usingBlockObject: как второй параметр.

7.2. Доступ к переменным в блоковых объектах.

Постановка задачи.

Необходимо понять разницу между доступом к переменным в методах Objective-C и доступом к этим переменным в блоковых объектах.

Решение.

Вот краткое обобщение того, что необходимо знать о переменных в блоковых объектах.

Локальные переменные в блоковых объектах работают точно так же, как и в методах Objective-C.

• При работе со встраиваемыми блоковыми объектами к локальным относятся не только те переменные, которые определены внутри блока, но и те, что определены в методе, реализующем данный блоковый объект (чуть позже рассмотрим примеры).

• Нельзя ссылаться на self в независимых блоковых объектах, реализованных в классе Objective-C. Если необходим доступ к self, то вам нужно передать его объект блоковому объекту в качестве параметра. Чуть позже рассмотрим на примере и такую ситуацию.

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

• При работе со встраиваемыми блоковыми объектами локальные переменные, определяемые внутри реализации блокового объекта, доступны для считывания, но не для записи. Однако есть и исключение. Блоковый объект может записывать информацию в такие переменные, если они определены с типом хранения __block. Пример мы также рассмотрим.

• Предположим, у вас есть блоковый объект типа NSObject, а внутри реализации этого объекта вы используете блоковый объект с GCD. Внутри данного блокового объекта у вас будет доступ для чтения и записи к объявленным свойствам того NSObject, внутри которого реализован блок.

• Вы можете получать доступ к объявленным свойствам NSObject внутри независимых блоковых объектов, только если вы работаете с методами-установщиками и методами-получателями этих свойств. Вы не сможете получить доступ к объявленным свойствам объекта внутри независимого блокового объекта с помощью точечной нотации.

Обсуждение.

Сначала научимся работать с переменными, которые являются локальными для реализаций двух блоковых объектов. Один из этих блоковых объектов будет встраиваемым, а другой — независимым:

void (^independentBlockObject)(void) = ^(void){

NSInteger localInteger = 10;

NSLog(@"local integer = %ld", (long)localInteger);

localInteger = 20;

NSLog(@"local integer = %ld", (long)localInteger);

};

При активизации этого блокового объекта те значения, которые мы присваиваем, выводятся в окне консоли:

local integer = 10

local integer = 20

Пока все несложно. Теперь рассмотрим встраиваемые блоковые объекты и переменные, которые являются для них локальными:

— (void) simpleMethod{

NSUInteger outsideVariable = 10;

NSMutableArray *array = [[NSMutableArray alloc]

initWithObjects:@"obj1",

@"obj2", nil];

[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {

NSUInteger insideVariable = 20;

NSLog(@"Outside variable = %lu", (unsigned long)outsideVariable);

NSLog(@"Inside variable = %lu", (unsigned long)insideVariable);

/* Возвращаем значение для блокового объекта. */

return NSOrderedSame;

}];

}

Метод экземпляра sortUsingComparator:, относящийся к классу NSMutableArray, пытается сортировать изменяемый массив. Цель кода, приведенного в данном примере, — просто продемонстрировать использование локальных переменных. Можно и не задаваться тем, что именно делает этот метод.

Блоковый объект может считывать информацию и записывать данные в собственную локальную переменную insideVariable. При этом по умолчанию блоковый объект имеет доступ только для чтения к переменной outsideVariable. Чтобы блоковый объект мог записывать информацию в outsideVariable, нужно поставить перед outsideVariable префикс __block, указывающий соответствующий тип хранения:

— (void) simpleMethod{

__block NSUInteger outsideVariable = 10;

NSMutableArray *array = [[NSMutableArray alloc]

initWithObjects:@"obj1",

@"obj2", nil];

[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {

NSUInteger insideVariable = 20;

outsideVariable = 30;

NSLog(@"Outside variable = %lu", (unsigned long)outsideVariable);

NSLog(@"Inside variable = %lu", (unsigned long)insideVariable);

/* Возвращаем значение для блокового объекта. */

return NSOrderedSame;

}];

}

Доступ к self во встраиваемых блоковых объектах не вызывает никаких проблем, пока self определяется в лексической области видимости, внутри которой создается встраиваемый блоковый объект. Например, в данной ситуации блоковый объект сможет получить доступ к self, поскольку метод simpleMethod является методом экземпляра класса языка Objective-C:

— (void) simpleMethod{

NSMutableArray *array = [[NSMutableArray alloc]

initWithObjects:@"obj1",

@"obj2", nil];

[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {

NSLog(@"self = %@", self);

/* Возвращаем значение для блокового объекта. */

return NSOrderedSame;

}];

}

Не внеся изменений в реализацию вашего блокового объекта, вы не сможете получить доступ к self в независимом блоковом объекте. При попытке скомпилировать данный код мы получим ошибку времени компиляции:

void (^incorrectBlockObject)(void) = ^{

NSLog(@"self = %@", self); /* self здесь не определен. */

};

Если вы хотите получить доступ к self в независимом блоковом объекте, просто передайте объект, представляемый self, вашему блоковому объекту в качестве параметра:

void (^correctBlockObject)(id) = ^(id self){

NSLog(@"self = %@", self);

};

— (void) callCorrectBlockObject{

correctBlockObject(self);

}

Этому параметру не обязательно присваивать имя self. Ему можно дать любое имя. Тем не менее если назвать этот параметр self, то можно будет просто собрать код блокового объекта позже и поместить его в реализацию метода на языке Objective-C. Не придется менять имя каждого экземпляра переменной на self, чтобы код был воспринят компилятором.

Рассмотрим объявленные свойства и посмотрим, как блоковые объекты могут получать к ним доступ. При работе со встраиваемыми блоковыми объектами можно применять точечную нотацию — она позволяет считывать информацию из объявленных свойств self или записывать в них данные. Допустим, например, что у нас в классе есть объявленное свойство типа NSString, которое называется stringProperty:

#import «AppDelegate.h»

@interface AppDelegate()

@property (nonatomic, copy) NSString *stringProperty;

@end

@implementation AppDelegate

Теперь не составляет труда получить доступ к этому свойству во встраиваемом блоковом объекте:

— (void) simpleMethod{

NSMutableArray *array = [[NSMutableArray alloc]

initWithObjects:@"obj1",

@"obj2", nil];

[array sortUsingComparator: ^NSComparisonResult(id obj1, id obj2) {

NSLog(@"self = %@", self);

self.stringProperty = @"Block Objects";

NSLog(@"String property = %@", self.stringProperty);

/* Возвращаем значение для блокового объекта. */

return NSOrderedSame;

}];

}

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

void (^correctBlockObject)(id) = ^(id self){

NSLog(@"self = %@", self);

/* Вместо этого используем метод-установщик */

self.stringProperty = @"Block Objects"; /* Ошибка времени компиляции */

/* Вместо этого используем метод-получатель. */

NSLog(@"self.stringProperty = %@",

self.stringProperty); /* Ошибка времени компиляции */

};

В данном сценарии будем пользоваться методом-установщиком и методом-получателем синтезированного свойства:

void (^correctBlockObject)(id) = ^(id self){

NSLog(@"self = %@", self);

/* Это будет работать нормально. */

[self setStringProperty:@"Block Objects"];

/* Это также будет работать нормально. */

NSLog(@"self.stringProperty = %@",

[self stringProperty]);

};

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

typedef void (^BlockWithNoParams)(void);

— (void) scopeTest{

NSUInteger integerValue = 10;

BlockWithNoParams myBlock = ^{

NSLog(@"Integer value inside the block = %lu",

(unsigned long)integerValue);

};

integerValue = 20;

/* Вызываем блок здесь после изменения

значения переменной integerValue. */

myBlock();

NSLog(@"Integer value outside the block = %lu",

(unsigned long)integerValue);

}

Мы определяем целочисленную локальную переменную и сначала присваиваем ей значение 10. Затем реализуем блоковый объект, но пока не вызываем его. После того как блоковый объект реализован, мы просто изменяем значение локальной переменной, которую затем (после того как мы его вызовем) попытается считать блоковый объект. Сразу после изменения значения локальной переменной на 20 вызываем блоковый объект. Логично предположить, что блоковый объект выведет для переменной на консоль значение 20, но этого не произойдет. Он выведет значение 10, как показано здесь:

Integer value inside the block = 10

Integer value outside the block = 20

Вот что здесь происходит. Блоковый объект сохраняет для себя копию переменной integerValue, доступную только для чтения, и делает это именно там, где реализуется блок. Напрашивается вопрос: почему же блоковый объект принимает доступное только для чтения значение переменной integerValue? Ответ прост, и мы уже дали его в этом разделе. Если у локальной переменной нет префикса __block, означающего соответствующий тип хранения, локальные переменные в лексической области видимости блокового объекта просто передаются блоковому объекту как переменные, доступные только для чтения. Следовательно, чтобы изменить это поведение, мы могли бы изменить реализацию метода scopeTest и сопроводить переменную integerValue префиксом __block, указывающим тип хранения. Это делается так:

— (void) scopeTest{

__block NSUInteger integerValue = 10;

BlockWithNoParams myBlock = ^{

NSLog(@"Integer value inside the block = %lu",

(unsigned long)integerValue);

};

integerValue = 20;

/* Вызываем блок здесь после изменения

значения переменной integerValue. */

myBlock();

NSLog(@"Integer value outside the block = %lu",

(unsigned long)integerValue);

}

Теперь, если вывести на консоль результаты после вызова метода scopeTest, мы увидим следующее:

Integer value inside the block = 20

Integer value outside the block = 20

Итак, в данном разделе мы довольно подробно рассмотрели вопросы использования переменных с блоковыми объектами. Рекомендую вам написать несколько блоковых объектов и попытаться использовать в них переменные. Присваивайте им переменные, считывайте из них информацию, чтобы лучше разобраться с тем, как в блоковых объектах применяются переменные. Перечитайте этот раздел, если случайно забудете правила, регулирующие доступ к переменным в блоковых объектах.

7.3. Вызов блоковых объектов.

Постановка задачи.

Вы научились создавать блоковые объекты, а теперь требуется их исполнять и получать определенные результаты.

Решение.

Исполняйте ваши блоковые объекты так же, как и функции на языке C. Подробнее об этом — в подразделе «Обсуждение».

Обсуждение.

В разделах 7.1 и 7.2 вы видели примеры вызова блоковых объектов. В данном разделе приводятся более конкретные примеры.

Если у вас есть независимый блоковый объект, его можно вызвать так же, как мы вызывали бы функцию на языке C:

void (^simpleBlock)(NSString *) = ^(NSString *paramString){

/* Реализуем блоковый объект и используем параметр paramString. */

};

— (void) callSimpleBlock{

simpleBlock(@"O'Reilly");

}

Если вы хотите вызвать независимый блоковый объект внутри другого независимого блокового объекта, действуйте так же, как при активизации метода на языке C:

NSString *(^trimString)(NSString *) = ^(NSString *inputString){

NSString *result = [inputString stringByTrimmingCharactersInSet:

[NSCharacterSet whitespaceCharacterSet]];

return result;

};

NSString *(^trimWithOtherBlock)(NSString *) = ^(NSString *inputString){

return trimString(inputString);

};

— (void) callTrimBlock{

NSString *trimmedString = trimWithOtherBlock(@" O'Reilly ");

NSLog(@"Trimmed string = %@", trimmedString);

}

Продолжим данный пример и вызовем метод callTrimBlock на языке Objective-C:

[self callTrimBlock];

Метод callTrimBlock вызовет блоковый объект trimWithOtherBlock, а этот объект вызовет блоковый объект trimString, чтобы обрезать указанную строку. Отсечение строки — простая операция, для ее выполнения требуется всего одна строка кода. Но этот пример демонстрирует, как можно вызывать блоковые объекты внутри блоковых объектов.

См. также.

Разделы 7.1 и 7.2.

7.4. Решение с помощью GCD задач, связанных с пользовательским интерфейсом.

Постановка задачи.

Интерфейс программирования приложений GCD используется для параллельного программирования, и необходимо узнать, каков оптимальный способ его применения с другими API, связанными с пользовательским интерфейсом.

Решение.

Воспользуйтесь функцией dispatch_get_main_queue.

Обсуждение.

Задачи, связанные с пользовательским интерфейсом, должны выполняться в главном потоке. Поэтому единственным каналом для передачи в GCD задач, связанных с пользовательским интерфейсом, и их выполнения оказывается главная очередь. В качестве описателя главной диспетчерской очереди можно применять функцию dispatch_get_main_queue.

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

функция dispatch_async выполняет блоковый объект применительно к диспетчерской очереди;

функция dispatch_async_f выполняет функцию C применительно к диспетчерской очереди.

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

Рассмотрим использование функции dispatch_async, которая принимает два параметра:

описатель диспетчерской очереди — диспетчерская очередь, в которой должна выполняться задача;

блоковый объект — блоковый объект, посылаемый в диспетчерскую очередь для асинхронного выполнения.

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

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_async(mainQueue, ^(void) {

[[[UIAlertView alloc] initWithTitle:@"GCD"

message:@"GCD is amazing!"

delegate: nil

cancelButtonTitle:@"OK"

otherButtonTitles: nil, nil] show];

});

Как видите, функция GCD dispatch_async не имеет ни параметров, ни возвращаемого значения. Блоковый объект, передаваемый данной функции для выполнения задачи, должен самостоятельно собирать данные для этого. В только что рассмотренном примере кода присутствует вид с предупреждением, имеющий все значения, которые требуются ему для выполнения задачи. Но так бывает не всегда. Иногда вам необходимо удостовериться, что блоковый объект, передаваемый GCD, располагает в собственной области видимости всеми значениями, которые требуются для решения стоящей перед ним задачи.

Если запустить данное приложение в эмуляторе iOS, пользователь увидит примерно такую картинку, как на рис. 7.1.

Обсуждение. 7.4. Решение с помощью GCD задач, связанных с пользовательским интерфейсом. Глава 7. Параллелизм. iOS. Приемы программирования.

Рис. 7.1. Предупреждение, при выводе которого применялись асинхронные вызовы к GCD.

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

Если вы не хотите передавать блоковый объект для выполнения в главную очередь, можно передать объект, представляющий собой функцию на языке C. Передавайте функции dispatch_async_f все те функции C, которые предполагается направлять на выполнение в GCD и которые относятся к работе пользовательского интерфейса. Мы можем получить такие же результаты, как на рис. 7.1, используя вместо блоковых объектов функции на языке C, при этом потребуется внести в код лишь незначительные корректировки.

Как было указано ранее, функция dispatch_async_f позволяет передавать указатель на контекст, определяемый приложением. Этот контекст впоследствии может использоваться вызываемой нами функцией C. Итак, создадим структуру, в которой будут содержаться значения — в частности, заголовок предупреждающего вида, сообщение и надпись Cancel (Отмена) на соответствующей кнопке. Когда приложение запустится, мы поместим в эту структуру все значения и передадим ее функции C для отображения. Вот как определяется эта структура:

typedef struct{

char *title;

char *message;

char *cancelButtonTitle;

} AlertViewData;

Итак, продолжим и реализуем функцию C, которая в дальнейшем будет вызываться с GCD. Эта функция должна ожидать параметр типа void *, тип которого затем приводится к AlertViewData *. Иными словами, мы ожидаем от вызывающей стороны этой функции, что нам будет передана ссылка на данные, необходимые для работы предупреждающего вида, которые инкапсулированы в структуре AlertViewData:

void displayAlertView(void *paramContext){

AlertViewData *alertData = (AlertViewData *)paramContext;

NSString *title =

[NSString stringWithUTF8String: alertData->title];

NSString *message =

[NSString stringWithUTF8String: alertData->message];

NSString *cancelButtonTitle =

[NSString stringWithUTF8String: alertData->cancelButtonTitle];

[[[UIAlertView alloc] initWithTitle: title

message: message

delegate: nil

cancelButtonTitle: cancelButtonTitle

otherButtonTitles: nil, nil] show];

free(alertData);

}

Причина, по которой мы применяем free к переданному нам контексту именно здесь, а не на вызывающей стороне, заключается в том, что вызывающая сторона будет выполнять эту функцию C асинхронно и не сможет узнать, когда выполнение функции на языке C завершится. Поэтому вызывающая сторона должна выделить достаточный объем памяти для контекста AlertViewData (операция malloc), и функция C displayAlertView должна высвободить это пространство.

А теперь вызовем функцию displayAlertView применительно к основной очереди и передадим ей контекст (структуру, содержащую данные для предупреждающего вида):

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t mainQueue = dispatch_get_main_queue();

AlertViewData *context = (AlertViewData *)

malloc(sizeof(AlertViewData));

if (context!= NULL){

context->title = «GCD»;

context->message = «GCD is amazing.»;

context->cancelButtonTitle = «OK»;

dispatch_async_f(mainQueue,

(void *)context,

displayAlertView);

}

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Если активизировать метод класса currentThread, относящийся к классу NSThread, то выяснится, что блоковые объекты или функции C, направляемые вами в главную очередь, действительно работают в главном потоке:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_async(mainQueue, ^(void) {

NSLog(@"Current thread = %@", [NSThread currentThread]);

NSLog(@"Main thread = %@", [NSThread mainThread]);

});

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Вывод данного кода будет примерно таким:

Current thread = <NSThread: 0x4b0e4e0>{name = (null), num = 1}

Main thread = <NSThread: 0x4b0e4e0>{name = (null), num = 1}

Итак, мы изучили, как с помощью GCD решаются задачи, связанные с пользовательским интерфейсом. Перейдем к другим темам — в частности, поговорим о том, как выполнять задачи параллельно, используя параллельные очереди (см. разделы 7.5 и 7.6), и как при необходимости смешивать создаваемый код с кодом пользовательского интерфейса.

7.5. Синхронное решение с помощью GCD задач, не связанных с пользовательским интерфейсом.

Постановка задачи.

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

Решение.

Воспользуйтесь функцией dispatch_sync.

Обсуждение.

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

Любая задача, не связанная с пользовательским интерфейсом, позволяет применять глобальные параллельные очереди, которые предоставляет GCD. Они могут выполняться как синхронно, так и асинхронно. Но синхронное выполнение не означает, что программа дожидается, пока выполнится определенный фрагмент кода, а потом продолжает работу. Это лишь означает, что параллельная очередь дождется выполнения вашей задачи и только потом перейдет к выполнению следующего блока кода, стоящего в очереди. Когда вы ставите в параллельную очередь блоковый объект, ваша собственная программа всегда продолжает работу, не дожидаясь, пока выполнится код, стоящий в очереди. Дело в том, что параллельные очереди (как понятно из их названия) выполняют свой код в неглавных потоках. (Из этого правила есть исключение: когда задача передается в параллельную или последовательную очередь посредством функции dispatch_sync, система iOS при наличии такой возможности запускает задачу в текущем потоке. А это может быть и главный поток в зависимости от актуальной ветви кода. Это специальная оптимизация, запрограммированная в GCD, и вскоре мы обсудим ее подробнее.)

Если вы отправляете синхронную задачу в параллельную очередь и в то же время отправляете синхронную задачу в другую параллельную очередь, то две эти синхронные задачи будут выполняться асинхронно друг относительно друга, так как относятся к двум разным параллельным очередям. Этот нюанс важно понимать, поскольку иногда необходимо гарантировать, что задача B начнет выполняться только после того, как завершится задача А. Чтобы обеспечить такую последовательность, эти две задачи нужно синхронно отправлять в одну и ту же очередь.

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

Рассмотрим пример. Данная функция выводит на консоль числа от 1 до 1000, всю последовательность подряд, и при этом не блокирует основной поток. Мы можем создать блоковый объект, выполняющий подсчет за нас, и синхронно (дважды) вызвать этот же блоковый объект:

void (^printFrom1To1000)(void) = ^{

NSUInteger counter = 0;

for (counter = 1;

counter <= 1000;

counter++){

NSLog(@"Counter = %lu — Thread = %@",

(unsigned long)counter,

[NSThread currentThread]);

}

};

Итак, попробуем активизировать этот блоковый объект с помощью GCD:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_sync(concurrentQueue, printFrom1To1000);

dispatch_sync(concurrentQueue, printFrom1To1000);

// Точка переопределения для дополнительной настройки

// после запуска приложения

[self.window makeKeyAndVisible];

return YES;

}

Запустив этот код, вы заметите, что счетчик работает в главном потоке даже при том, что вы поставили эту задачу на выполнение в параллельную очередь. Оказывается, что это явление — специальная оптимизация GCD. Функция dispatch_sync будет использовать актуальный поток, то есть поток, который вы задействуете при направлении задачи в очередь, всякий раз, когда это возможно. В этом и заключается упомянутая оптимизация. Вот что об этом пишет Apple в справке по GCD: «В целях оптимизации работы данная функция активизирует блок кода в актуальном потоке всякий раз, когда это возможно».

Чтобы выполнить вместо блокового объекта функцию на языке C и сделать это синхронно, в диспетчерской очереди, используйте функцию dispatch_sync_f. Давайте просто преобразуем код, написанный для блокового объекта printFrom1To1000, в эквивалентную ему функцию на языке C:

void printFrom1To1000(void *paramContext){

NSUInteger counter = 0;

for (counter = 1;

counter <= 1000;

counter++){

NSLog(@"Counter = %lu — Thread = %@",

(unsigned long)counter,

[NSThread currentThread]);

}

}

А теперь можно воспользоваться функцией dispatch_sync_f для выполнения функции printFrom1To1000 в параллельной очереди:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_sync_f(concurrentQueue,

NULL,

printFrom1To1000);

dispatch_sync_f(concurrentQueue,

NULL,

printFrom1To1000);

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

• DISPATCH_QUEUE_PRIORITY_LOW — ваша задача будет получать меньше процессорного времени, чем выделяется на задачу в среднем;

• DISPATCH_QUEUE_PRIORITY_DEFAULT — ваша задача получит стандартный системный приоритет;

• DISPATCH_QUEUE_PRIORITY_HIGH — ваша задача будет получать больше процессорного времени, чем выделяется на задачу в среднем.

Второй параметр функции dispatch_get_global_queue зарезервирован, ему всегда следует передавать значение 0.

В данном разделе было рассмотрено, как передавать задачи в параллельные очереди для синхронного исполнения. В следующем разделе обсудим асинхронное исполнение в параллельных очередях, а в разделе 7.10 будет показано, как исполнять задачи синхронно и асинхронно в последовательных очередях, создаваемых вами для приложений.

См. также.

Разделы 7.6 и 7.10.

7.6. Асинхронное решение с помощью GCD задач, не связанных с пользовательским интерфейсом.

Постановка задачи.

Необходимо иметь возможность решать задачи, не связанные с пользовательским интерфейсом, с помощью GCD.

Решение.

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

Чтобы выполнять в диспетчерской очереди асинхронные задачи, следует пользоваться одной из следующих функций:

• dispatch_async — отправляет блоковый объект в диспетчерскую очередь (и объект и очередь указываются в соответствующих параметрах) для асинхронного выполнения;

• dispatch_async_f — отправляет в диспетчерскую очередь функцию языка C вместе со ссылкой на контекст (все три элемента указываются в соответствующих параметрах) для асинхронного выполнения.

Обсуждение.

Рассмотрим реальный пример. Напишем приложение для iOS, которое позволит нам скачивать изображение из Интернета по имеющейся гиперссылке (URL). После завершения загрузки наша программа должна отобразить изображение для пользователя. Далее приведен план работы и описано, как будут применены те или иные концепции, связанные с GCD, которые мы уже успели изучить.

1. Мы собираемся асинхронно запускать блоковый объект в параллельной очереди.

2. В ходе выполнения этого блока будем однократно (синхронно) запускать другой блоковый объект. Его мы будем использовать для скачивания изображения по URL, при этом будет применяться функция dispatch_sync. Мы поступаем именно так, поскольку хотим, чтобы обработка остального кода, стоящего в данной параллельной очереди, не начиналась, пока не загрузится изображение. В результате мы заставляем подождать только одну параллельную очередь, а не все остальные очереди. Если синхронно скачивать файл по URL из асинхронного блока кода, мы заблокируем лишь очередь, обрабатывающую синхронную функцию, но не главный поток. Вся операция так и остается асинхронной с точки зрения главного потока. Мы решаем основную задачу: при загрузке изображения главный поток не блокируется.

3. Сразу после того, как загрузка изображения завершится, мы синхронно выполним блоковый объект в главной очереди (см. раздел 7.4), чтобы отобразить картинку в пользовательском интерфейсе.

Каркас для планируемой программы совершенно прост:

— (void) viewDidAppear:(BOOL)animated{

[super viewDidAppear: animated];

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(concurrentQueue, ^{

__block UIImage *image = nil;

dispatch_sync(concurrentQueue, ^{

/* Здесь скачивается изображение. */

});

dispatch_sync(dispatch_get_main_queue(), ^{

/* Здесь мы демонстрируем изображение пользователю и делаем это

в главной очереди. */

});

});

}

Второй вызов к dispatch_sync, после которого отобразится картинка, будет выполняться в очереди после первого синхронного вызова, который обеспечивает загрузку изображения. Именно этого мы и добивались, поскольку нам необходимо дождаться, пока изображение загрузится полностью, и только после этого мы сможем отобразить его для пользователя. Итак, после завершения скачивания изображения мы выполняем второй блоковый объект, но на этот раз — в главной очереди.

Скачаем изображение и отобразим его для пользователя. Это мы сделаем в методе экземпляра viewDidAppear:, относящемся к контроллеру вида, который в данный момент отображается в приложении для iPhone:

— (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear: paramAnimated];

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(concurrentQueue, ^{

__block UIImage *image = nil;

dispatch_sync(concurrentQueue, ^{

/* Здесь скачивается изображение. */

/* Изображение iPad с сайта Apple. Гиперссылка слишком длинная,

поэтому ее нужно правильно разбить на две строки. */

NSString *urlAsString = @"http://images.apple.com/mobileme/features"\

«/images/ipad_findyouripad_201 00518.jpg»;

NSURL *url = [NSURL URLWithString: urlAsString];

NSURLRequest *urlRequest = [NSURLRequest requestWithURL: url];

NSError *downloadError = nil;

NSData *imageData = [NSURLConnection

sendSynchronousRequest: urlRequest

returningResponse: nil

error:&downloadError];

if (downloadError == nil &&

imageData!= nil){

image = [UIImage imageWithData: imageData];

/* Изображение у нас есть. Теперь можно его использовать. */

}

else if (downloadError!= nil){

NSLog(@"Error happened = %@", downloadError);

} else {

NSLog(@"No data could get downloaded from the URL.");

}

});

dispatch_sync(dispatch_get_main_queue(), ^{

/* Здесь картинка отображается, и это происходит в главной очереди. */

if (image!= nil){

/* Здесь создается вид с изображением. */

UIImageView *imageView = [[UIImageView alloc]

initWithFrame: self.view.bounds];

/* Задаем характеристики изображения. */

[imageView setImage: image];

/* Убеждаемся, что изображение масштабировано правильно. */

[imageView setContentMode: UIViewContentModeScaleAspectFit];

/* Добавляем изображение к виду данного контроллера вида. */

[self.view addSubview: imageView];

} else {

NSLog(@"Image isn't downloaded. Nothing to display.");

}

});

});

}

Как показано на рис. 7.2, мы успешно загрузили изображение, а также создали вид изображения, в котором картинка будет представлена пользователю в графическом интерфейсе.

Обсуждение. 7.6. Асинхронное решение с помощью GCD задач, не связанных с пользовательским интерфейсом. Глава 7. Параллелизм. iOS. Приемы программирования.

Рис. 7.2. Загрузка изображения и демонстрация его пользователю, применяется GCD

Приведем другой пример. Допустим, у нас есть массив из 10 000 случайных чисел, которые сохранены в файле на диске. Мы хотим загрузить этот файл в память и отсортировать числа в порядке возрастания (то есть сделать так, чтобы список начинался с наименьшего числа). Потом мы хотим отобразить полученный список для пользователя. Инструмент управления, который будет применяться при этой операции, определяется тем, для какой системы вы пишете программу. В случае с iOS идеальным выходом было бы использовать экземпляр UITableView, а при работе с Mac OS X — экземпляр NSTableView. Поскольку массива у нас еще нет, начнем с его создания, потом загрузим этот массив, а потом отобразим.

Вот два метода, которые помогут нам найти место на диске устройства, где мы собираемся сохранить массив из 10 000 случайных чисел:

— (NSString *) fileLocation{

/* Получаем каталог (-и) документа. */

NSArray *folders =

NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,

NSUserDomainMask,

YES);

/* Мы что-нибудь нашли? */

if ([folders count] == 0){

return nil;

}

/* Получаем первый каталог. */

NSString *documentsFolder = [folders objectAtIndex:0];

/* Прикрепляем имя файла к концу пути документа. */

return [documentsFolder

stringByAppendingPathComponent:@"list.txt"];

}

— (BOOL) hasFileAlreadyBeenCreated{

BOOL result = NO;

NSFileManager *fileManager = [[NSFileManager alloc] init];

if ([fileManager fileExistsAtPath: [self fileLocation]]){

result = YES;

}

return result;

}

А вот теперь очень важный нюанс. Мы хотим сохранить на диске массив из 10 000 случайных чисел, если, и только если мы не создавали такой массив на диске раньше. В противном случае мы сразу загрузим массив с диска. Если же прежде мы не создавали этот массив на диске, то сначала создадим его, а потом перейдем к загрузке массива с диска. В итоге, если считывание массива с диска пройдет успешно, мы отсортируем этот массив в порядке возрастания и, наконец, отобразим результаты для пользователя в графическом интерфейсе. Реализацию отображения результатов пользователю оставляю вам для самостоятельной работы.

— (void) viewDidAppear:(BOOL)paramAnimated{

[super viewDidAppear: paramAnimated];

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

/* Если мы еще не отсортировали массив из 10 000 случайных чисел

на диске ранее, сгенерируем эти числа сейчас, а потом сохраним

их на диск в массиве. */

dispatch_async(concurrentQueue, ^{

NSUInteger numberOfValuesRequired = 10000;

if ([self hasFileAlreadyBeenCreated] == NO){

dispatch_sync(concurrentQueue, ^{

NSMutableArray *arrayOfRandomNumbers =

[[NSMutableArray alloc] initWithCapacity: numberOfValuesRequired];

NSUInteger counter = 0;

for (counter = 0;

counter < numberOfValuesRequired;

counter++){

unsigned int randomNumber =

arc4random() % ((unsigned int)RAND_MAX + 1);

[arrayOfRandomNumbers addObject:

[NSNumber numberWithUnsignedInt: randomNumber]];

}

/* Теперь записываем массив на диск. */

[arrayOfRandomNumbers writeToFile: [self fileLocation]

atomically: YES];

});

}

__block NSMutableArray *randomNumbers = nil;

/* Считываем числа с диска и сортируем их в порядке возрастания. */

dispatch_sync(concurrentQueue, ^{

/* Если файл на данный момент уже создан, занимаемся его считыванием. */

if ([self hasFileAlreadyBeenCreated]){

randomNumbers = [[NSMutableArray alloc]

initWithContentsOfFile: [self fileLocation]];

/* Теперь сортируем числа. */

[randomNumbers sortUsingComparator:

^NSComparisonResult(id obj1, id obj2) {

NSNumber *number1 = (NSNumber *)obj1;

NSNumber *number2 = (NSNumber *)obj2;

return [number1 compare: number2];

}];

}

});

dispatch_async(dispatch_get_main_queue(), ^{

if ([randomNumbers count] > 0){

/* Обновляем пользовательский интерфейс, задействуя числа

из массива randomNumbers. */

}

});

});

}

Функционал GCD далеко не ограничивается синхронным или асинхронным выполнением блоков кода или функций. В разделе 7.9 вы научитесь группировать блоковые объекты и готовить их к выполнению в диспетчерской очереди. Кроме того, рекомендую вам изучить разделы 7.7. и 7.8, где говорится о прочих функциях, которые предоставляются программисту в GCD.

См. также.

Разделы 7.4, 7.7 и 7.8.

7.7. Выполнение задач после задержки с помощью GCD.

Постановка задачи.

Требуется выполнить код, но после определенной задержки. Задержку планируется указывать с помощью GCD.

Решение.

Воспользуйтесь функциями dispatch_after и dispatch_after_f.

Обсуждение.

Работая с фреймворком Core Foundation, можно активизировать селектор в объекте по истечении заданного временного промежутка с помощью метода performSelector: withObject: afterDelay:, относящегося к классу NSObject. Например:

— (void) printString:(NSString *)paramString{

NSLog(@"%@", paramString);

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

[self performSelector:@selector(printString:)

withObject:@"Grand Central Dispatch"

afterDelay:3.0];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

// Точка переопределения для настройки после запуска приложения

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

В данном примере мы приказываем среде времени исполнения вызвать метод printString: после трехсекундной задержки. Ту же операцию можно осуществить и в GCD с помощью функций dispatch_after и dispatch_after_f. Обе эти функции описаны далее.

• dispatch_after — направляет блоковый объект в диспетчерскую очередь по истечении заданного периода времени, указываемого в наносекундах. Эта функция требует следующих параметров:

задержка в наносекундах — количество наносекунд, в течение которых длится ожидание в определенной диспетчерской очереди в GCD (указываемой во втором параметре), после чего выполняется блоковый объект (задаваемый в третьем параметре);

диспетчерская очередь — диспетчерская очередь, в которой должен быть выполнен блоковый объект (указываемый в третьем параметре) после определенной задержки (задаваемой в первом параметре);

блоковый объект — блоковый объект, который должен быть активизирован в заданной диспетчерской очереди по истечении заданного количества наносекунд. Блоковый объект не должен иметь возвращаемого значения и не должен принимать никаких параметров (см. раздел 7.1).

• dispatch_after_f — направляет функцию на языке C в GCD для выполнения по истечении указанного периода времени, задаваемого в наносекундах. Данная функция принимает четыре параметра:

задержка в наносекундах — количество наносекунд, в течение которых длится ожидание в определенной диспетчерской очереди в GCD (указываемой во втором параметре), после чего выполняется заданная функция (задаваемая в четвертом параметре);

диспетчерская очередь — диспетчерская очередь, в которой должна быть выполнена функция на языке C (указываемая во втором параметре) после определенной задержки (задаваемой в первом параметре);

контекст — адрес в памяти, по которому находится определенное значение, относящееся к неупорядоченному массиву данных (куче). Это значение должно передаваться функции C. Подробнее об этом говорилось в разделе 7.4;

функция на языке C — адрес функции на языке C, которая должна быть выполнена по истечении определенного периода времени (указываемого в первом параметре) в заданной диспетчерской очереди (указываемой во втором параметре).

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

Сначала рассмотрим пример работ с функцией dispatch_after:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

double delayInSeconds = 2.0;

dispatch_time_t delayInNanoSeconds =

dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_after(delayInNanoSeconds, concurrentQueue, ^(void){

/* Здесь выполняются требуемые операции. */

});

// Точка переопределения для настройки после запуска приложения

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Как видите, параметр задержки в наносекундах для функций dispatch_after и dispatch_after_f должен относиться к типу dispatch_time_t, который является абстрактным представлением абсолютного времени. Чтобы получить значение этого параметра, можно пользоваться функцией dispatch_time так, как показано в данном образце кода. Вот параметры, которые можно сообщать функции dispatch_time.

Исходное время — если обозначить этот параметр через B, а приращение времени (Delta Parameter) — через D, то результирующее время от этой функции будет равно B+D. Для этого параметра можно задать значение DISPATCH_TIME_NOW, определив таким образом в качестве базового времени настоящий момент, а потом указать приращение, добавляемое к этому времени, используя дельта-параметр.

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

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

dispatch_time_t delay =

dispatch_time(DISPATCH_TIME_NOW, 3.0f * NSEC_PER_SEC);

А вот так задается период 0,5 с от настоящего момента:

dispatch_time_t delay =

dispatch_time(DISPATCH_TIME_NOW, (1.0 / 2.0f) * NSEC_PER_SEC);

Теперь рассмотрим, как можно использовать функцию dispatch_after_f:

void processSomething(void *paramContext){

/* Здесь происходит обработка. */

NSLog(@"Processing…");

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

double delayInSeconds = 2.0;

dispatch_time_t delayInNanoSeconds =

dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_after_f(delayInNanoSeconds,

concurrentQueue,

NULL,

processSomething);

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

// Точка переопределения для настройки после запуска приложения

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

См. также.

Разделы 7.1 и 7.4.

7.8. Однократное выполнение задач с помощью GCD.

Постановка задачи.

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

Решение.

Воспользуйтесь функцией dispatch_once.

Обсуждение.

Выделение и инициализация синглтона — одна из таких задач, которые должны происходить один, и только один раз за весь жизненный цикл приложения. Уверен, что вы можете вспомнить и другие аналогичные сценарии.

GCD позволяет указывать идентификатор для фрагмента кода при попытке выполнить этот код. Если GCD обнаруживает, что данный идентификатор уже передавался фреймворку ранее, то система не будет вновь выполнять этот блок кода. Функция, которая обеспечивает выполнение подобных задач, называется dispatch_once. Она может принимать два параметра.

Маркер — маркер типа dispatch_once_t, содержащий сгенерированную GCD метку при первом выполнении блока кода. Если вы хотите, чтобы блок кода был выполнен лишь один раз, нужно указывать для данного метода один и тот же маркер независимо от того, когда он активизируется в приложении. Такой пример мы вскоре рассмотрим.

Блоковый объект — блоковый объект, выполняемый не более одного раза. Блоковый объект не возвращает никаких значений и не принимает никаких параметров.

dispatch_once всегда выполняет свою задачу в актуальной очереди, используемой кодом, который делает вызов. Это может быть как последовательная, так и параллельная или главная очереди.

Например:

static dispatch_once_t onceToken;

void (^executedOnlyOnce)(void) = ^{

static NSUInteger numberOfEntries = 0;

numberOfEntries++;

NSLog(@"Executed %lu time(s)", (unsigned long)numberOfEntries);

};

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t concurrentQueue =

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_once(&onceToken, ^{

dispatch_async(concurrentQueue,

executedOnlyOnce);

});

dispatch_once(&onceToken, ^{

dispatch_async(concurrentQueue,

executedOnlyOnce);

});

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Как видите, мы пытаемся активизировать блоковый объект executedOnlyOnce дважды с помощью функции dispatch_once, но на самом деле GCD выполняет этот блоковый объект лишь однажды, поскольку идентификатор, передаваемый функции dispatch_once, оба раза один и тот же.

В руководстве Cocoa Fundamentals Guide (Руководство по основам Cocoa) (https://developer.apple.com/library/ios/#documentation/General/Conceptual/DevPedia-CocoaCore/Singleton.html) Apple объясняется, как создавать синглтон. Исходный код довольно старый и еще не обновлен с учетом использования GCD и автоматического подсчета ссылок. Мы можем изменить эту модель, чтобы можно было пользоваться GCD и функцией dispatch_once. В результате мы сможем создавать совместно используемый экземпляр объекта:

#import «MySingleton.h»

@implementation MySingleton

— (instancetype) sharedInstance{

static MySingleton *SharedInstance = nil;

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

SharedInstance = [MySingleton new];

});

return SharedInstance;

}

@end

7.9. Объединение задач в группы с помощью GCD.

Постановка задачи.

Требуется объединять блоки кода в группы и гарантировать, что GCD будет выполнять все задачи одну за другой, выстраивая таким образом зависимости между ними.

Решение.

Для создания групп в GCD пользуйтесь функцией dispatch_group_create.

Обсуждение.

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

— (void) reloadTableView{

/* Здесь перезагружается табличный вид. */

NSLog(@"%s", __FUNCTION__);

}

— (void) reloadScrollView{

/* Здесь выполняется работа. */

NSLog(@"%s", __FUNCTION__);

}

— (void) reloadImageView{

/* Здесь перезагружается вид с изображением. */

NSLog(@"%s", __FUNCTION__);

}

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

• dispatch_group_create — создает описатель группы;

• dispatch_group_async — отправляет блок кода в группу для выполнения. Необходимо указать диспетчерскую очередь, в которой должен выполняться этот блок кода, а также группу, к которой этот блок кода относится;

• dispatch_group_notify — позволяет отправить блоковый объект, который необходимо выполнить после того, как все задачи, направленные в группу для выполнения, закончат свою работу. Эта функция также позволяет указывать диспетчерскую очередь, в которой должен выполняться данный блоковый объект.

Рассмотрим пример. Как объяснялось ранее, в этом примере мы собираемся активизировать методы reloadTableView, reloadScrollView и reloadImageView один за другим, а потом отобразить для пользователя сообщение о том, что задача выполнена. Для достижения этой цели применим мощные групповые функции, присущие GCD:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_group_t taskGroup = dispatch_group_create();

dispatch_queue_t mainQueue = dispatch_get_main_queue();

/* Перезагружаем табличный вид в главной очереди. */

dispatch_group_async(taskGroup, mainQueue, ^{

[self reloadTableView];

});

/* Перезагружаем прокручиваемый вид в главной очереди. */

dispatch_group_async(taskGroup, mainQueue, ^{

[self reloadScrollView];

});

/* Перезагружаем вид с изображением в главной очереди. */

dispatch_group_async(taskGroup, mainQueue, ^{

[self reloadImageView];

});

/* Когда все это будет сделано, диспетчеризуем следующий блок. */

dispatch_group_notify(taskGroup, mainQueue, ^{

/* Здесь происходит обработка. */

[[[UIAlertView alloc] initWithTitle:@"Finished"

message:@"All tasks are finished"

delegate: nil

cancelButtonTitle:@"OK"

otherButtonTitles: nil, nil] show];

});

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Кроме работы с функцией dispatch_group_async, можно также направлять асинхронные функции на языке C, используя функцию dispatch_group_async_f.

GCDAppDelegate — это просто имя класса, из которого взят пример. Данное имя класса мы будем использовать для приведения типа контекстного объекта так, чтобы компилятор понимал наши команды.

Вот так:

void reloadAllComponents(void *context){

AppDelegate *self = (__bridge AppDelegate *)context;

[self reloadTableView];

[self reloadScrollView];

[self reloadImageView];

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_group_t taskGroup = dispatch_group_create();

dispatch_queue_t mainQueue = dispatch_get_main_queue();

dispatch_group_async_f(taskGroup,

mainQueue,

(__bridge void *)self,

reloadAllComponents);

/* Когда все это будет сделано, диспетчеризуем следующий блок. */

dispatch_group_notify(taskGroup, mainQueue, ^{

/* Здесь происходит обработка. */

[[[UIAlertView alloc] initWithTitle:@"Finished"

message:@"All tasks are finished"

delegate: nil

cancelButtonTitle:@"OK"

otherButtonTitles: nil, nil] show];

});

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Поскольку функция dispatch_group_async_f принимает функцию на языке C как блок кода для исполнения, у функции C должна быть ссылка на self, чтобы она могла активизировать методы экземпляра актуального объекта, где реализована функция C. Вот почему self передается как указатель контекста в функции dispatch_group_async_f. Подробнее о контекстах и функциях C рассказано в разделе 7.4.

После того как все поставленные задачи будут завершены, пользователь увидит примерно такую картинку, как на рис. 7.3.

Обсуждение. 7.9. Объединение задач в группы с помощью GCD. Глава 7. Параллелизм. iOS. Приемы программирования.

Рис. 7.3. Управление группой задач в GCD

См. также.

Раздел 7.4.

7.10. Создание собственных диспетчерских очередей с помощью GCD.

Постановка задачи.

Требуется создавать собственные диспетчерские очереди с уникальными именами.

Решение.

Воспользуйтесь функцией dispatch_queue_create.

Обсуждение.

Работая с GCD, вы можете создавать собственные последовательные диспетчерские очереди (см. раздел 7.0, где подробно рассказано о последовательных очередях). Задачи в последовательных диспетчерских очередях выполняются по принципу «первым пришел — первым обслужен» (FIFO). Но асинхронные задачи, выполняемые в последовательных очередях, не осуществляются в главном потоке, благодаря чему последовательные очереди очень хорошо подходят для решения параллельных FIFO-задач.

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

Для создания последовательных очередей мы будем пользоваться функцией dispatch_queue_create. Первый параметр этой функции — строка на языке C (char *), которая уникально идентифицирует данную последовательную очередь в системе. Я делаю особый акцент на системе, потому что данный идентификатор действует в рамках всей системы. Это означает, что если ваше приложение создает новую последовательную очередь с идентификатором serialQueue1 и то же самое делает какое-то другое приложение, GCD не сможет зафиксировать акт создания такой одноименной последовательной очереди. Поэтому Apple настоятельно рекомендует, чтобы идентификаторы записывались в формате «обратное доменное имя» (Reverse DNS Format). Идентификаторы в формате обратных доменных имен обычно составляются по следующему принципу: com.COMPANY.PRODUCT.IDENTIFIER. Например, я могу создать две последовательные очереди и присвоить им следующие имена:

com.pixolity.GCD.serialQueue1

com.pixolity.GCD.serialQueue2

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

Пожалуй, самое время для примера. Вот он!

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t firstSerialQueue =

dispatch_queue_create(«com.pixolity.GCD.serialQueue1», 0);

dispatch_async(firstSerialQueue, ^{

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"First iteration, counter = %lu", (unsigned long)counter);

}

});

dispatch_async(firstSerialQueue, ^{

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"Second iteration, counter = %lu", (unsigned long)counter);

}

});

dispatch_async(firstSerialQueue, ^{

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"Third iteration, counter = %lu", (unsigned long)counter);

}

});

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Запустив этот код, обратите внимание на то, какая информация выводится в окне консоли. Результаты будут примерно такими:

First iteration, counter = 0

First iteration, counter = 1

First iteration, counter = 2

First iteration, counter = 3

First iteration, counter = 4

Second iteration, counter = 0

Second iteration, counter = 1

Second iteration, counter = 2

Second iteration, counter = 3

Second iteration, counter = 4

Third iteration, counter = 0

Third iteration, counter = 1

Third iteration, counter = 2

Third iteration, counter = 3

Third iteration, counter = 4

Очевидно, что, хотя мы и направляли блоковые объекты в последовательную очередь асинхронно, очередь выполняла их код в порядке «первым пришел — первым обслужен». Мы можем изменить этот пример с кодом так, чтобы пользоваться функцией dispatch_async_f вместо dispatch_async:

void firstIteration(void *paramContext){

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"First iteration, counter = %lu", (unsigned long)counter);

}

}

void secondIteration(void *paramContext){

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"Second iteration, counter = %lu", (unsigned long)counter);

}

}

void thirdIteration(void *paramContext){

NSUInteger counter = 0;

for (counter = 0;

counter < 5;

counter++){

NSLog(@"Third iteration, counter = %lu", (unsigned long)counter);

}

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

dispatch_queue_t firstSerialQueue =

dispatch_queue_create(«com.pixolity.GCD.serialQueue1», 0);

dispatch_async_f(firstSerialQueue, NULL, firstIteration);

dispatch_async_f(firstSerialQueue, NULL, secondIteration);

dispatch_async_f(firstSerialQueue, NULL, thirdIteration);

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

7.11. Синхронное выполнение задач с помощью операций.

Постановка задачи.

Необходимо синхронно выполнить серию задач.

Решение.

Создавайте операции и запускайте их вручную:

@interface AppDelegate ()

@property (nonatomic, strong) NSInvocationOperation *simpleOperation;

@end

Реализация делегата приложения такова:

— (void) simpleOperationEntry:(id)paramObject{

NSLog(@"Parameter Object = %@", paramObject);

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

NSNumber *simpleObject = [NSNumber numberWithInteger:123];

self.simpleOperation = [[NSInvocationOperation alloc]

initWithTarget: self

selector:@selector(simpleOperationEntry:)

object: simpleObject];

[self.simpleOperation start];

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Вывод этой программы (в окне консоли) будет примерно таким:

Parameter Object = 123

Main Thread = <NSThread: 0x68 10280>{name = (null), num = 1}

Current Thread = <NSThread: 0x68 10280>{name = (null), num = 1}

Из имени данного класса (NSInvocationOperation) понятно[6], что основное применение объекта такого типа связано с активизацией метода в объекте. Это наиболее непосредственный способ активизации метода в объекте с помощью операций.

Обсуждение.

Операция активизации, как объяснялось в разделе 7.0, позволяет активизировать метод в объекте. «Что же в этом особенного?» — спросите вы. Потенциал активизирующей операции можно продемонстрировать, когда такая операция добавляется в операционную очередь. Примененная вместе с операционной очередью, активизирующая операция может асинхронно запустить метод в заданном объекте параллельно тому потоку, который начал операцию. Внимательно рассмотрев вывод с консоли (приведенный в подразделе «Решение» данного раздела), вы заметите, что актуальный поток в методе, запущенный активизирующей операцией, равен главному потоку. Действительно, главный поток в методе application: didFinishLaunchingWithOptions: запускает операцию, пользуясь ее методом start. В разделе 7.12 мы научимся эффективно использовать операционные очереди для асинхронного выполнения задач.

Кроме активизирующих операций, вы можете применять блоковые или обычные операции для синхронного выполнения задач. Вот пример использования блоковой операции для подсчета чисел от 0 до 999 (это происходит в. h-файле делегата приложения):

@interface AppDelegate ()

@property (nonatomic, strong) NSBlockOperation *simpleOperation;

@end

@implementation AppDelegate

А вот реализация делегата приложения (.m-файл):

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

self.simpleOperation = [NSBlockOperation blockOperationWithBlock: ^{

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

NSUInteger counter = 0;

for (counter = 0;

counter < 1000;

counter++){

NSLog(@"Count = %lu", (unsigned long)counter);

}

}];

/* Запуск операции. */

[self.simpleOperation start];

/* Выводим что-нибудь на консоль, просто чтобы проверить,

должны мы дожидаться, пока выполнится блок кода, или нет.*/

NSLog(@"Main thread is here");

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Если запустить приложение, мы увидим, что на экране выводятся значения от 0 до 999, а за ними следует сообщение Main thread is here (Это главный поток):

Main Thread = <NSThread: 0x68 10280>{name = (null), num = 1}

Current Thread = <NSThread: 0x68 10280>{name = (null), num = 1}

Count = 991

Count = 992

Count = 993

Count = 994

Count = 995

Count = 996

Count = 997

Count = 998

Count = 999

Main thread is here

Итак, убеждаемся, что, поскольку блоковая операция была запущена в методе application: didFinishLaunchingWithOptions:, который сам работает в главном потоке, код внутри блока также выполняется в главном потоке. Основные сведения, которые мы получаем из этих регистрационных записей (логов), сводятся к следующему: операция блокировала главный поток, и потребовалось вернуться к выполнению кода основного потока после того, как была завершена работа блоковой операции. Это образец очень непрофессионального программирования. На самом деле программисты, работающие с iOS, должны идти на любые уловки и пользоваться любыми известными им приемами, чтобы обеспечивать отклик основного потока в любой момент и чтобы этот поток мог заниматься своим основным делом — обработкой пользовательского ввода. Вот что об этом пишет Apple.

«Необходимо внимательно отслеживать, какие задачи вы решаете в главном потоке вашего приложения. Именно в главном потоке ваша программа отрабатывает события касания и другой пользовательский ввод. Чтобы гарантировать, что приложение в любой момент будет откликаться на действия пользователя, никогда не следует загружать главный поток выполнением долговременных задач либо выполнением задач с потенциально неопределенным концом. Таковы, в частности, задачи, связанные с доступом к сети. Напротив, подобные задачи следует решать в фоновых потоках. Оптимальный способ решения таких задач — заключение их в объект операции и добавление этого объекта к операционной очереди. Но вы можете и сами создавать потоки вручную».

Подробнее эта тема рассматривается в документе Performance Tuning («Повышение производительности») в справочной библиотеке iOS. Документ расположен по адресу https://developer.apple.com/library/ios/documentation/iphone/conceptual/iphoneosprogrammingguide/PerformanceTuning/PerformanceTuning.html#//apple_ref/doc/uid/TP400 07072-CH8-SW1.

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

Если вы не планируете пользоваться операционной очередью, то необходимо открепить от вашего потока новый поток. Это делается в методе start, относящемся к операции. Если вы не хотите пользоваться операционной очередью, а также не собираетесь выполнять данную операцию асинхронно с другими операциями, запускаемыми вручную, то можно просто вызвать метод main операции в методе start.

В реализации операции необходимо переопределить два важных метода экземпляра NSOperation — методы isExecuting и isFinished. Их может вызывать любой другой объект. В этих методах необходимо возвращать потоковобезопасное значение, которым можно будет управлять прямо из операции. Как только операция начинается, она должна посредством механизма «уведомления наблюдателей об изменениях в свойствах наблюдаемого объекта» (KVO) сообщать всем слушателям о том, что вы изменяете возвращаемые значения для двух этих методов. В примере с кодом мы рассмотрим, как это происходит на практике.

В методе main, относящемся к операции, необходимо создать собственный автоматически высвобождаемый пул на случай, если когда-нибудь в будущем операция будет добавлена в операционную очередь. Необходимо убедиться в том, что операции можно задействовать обоими способами — как при запуске вручную, так и при запуске в рамках операционной очереди.

У вас должен быть метод-инициализатор для ваших операций. Это обязательно должен быть специальный метод, выделенный под конкретную операцию. Все остальные методы-инициализаторы, в том числе применяемый по умолчанию метод init, должны вызывать вышеупомянутый специальный инициализатор, который содержит наибольшее количество параметров. Другие методы-инициализаторы должны гарантировать, что они передают подходящие параметры методу-инициализатору (если вообще передают).

Вот объявление объекта операции (.h-файл):

#import <Foundation/Foundation.h>

@interface CountingOperation: NSOperation

/* Выделенный инициализатор */

— (id) initWithStartingCount:(NSUInteger)paramStartingCount

endingCount:(NSUInteger)paramEndingCount;

@end

Реализация операции (записываемая в. m-файле) несколько длинновата, но, надеюсь, вполне понятна:

#import «CountingOperation.h»

@implementation CountingOperation

@property (nonatomic, unsafe_unretained) NSUInteger startingCount;

@property (nonatomic, unsafe_unretained) NSUInteger endingCount;

@property (nonatomic, unsafe_unretained, getter=isFinished) BOOL finished;

@property (nonatomic, unsafe_unretained, getter=isExecuting) BOOL executing;

@end

@implementation CountingOperation

— (instancetype) init {

return([self initWithStartingCount:0

endingCount:1000]);

}

— (instancetype) initWithStartingCount:(NSUInteger)paramStartingCount

endingCount:(NSUInteger)paramEndingCount{

self = [super init];

if (self!= nil){

/* Сохраните эти значения для главного метода. */

startingCount = paramStartingCount;

endingCount = paramEndingCount;

}

return(self);

}

— (void) main {

@try {

/* Это автоматически высвобождаемый пул. */

@autoreleasepool {

/* Сохраняем здесь локальную переменную, которая

должна быть установлена в YES всякий раз, когда

мы завершаем выполнение задачи. */

BOOL taskIsFinished = NO;

/* Создаем здесь цикл while, существующий лишь в том случае,

когда переменная taskIsFinished устанавливается в YES

или операция отменяется. */

while (taskIsFinished == NO &&

[self isCancelled] == NO){

/* Здесь выполняется задача. */

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

NSUInteger counter = startingCount;

for (counter = startingCount;

counter < endingCount;

counter++){

NSLog(@"Count = %lu", (unsigned long)counter);

}

/* Очень важно. Здесь мы можем выйти из цикла, по-прежнему

соблюдая правила, по которым отменяются операции. */

taskIsFinished = YES;

}

/* Соответствие KVO. Генерируем требуемые уведомления KVO. */

[self willChangeValueForKey:@"isFinished"];

[self willChangeValueForKey:@"isExecuting"];

finished = YES;

executing = NO;

[self didChangeValueForKey:@"isFinished"];

[self didChangeValueForKey:@"isExecuting"];

}

}

@catch (NSException * e) {

NSLog(@"Exception %@", e);

}

}

@end

Операцию можно начать так:

@interface AppDelegate ()

@property (nonatomic, strong) CountingOperation *simpleOperation;

@end

@implementation AppDelegate

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

self.simpleOperation = [[CountingOperation alloc] initWithStartingCount:0

endingCount:1000];

[self.simpleOperation start];

NSLog(@"Main thread is here");

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

@end

Запустив данный код, мы увидим в окне консоли следующие результаты, точно как при применении блоковой операции:

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Current Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Count = 993

Count = 994

Count = 995

Count = 996

Count = 997

Count = 998

Count = 999

Main thread is here

См. также.

Раздел 7.12.

7.12. Асинхронное выполнение задач с помощью операций.

Постановка задачи.

Требуется параллельно выполнять операции.

Решение.

Воспользуйтесь операционными очередями. В качестве альтернативы можно создавать подклассы от NSOperation и откреплять новый поток в методе main.

Обсуждение.

Как говорилось в разделе 7.11, операции по умолчанию работают в том потоке, который вызывает метод start. Обычно операции запускаются в основном потоке, но в то же время мы ожидаем, что операции будут выполняться в собственных потоках и, соответственно, не будут тратить процессорное время, уделяемое главному потоку. Наилучшим решением для обеспечения такой работы будет применение операционных очередей. Однако если вы хотите управлять своими операциями вручную, чего бы я не рекомендовал, то можно было бы создавать подклассы от NSOperation и откреплять новый поток в главном методе. Подробнее об открепленных потоках поговорим в разделе 7.15.

Идем дальше. Попробуем воспользоваться операционной очередью и добавим к ней две простые инициирующие операции (подробнее об инициирующих операциях рассказано в разделе 7.0). Дополнительные примеры кода, описывающие инициирующие операции, имеются в разделе 7.11. Вот объявление (.hm-файл) делегата приложения, в котором используются операционная очередь и две инициирующие операции:

@interface AppDelegate ()

@property (nonatomic, strong) NSOperationQueue *operationQueue;

@property (nonatomic, strong) NSInvocationOperation *firstOperation;

@property (nonatomic, strong) NSInvocationOperation *secondOperation;

@end

@implementation AppDelegate

А вот и внутренняя часть файла реализации делегата приложения:

— (void) firstOperationEntry:(id)paramObject{

NSLog(@"%s", __FUNCTION__);

NSLog(@"Parameter Object = %@", paramObject);

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

}

— (void) secondOperationEntry:(id)paramObject{

NSLog(@"%s", __FUNCTION__);

NSLog(@"Parameter Object = %@", paramObject);

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

NSNumber *firstNumber = @111;

NSNumber *secondNumber = @222;

self.firstOperation =[[NSInvocationOperation alloc]

initWithTarget: self

selector:@selector(firstOperationEntry:)

object: firstNumber];

self.secondOperation = [[NSInvocationOperation alloc]

initWithTarget: self

selector:@selector(secondOperationEntry:)

object: secondNumber];

self.operationQueue = [[NSOperationQueue alloc] init];

/* Добавляем операции в очередь. */

[self.operationQueue addOperation: self.firstOperation];

[self.operationQueue addOperation: self.secondOperation];

NSLog(@"Main thread is here");

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Вот что происходит в реализации данного кода.

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

Мы инициализируем два метода типа NSInvocationOperation и задаем целевой селектор в точке входа каждой операции (эти точки входа были описаны выше).

Затем инициализируем объект типа NSOperationQueue. (Он может создаваться и до того, как созданы методы входа.) Объект очереди будет обеспечивать параллелизм в работе операционных объектов. На данном этапе операционная очередь может немедленно начать (а может и не начать) запускать инициирующие операции, пользуясь их методами start. При этом очень важно помнить, что после добавления операции в операционную очередь от вас не требуется запускать операции вручную. Обеспечением запуска занимается операционная очередь.

Итак, еще раз запустим код примера и посмотрим, что же у нас на консоли:

[Running_Tasks_Asynchronously_with_OperationsAppDelegate firstOperationEntry: ]

Main thread is here

Parameter Object = 111

[Running_Tasks_Asynchronously_with_OperationsAppDelegate secondOperationEntry: ]

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Parameter Object = 222

Current Thread = <NSThread: 0x6805c20>{name = (null), num = 3}

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Current Thread = <NSThread: 0x6b2d1d0>{name = (null), num = 4}

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

Main thread is here

[Running_Tasks_Asynchronously_with_OperationsAppDelegate firstOperationEntry: ]

[Running_Tasks_Asynchronously_with_OperationsAppDelegate secondOperationEntry: ]

Parameter Object = 111

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Current Thread = <NSThread: 0x68247c0>{name = (null), num = 3}

Parameter Object = 222

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Current Thread = <NSThread: 0x6819b00>{name = (null), num = 4}

Очевидно, что главный поток не блокируется и что обе инициирующие операции работают параллельно с главным потоком. Это доказывает, что в операционной очереди сохраняется параллелизм даже тогда, когда в нее добавляются две непараллельные операции. Операционная очередь управляет потоками, необходимыми для осуществления операций.

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

Если обычные операции, являющиеся подклассами от NSOperation, добавлять в операционную очередь, то они будут работать асинхронно. Поэтому необходимо переопределить метод экземпляра isConcurrent, относящийся к классу NSOperation, и возвратить значение YES.

Необходимо подготовить операцию к отмене, периодически проверяя значение метода isCancelled при осуществлении основной задачи операции, а также в методе start еще до запуска самой операции. В таком случае метод start вызывается операционной очередью после того, как операция будет добавлена в очередь. В этом методе проверяется, не отменена ли операция. Это делается с помощью метода isCancelled. Если операция отменена, просто верните такое значение от метода start. В противном случае вызовите метод main из метода start.

Переопределите метод main собственной реализацией основной задачи, которую должна выполнять операция. Обязательно выделите и инициализируйте в этом методе ваш собственный автоматически высвобождаемый пул и высвободите его непосредственно перед актом возврата.

Переопределите методы isFinished и isExecuting операции и верните соответствующие логические (BOOL) значения, показывающие, завершена операция или продолжается в настоящий момент.

Вот объявление операции (.h-файл):

#import <Foundation/Foundation.h>

@interface SimpleOperation: NSOperation

/* Выделенный инициализатор */

— (id) initWithObject:(NSObject *)paramObject;

@end

Реализация операции такова:

#import «SimpleOperation.h»

@implementation SimpleOperation

— (instancetype) init {

return([self initWithObject:@123]);

}

— (instancetype) initWithObject:(NSObject *)paramObject{

self = [super init];

if (self!= nil){

/* Сохраните эти значения для главного метода. */

_givenObject = paramObject;

}

return(self);

}

— (void) main {

@try {

@autoreleasepool {

/* Сохраняем здесь локальную переменную, которая должна быть

установлена в YES всякий раз, когда мы завершаем

выполнение задачи. */

BOOL taskIsFinished = NO;

/* Создаем здесь цикл while, существующий лишь в том случае,

когда переменная taskIsFinished устанавливается в YES

или операция отменяется. */

while (taskIsFinished == NO &&

[self isCancelled] == NO){

/* Здесь выполняется задача. */

NSLog(@"%s", __FUNCTION__);

NSLog(@"Parameter Object = %@", givenObject);

NSLog(@"Main Thread = %@", [NSThread mainThread]);

NSLog(@"Current Thread = %@", [NSThread currentThread]);

/* Очень важно. Здесь мы можем выйти из цикла, по-прежнему

соблюдая правила, по которым отменяются операции. */

taskIsFinished = YES;

}

/* Соответствие KVO. Генерируем требуемые уведомления KVO. */

[self willChangeValueForKey:@"isFinished"];

[self willChangeValueForKey:@"isExecuting"];

finished = YES;

executing = NO;

[self didChangeValueForKey:@"isFinished"];

[self didChangeValueForKey:@"isExecuting"];

}

}

@catch (NSException * e) {

NSLog(@"Exception %@", e);

}

}

— (BOOL) isConcurrent{

return YES;

}

@end

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

@interface AppDelegate ()

@property (nonatomic, strong) NSOperationQueue *operationQueue;

@property (nonatomic, strong) SimpleOperation *firstOperation;

@property (nonatomic, strong) SimpleOperation *secondOperation;

@end

@implementation AppDelegate

Реализация делегата приложения такова:

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

NSNumber *firstNumber = @111;

NSNumber *secondNumber = @222;

self.firstOperation = [[SimpleOperation alloc]

initWithObject: firstNumber];

self.secondOperation = [[SimpleOperation alloc]

initWithObject: secondNumber];

self.operationQueue = [[NSOperationQueue alloc] init];

/* Добавляем операции в очередь. */

[self.operationQueue addOperation: self.firstOperation];

[self.operationQueue addOperation: self.secondOperation];

NSLog(@"Main thread is here");

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

Main thread is here

-[SimpleOperation main]

-[SimpleOperation main]

Parameter Object = 222

Parameter Object = 222

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Main Thread = <NSThread: 0x68 10260>{name = (null), num = 1}

Current Thread = <NSThread: 0x6a10b90>{name = (null), num = 3}

Current Thread = <NSThread: 0x6a13f50>{name = (null), num = 4}

См. также.

Разделы 7.11 и 7.15.

7.13. Создание зависимости между операциями.

Постановка задачи.

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

Решение.

Если операция B может начать выполнение содержащейся в ней задачи только после того, как операция A выполнит свою задачу, то операция B должна добавить к себе операцию A в качестве зависимой. Это делается с помощью метода экземпляра addDependency:, относящегося к классу NSOperation:

[self.firstOperation addDependency: self.secondOperation];

Свойства firstOperation и secondOperation относятся к типу NSInvocationOperation, подробнее об этом мы поговорим в подразделе «Обсуждение» данного раздела. В приведенном примере кода первая операция, находящаяся в операционной очереди, не будет выполняться до тех пор, пока не будет выполнена задача второй операции.

Обсуждение.

Выполнение операции не начинается до тех пор, пока не будут успешно завершены все операции, от которых она зависит. По умолчанию после инициализации операция не связана зависимостями с какими-либо другими операциями.

Если мы хотим внедрить зависимости в пример с кодом, описанный в разделе 7.12, то можем немного изменить реализацию делегата приложения и воспользоваться методом экземпляра addDependency:, чтобы первая операция дождалась окончания выполнения второй операции:

#import «AppDelegate.h»

@interface AppDelegate ()

@property (nonatomic, strong) NSInvocationOperation *firstOperation;

@property (nonatomic, strong) NSInvocationOperation *secondOperation;

@property (nonatomic, strong) NSOperationQueue *operationQueue;

@end

@implementation AppDelegate

— (void) firstOperationEntry:(id)paramObject{

NSLog(@"First Operation — Parameter Object = %@",

paramObject);

NSLog(@"First Operation — Main Thread = %@",

[NSThread mainThread]);

NSLog(@"First Operation — Current Thread = %@",

[NSThread currentThread]);

}

— (void) secondOperationEntry:(id)paramObject{

NSLog(@"Second Operation — Parameter Object = %@",

paramObject);

NSLog(@"Second Operation — Main Thread = %@",

[NSThread mainThread]);

NSLog(@"Second Operation — Current Thread = %@",

[NSThread currentThread]);

}

— (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

NSNumber *firstNumber = @111;

NSNumber *secondNumber = @222;

self.firstOperation = [[NSInvocationOperation alloc]

initWithTarget: self

selector:@selector(firstOperationEntry:)

object: firstNumber];

self.secondOperation = [[NSInvocationOperation alloc]

initWithTarget: self

selector:@selector(secondOperationEntry:)

object: secondNumber];

[self.firstOperation addDependency: self.secondOperation];

self.operationQueue = [[NSOperationQueue alloc] init];

/* Добавляем операции в очередь. */

[self.operationQueue addOperation: self.firstOperation];

[self.operationQueue addOperation: self.secondOperation];

NSLog(@"Main thread is here");

self.window = [[UIWindow alloc] initWithFrame:

[[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Теперь после запуска программ вы увидите в окне консоли примерно следующее:

Second Operation — Parameter Object = 222

Main thread is here

Second Operation — Main Thread = <NSThread: 0x68 10250>{name = (null),

num = 1}

Second Operation — Current Thread = <NSThread: 0x6836ab0>{name = (null),

num = 3}

First Operation — Parameter Object = 111

First Operation — Main Thread = <NSThread: 0x68 10250>{name = (null),

num = 1}

First Operation — Current Thread = <NSThread: 0x6836ab0>{name = (null),

num = 3}

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

Если вы в любой момент пожелаете разорвать зависимость между двумя операциями, воспользуйтесь методом экземпляра removeDependency:, относящимся к объекту операции.

См. также.

Раздел 7.12.

7.14. Создание таймеров.

Постановка задачи.

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

Решение.

Воспользуйтесь таймером:

— (void) paint:(NSTimer *)paramTimer{

/* Делаем здесь что-либо. */

NSLog(@"Painting");

}

— (void) startPainting{

self.paintingTimer = [NSTimer

scheduledTimerWithTimeInterval:1.0

target: self

selector:@selector(paint:)

userInfo: nil

repeats: YES];

}

— (void) stopPainting{

if (self.paintingTimer!= nil){

[self.paintingTimer invalidate];

}

}

— (void)applicationWillResignActive:(UIApplication *)application{

[self stopPainting];

}

— (void)applicationDidBecomeActive:(UIApplication *)application{

[self startPainting];

}

Кроме того, метод invalidate будет высвобождать таймер сам и нам не придется делать это вручную. Как видите, мы определили свойство paintingTimer, которое следующим образом определяется в заголовочном файле (.h-файле):

#import «AppDelegate.h»

@interface AppDelegate ()

@property (nonatomic, strong) NSTimer *paintingTimer;

@end

@implementation AppDelegate

Обсуждение.

Таймер — это объект, инициирующий определенное событие через заданные временные интервалы. Таймер должен быть запланирован в рабочем цикле. При определении объекта NSTimer создается незапланированный таймер, который ничего не делает, но остается в распоряжении программы на случай, если этот таймер понадобится запланировать. Как только будет сделан вызов вида scheduledTimerWithTimeInterval: target: selector: userInfo: repeats:, начинается работа запланированного таймера и будет инициировано затребованное вами событие. Запланированным называется такой таймер, который добавлен к рабочему циклу. Чтобы получить любой таймер и инициировать связанное с ним событие, таймер нужно запланировать в рабочем цикле. Это будет продемонстрировано в следующем примере, где мы создадим незапланированный таймер, а затем вручную запланируем его в главном рабочем цикле приложения.

После того как таймер запланирован и добавлен к рабочему циклу — явно или неявно, — он начинает вызывать метод в своем целевом объекте (указываемом программистом) каждые n секунд (n также указывает программист). Поскольку n — это число с плавающей точкой, в данном параметре можно задать долю секунды.

Существуют различные способы создания, инициализации и планирования таймеров. Один из наиболее простых способов связан с использованием метода класса scheduledTimerWithTimeInterval: target: selector: userInfo: repeats:, относящегося к классу NSTimer. Далее перечислены параметры данного метода:

• scheduledTimerWithTimeInterval — количество секунд, в течение которого таймер должен ожидать, прежде чем запустит то или иное событие. Например, если вы хотите, чтобы таймер вызывал метод в своем целевом объекте дважды в секунду, то для этого параметра нужно установить значение 0.5 (1 секунда, деленная на 2). Если вы желаете, чтобы целевой метод вызывался четыре раза в секунду, то этот параметр должен иметь значение 0.25 (1 секунда, деленная на 4);

• target — объект, который будет получать событие;

• selector — сигнатура метода в том целевом объекте, который будет получать событие;

• userInfo — объект, который будет содержаться в таймере для дальнейшего пользования (в целевом методе целевого объекта);

• repeats — параметр указывает, как таймер должен вызывать целевой метод многократно (в таком случае данный параметр получает значение YES) или однократно (тогда этот параметр получит значение NO).

Как только таймер создан и добавлен к рабочему циклу, можно остановиться и высвободить этот таймер, воспользовавшись методом экземпляра invalidate, относящимся к классу NSTimer. Таким образом будет высвобожден не только таймер, но и объект (если имеется объект, который передан таймеру и который требуется сохранять на протяжении всего жизненного цикла таймера; например, объект может быть сообщен параметру userInfo метода класса scheduledTimerWithTimeInterval: target: selector: userInfo: repeats:, относящемуся к классу NSTimer). Если передать параметру repeats значение NO, то таймер самоуничтожится после первого прохода цикла и высвободит любой удерживаемый объект (при его наличии).

Есть и другие методы, с помощью которых можно создать запланированный таймер. Один из них — метод класса scheduledTimerWithTimeInterval: invocation: repeats:, относящийся к классу NSTimer:

— (void) paint:(NSTimer *)paramTimer{

/* Делаем здесь что-либо. */

NSLog(@"Painting");

}

— (void) startPainting{

/* Здесь находится селектор, который мы хотим вызвать. */

SEL selectorToCall = @selector(paint:);

/* Здесь на основе селектора составляется сигнатура метода.

Нам известно, что селектор относится к текущему классу,

поэтому составить сигнатуру метода совсем не сложно. */

NSMethodSignature *methodSignature =

[[self class] instanceMethodSignatureForSelector: selectorToCall];

/* Теперь основываем активизацию на сигнатуре метода. Данная активизация

требуется нам для того, чтобы запланировать таймер. */

NSInvocation *invocation =

[NSInvocation invocationWithMethodSignature: methodSignature];

[invocation setTarget: self];

[invocation setSelector: selectorToCall];

/* Теперь запускаем запланированный таймер. */

self.paintingTimer = [NSTimer scheduledTimerWithTimeInterval:1.0

invocation: invocation

repeats: YES];

}

— (void) stopPainting{

if (self.paintingTimer!= nil){

[self.paintingTimer invalidate];

}

}

— (void)applicationWillResignActive:(UIApplication *)application{

[self stopPainting];

}

— (void)applicationDidBecomeActive:(UIApplication *)application{

[self startPainting];

}

Планирование таймера можно сравнить с запуском автомобильного двигателя. Запланированный таймер — это работающий мотор. Незапланированный таймер — это мотор, который уже готов завестись, но пока не работает. Мы можем планировать и отменять (распланировать) таймер в любой момент работы приложения, точно так же как можем заводить и глушить двигатель, не выходя из машины. Если вы хотите вручную запланировать таймер на определенный момент жизненного цикла приложения, можно воспользоваться методом класса timerWithTimeInterval: target: selector: userInfo: repeats:, относящимся к классу NSTimer. Когда придет нужный момент, можно добавить таймер к интересующему вас рабочему циклу:

— (void) startPainting{

self.paintingTimer = [NSTimer timerWithTimeInterval:1.0

target: self

selector:@selector(paint:)

userInfo: nil

repeats: YES];

/* Здесь выполняется обработка, и когда наступает нужный момент,

задействуется метод экземпляра addTimer: forMode, относящийся к классу

NSRunLoop, чтобы запланировать данный таймер в этом рабочем цикле. */

[[NSRunLoop currentRunLoop] addTimer: self.paintingTimer

forMode: NSDefaultRunLoopMode];

}

Методы класса currentRunLoop и mainRunLoop, относящиеся к классу NSRunLoop, возвращают соответственно актуальный и главный рабочие циклы конкретного приложения, что понятно из их названий[7].

Можно создавать запланированные таймеры с применением активизации, воспользовавшись вариантом с методом scheduledTimerWithTimeInterval: invocation: repeats:. С тем же успехом можно пользоваться методом класса timerWithTimeInterval: invocation: repeats:, относящимся к классу NSTimer, чтобы создать незапланированный таймер — также с применением активизации:

— (void) paint:(NSTimer *)paramTimer{

/* Делаем здесь что-нибудь. */

NSLog(@"Painting");

}

— (void) startPainting{

/* Здесь находится селектор, который мы хотим вызвать. */

SEL selectorToCall = @selector(paint:);

/* Здесь на основе селектора составляется сигнатура метода.

Нам известно, что селектор относится к текущему классу,

поэтому составить сигнатуру метода совсем не сложно. */

NSMethodSignature *methodSignature =

[[self class] instanceMethodSignatureForSelector: selectorToCall];

/* Теперь основываем активизацию на сигнатуре метода. Данная активизация

требуется нам для того, чтобы запланировать таймер. */

NSInvocation *invocation =

[NSInvocation invocationWithMethodSignature: methodSignature];

[invocation setTarget: self];

[invocation setSelector: selectorToCall];

self.paintingTimer = [NSTimer timerWithTimeInterval:1.0

invocation: invocation

repeats: YES];;

/* Здесь выполняется обработка, и когда наступает нужный момент,

задействуется метод экземпляра addTimer: forMode, относящийся к классу

NSRunLoop, чтобы запланировать данный таймер в данном рабочем цикле. */

[[NSRunLoop currentRunLoop] addTimer: self.paintingTimer

forMode: NSDefaultRunLoopMode];

}

— (void) stopPainting{

if (self.paintingTimer!= nil){

[self.paintingTimer invalidate];

}

}

— (void)applicationWillResignActive:(UIApplication *)application{

[self stopPainting];

}

— (void)applicationDidBecomeActive:(UIApplication *)application{

[self startPainting];

}

Целевой метод таймера получает экземпляр таймера, вызывающий его в качестве параметра. Например, метод paint:, показанный в начале данного раздела, демонстрирует, как таймер передается своему целевому методу — по умолчанию он (таймер) выступает в качестве единственного параметра целевого метода:

— (void) paint:(NSTimer *)paramTimer{

/* Что-то здесь делаем. */

NSLog(@"Painting");

}

Данный параметр дает нам ссылку на таймер, запускающий этот метод. Вы можете, например, при необходимости не допустить повторного запуска таймера — для этого используется метод invalidate. Кроме того, можно активизировать метод userInfo экземпляра класса NSTimer, чтобы получить объект, удерживаемый таймером (если такой объект имеется). Здесь мы имеем дело с обычным объектом, передаваемым методам инициализации NSTimer, затем этот объект передается непосредственно таймеру для дальнейшего пользования.

7.15. Параллельное программирование с использованием потоков.

Постановка задачи.

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

Решение.

В приложении воспользуйтесь потоками. Это делается примерно так:

— (void) downloadNewFile:(id)paramObject{

@autoreleasepool {

NSString *fileURL = (NSString *)paramObject;

NSURL *url = [NSURL URLWithString: fileURL];

NSURLRequest *request = [NSURLRequest requestWithURL: url];

NSURLResponse *response = nil;

NSError *error = nil;