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

Глава 15. Уведомления

15.0. Введение

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

В iOS доступны уведомления трех типов.

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

• Локальное уведомление (экземпляр класса UILocalNotification). Это уведомление, которое должно быть доставлено вашему приложению в определенный момент времени. Приложение сможет его получить, даже если находится в фоновом режиме или не работает вообще. Если приложение не работало, но получило такое уведомление, то оно запускается. Как правило, вы назначаете локальное уведомление, если хотите гарантированно разбудить приложение (предполагается, что пользователь разрешил вам такое действие, подробнее об этом – в дальнейшем) в определенный момент дня.

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

Далее мы будем называть обычные уведомления просто уведомлениями. Слово «обычный» в данном контексте избыточно.

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

Уведомления – важнейшая составляющая операционных систем iOS и OS X. iOS выдает уведомления, действующие в масштабах всей системы. Эти уведомления адресуются всем приложениям в системе, которые их слушают, и сами приложения также могут отсылать уведомления. Такое уведомление, действующее в масштабах всей системы (также называемое распределенным), может выдаваться только самой системой iOS.

Уведомление – это простая сущность, представленная в iOS SDK классом NSNotification. Уведомление отсылается объектом и может нести информацию. Объект, отсылающий уведомление, «представляет себя» центру уведомления в момент самой отправки уведомления. Затем получатель уведомления может «справиться» об отправителе по его имени класса для получения более подробной информации об этом объекте. Объект-отправитель называется объектом уведомления. Кроме того, уведомление может включать в себя словарь с пользовательской информацией. Это словарная структура данных, которая может нести дополнительную информацию об уведомлении. Если словарь не предоставляется, то этот параметр равен nil.

15.1. Отправка уведомлений

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

Создайте экземпляр класса NSNotification и широковещательно передайте его вашему приложению, воспользовавшись методом класса postNotification:. Вы можете получить экземпляр центра уведомлений, воспользовавшись его методом класса defaultCenter, вот так:

#import «AppDelegate.h»

NSString *const kNotificationName = @"NotificationNameGoesHere";

@implementation AppDelegate

– (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

NSNotification *notification = [NSNotification

notificationWithName: kNotificationName

object: self

userInfo:@{@"Key 1": @"Value 1",

@"Key 2": @2}];

[[NSNotificationCenter defaultCenter] postNotification: notification];

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

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

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

• Объект-отправитель. По желанию вы можете указать объект, являющийся отправителем уведомления. Обычно в таком качестве задается self. Но зачем же нужно указывать отправитель уведомления? Эта информация полезна для тех компонентов приложения, которые слушают уведомления. Допустим, в одном из ваших классов вы отправляете уведомление с именем MyNotification, а другой класс приложения отсылает уведомление с точно таким же именем. Когда элемент начинает слушать уведомление с именем MyNotification, получатель может указать, из какого источника ожидается интересующее его уведомление. Так, получатель может указать, что ему требуются все уведомления с именем MyNotification, поступающие от конкретного объекта, но не интересуют одноименные уведомления, приходящие от другого объекта. Таким образом, получатель действительно контролирует ситуацию. Хотя вы даже и можете при отправке уведомления указать вместо объекта-получателя nil, гораздо целесообразнее задавать данному свойству self, то есть имя объекта, отправляющего уведомление.

• Словарь с пользовательской информацией. Это словарный объект, который вы можете прикреплять к объекту уведомления. Затем получатель может считывать этот словарь, когда получает уведомление. Можно сказать, что в этом параметре удобно передавать получателям вашего уведомления дополнительную информацию.

Раздел 15.0.

15.2. Слушание уведомлений и реагирование на них

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

Слушайте интересующее вас уведомление путем вызова метода addObserver: selector: name: object: стандартного центра уведомлений. Этот метод имеет следующие параметры:

• addObserver – объект, который должен отслеживать заданное уведомление. Поэтому, если речь идет о текущем классе, задайте здесь self, чтобы указать на актуальный экземпляр вашего класса;

• selector – селектор, который будет получать уведомление. Этот селектор должен иметь один параметр типа NSNotification;

• name – имя уведомления, которое вы хотите слушать;

• object – объект, который должен прислать вам уведомление. Например, если одноименные уведомления поступают сразу от двух объектов, то вы можете сузить круг интересующих вас уведомлений и слушать только те из них, которые приходят от объекта A, игнорируя при этом приходящие от объекта B.

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

Вся эта теория станет значительно более понятной, если пояснить на примере. Мы собираемся создать класс Person и добавить к нему два свойства: имя и фамилию. Оба этих свойства будут относиться к типу NSString. Затем в делегате нашего приложения мы собираемся инстанцировать объект типа Person. Но не будем задавать имя и фамилию этой персоны, а отошлем в центр уведомлений само уведомление и его пользовательский словарь. В этом пользовательском словаре уведомления запишем имя и фамилию как элементы типа NSString. В методе инициализации класса Person мы собираемся слушать уведомление, которое приходит от делегата приложения. Затем извлечем имя и фамилию из пользовательского словаря и зададим эти значения для соответствующих свойств объекта-персоны.

Вот заголовочный файл делегата нашего приложения:

#import <UIKit/UIKit.h>

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

extern NSString *const kSetPersonInfoNotification;

/* Ключ имени в словаре пользовательской информации уведомления */

extern NSString *const kSetPersonInfoKeyFirstName;

/* Ключ фамилии в словаре пользовательской информации уведомления */

extern NSString *const kSetPersonInfoKeyLastName;

@interface AppDelegate: UIResponder <UIApplicationDelegate>

@property (nonatomic, strong) UIWindow *window;

@end

А вот реализация делегата нашего приложения:

#import «AppDelegate.h»

#import «Person.h»

NSString *const kSetPersonInfoNotification = @"SetPersonInfoNotification";

NSString *const kSetPersonInfoKeyFirstName = @"firstName";

NSString *const kSetPersonInfoKeyLastName = @"lastName";

@implementation AppDelegate

– (BOOL) application:(UIApplication *)application

didFinishLaunchingWithOptions:(NSDictionary *)launchOptions{

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

NSNotification *notification =

[NSNotification

notificationWithName: kSetPersonInfoNotification

object: self

userInfo:@{kSetPersonInfoKeyFirstName: @"Steve",

kSetPersonInfoKeyLastName: @"Jobs"}];

/* В настоящее время класс person слушает это уведомление. Этот класс

извлечет из уведомления информацию об имени и фамилии и задаст

собственные имя и фамилию, основываясь на информации, полученной

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

[[NSNotificationCenter defaultCenter] postNotification: notification];

/* Вот доказательство */

NSLog(@"Person's first name = %@", steveJobs.firstName);

NSLog(@"Person's last name = %@", steveJobs.lastName);

self.window = [[UIWindow alloc]

initWithFrame: [[UIScreen mainScreen] bounds]];

self.window.backgroundColor = [UIColor whiteColor];

[self.window makeKeyAndVisible];

return YES;

}

Важнее всего в данном случае будет реализация класса Person (Person.m):

#import «Person.h»

#import «AppDelegate.h»

@implementation Person

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

self.firstName = paramNotification.userInfo[kSetPersonInfoKeyFirstName];

self.lastName = paramNotification.userInfo[kSetPersonInfoKeyLastName];

}

– (instancetype) init{

self = [super init];

if (self!= nil){

NSNotificationCenter *center = [NSNotificationCenter defaultCenter];

[center addObserver: self

selector:@selector(handleSetPersonInfoNotification:)

name: kSetPersonInfoNotification

object: [[UIApplication sharedApplication] delegate]];

}

return self;

}

– (void) dealloc{

[[NSNotificationCenter defaultCenter] removeObserver: self];

}

@end

Значение, указываемое для параметра object метода addObs erver: selector: name: object:, – это объект, от которого, как предполагается, должно поступать уведомление. Если какой-то другой объект пошлет уведомление с таким же именем, то ваш слушатель не должен будет обрабатывать это уведомление. Как правило, вы указываете такой объект в тех случаях, когда точно знаете, какой именно объект должен посылать интересующее вас уведомление. Такая возможность есть не всегда. Например, бывают очень сложные приложения, где один контроллер вида, расположенный на конкретной вкладке, должен слушать уведомления, поступающие от другого контроллера вида, находящегося на другой вкладке. При этом у слушателя может и не быть ссылки на тот экземпляр контроллера вида, откуда будет исходить уведомление. В таком случае можно передать nil параметру parameter вышеупомянутого метода.

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

Person's first name = Steve

Person's last name = Jobs

Итак, и отправка, и получение этого уведомления произошли внутри нашей программы. А что насчет системных уведомлений? Мы подробнее поговорим о них в дальнейшем. Сейчас, пока вы находитесь в Xcode, нажмите комбинацию клавиш Command+Shift+O (O – это Open (Открыть)), после чего введите UIWindow.h. Открыв этот файл заголовка, найдите в нем объект UIKeyboardWillShowNotification, а в этом объекте – такой блок кода:

// Каждое уведомление включает в себя объект nil и словарь userInfo,

// содержащий (в координатах экрана) начало и конец области, которую

// занимает на дисплее виртуальная клавиатура.

// Пользуйтесь различными возможностями convertRect, относящимися к UIView и UIWindow, чтобы получить контур клавиатуры в желаемой системе

// координат. Анимационные пары «ключ/значение» доступны лишь для

// уведомлений, относящихся к семейству «will»

UIKIT_EXTERN NSString *const UIKeyboardWillShowNotification;

UIKIT_EXTERN NSString *const UIKeyboardDidShowNotification;

UIKIT_EXTERN NSString *const UIKeyboardWillHideNotification;

UIKIT_EXTERN NSString *const UIKeyboardDidHideNotification;

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

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

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

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

У устройств, работающих с операционной системой iOS, нет физической клавиатуры. Но у них есть виртуальная клавиатура, всплывающая на экране всякий раз, когда пользователь должен ввести текст в какое-нибудь текстовое поле (UITextField, см. раздел 1.19) или текстовый вид (UITextView, см. раздел 1.20). На iPad пользователь даже может делить клавиатуру на части и перемещать их вверх и вниз. Есть несколько пограничных случаев, о которых, вам, возможно, придется позаботиться при проектировании пользовательского интерфейса. Можете обратиться к помощи дизайнеров пользовательских интерфейсов (если в вашей компании есть такие специалисты) и рассказать им, что на iPad пользователь может делить клавиатуру на части. Перед тем как приступать к творческой работе, они должны об этом узнать. В этом разделе мы коснемся подобного пограничного случая.

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

Рис. 15.1. Клавиатура на iPhone, книжная ориентация

А клавиатура в альбомной ориентации на iPhone будет выглядеть так, как на рис. 15.2.

Рис. 15.2. Клавиатура в iPhone, альбомная ориентация

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

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

• UIKeyboardWillShowNotification – распространяется, когда клавиатура вот-вот появится на экране. Уведомление несет с собой словарь с пользовательской информацией, в котором содержатся различные данные о клавиатуре, анимации, которая будет применяться при выводе клавиатуры на экран, и другая информация;

• UIKeyboardDidShowNotification – распространяется, когда клавиатура уже появилась на экране;

• UIKeyboardWillHideNotification – распространяется, когда клавиатура вот-вот будет убрана с экрана. Уведомление несет с собой словарь с пользовательской информацией, в котором содержатся различные данные о клавиатуре, анимации, которая будет применяться при уходе клавиатуры с экрана, длительности анимации и т. д.;

• UIKeyboardDidHideNotification – распространяется после того, как клавиатура полностью скроется с экрана.

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

• UIKeyboardAnimationCurveUserInfoKey – значение этого ключа характеризует тип анимационной кривой, которая будет использоваться при выводе клавиатуры на экран или ее скрытии. Этот ключ содержит значение типа NSNumber (инкапсулированное в объекте типа NSValue), которое, в свою очередь, содержит беззнаковое целое типа NSUInteger;

• UIKeyboardAnimationDurationUserInfoKey – значение данного ключа указывает в секундах длительность анимации, применяемой при отображении или скрытии клавиатуры. Если клавиатура вот-вот будет отображена, то это будет рамка, в которой появится клавиатура. Если клавиатура уже есть на экране, это будет контур, обрамляющий клавиатуру на экране перед тем, как она уйдет с экрана. Этот ключ содержит значение типа CGRect (инкапсулированное в объекте типа NSValue);

• UIKeyboardFrameBeginUserInfoKey – значение данного ключа указывает размеры рамки клавиатуры до того, как начнется анимация. Если клавиатура вот-вот отобразится, то перед появлением клавиатуры появится эта рамка. Если клавиатура в данный момент отображена и вот-вот уйдет с экрана, это будет рамка, фактически занимаемая клавиатурой на экране, прежде чем клавиатура уйдет с экрана в сопровождении соответствующей анимации. Этот ключ содержит значение типа CGRect (инкапсулированное в объект типа NSValue);

• UIKeyboardFrameEndUserInfoKey – значение данного ключа описывает контур клавиатуры, который оформится после того, как будет применена анимация. Если клавиатура вот-вот появится на экране, то она займет именно этот контур. Если клавиатура уходит с экрана, то именно этот контур от нее освободится. Этот ключ содержит значение типа CGRect (инкапсулированное в объекте типа NSValue).

Рассмотрим пример. Мы собираемся создать простое приложение с единственным видом. Это приложение будет работать только на iPhone. В нем будут отображаться вид с изображением и текстовое поле. Текстовое поле находится в нижней части экрана. Итак, когда пользователь дотрагивается до текстового поля, чтобы ввести в него некоторый текст, на экране всплывает виртуальная клавиатура, полностью заслоняющая текстовое поле. Наша задача – анимировать содержимое вида и перераспределить элементы так, чтобы все они оставались видимыми, даже если экран наполовину закрыт клавиатурой. В этом приложении мы будем использовать раскадровки. В контроллере вида заполним вид с изображением, поместив в него прокручивающийся вид, и поместим в этом прокручивающемся виде и вид с изображением, и текстовое поле (рис. 15.3).

Рис. 15.3. Простая раскадровка, содержащая вид с изображением и текстовое поле

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

Я уже прикрепил прокручивающийся вид, вид с изображением и текстовое поле, определенные в раскадровке, к файлу реализации контроллера вида, вот так:

#import «ViewController.h»

@interface ViewController () <UITextFieldDelegate>

@property (weak, nonatomic) IBOutlet UIScrollView *scrollView;

@property (weak, nonatomic) IBOutlet UITextField *textField;

@property (weak, nonatomic) IBOutlet UIImageView *imageView;

@end

@implementation ViewController

…

Теперь, когда аутлеты прикреплены к свойствам в контроллере нашего вида, можно приступить к слушанию клавиатурных уведомлений:

– (void) viewWillAppear:(BOOL)paramAnimated{

[super viewWillAppear: paramAnimated];

NSNotificationCenter *center = [NSNotificationCenter defaultCenter];

[center addObserver: self selector:@selector(handleKeyboardWillShow:)

name: UIKeyboardWillShowNotification object: nil];

[center addObserver: self selector:@selector(handleKeyboardWillHide:)

name: UIKeyboardWillHideNotification object: nil];

}

– (void)viewWillDisappear:(BOOL)paramAnimated{

[super viewWillDisappear: paramAnimated];

[[NSNotificationCenter defaultCenter] removeObserver: self];

}

Многие программисты допускают распространенную ошибку: продолжают слушать клавиатурные уведомления, когда контроллер вида не отображается на экране. Они начинают слушать уведомления в методе viewDidLoad, а удаляют элементы, действовавшие в качестве наблюдателей, только в методе dealloc. Такой подход проблематичен, так как, когда наш вид не отображается на экране, а клавиатура вновь открывается в каком-то другом виде, вы не должны корректировать положение каких-либо других компонентов контроллера вида. Учтите, что клавиатурные уведомления, как и любые другие, широковещательно передаются всем объектам-наблюдателям в контексте вашего приложения. Поэтому придется принимать дополнительные меры, чтобы программа реагировала не на все клавиатурные уведомления. Если клавиатурные уведомления поступают от вида, не отображаемого на экране в данный момент, они должны игнорироваться.

В предыдущем фрагменте кода мы начали слушать уведомления типа «клавиатура будет отображена» в методе экземпляра handleKeyboardWillShow: контроллера нашего вида. Уведомления типа «клавиатура будет скрыта» мы ожидаем в методе handleKeyboardWillHide:. Пока эти методы еще не написаны. Начнем с первого метода, handleKeyboardWillShow:. В этом методе нам требуется определить высоту клавиатуры, воспользовавшись ключом UIKeyboardFrameEndUserInfoKey из словаря с пользовательской информацией, сопровождающего уведомление. Это значение мы используем, чтобы переместить содержимое вида вверх – так, чтобы все необходимые элементы оказались над клавиатурой. Здесь приятно вспомнить, что мы поместили все нужное содержимое в прокручивающемся виде. Соответственно, потребуется всего лишь откорректировать краевые отступы прокручивающегося вида:

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

NSDictionary *userInfo = paramNotification.userInfo;

/* Получаем длительность клавиатурной анимации – время, за которое

клавиатура успеет отобразиться на экране. При анимировании и перемещении

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

*/

NSValue *animationDurationObject =

userInfo[UIKeyboardAnimationDurationUserInfoKey];

NSValue *keyboardEndRectObject = userInfo[UIKeyboardFrameEndUserInfoKey];

double animationDuration = 0.0;

CGRect keyboardEndRect = CGRectMake(0.0f, 0.0f, 0.0f, 0.0f);

[animationDurationObject getValue:&animationDuration];

[keyboardEndRectObject getValue:&keyboardEndRect];

UIWindow *window = [UIApplication sharedApplication].keyWindow;

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

в координатную систему нашего вида. */

keyboardEndRect = [self.view convertRect: keyboardEndRect

fromView: window];

/* Определяем, в какой степени наш вид накрыт клавиатурой */

CGRect intersectionOfKeyboardRectAndWindowRect =

CGRectIntersection(self.view.frame, keyboardEndRect);

/* Прокручиваем прокручивающийся вид таким образом, чтобы содержимое

нашего вида отображалось полностью */

[UIView animateWithDuration: animationDuration animations: ^{

self.scrollView.contentInset =

UIEdgeInsetsMake(0.0f,

0.0f,

intersectionOfKeyboardRectAndWindowRect.size.height,

0.0f);

[self.scrollView scrollRectToVisible: self.textField.frame animated: NO];

}];

}

У нас получился довольно интересный и прямолинейный код. Единственная деталь, возможно требующая дополнительного разъяснения, – это функция CGRectIntersection. В ней мы получаем информацию о прямоугольном контуре клавиатуры (о верхней границе, левой границе, ширине и высоте). Это параметры клавиатуры в момент завершения анимации, когда она полностью отобразится на экране. Теперь, зная параметры клавиатуры, можем воспользоваться функцией CGRectIntersection и определить, какая часть нашего вида накрыта клавиатурой. Итак, берем контур клавиатуры, контур вида, а затем определяем, какая часть контура вида накрыта контуром клавиатуры. В результате получаем структуру типа CGRect, соответствующую той прямоугольной области вида, которая накрыта клавиатурой. Известно, что клавиатура появляется на нижней границе экрана и в ходе анимации выплывает вверх. Поэтому нас интересует вертикаль этой области. Итак, мы получаем высоту области пересечения контура клавиатуры и контура вида, а затем поднимаем на эту высоту содержимое вида. Длительность анимации перемещения задаем равной длительности анимации выдвижения клавиатуры. Таким образом, движения клавиатуры и поднимающихся экранных элементов синхронизируются.

Далее нужно написать метод handleKeyboardWillHide:. В нем мы будем скрывать клавиатуру – соответственно, она больше не будет закрывать наш вид. Итак, в этом методе всего лишь требуется сбросить размеры краевых отступов прокручивающегося вида к начальным значениям, перенести все элементы обратно вниз, чтобы вид выглядел точно так же, как было до появления клавиатуры:

– (void) handleKeyboardWillHide:(NSNotification *)paramSender{

NSDictionary *userInfo = [paramSender userInfo];

NSValue *animationDurationObject =

[userInfo valueForKey: UIKeyboardAnimationDurationUserInfoKey];

double animationDuration = 0.0;

[animationDurationObject getValue:&animationDuration];

[UIView animateWithDuration: animationDuration animations: ^{

self.scrollView.contentInset = UIEdgeInsetsZero;

}];

}

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

– (BOOL) textFieldShouldReturn:(UITextField *)paramTextField{

[paramTextField resignFirstResponder];

return YES;

}