Разработка приложений для windows 8 на языке c

• Книги
• Программирование
• Сергей Пугачев
• 
  📚 Разработка приложений для Windows 8 на языке C#

Эта и ещё 2 книги за 399 ₽

По абонементу вы каждый месяц можете взять из каталога одну книгу до 700 ₽ и две книги из специальной подборки. Узнать больше

Оплачивая абонемент, я принимаю условия оплаты и её автоматического продления, указанные в оферте

Поделиться отзывом на книгу

Сергей Пугачев Ахмед Шериев Константин Кичинский

Санкт-Петербург «БХВ-Петербург»

2013

УДК 681.3.06 ББК 32.973.26-018.2 П88 Пугачев, С. В. П88 Разработка приложений для Windows 8 на языке C# / С. В. Пугачев,

А. М. Шериев, К. А. Кичинский. — СПб.: БХВ-Петербург, 2013. — 416 с.: ил. — (Профессиональное программирование)

ISBN 978-5-9775-0846-9 Рассмотрены принципы разработки Windows Store-приложений для Windows 8

на языке C# в среде Visual Studio 2012. Описаны основные возможности платфор-мы и показаны сценарии их практического использования. Особое внимание уделяется дизайну и проектированию приложений. Описана работа c живыми плитками, контрактами, сервисом определения местоположения, сенсорами, уве-домлениями и камерой. Рассказывается про хранение и доступ к данным, интерна-ционализацию и размещение приложений в специализированном магазине прило-жений Windows Store.

Для программистов

УДК 681.3.06 ББК 32.973.26-018.2

Группа подготовки издания:

Главный редактор Екатерина Кондукова Зам. главного редактора Игорь Шишигин Зав. редакцией Екатерина Капалыгина Редактор Леонид Кочин Компьютерная верстка Ольги Сергиенко Корректор Зинаида Дмитриева Дизайн серии Инны Тачиной Оформление обложки Марины Дамбиевой

Подписано в печать 31.10.12. Формат 70 1001/16. Печать офсетная. Усл. печ. л. 33,54.

Тираж 3000 экз. Заказ № «БХВ-Петербург», 191036, Санкт-Петербург, Гончарная ул., 20.

Первая Академическая типография «Наука» 199034, Санкт-Петербург, 9 линия, 12/28

ISBN 978-5-9775-0846-9 © Пугачев С. В., Шериев А. М., Кичинский К. А., 2013 © Оформление, издательство «БХВ-Петербург», 2013

Оглавление

Почему это первая книга о Windows, которую я прочитаю

от начала до конца ……………………………………………………………………………………………. 9

Введение ………………………………………………………………………………………………………….. 11

На кого рассчитана эта книга …………………………………………………………………………………………. 11

Краткое описание глав …………………………………………………………………………………………………… 12

Благодарности ……………………………………………………………………………………………………………….. 14

Глава 1. Платформа Windows 8 ………………………………………………………………………. 15

Windows Store-приложения…………………………………………………………………………………………….. 16

Программная платформа ………………………………………………………………………………………………… 21

Дизайн Windows Store-приложений ………………………………………………………………………………… 23

Итоги …………………………………………………………………………………………………………………………….. 25

Глава 2. Среда разработки ……………………………………………………………………………… 26

Итоги …………………………………………………………………………………………………………………………….. 30

Глава 3. Первое Windows Store-приложение ………………………………………………….. 31

Создание проекта в Visual Studio ……………………………………………………………………………………. 31

Структура проекта приложения………………………………………………………………………………………. 35

Добавляем функциональность ………………………………………………………………………………………… 40

Отладка приложения на симуляторе ……………………………………………………………………………….. 46

Отладка приложений на удаленных устройствах …………………………………………………………….. 49

Итоги …………………………………………………………………………………………………………………………….. 52

Глава 4. Страницы и навигация в приложениях……………………………………………. 53

Задание начальной страницы приложения ………………………………………………………………………. 53

Создание новой страницы ………………………………………………………………………………………………. 56

Анимация при переходе между страницами ……………………………………………………………………. 60

Передача параметров между страницами ………………………………………………………………………… 61

Сохранение состояния страниц и приложения ………………………………………………………………… 62

Кэширование страниц ……………………………………………………………………………………………………. 64

Открытие ссылок из приложения ……………………………………………………………………………………. 67

Итоги …………………………………………………………………………………………………………………………….. 68

4 Оглавление

Глава 5. Тема оформления ……………………………………………………………………………… 69

Задание темы для приложения ……………………………………………………………………………………….. 70

Отображение текста ………………………………………………………………………………………………… 72

Итоги …………………………………………………………………………………………………………………………….. 75

Глава 6. Панель приложения ………………………………………………………………………….. 77

Cоздание панелей приложения ……………………………………………………………………………………….. 79

Свойство IsSticky ……………………………………………………………………………………………………………. 83

Отображение всплывающих окон и меню ……………………………………………………………………….. 83

Итоги …………………………………………………………………………………………………………………………….. 86

Глава 7. RSS-клиент на основе шаблона Grid App …………………………………………. 87

Итоги …………………………………………………………………………………………………………………………….. 97

Глава 8. Элементы управления GridView, ListView и FlipView ……………………….. 98

Элемент управления GridView ………………………………………………………………………………………… 99

Задание разного размера для элементов в GridView ……………………………………………………….. 110

Установка разных шаблонов для элементов в GridView …………………………………………………. 114

Контекстное масштабирование (Semantic Zoom) ……………………………………………………………. 115

Элемент управления ListView ……………………………………………………………………………………….. 120

Элемент управления FlipView ……………………………………………………………………………………….. 123

Итоги …………………………………………………………………………………………………………………………… 124

Глава 9. Закрепленный режим работы и поддержка

различной ориентации экрана ………………………………………………………………………. 125

Поддержка закрепленного режима ……………………………………………………………………………….. 126

Visual State Manager ……………………………………………………………………………………………………… 130

Масштабирование изображений в зависимости от плотности пикселов ………………………….. 133

Итоги …………………………………………………………………………………………………………………………… 135

Глава 10. Модель исполнения приложений. Многозадачность

через фоновые задачи ……………………………………………………………………………………. 136

Модель исполнения приложений ………………………………………………………………………………….. 136

Реализация сценариев многозадачности ………………………………………………………………………… 139

Фоновая загрузка/выгрузка файлов ………………………………………………………………………… 139

Фоновые задачи …………………………………………………………………………………………………………… 142

Создание фоновой задачи …………………………………………………………………………………………….. 146

Итоги …………………………………………………………………………………………………………………………… 150

Глава 11. Уведомления …………………………………………………………………………………. 151

Всплывающие уведомления………………………………………………………………………………………….. 151

Push-уведомления ………………………………………………………………………………………………………… 155

Авторизация на WNS-сервере. Регистрация и получение ключей в Windows Store………….. 156

Отправка Push-уведомлений …………………………………………………………………………………………. 157

Итоги …………………………………………………………………………………………………………………………… 161

Глава 12. «Живые» плитки …………………………………………………………………………… 162

Плитки по умолчанию ………………………………………………………………………………………………….. 162

Шаблоны «живых» плиток ……………………………………………………………………………………………. 163

Оглавление 5

Обновление плитки приложения …………………………………………………………………………………… 166

Широкие плитки ………………………………………………………………………………………………………….. 169

Шаблоны плиток с изображениями ………………………………………………………………………………. 170

Управление временем жизни плиток …………………………………………………………………………….. 171

Очередь плиток ……………………………………………………………………………………………………………. 172

Бейджи на плитках ………………………………………………………………………………………………… 173

Обновление плиток с помощью удаленного сервера ……………………………………………………… 175

Вторичные плитки ………………………………………………………………………………………………… 177

Итоги …………………………………………………………………………………………………………………………… 179

Глава 13. Контракт «Поиск» ………………………………………………………………………… 180

Поддержка контракта «Поиск» ……………………………………………………………………………………… 182

Поиск по мере ввода текста ………………………………………………………………………………………….. 186

Добавление поисковых подсказок …………………………………………………………………………………. 188

Подсказки результатов с графикой и текстом ………………………………………………………………… 191

Итоги …………………………………………………………………………………………………………………………… 193

Глава 14. Контракт «Общий доступ» ……………………………………………………………. 194

Реализация поставщика данных ……………………………………………………………………………………. 196

Реализация приемника данных ……………………………………………………………………………………… 199

Передача и прием изображений ……………………………………………………………………………………. 202

Отправка и прием нестандартных типов данных ……………………………………………………………. 203

Передача поставщика данных ………………………………………………………………………………………. 206

Итоги …………………………………………………………………………………………………………………………… 208

Глава 15. Контракт «Параметры» ………………………………………………………………… 209

Добавление пунктов параметров …………………………………………………………………………………… 209

Всплывающее окно с настройками ……………………………………………………………………………….. 213

Итоги …………………………………………………………………………………………………………………………… 215

Глава 16. Хранение и доступ к данным ………………………………………………………… 216

Изолированное хранилище …………………………………………………………………………………………… 216

Хранение настроек ………………………………………………………………………………………………………. 218

Хранение файлов …………………………………………………………………………………………………………. 219

Прямой доступ к файлам в изолированном хранилище ………………………………………………….. 221

Работа с СУБД SQLite ………………………………………………………………………………………………….. 221

Итоги …………………………………………………………………………………………………………………………… 228

Глава 17. Файловые контракты и расширения ……………………………………………. 229

Расширение FileOpenPicker ………………………………………………………………………………………….. 229

Расширение FileSavePicker …………………………………………………………………………………………… 232

Расширение FolderPicker ……………………………………………………………………………………………… 233

Разрешение на доступ к папкам с помощью манифеста приложения ………………………………. 233

Контракт File Open Picker ……………………………………………………………………………………… 235

Контракт File Save Picker ………………………………………………………………………………………. 239

Расширение StorageApplicationPermissions для кэширования доступа к файлам ……………… 239

Ассоциация с расширением файлов и протоколом ………………………………………………………… 240

Итоги …………………………………………………………………………………………………………………………… 244

6 Оглавление

Глава 18. Работа с камерой …………………………………………………………………………… 245

Использование CameraCaptureUI …………………………………………………………………………………. 245

Настройка параметров для съемки фотографий …………………………………………………………….. 249

PhotoSettings.AllowCropping ………………………………………………………………………………….. 249

PhotoSettings.CroppedAspectRatio …………………………………………………………………………… 249

PhotoSettings.CroppedSizeInPixels …………………………………………………………………………… 249

PhotoSettings.Format ……………………………………………………………………………………………… 250

PhotoSettings.MaxResolution …………………………………………………………………………………… 250

Настройка параметров для съемки видео ………………………………………………………………………. 251

VideoSettings.AllowTrimming ………………………………………………………………………………….. 251

VideoSettings.Format ……………………………………………………………………………………………… 251

VideoSettings.MaxDurationInSeconds ………………………………………………………………………. 251

VideoSettings.MaxResolution …………………………………………………………………………………… 252

Использование расширения MediaCapture для прямой работы с видео/аудио …………………. 252

Дополнительные настройки расширения MediaCapture …………………………………………………. 256

Итоги …………………………………………………………………………………………………………………………… 258

Глава 19. Работа с картами и определение местоположения ……………………….. 259

Сервис определения местоположения …………………………………………………………………………… 259

Определение местоположения ……………………………………………………………………………………… 260

Определение изменения местоположения ……………………………………………………………………… 264

Работа с Bing Maps SDK ………………………………………………………………………………………………. 267

Итоги …………………………………………………………………………………………………………………………… 274

Глава 20. Работа с сенсорами ………………………………………………………………………… 275

Датчик света ………………………………………………………………………………………………………………… 275

Акселерометр ………………………………………………………………………………………………………………. 278

Гироскоп ……………………………………………………………………………………………………………………… 281

Инклинометр ……………………………………………………………………………………………………………….. 282

Компас ………………………………………………………………………………………………………………………… 286

Простой сенсор ориентации …………………………………………………………………………………………. 287

Итоги …………………………………………………………………………………………………………………………… 288

Глава 21. Интернационализация ………………………………………………………………….. 289

Глобализация……………………………………………………………………………………………………………….. 290

Культура по умолчанию и выбор культуры …………………………………………………………………… 291

Локализация интерфейса приложения …………………………………………………………………………… 293

Локализация изображений ……………………………………………………………………………………………. 296

Использование локализованных ресурсов в коде …………………………………………………………… 297

Локализация названия приложения……………………………………………………………………………….. 298

Итоги …………………………………………………………………………………………………………………………… 299

Глава 22. Базовые принципы дизайна приложений для Windows 8 …………….. 300

Истоки нового стиля Windows 8 ……………………………………………………………………………………. 300

Принципы современного дизайна для Windows …………………………………………………………….. 303

Будьте искусным в деталях ……………………………………………………………………………………. 303

Достигайте большего меньшими средствами …………………………………………………………. 307

Делайте по-настоящему цифровым ………………………………………………………………………… 311

Оглавление 7

Делайте быстрым и подвижным …………………………………………………………………………….. 314

Выигрывайте вместе ……………………………………………………………………………………………… 316

Итоги …………………………………………………………………………………………………………………………… 318

Глава 23. Расстановка приоритетов, или пять первых шагов

к отличному приложению для Windows 8 …………………………………………………….. 320

Жесткая расстановка приоритетов ………………………………………………………………………………… 321

Этап 1. Знайте своего пользователя ………………………………………………………………………………. 321

Этап 2. Чем ваше приложение лучше других? ……………………………………………………………….. 324

Этап 3. Выделите ключевые сценарии …………………………………………………………………………… 325

Этап 4. Спланируйте навигацию …………………………………………………………………………………… 329

Этап 5. Продумайте функциональность ………………………………………………………………………… 344

Итоги …………………………………………………………………………………………………………………………… 353

Глава 24. Размещение и продажа приложений в Windows Store ………………….. 354

Устройство Windows Store ……………………………………………………………………………………………. 356

Аудитория Windows Store …………………………………………………………………………………………….. 358

Регистрация в Windows Store ………………………………………………………………………………………… 358

Резервирование имени приложения ………………………………………………………………………………. 362

Создание пакета приложения для публикации в Windows Store ……………………………………… 363

Демо-версии приложений …………………………………………………………………………………………….. 366

Итоги …………………………………………………………………………………………………………………………… 368

ПРИЛОЖЕНИЯ ……………………………………………………………………………………………. 371

Приложение 1. Язык разметки XAML ………………………………………………………….. 373

Задание значений свойств …………………………………………………………………………………………….. 376

Использование стилей ………………………………………………………………………………………………….. 378

XAML-ресурсы и ресурсные словари ……………………………………………………………………………. 381

Шаблоны элементов управления …………………………………………………………………………………… 383

Менеджеры размещения ………………………………………………………………………………………………. 384

Связывание данных ……………………………………………………………………………………………………… 389

Работа с DataContext……………………………………………………………………………………………… 392

Связывание с коллекциями ……………………………………………………………………………………. 396

Итоги …………………………………………………………………………………………………………………………… 398

Приложение 2. C# 5 и асинхронное программирование ……………………………….. 399

Ключевые слова async и await в C# 5 …………………………………………………………………………….. 403

Итоги …………………………………………………………………………………………………………………………… 407

Предметный указатель …………………………………………………………………………………. 409

8 Оглавление

Почему это первая книга о Windows,

которую я прочитаю от начала

до конца

Операционной системе Windows уже несколько десятков лет — ее первая версия увидела свет в конце 1985 года. С тех пор она стремительно развивалась и достигла небывалых успехов — сегодня ею пользуется более 1,3 миллиарда человек!

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

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

Вместе с Windows 8 компания Microsoft перезапускает все ключевые продукты — Office, Windows Phone, Visual Studio, Outlook.com (бывший Hotmail), Microsoft Account (бывший Live ID), клавиатуры, мыши и т. д. Кроме того, Microsoft поменя-ла логотипы всех своих продуктов, в том числе логотип Windows и даже логотип самой компании.

Изменения носят не только внутренний, но и внешний характер. Полностью меня-ется внешний вид Windows и других продуктов, изменяется позиционирование продуктов и стиль анонсов, новостей и любых внешних коммуникаций.

Для разработчиков Windows 8 есть реальная возможность урвать большой куш — и еще один такой шанс вряд ли представится в обозримом будущем. Ведь только сейчас у самой большой в мире группы пользователей появляется единый магазин приложений — Windows Store. Благодаря магазину Windows у разработчиков от-крывается единый доступ ко всем пользователям. Более того, именно те приложе-ния, которые окажутся успешными в самом начале, получат признание (а значит, принесут и заслуженный доход) у армии пользователей, ранее искавших приложе-ния в самых разных местах. Теперь же Windows Store — то самое место, где поль-зователи смогут найти необходимые им приложения, — есть на любом устройстве с Windows, будь то настольный компьютер, ноутбук или планшет.

10 Почему это первая книга о Windows, которую я прочитаю от начала до конца

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

ными и понятными — это C# и XAML, знакомые приверженцам платформы Microsoft, это C++ и DirectX, широко используемые создателями популярных игр,

это HTML 5 и JavaScript, на которых творят Web-разработчики всего мира.

Мое личное знакомство с Windows началось с далекой Windows 3.1. Помню, мне

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

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

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

и до конца.

Желаю вам интересного чтения и захватывающих приключений в мире разработки

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

Михаил Черномордиков Руководитель отдела экспертов по стратегическим технологиям

Microsoft Россия

[email protected]

Tweets by mixen

Введение

С помощью данной книги вы научитесь создавать новый тип приложений — Windows Store-приложения для операционной системы Windows 8. В них новая па-радигма интерфейса сочетается с эффективным современным API и соответствую-щей платформой разработки.

На кого рассчитана эта книга

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

Если вы не работали с C# ранее, но использовали один из объектно-ориенти-рованных языков программирования, например Java, понимание примеров данной книги не должно вызвать у вас существенных трудностей. В книге мы рассматри-ваем в первую очередь API (Application Programming Interface, интерфейс програм-мирования приложений) платформы Windows 8, поэтому отсутствие опыта разра-ботки на C# не должно стать препятствием. Вы можете изучать язык C# параллель-но с чтением данной книги.

Книга в основном рассчитана на следующих читателей:

� Разработчиков на платформе Microsoft .NET, использующих технологии WPF, Silverlight, ASP.NET и т. д., которые хотят научиться создавать приложения для Windows 8 с помощью знакомых инструментов и технологий.

� Разработчиков настольных приложений для предыдущих версий Windows, рабо-тающих с Win32 API, MFC, Qt и т. д., стремящихся не отставать от прогресса и освоить создание приложений для Windows 8.

� Разработчиков, имеющих опыт создания приложений для мобильных платформ, таких как Windows Phone, Windows Mobile, Android или iOS, желающих созда-вать приложения для Windows 8.

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

12 Введение

Краткое описание глав

Книга состоит из 24-х глав и двух приложений. Далее приведено краткое описание глав и приложений.

В главе 1 рассмотрена история создания операционной системы Windows 8. Здесь подробно описаны возможности платформы и даны предварительные сведения о создании Windows Store-приложений.

В главе 2 перечислено программное обеспечение, необходимое для разработки Windows Store-приложений: Microsoft Visual Studio, Blend и т. д.

Глава 3 посвящена созданию простого приложения для Windows 8 и его отладке на реальном устройстве, симуляторе и удаленном устройстве. Описана структура про-екта Windows Store-приложения и назначение файлов, входящих в проект.

В главе 4 рассмотрены базовые принципы разработки Windows Store-приложения на языке C#. Приведены примеры создания приложений, состоящих из нескольких страниц, и реализации навигации между страницами.

В главе 5 рассмотрена поддержка тем оформления и выбор одной из стандартных тем: темной и светлой.

В главе 6 подробно описана панель приложения (Application Bar) — один из ключе-вых элементов управления в Windows Store-приложениях. Проиллюстрирована ра-бота с нижней и верхней панелями приложения.

В главе 7 разобран пример создания RSS-клиента на основе шаблона Grid App.

В главе 8 детально изложена работа с элементами управления GridView и ListView, на основе которых строится интерфейс многих Windows Store-приложений. Затро-нуты такие темы, как группировка и шаблоны элементов.

В главе 9 продемонстрирована поддержка закрепленного режима (ширина окна приложения при этом составляет 320 пикселов) и работа с VSM (Visual State Manager) для настройки состояний пользовательского интерфейса приложений в разных режимах.

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

В главе 11 рассмотрено создание уведомлений, как инициируемых локально, так и Push-уведомлений, отправляемых из серверной части приложения через Интернет.

Глава 12 посвящена плиткам (Tiles) — удобному способу предоставить пользовате-лю полезную информацию или уведомить об изменениях без запуска самого при-ложения.

В главе 13 рассмотрена одна из наиболее важных и интересных новых функций Windows 8 — поиск и его интерфейс в Windows Store-приложениях. Основное вни-мание уделено контракту поиска.

В главе 14 показана работа с контрактом общего доступа (Share), который очень важен для Windows Store-приложений. Не случайно кнопка для работы с общим

Введение 13

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

В главе 15 описана еще одна полезная кнопка «чудо-панели» — «Параметры»

(Settings), с помощью которой пользователь начинает настройку приложения.

Глава 16 посвящена работе с данными — «движущей силой» приложений. Очень

важно то, где и как хранятся данные. Windows 8 предоставляет для этого несколько вариантов. Данные приложений обычно хранятся в изолированном хранилище, ин-

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

мых СУБД. В данной главе проиллюстрирована работа с СУБД SQLite.

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

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

файлам и папкам, пользователь должен явно это разрешить.

В главе 18 изложена работа c Web-камерой через диалог получения фотогра-

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

В главе 19 рассмотрено определение местоположения и работа с картами от Microsoft.

В главе 20 приведены основные принципы работы с сенсорами: акселерометром, гироскопом, компасом, инклинометром и датчиком света. Данные возможности

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

устройства.

В главе 21 затронуты вопросы интернационализации Windows Store-приложений.

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

Глава 22 содержит базовые принципы дизайна приложений для Windows 8. Прило-жения Windows 8, как и практически все современные продукты Microsoft (напри-

мер, Windows Phone, Xbox 360 или Visual Studio 2012), отличаются не просто набо-ром новых возможностей, но и иным подходом к дизайну пользовательского ин-

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

Глава 23 посвящена расстановке приоритетов при планировании и проектировании приложений для Windows 8.

Одна из сложностей, с которой, по нашему опыту, сталкиваются практически все разработчики и дизайнеры, работая над приложениями для Windows 8 и Windows

Phone, начинается прямо с порога — с проектирования пользовательского взаимо-действия с приложением (UX и UI).

14 Введение

Часто разработчик (автор приложения) приходит с некоторой готовой идей и стара-ется напрямую перенести в Windows 8 привычную функциональность настольных,

мобильных или Web-интерфейсов. Обычно такая прямолинейная попытка «порти-рования» оборачивается стремлением сохранить все, что есть в оригинальном ре-

шении, включая схожие шаблоны решения интерфейсных задач и знакомые прие-мы разработки и написания кода.

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

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

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

В главе 24 рассмотрена публикация приложений в Windows Store. Хотя это относи-тельно простой процесс, но он может потребовать достаточно много времени. Основное время требуется на сертификацию, которая занимает несколько дней.

Благодаря использованию Windows App Certification Kit можно не бояться, что ав-томатизированные тесты не будут пройдены, а значит, уменьшается вероятность

повторной отправки приложения на сертификацию. В данной главе также изложе-ны сведения о создании пробных версий приложений.

В приложении 1 описан расширяемый язык разметки XAML и приведены много-численные примеры XAML-кода.

Приложение 2 содержит примеры асинхронного программирования. Здесь рас-

смотрены, в частности, ключевые слова async и await — одно из наиболее важных нововведений в языке программирования C# 5.

Электронный архив с рассмотренными в книге проектами доступен по ссылке

ftp://ftp.bhv.ru/9785977508469.zip и со страницы книги на сайте www.bhv.ru.

Благодарности

Хочется поблагодарить всех тех, кто помогал в создании данной книги: Даниила Кальченко, Стаса Павлова, Владимира Колесникова, Марию Аникину, Антона

Белоусова, Михаила Черномордикова, Дениса Котлярова и Алексея Гусарова.

Сергей Пугачев хотел бы выразить признательность также Роману Чувашину, Вла-

димиру Аверьянову, Борису Фомину и Ирине Бутримовой за помощь и поддержку.

Отдельная благодарность заместителю главного редактора издательства «БХВ-Пе-

тербург» Игорю Владимировичу Шишигину и другим сотрудникам издательства, без которых данная книга не увидела бы свет.

T�a�a1

Платформа Windows 8

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

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

1. Увеличить время автономной работы путем общей оптимизации, переноса ОС на другие процессорные архитектуры (Windows 8 работает, в том числе, на

ARM-процессорах) и, наконец, выработки правил для разработчиков, с целью минимизации потребления ресурсов приложениями.

2. Оптимизировать ОС под сенсорный ввод (тач-интерфейс).

3. Создать механизмы по продаже и продвижению приложений.

В результате начала выкристаллизовываться новая версия Windows, обещающая

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

и разработчиков.

Одновременно для разработчиков Windows 8 появился уникальный шанс. Ведь у каждого пользователя Windows теперь будет Windows Store — магазин, который является основным (а в некоторых случаях и единственным) источником приложе-

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

Все приложения, работающие на Windows 7, функционируют и на Windows 8. Однако в Windows Store можно загрузить только приложения, использующие но-вую программную платформу Windows Runtime (WinRT). Поэтому мы будем назы-

вать их Windows Store-приложениями. Также Windows 8 предлагает новый пользо-вательский интерфейс. Понять его концепцию можно, взглянув на начальный экран

(рис. 1.1).

Windows Runtime — это своего рода новый Windows API и замена «старого добро-

го» Win32 API. По типу программной платформы приложения для Windows можно разделить на две группы:

16 Глава 1

1. Классические Windows-приложения.

2. Windows Store-приложения.

Создание Windows Store-приложений на языке C# и работа с Windows Runtime — вот тема данной книги. Такие приложения представляют собой сплав новой пара-дигмы интерфейса, эффективного современного API и соответствующей платфор-мы разработки.

Рис. 1.1. Начальный экран Windows 8

Windows Store-приложения

В отличие от классических, Windows Store-приложения содержат одно окно без обрамления (а также без заголовка, кнопок «Закрыть», «Развернуть» и «Свернуть»), по умолчанию занимающее весь экран. Это сделано для того, чтобы не отвлекать пользователей на лишние детали (рис. 1.2).

Windows Store-приложения могут поддерживать различные компоновки и пред-ставления, чтобы обеспечить динамичное и удобное обслуживание пользователей при различных параметрах конструкции и размерах экрана устройств (от 30 дюй-мовых мониторов настольных компьютеров до сравнительно небольших экранов планшетов). Такие приложения могут работать в трех режимах (рис. 1.3):

� приложение развернуто на весь экран (Full Screen);

� приложение закреплено сбоку экрана (слева или справа) (Snapped). Ширина

приложения в таком режиме составляет 320 пикселов;

Платформа Windows 8 17

Рис. 1.2. Вид приложения в стиле Windows 8, работающего в эмуляторе

Рис. 1.3. Режимы работы приложений

� приложение работает совместно с другим закрепленным сбоку приложением и занимает все оставшееся пространство (Filled).

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

разрешение как минимум 1366×768 пикселов. При меньшем разрешении закрепле-ние приложений недоступно, и одновременно может отображаться только одно Windows Store-приложение.

Кроме того, Windows Store-приложения могут работать в ландшафтной или порт-ретной ориентации экрана (рис. 1.3), что особенно актуально для планшетов. Вер-

тикальная ориентация, когда высота экрана больше его ширины, является портрет-ной (Portrait) (крайний правый вариант на рис. 1.3). При ландшафтной ориентации

(Landscape) ширина экрана больше его высоты.

18 Глава 1

Windows Store-приложения без проблем работают с различными устройствами вво-да, включая перо, мышь, клавиатуру и сенсорный ввод. Для всех этих устройств в программной модели приложений используется единый набор событий. Также имеется набор стилей по умолчанию, гарантирующий нормальную работу элемен-тов пользовательского интерфейса с сенсорным вводом. Раньше программный API был почти исключительно нацелен на работу с мышью и клавиатурой, а в Win-dows 8 одинаково хорошо поддерживаются все способы ввода, в особенности сен-сорный ввод.

Windows Store-приложения содержат, кроме уже знакомых, но выполненных в дру-гом стиле элементов управления, несколько новых элементов, повышающих эф-фективность взаимодействия с пользователями. Среди новинок можно отметить панель приложения (App Bar) и «чудо-кнопки» (Charms). Панель приложения — это концепция, уже знакомая многим по операционной системе Windows Phone, но претерпевшая в Windows 8 существенные изменения.

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

Рис. 1.4. Панель приложения

Платформа Windows 8 19

Новая концепция Windows 8 — «чудо-кнопки» (Charms) (рис. 1.5) — фиксирован-ный набор кнопок, используемый во всех приложениях для поиска, взаимодействия

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

приложении. С помощью «чудо-кнопок» пользователи могут:

� искать содержимое, размещенное в вашем или каком-либо ином приложении.

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

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

� делиться содержимым из вашего приложения с другими приложениями стандар-тизированным образом. При этом вам не требуется знать, как работают другие

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

� подключаться к устройствам и отправлять им содержимое, выполнять потоко-вую передачу мультимедийных данных, а также печатать документы;

� выполнять настройку приложений;

� кнопка «Пуск» с логотипом Windows, как можно догадаться, переключает поль-зователя на стартовый экран.

Рис. 1.5. «Чудо-кнопки»

Взаимодействие с «чудо-кнопками» осуществляется с помощью контрактов, работе с каждым из которых (поиск, настройки, передача данных) посвящена отдельная

глава.

Когда пользователь устанавливает приложение, оно появляется на начальном экра-не в виде «плитки» (Tile) (см. рис. 1.1). Если нажать на плитку, приложение будет запущено. Приложения могут отображать на плитках различную информацию, как

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

20 Глава 1

Интернета через Web-службу, задействуя систему Push-уведомлений. С помощью механизма плиток Windows Store-приложения способны выводить на экран полез-

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

дексах приведен на рис. 1.6.

Рис. 1.6. Плитки с информацией о новостях, спорте и биржевых индексах

Благодаря возможности создания вторичных плиток (Secondary Tiles) у приложе-ний может быть несколько плиток одновременно. При нажатии на вторичную

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

Таким образом, плитки, «чудо-кнопки» и панели приложения — это как раз те эле-

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

платформу.

Платформа Windows 8 21

Программная платформа

До недавнего времени разработчики приложений для Windows использовали две основные группы API: неуправляемый (native) через Win32 API и управляемый

(managed) через .NET Framework. Вторая группа постепенно развивалась, получая различные новые и усовершенствованные библиотеки для создания пользователь-

ского интерфейса (например WPF, Windows Presentation Foundation), работы с дан-ными и сервисами, дополнительные инструменты для разработки, построения ис-

ходного кода и архитектуры приложений.

Между тем, сама платформа Windows, т. е. Win32 API получала не так много на-

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

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

энергопотребление, становился все более важным. Если для Windows 95 энергопо-требление почти не имело значения, то для Windows 8 — это один из основных по-

казателей.

Поэтому, создавая новую версию Windows, в Microsoft понимали, что необходимо

разработать и новый API, который, будучи родным (native) для операционной сис-темы, станет отвечать новым требованиям и веяниям времени. В результате по- явился Windows Runtime (WinRT).

Windows Runtime — это новая модель разработки приложений, а также объектно-

ориентированный языконезависимый программный интерфейс (API), написанный на неуправляемом коде и реализующий концепции асинхронного программирова-ния. Все функции и методы, потенциально работающие более 50 мс, реализованы

асинхронно. Синхронных аналогов для них нет. Это обеспечивает лучшие характе-ристики и бóльшую «отзывчивость» приложений.

ПРИМЕЧАНИЕ

Более подробно про асинхронное программирование можно узнать в приложении 2.

WinRT работает на основе новой оптимизированной версии COM, при этом благо-

даря системе метаданных и языковых проекций он может напрямую интегриро-ваться с управляемыми средами, такими как .NET Framework. Некоторые API, вхо-

дящие в WinRT, могут быть использованы и в классических приложениях, но бóльшая часть из них доступна только для Windows Store-приложений.

Windows Store-приложения могут создаваться на различных языках программиро-вания: C#, JavaScript, Visual Basic и C++. Хочется отметить, что можно создавать

невизуальные компоненты WinRT на одном из перечисленных языков (кроме JavaScript), например на языке C#, и встраивать их в приложения, написанные на других языках программирования, например на C++ или JavaScript.

Все программные интерфейсы WinRT выглядят «родными» для каждого из поддер-

живаемых языков программирования. Поэтому для взаимодействия с WinRT не

22 Глава 1

придется предпринимать никаких дополнительных усилий, как, например, для взаимодействия с COM из C#. Для разработчика управляемые типы .NET

Framework и типы WinRT выглядят одинаково.

Пользовательский интерфейс приложений, написанных на JavaScript, создается с помощью HTML 5, в остальных случаях применяется XAML (eXtensible Application Markup Language — расширяемый язык разметки приложений).

XAML знаком многим разработчикам по WPF и Silverlight. На XAML разрабаты-

вают приложения для Windows Phone. А теперь XAML стал и частью Windows Runtime, а значит, и одним из базовых компонентов операционной системы Windows.

В общем случае Windows Store-приложения изолированы друг от друга. Это обес-

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

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

данное действие. Аналогично обстоит дело и, например, с определением местопо-ложения. Пользователь может явно разрешить или запретить предоставление при-ложению такой информации.

Архитектуру платформы Windows 8 иллюстрирует рис. 1.7.

Рис. 1.7. Платформа Windows 8

В данной книге мы рассмотрим создание Windows Store-приложений на языках C# и XAML. В основной части книги мы не будем подробно останавливаться на опи-

сании этих языков. Про язык C# написано много хороших книг, например, http://bhv.ru/books/book.php?id=188312. Языку разметки XAML посвящено при-

ложение 1.

Платформа Windows 8 23

Дизайн Windows Store-приложений

В Windows Store-приложениях используется новое направление (стиль) дизайна пользовательских интерфейсов, сегодня широко применяемое Microsoft, а также

независимыми разработчиками в своих продуктах. Данный стиль реализован в Windows 8, Windows Phone, Xbox, а также Web-приложениях и сайтах компании,

таких как http://outlook.com и др.

Принятый в Windows 8 и других платформах Microsoft дизайн основывается на

идеях Баухауса (Bauhaus), швейцарского дизайна (он же International Typographic Style) и анимационного дизайна (Motion Design).

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

щем мире: указатели, дорожные знаки, информационные табло в аэропортах, на вокзалах и в метро (рис. 1.8). Все это характеризует быстрый, современный мо-

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

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

Рис. 1.8. Истоки дизайна приложений Windows 8

24 Глава 1

на, оболочка вторична. Все элементы максимально упрощены. Поэтому в Win-

dows Store-приложениях нет обилия градиентов, теней и закруглений. Информация,

содержимое, — это и есть собственно пользовательский интерфейс, а фон, кнопки

и другие элементы управления — только дополнение.

Еще одним важным источником нового стиля стала качественная типографика (ти-

пографика — это и искусство, и ремесло, и набор правил, которые используют

шрифты и оформительские средства для достижения одной-единственной цели:

сделать текст наиболее оптимальным для восприятия). При этом текст, его шрифт

(гарнитура шрифта), размер и положение сами по себе являются элементами ди-

зайна и этот дизайн создают. Разные комбинации текста и шрифтов позволяют за-

дать иерархию и расставить приоритеты.

Однако одних «уличных указателей» и шрифтов мало. Сами по себе они не инте-

рактивны. Пользовательский интерфейс Windows Store-приложений подвижен, ги-

бок и интерактивен. Движение и навигация, — один из важных принципов дизайна,

применяемого в Windows 8.

Интерфейсы Windows Store-приложений по-настоящему цифровые. Это значит, что

мы можем выйти за рамки метафор реального мира и отказаться от некоторых из

них. К примеру, в iPad есть приложение iBooks, повторяющее с графической точки

зрения вид настоящей деревянной книжной полки. Это прекрасная метафора. И в

этом суть иконографического дизайна. Еще один пример иконографического сти-

ля — традиционный интерфейс рабочего стола Windows (рис. 1.9). Но «экранное»

Рис. 1.9. Иконографический дизайн

Платформа Windows 8 25

дерево деревом не является, а книги не обладают весом, чтобы где-то стоять и иметь возможность падать (гравитации тоже нет). Поэтому вся оболочка в виде

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

книг). Дизайн Windows 8, в противовес иконографическому стилю, является инфо-графическим. Мы работаем с пикселами и не нужно пытаться повторить в цифро-

вом мире метафоры мира реального.

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

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

Итоги

В данной главе мы на базовом уровне рассмотрели архитектуру Windows 8, узнали

про новую программную платформу под названием Windows Runtime (WinRT), на которой строятся Windows Store-приложения. Такие приложения можно загружать в магазин Windows и продавать на мировом рынке.

В Windows 8 реализован новый стиль дизайна, который существенно отличается от

того, что можно увидеть на других платформах и в более ранних версиях Windows.

Пришло время установить инструменты разработки и начать создавать Windows

Store-приложения, чем мы и займемся в следующей главе.

T�a�a2

Среда разработки

Все необходимое для разработки приложений для Windows, включая инструменты

создания Windows Store-приложений, вы можете найти в центре Windows-раз-работки на сайте MSDN (Microsoft Software Development Network):

http://msdn.microsoft.com/windows

Данный центр доступен и на русском языке по адресу:

http://msdn.microsoft.com/ru-ru/windows

В центре Windows-разработки вы найдете ссылки на скачивание SDK (Software

Development Kit), актуальную версию документации, примеры и т. д.

Для разработки Windows Store-приложений вам потребуется x86 или x64 версия

Windows 8. Разработка Windows Store-приложений на более ранних версиях

Windows или на Windows RT для ARM-процессоров не поддерживается.

Если у вас пока нет Windows 8, вы можете бесплатно скачать пробную (не для

коммерческого использования) 90-дневную версию. По истечении 90-дневного

срока обновить эту версию нельзя, потребуется полная переустановка системы. Но,

если вы хотите попробовать разработку Windows Store-приложений, благодаря

пробной версии Windows это можно сделать абсолютно бесплатно.

Если вы студент, аспирант или преподаватель и ваш вуз имеет подписку

DreamSpark Premium, то можно бесплатно получить полноценную версию

Windows 8. Узнайте необходимые детали у администрации своего вуза.

Итак, у вас инсталлирована Windows 8, пришло время установить и все необходи-

мое для разработки Windows Store-приложений.

Главный инструмент для создания приложений на платформе Microsoft — это

Visual Studio, имеющий множество редакций. Microsoft предоставляет бесплатную

Express-редакцию Visual Studio 2012, позволяющую создавать Windows Store-

приложения. Полное название данной редакции — Visual Studio Express 2012 for

Windows 8. Для создания Windows Store-приложений вы можете также воспользо-

Среда разработки 27

ваться старшими коммерческими редакциями Visual Studio 2012, такими как

Ultimate, Premium и Professional.

Если у вас не установлена одна из старших редакций Visual Studio 2012, скачайте и установите Visual Studio Express 2012. Существует русскоязычная версия данного

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

Быстро найти ссылку на загрузку Visual Studio Express 2012 for Windows 8 вы мо-жете через Windows Store. Во встроенном приложении Store выполните поиск

Visual Studio, откройте страницу продукта (рис. 2.1), а затем нажмите на ссылку Go

to publisher’s website.

Рис. 2.1. Страница Visual Studio Express 2012 в Windows Store

Вместе с Visual Studio Express for Windows 8 в числе прочих продуктов, таких как Windows 8 SDK, будет установлен Blend for Visual Studio. Blend поставляется также

и в составе старших редакций Visual Studio.

Blend — это инструмент для создания (дизайна) пользовательского интерфейса приложений. Данный продукт существует уже достаточно давно, есть различные версии Blend, предназначенные, например, для создания приложений WPF

(Windows Presentation Foundation), а также приложений для Windows Phone. Blend for Visual Studio позволяет создавать Windows Store-приложения.

Разрабатывать Windows Store-приложения можно полностью в Visual Studio, ни разу не запуская Blend. Однако Blend предоставляет интерфейс, более удобный для

формирования дизайна приложений, в то время как в Visual Studio удобней рабо-

28 Глава 2

тать над исходным кодом. Blend имеет ряд полезных возможностей, таких как лег-кое создание анимации, работу с VSM (Visual State Manager) в графическом интер-

фейсе и т. д. Интерфейс Blend привычней для дизайнеров, которых очень нелегко, если вообще возможно, заставить работать в Visual Studio.

Несмотря на то, что Blend подразумевает работу в графическом редакторе, он под-держивает редактирование разметки XAML и кода на языке C# напрямую (или

HTML и JavaScript в случае JavaScript-приложений). Таким образом, можно создать приложение полностью в Blend, ни разу не запуская Visual Studio.

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

дит благодаря тому, что и в Blend, и в Visual Studio можно работать с одними и те-ми же типами проектов, над одними и теми же физическими файлами.

На рис. 2.2 изображено окно Visual Studio, на рис. 2.3 — окно Blend во время ре-дактирования одной и той же страницы Windows Store-приложения.

И Visual Studio, и Blend поддерживают как темную, так и светлую тему оформле-

ния. В Visual Studio вы можете настроить тему, выбрав пункт меню TOOLS |

Options…, и в появившемся диалоговом окне в разделе Environment | General, от-крытом по умолчанию, указать настройку Color theme. Вид Visual Studio в светлой

теме оформления приведен на рис. 2.4.

В Blend тему оформления можно настроить, выбрав пункт меню Tools | Options…,

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

Рис. 2.2. Visual Studio Express 2012 for Windows 8

Среда разработки 29

Рис. 2.3. Blend for Visual Studio

Рис. 2.4. Светлая тема оформления Visual Studio

30 Глава 2

Кроме Visual Studio Express 2012, вам могут потребоваться и другие инструменты и примеры, которые можно скачать в центре Windows разработки на MSDN:

� Live SDK — пакет средств разработчика для интеграции с учетной записью

Microsoft (Microsoft Account, ранее Windows Live ID), работы с сервисом SkyDrive и другими сервисами.

� Windows 8 Ads in Apps SDK — пакет средств разработчика для интеграции тек-стовой рекламы и баннеров в приложения. Многие разработчики зарабатывают,

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

� Multilingual App Toolkit for Visual Studio 2012 — расширение для Visual Studio, облегчающее локализацию Windows Store-приложений. Поддерживаются инст-

рументы и редакторы для работы с переводами.

� Remote Tools for Visual Studio 2012 — инструменты для удаленной отладки и

профилирования приложений на устройствах, на которых не установлена Visual Studio. С помощью данных инструментов можно проводить отладку Win-

dows Store-приложений на Windows RT, работающей на ARM-процессорах, где Visual Studio не доступна в принципе.

� Sample app pack — набор примеров Windows Store-приложений, поставляемый в исходных кодах. Если вам непонятно, как реализовать ту или иную возмож-ность в вашем приложении, возьмите соответствующий пример из Sample app

pack и посмотрите, как реализована эта возможность в нем.

Если вам требуется использовать картографию в приложениях, скачайте и устано-вите Bing Maps SDK. Подробнее про определение местоположения и картографию мы будем говорить в главе 19.

Итоги

В данной главе мы рассмотрели программное обеспечение, необходимое для разра-

ботки Windows Store-приложений. Мы узнали, что потребуется Windows 8, проб-ную 90-дневную версию которой можно получить бесплатно.

Базовые инструменты разработки Windows Store-приложений также бесплатны. Необходимо скачать и установить Visual Studio Express 2012 for Windows 8 (если

у вас уже не установлена одна из старших коммерческих редакций Visual Studio 2012).

Мы узнали, что в состав Visual Studio 2012 входит мощный инструмент для работы над дизайном приложений — Blend for Visual Studio.

Теперь у нас есть все, чтобы приступить к разработке нашего первого Win-dows Store-приложения, созданию которого и будет посвящена следующая глава.

T�a�a3

Первое Windows Store-приложение

После того как мы скачали и установили Visual Studio, настало время создать наше

первое Windows Store-приложение. По традиции это будет простая программа «Hello World», выводящая на экран соответствующую строку. Многим такое при-ложение может показаться несерьезным, но на его примере мы рассмотрим весь

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

тах c ARM-процессорами под управлением Windows RT.

Создание проекта в Visual Studio

Откройте Visual Studio Express 2012 for Windows 8 либо одну из старших версий

Visual Studio 2012, если она у вас установлена. При выполнении примеров данной книги мы будем предполагать, что вы работаете с бесплатной Express-версией.

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

приложения довольно легко, с какой бы версией Visual Studio 2012 вы ни рабо- тали.

После того как Visual Studio Express загрузится, вам будет предложено бесплатно получить лицензию разработчика (рис. 3.1). В старших версиях Visual Studio ли-

цензию предлагается получить после создания проекта Windows Store-приложения, а не при запуске Visual Studio.

Лицензия разработчика позволяет разрабатывать и тестировать Windows Store-приложения на конкретной копии операционной системы Windows 8 до их серти-

фикации в Windows Store. Без такой лицензии приложения, не прошедшие серти-фикацию, в том числе разрабатываемые вами в данный момент, работать не будут

(кроме корпоративных сценариев). Лицензию необходимо периодически обнов-лять, т. к. она выдается на фиксированный период. После истечения срока действия

32 Глава 3

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

Следует различать лицензию разработчика и учетную запись для выкладывания

приложений в Windows Store. Лицензия выдается бесплатно, учетная запись Windows Store стоит денег. Если у вас есть учетная запись в Windows Store, лицен-зия разработчика будет выдана на более длительный срок.

Рис. 3.1. Запрос на получение лицензии разработчика

Для получения лицензии разработчика нажмите кнопку I Agree. Будет выполнена попытка соединиться с сервером лицензирования, для чего понадобится соедине-ние с Интернетом.

Лицензия разработчика привязывается к учетной записи Microsoft (Microsoft

account, ранее известный как Windows LiveID). В открывшемся диалоговом окне (рис. 3.2) введите данные своей учетной записи и нажмите кнопку Sign in. После этого лицензия будет получена и откроется диалоговое окно, сообщающее дату ис-

течения действия лицензии (рис. 3.3).

До срока ее истечения вы можете получить новую лицензию, выбрав в меню в Visual Studio Express пункт STORE | Acquire Developer Licence… или PROJECT |

Store | Acquire Developer Licence… в старших версиях Visual Studio.

Создадим новый проект Windows Store-приложения. Выберите пункт меню File | New Project. В левой части открывшегося диалогового окна New Project в разделе

Installed | Templates выберите сначала опцию Visual C#, а затем — Windows

Store. В центральной части окна New Project вам будут доступны несколько шаб-

лонов проектов, но в данном примере мы выберем самый простой шаблон под на-званием Blank App (XAML). Введите в поле Name название приложения,

HelloWorldApp, а также укажите в поле Location папку, в которой будет разме-щаться проект приложения. После этого нажмите кнопку OK (рис. 3.4). В результа-

Первое Windows Store-приложение 33

Рис. 3.2. Ввод данных учетной записи Microsoft

Рис. 3.3. Диалоговое окно, сообщающее об успешном получении лицензии разработчика

те будет создан новый проект Windows Store-приложения, и откроется C#-код фай-

ла App.xaml (рис. 3.5).

Для того чтобы запустить приложение на отладку, нажмите клавишу <F5> на кла-

виатуре либо кнопку с зеленой стрелкой на панели инструментов, либо выберите пункт меню Debug | Start Debugging. Приложение запустится, и вы увидите чер-

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

34 Глава 3

Рис. 3.4. Создание нового проекта Windows Store-приложения

Рис. 3.5. Открытый проект Windows Store-приложения

Хочется отметить, что созданное вами приложение было установлено в систему. Поэтому вы можете запустить его отдельно с помощью плитки на начальном экра-не. Плитка (Tile) приложения была добавлена в самый конец списка плиток (правая

нижняя плитка на рис. 3.6, выделенная красным прямоугольником).

Первое Windows Store-приложение 35

Рис. 3.6. Плитка приложения на начальном экране

Структура проекта приложения

Рассмотрим структуру проекта Windows Store-приложения, узнаем, какие файлы в

него входят и каково их назначение. Это можно сделать с помощью окна Solution

Explorer в Visual Studio (рис. 3.7).

� Файл MainPage.xaml — это разметка главной страницы приложения на языке

XAML. Название страницы выбрано произвольно, к нему не предъявляется ни-

каких требований. Важно только указать в файле App.xaml.cs, какую страницу

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

MainPage.xaml. Почти во всех приложениях данная страница не будет, да и не

должна быть единственной. Платформа Windows 8 очень хорошо оптимизиро-

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

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

ев. Подробную информацию по навигации между страницами в Windows Store-

приложениях см. в главе 4.

� MainPage.xaml.cs — это файл кода (code-behind) на языке C# страницы

MainPage.xaml. Если вам требуется добавить на какую-либо страницу код, вы

можете использовать для этого файл с расширением xaml.cs. В данном случае

36 Глава 3

это файл MainPage.xaml.cs. Однако существуют и другие подходы, например

паттерн проектирования MVVM (Model-View-ViewModel), когда файл кода

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

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

файлах кода удобнее, в дальнейшем мы выберем именно такой подход, хотя час-

то предпочтительнее использовать паттерн MVVM.

� Файл App.xaml — это разметка объекта Windows Store-приложения на языке

XAML. Данная разметка не имеет визуального представления и не является страницей приложения. В файле App.xaml вы можете хранить данные и на-стройки для всего приложения. Кроме того, в данном файле удобно определять

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

(светлую или темную) оформления приложения.

Рис. 3.7. Структура проекта Windows Store-приложения

Исходный код файла App.xaml приведен в листинге 3.1.

Листинг 3.1. Файл App.xaml

<Application

x:Class=»HelloWorldApp.App»

xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation»

xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»

xmlns:local=»using:HelloWorldApp»>

<Application.Resources>

<ResourceDictionary>

Первое Windows Store-приложение 37

<ResourceDictionary.MergedDictionaries>

<ResourceDictionary Source=»Common/StandardStyles.xaml»/>

</ResourceDictionary.MergedDictionaries>

</ResourceDictionary>

</Application.Resources>

</Application>

Обратите внимание на подключение в ресурсах файла StandardStyles.xaml. Стили из данного ресурсного файла будут доступны на всех страницах приложения.

� App.xaml.cs — это файл кода (code-behind) на языке C# для App.xaml. В данном файле обрабатываются события уровня приложения, такие как запуск, актива-ция, в том числе активация по поисковому запросу, и деактивация приложения. Кроме того, в App.xaml.cs вы можете перехватывать необработанные исключе-ния и отлавливать ошибки навигации между страницами.

� StandardStyles.xaml — файл ресурсов стилей для графических элементов управ-ления. Как было сказано ранее, данный файл подключается в App.xaml и его стили доступны во всех страницах приложения. Вы можете создать свои стили, основанные на стилях из данного файла, или применять имеющиеся стили на-прямую. В любом случае стили из файла StandardStyles.xaml применяются очень и очень часто, поэтому уделите время и посмотрите, какие стили содержатся в данном файле. Мы не будем приводить их здесь из-за их слишком большого объема.

� Package.appxmanifest — это манифест приложения. Он содержит множество на-строек, таких как заголовок, пути к картинкам для плиток (Tiles) и экрана за-ставки (Splash Screen), задание поддерживаемых ориентаций экрана, определе-ние необходимых приложению системных возможностей и т. д. Несмотря на то, что это XML-файл, он почти всегда редактируется не напрямую, а с помощью встроенного в Visual Studio графического редактора (рис. 3.8). Откройте редак-тор манифеста приложения двойным щелчком мышью по имени файла Package.appxmanifest в окне Solution Explorer.

В редакторе вы можете увидеть вкладки Application UI, Capabilities, Declarations и Packaging, работа с которыми будет рассмотрена далее в этой книге.

Для тех, кто интересуется кодом манифеста, в листинге 3.2 приведен полный текст файла Package.appxmanifest для нашего проекта. Естественно, на вашей машине

значение такого свойства, как Publisher, будет другим.

Листинг 3.2. Файл Package.appxmanifest

<?xml version=»1.0″ encoding=»utf-8″?>

<Package xmlns=»http://schemas.microsoft.com/appx/2010/manifest»>

<Identity Name=»f1e59aea-15c7-4515-89ba-1976f2499f4f»

Publisher=»CN=v-sepuga»

Version=»1.0.0.0″ />

38 Глава 3

<Properties>

<DisplayName>HelloWorldApp</DisplayName>

<PublisherDisplayName>v-sepuga</PublisherDisplayName>

<Logo>Assets\StoreLogo.png</Logo>

</Properties>

<Prerequisites>

<OSMinVersion>6.2.1</OSMinVersion>

<OSMaxVersionTested>6.2.1</OSMaxVersionTested>

</Prerequisites>

<Resources>

<Resource Language=»x-generate»/>

</Resources>

<Applications>

<Application Id=»App»

Executable=»$targetnametoken$.exe»

EntryPoint=»HelloWorldApp.App»>

<VisualElements

DisplayName=»HelloWorldApp»

Logo=»Assets\Logo.png»

SmallLogo=»Assets\SmallLogo.png»

Description=»HelloWorldApp»

ForegroundText=»light»

BackgroundColor=»#464646″>

<DefaultTile ShowName=»allLogos» />

<SplashScreen Image=»Assets\SplashScreen.png» />

</VisualElements>

</Application>

</Applications>

<Capabilities>

<Capability Name=»internetClient» />

</Capabilities>

</Package>

� AssemblyInfo.cs — еще один конфигурационный файл, в котором определяются

некоторые метаданные главной сборки (Assembly) приложения.

� HelloWorldApp_TemporaryKey.pfx — это криптографический сертификат с за-

крытым ключом, которым подписывается приложение.

� Logo.png, SmallLogo.png, StoreLogo.png — логотипы для большой и малой пли-

ток приложения, а также иконка для списка всех приложений. Это действитель-

но важные файлы, т. к. логотипы пользователь увидит сразу же после установки

приложения. Было бы разумно сделать большую и малую плитку визуально по-

хожими, хотя они могут и существенно отличаться. В процессе работы прило-

Первое Windows Store-приложение 39

Рис. 3.8. Редактор манифеста приложения

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

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

� SplashScreen.png — картинка для экрана заставки, отображаемая во время за-грузки приложения до главной страницы. Вы можете задать свою картинку, но учтите, что она служит исключительно для информирования пользователя о за-грузке приложения. В этом месте не стоит пытаться сделать что-то необычное.

Кроме перечисленных файлов в проекте присутствует раздел References, знакомый всем .NET-разработчикам. В данном разделе находятся ссылки на сборки (Assemblies) и фреймворки (Frameworks), подключенные приложением. В нашем

40 Глава 3

примере подключены два фреймворка: .NET for Windows Store apps и Windows, включающие все необходимые сборки из .NET Framework и Windows Runtime со-ответственно.

Добавляем функциональность

Редактор пользовательского интерфейса главной страницы приложения (рис. 3.9) можно открыть с помощью двойного щелчка мышью по файлу MainPage.xaml

в окне Solution Explorer. Как вы уже знаете, пользовательский интерфейс Windows Store-приложений, написанных на языке C#, описывается декларативным образом на языке XAML (см. приложение 1). Visual Studio позволяет редактировать XAML-

код напрямую, а также в графическом редакторе WYSIWYG (What You See Is What You Get, «что видишь, то и получишь»). В Visual Studio окно редактора пользова-

тельского интерфейса Windows Store-приложений по умолчанию разделено по го-ризонтали на две половины. Вверху находится графический редактор WYSIWYG, схематически выполненный в виде планшета, а внизу редактор XAML-разметки.

Посередине располагается панель, с помощью которой вы можете поменять редак-торы местами, изменить размер каждого из них, переключиться в режим, когда

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

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

Первое Windows Store-приложение 41

Несмотря на то, что можно создать полноценный пользовательский интерфейс, просто перетаскивая элементы управления из панели Toolbox в графический редак-

тор и изменяя их свойства в окне Properties, большинство разработчиков предпо-читает редактировать XAML-разметку напрямую. В большинстве примеров данной

книги мы также будем напрямую редактировать XAML-разметку.

Итак, давайте рассмотрим XAML-разметку главной страницы приложения

MainPage.xaml (листинг 3.3).

Листинг 3.3. Разметка главной страницы приложения

<Page

x:Class=»HelloWorldApp.MainPage»

xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation»

xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»

xmlns:local=»using:HelloWorldApp»

xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″

xmlns:mc=

«http://schemas.openxmlformats.org/markup-compatibility/2006»

mc:Ignorable=»d»>

<Grid

Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

</Grid>

</Page>

Разметка предельно проста. Далее в книге мы рассмотрим и более сложные шабло-ны страниц, такие как Basic Page. Но пока вернемся к нашей странице. XAML-

разметка содержит элемент самой страницы Page, а также менеджер размещения

Grid (сетка), занимающий все пространство. В качестве фона данного менеджера

размещения указана кисть ApplicationPageBackgroundThemeBrush, являющаяся сис-темным ресурсом и зависящаяся от текущей темы (светлой или темной).

С XAML-разметкой связан код на языке C#, располагающийся в файле

MainPage.xaml.cs. Перейти к C#-коду можно также, выбрав пункт View Code в кон-текстном меню при редактировании XAML-разметки.

C#-код страницы MainPage приведен в листинге 3.4.

Листинг 3.4. C# код страницы MainPage

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using Windows.Foundation;

using Windows.Foundation.Collections;

42 Глава 3

using Windows.UI.Xaml;

using Windows.UI.Xaml.Controls;

using Windows.UI.Xaml.Controls.Primitives;

using Windows.UI.Xaml.Data;

using Windows.UI.Xaml.Input;

using Windows.UI.Xaml.Media;

using Windows.UI.Xaml.Navigation;

namespace HelloWorldApp

{

public sealed partial class MainPage : Page

{

public MainPage()

{

this.InitializeComponent();

}

protected override void OnNavigatedTo(NavigationEventArgs e)

{

}

}

}

Страница представляет собой класс MainPage, в конструкторе которого инициализи-

руется графический интерфейс (метод this.InitializeComponent). В классе переоп-

ределен метод OnNavigatedTo, вызываемый при переходе на страницу.

Мы разместим по центру страницы кнопку с текстом «Нажми меня!», при нажатии которой будет показываться сообщение «Hello World». Кнопка будет находиться

внутри менеджера размещения Grid (листинг 3.5).

Листинг 3.5. Кнопка с текстом «Нажми меня!»

<Grid Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

<Button Content=»Нажми меня!»

HorizontalAlignment=»Center» VerticalAlignment=»Center»/>

</Grid>

Кнопка находится в единственной ячейке внутри Grid и располагается по цент-

ру, как по горизонтали (HorizontalAlignment=»Center»), так и по вертикали

(VerticalAlignment=»Center»). Высота и ширина кнопки определяется ее содержи-мым (рис. 3.10).

Добавим обработчик события нажатия на кнопку. Вы можете два раза щелкнуть мышью по кнопке в графическом редакторе или в XAML-разметке задать событие

Click элемента управления Button. При задании события Click в XAML-коде вам будет предложено создать новый обработчик события (<New Event Handler>) или

Первое Windows Store-приложение 43

выбрать нужный обработчик из уже существующих (рис. 3.11). Создадим новый обработчик. Так как у нашей кнопки нет имени, обработчик события нажатия будет

называться Button_Click_1. Имя кнопки автоматически добавляется в название соз-даваемого обработчика. Хороший стиль программирования — всегда задавать име-на элементов управления, с которыми вы собираетесь взаимодействовать каким-либо образом.

Рис. 3.10. Интерфейс приложения с кнопкой «Нажми меня!»

Рис. 3.11. Создание обработчика события

Чтобы перейти к C#-коду обработчика события, нажмите правой кнопкой мыши на имени обработчика в XAML-коде и в контекстном меню выберите пункт Navigate to Event Handler. Откроется редактор C#-кода, в котором будет находиться код главной страницы нашего приложения с пустым обработчиком нажатия кнопки (листинг 3.6).

Листинг 3.6. Обработчик события нажатия кнопки

public sealed partial class MainPage : Page

{

public MainPage()

44 Глава 3

{

this.InitializeComponent();

}

protected override void OnNavigatedTo(NavigationEventArgs e)

{

}

private void Button_Click_1(object sender, RoutedEventArgs e)

{

}

}

Сейчас обработчик нажатия кнопки не выполняет никаких полезных действий. Да-вайте это исправим. Добавим код показа модального сообщения с текстом «Hello

World!» (листинг 3.7).

Листинг 3.7. Обработчик события нажатия кнопки

private void Button_Click_1(object sender, RoutedEventArgs e)

{

var dlg = new MessageDialog(«Hello World!»);

dlg.ShowAsync();

}

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

ствующее сообщение (рис. 3.12).

Класс MessageDialog из пространства имен Windows.UI.Popups позволяет показы-вать модальные сообщения, имеющие заголовок, текст и различные кнопки. За за-головок отвечает второй параметр конструктора данного класса (листинг 3.8).

Рис. 3.12. Сообщение «Hello World!»

Первое Windows Store-приложение 45

Листинг 3.8. Задание заголовка сообщения

var dlg = new MessageDialog(«Hello World!», «Заголовок»);

dlg.ShowAsync();

За отображение кнопок отвечают команды. Добавим сообщению три команды:

Команда 1, Команда 2 и Команда 3 (листинг 3.9). У первой команды зададим пус-

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

Вторую команду сделаем командой по умолчанию (dlg.DefaultCommandIndex = 1).

Команда по умолчанию выделяется цветом и будет вызываться при нажатии поль-

зователем клавиши <Enter>. Третью команду сделаем командой отмены, вызывае-

мой при нажатии пользователем клавиши <Escape>. Индексы команд начинаются

с нуля.

Чтобы дождаться закрытия сообщения, сделаем метод Button_Click_1 асинхрон-

ным, указав ключевое слово async. Ожидание задается с помощью ключевого слова

await (про ключевые слова async и await рассказывается в приложении 2). После

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

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

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

Листинг 3.9. Добавление команд

private async void Button_Click_1(object sender, RoutedEventArgs e)

{

var dlg = new MessageDialog(«Hello World!», «Заголовок»);

dlg.Commands.Add(new UICommand(«Команда 1»,

new UICommandInvokedHandler((args) =>

{

// Обработчик команды

})));

dlg.Commands.Add(new UICommand(«Команда 2»));

dlg.Commands.Add(new UICommand(«Команда 3») { Id = 3 });

dlg.DefaultCommandIndex = 1;

dlg.CancelCommandIndex = 2;

var command = await dlg.ShowAsync();

}

Запустите приложение и нажмите кнопку. Новый вариант сообщения показан на

рис. 3.13.

46 Глава 3

Рис. 3.13. Сообщение с тремя командами

СОВЕТ

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

Отладка приложения на симуляторе

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

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

Как видите, симулятор очень полезен. Рассмотрим работу с ним. Но вначале хочет-ся отметить, что симулятор — это не эмулятор. Симулятор не является виртуаль-ной машиной. Внутри симулятора работает та же копия Windows, на той же маши-не и под тем же пользователем, что работаете вы. Рассматривайте симулятор как немного другой вид подключения к терминалу удаленного рабочего стола (Remote Desktop, RDP).

Для запуска приложения в симуляторе измените в выпадающем списке кнопки за-пуска пункт Local Machine на Simulator (рис. 3.14).

Нажмите кнопку запуска. Откроется симулятор и запустится приложение (рис. 3.15).

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

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

Первое Windows Store-приложение 47

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

Рис. 3.15. Вид приложения в симуляторе

По центру внизу симулятора располагается кнопка Start, функциональность кото-рой аналогична программной кнопке в «чудо-панели» или аппаратной кнопке на клавиатуре.

В правой части окна симулятора находятся 13 кнопок управления. Рассмотрим их

назначение сверху вниз.

� Свернуть симулятор (Minimize).

� Располагать симулятор поверх других окон (Always on top).

� Режим работы, при котором физическая мышь является мышью в симуляторе (Mouse mode).

� Режим работы, при котором физическая мышь эмулирует сенсорный ввод (каса-ние пальцем) в симуляторе (Basic touch mode).

� Эмуляция сенсорного зуммирования с помощью мыши (Pinch/zoom touch mode).

48 Глава 3

� Эмуляция сенсорного вращения с помощью мыши.

� Поворот экрана по часовой стрелке на 90° (Rotate clockwise (90 degrees)).

� Поворот экрана против часовой стрелки на 90° (Rotate counterclockwise

(90 degrees)).

� Изменение разрешения экрана (Change resolution).

� Установка местоположения (Set location).

� Получение снимка экрана (Copy screenshot).

� Настройки снятия снимков экрана (Screenshot settings).

� Помощь (Help).

С поворотом симулятора все понятно, это действие аналогично повороту реального

устройства. Для изменения разрешения экрана симулятора нажмите на соответст-вующую кнопку. Откроется меню с выбором размера диагонали экрана и разреше-ния (рис. 3.16).

Рис. 3.16. Выбор разрешения и размера диагонали экрана

симулятора

Как видно, при одной и той же диагонали экрана, например 10,6 дюймов, можно задать разное разрешение. Это связано с тем, что экраны могут иметь различную плотность пикселов (точек на дюйм — PPI, Pixels Per Inch). Для растровых рисун-

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

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

Первое Windows Store-приложение 49

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

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

Отладка приложений на удаленных устройствах

Третий вариант отладки, кроме локальной машины и симулятора, — отладка на удаленном устройстве. Удобно разрабатывать приложения на мощном настольном компьютере с большим экраном, а отлаживать, например, на планшете. Для этого на удаленном устройстве должны быть установлены соответствующие инструмен-ты — Remote Tools for Visual Studio 2012. Установите и запустите их на устройстве, где будет проходить отладка. Если на устройстве нет лицензии разработчика, ее следует запросить.

Вид удаленного отладчика, запущенного на устройстве, приведен на рис. 3.17.

Рис. 3.17. Вид удаленного отладчика

Теперь к устройству необходимо подключиться из Visual Studio. Выберите пункт Remote Machine в выпадающем списке запуска. Откроется окно установки соеди-нения (рис. 3.18).

Выберите нужное удаленное устройство. Теперь вы можете проводить на нем от-ладку ваших приложений.

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

Для того чтобы собрать пакет приложения, выберите в меню Visual Studio Express пункт STORE | Create App Packages… или PROJECT | Store | Create App

Packages… в старших версиях Visual Studio. Будет предложено создать пакет при-ложения для загрузки в Windows Store. Ответьте «Нет» (No) на данный вопрос (рис. 3.19).

50 Глава 3

Рис. 3.18. Окно установки соединения

с удаленным отладчиком

Рис. 3.19. Создание пакета приложения

Первое Windows Store-приложение 51

Нажмите кнопку Next, укажите место размещения пакета приложения (или оставь-

те значение по умолчанию). Для создания пакета нажмите кнопку Create.

В результате будет создан пакет приложения с расширением appx, а также сопутст-

вующие файлы (рис. 3.20). В файле с расширением appx хранится весь скомпили-

рованный код и ресурсы приложения. Данный файл представляет собой ZIP-архив,

поэтому, если вы хотите посмотреть его содержимое, можно сменить расширение

файла HelloWorldApp_1.0.0.0_AnyCPU_Debug.appx на zip и распаковать любым

архиватором.

Второй по важности из созданных файлов — скрипт PowerShell с расширением ps1,

который служит для установки приложения на другие компьютеры, имеющие

лицензию разработчика.

ПРИМЕЧАНИЕ

Windows PowerShell — расширяемое средство автоматизации от Microsoft, состоящее

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

PowerShell входит в поставку Windows 8.

Рис. 3.20. Пакет приложения и сопутствующие файлы

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

PowerShell скрипт установки Add-AppDevPackage.ps1. Приложение установится,

и его можно будет тестировать.

52 Глава 3

Итоги

В данной главе мы рассмотрели процесс создания простого Windows Store-приложения «Hello World». Мы получили лицензию разработчика для отладки

Windows Store-приложений на локальном устройстве.

В качестве основы мы использовали шаблон проекта под названием Blank App, и увидели, какие файлы входят в данный проект. Мы добавили на страницу

MainPage.xaml кнопку и создали обработчик события нажатия кнопки, написанный

на языке C#. Мы запустили данное приложение на локальной машине, симуляторе и на удаленном устройстве.

Приложение, созданное нами в данной главе, состоит всего из одной страницы. В следующей главе мы рассмотрим создание страниц, а также навигацию между

ними.

T�a�a4

Страницы и навигация

в приложениях

В данной главе мы рассмотрим одну из основных концепций разработки Win-dows Store-приложений: навигацию между страницами. В главе 3 мы создали при-

ложение, состоящее из одной страницы MainPage.xaml, в реальных приложениях таких страниц может быть множество. Это напоминает то, как работают Web-браузеры. С точки зрения пользователя отличие между работой с Web-страницами и Windows Store-приложениями минимально (игры — отдельный разговор). Для разработчика различия более существенны, в первую очередь потому, что все стра-ницы конкретного приложения разделяют состояние этого приложения (например, статические объекты), но базовые концепции аналогичны. Представьте, что ваше Windows Store-приложение является Web-сайтом. Для Windows Store-приложений, написанных на JavaScript, аналогия прямая. В случае с приложениями, написанны-ми на C#, вместо HTML-страниц и кода на JavaScript у вас есть XAML-страницы и код на языке C#. Аналогом CSS в нашем примере будут стили, задаваемые также в XAML-разметке.

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

Задание начальной страницы приложения

Сейчас начальной страницей приложения из главы 3 является MainPage.xaml. На-чальная страница задается в файле App.xaml.cs. Рассмотрим его содержимое (лис-тинг 4.1).

Листинг 4.1. C#-код для App.xaml

using System;

using Windows.ApplicationModel;

using Windows.ApplicationModel.Activation;

54 Глава 4

using Windows.UI.Xaml;

using Windows.UI.Xaml.Controls;

namespace HelloWorldApp

{

/// <summary>

/// Класс, определяющий поведение, специфичное для приложения

/// Расширяет стандартный класс Application

/// </summary>

sealed partial class App : Application

{

/// <summary>

/// Конструктор класса App

/// Инициализация Singleton объекта приложения

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

/// Конструктор объекта приложения является логическим

/// эквивалентом функций main() и WinMain()

/// </summary>

public App()

{

this.InitializeComponent();

this.Suspending += OnSuspending;

}

/// <summary>

/// Вызывается, когда приложение запускается

/// пользователем обычным способом

/// Другие входные точки вызываются, когда приложение

/// запускается для открытия файла,

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

/// </summary>

/// <param name=»args»>Информация о параметрах запуска.</param>

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

Frame rootFrame = Window.Current.Content as Frame;

// Не производите повторной инициализации, если

// окно приложения имеет содержимое,

// просто убедитесь, что окно активно

if (rootFrame == null)

{

// Создание объекта класса Frame, который используется

// для навигации между страницами

rootFrame = new Frame();

if (args.PreviousExecutionState ==

ApplicationExecutionState.Terminated)

Страницы и навигация в приложениях 55

{

// TODO: Загрузка данных, если приложение

// восстанавливается из состояния Terminated

}

// Установка объекта класса Frame

// содержимым окна приложения

Window.Current.Content = rootFrame;

}

if (rootFrame.Content == null)

{

// Если стек навигации не был восстановлен,

// переходим на главную страницу

// приложения и передаем данной

// странице параметры запуска приложения

if (!rootFrame.Navigate(typeof(MainPage),

args.Arguments))

{

throw new Exception(«Failed to create initial page»);

}

}

// Гарантируем, что окно приложения является активным

Window.Current.Activate();

}

/// <summary>

/// Сохранение состояния приложения при переходе

/// в приостановленное состояние (suspended)

/// Состояние приложения сохраняется независимо от того,

/// будет ли приложение закрыто (tetminated)

/// или возобновлено (resumed) без необходимости

/// загрузки сохраненных данных,

/// о чем приложение не может знать

/// </summary>

/// <param name=»sender»>Источник запроса.</param>

/// <param name=»e»>Информация о параметрах приостановки.</param>

private void OnSuspending(object sender, SuspendingEventArgs e)

{

var deferral = e.SuspendingOperation.GetDeferral();

// TODO: Сохранение состояния приложения

// и приостановка фоновой активности

deferral.Complete();

}

}

}

56 Глава 4

Класс App, наследуемый от класса Application, установлен в манифесте приложения

Package.appxmanifest в качестве входной точки. Его конструктор выполняется пер-

вым из всего несистемного кода приложения (того кода, что пишете вы). Это свое-

образный аналог функции Main() в традиционных .NET-приложениях (функций

main() или WinMain() в приложениях, написанных на C/C++).

При запуске приложения обычном способом (нажатие на плитку приложения) вы-

зывается метод OnLaunched объекта класса приложения. Приложение состоит из

одного окна, которое по умолчанию занимает все пространство экрана. Содержи-

мое приложения будет находиться в этом окне.

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

ними, в методе OnLaunched создается объект класса Frame. Фрейм будет занимать все

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

цами.

Далее во фрейм загружается главная страница приложения (листинг 4.2).

Листинг 4.2. Переход на главную страницу приложения

rootFrame.Navigate(typeof(MainPage), args.Arguments);

Для этого вызывается функция Navigate объекта фрейма и ей передается тип стра-

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

страницы — MainPage. Вы можете указать класс любой другой страницы. Тогда она

станет главной страницей приложения, открываемой при его запуске. Второй аргу-

мент функции Navigate — параметры, передаваемые загружаемой странице.

Создание новой страницы

Для создания новой страницы в окне Solution Explorer в контекстном меню проек-

та выберите пункт Add | New Item…. Откроется окно, предлагающее выбрать тип

элемента, который мы хотим добавить в проект (рис. 4.1).

Выберите шаблон Basic Page, назовите страницу SecondPage.xaml и нажмите кноп-

ку Add. Будет предложено добавить в проект дополнительные зависимости. От-

ветьте Yes на данный вопрос.

Шаблон Basic Page сложнее, чем рассмотренный нами ранее Blank Page. У Basic

Page есть заголовок страницы, а также кнопка «Назад», отображаемая, когда воз-

можен переход на предыдущую страницу (рис. 4.2).

XAML-разметка страницы SecondPage.xaml приведена в листинге 4.3. Детали,

не рассматриваемые в данной главе, такие как визуальные группы

(VisualStateManager.VisualStateGroups) менеджера состояний, здесь опущены.

Страницы и навигация в приложениях 57

Рис. 4.1. Добавление нового элемента

Рис. 4.2. Вид страницы SecondPage.xaml в дизайнере

58 Глава 4

Листинг 4.3. Разметка страницы SecondPage.xaml

<common:LayoutAwarePage

x:Name=»pageRoot»

…

>

<Page.Resources>

<x:String x:Key=»AppName»>My Application</x:String>

</Page.Resources>

<Grid Style=»{StaticResource LayoutRootStyle}»>

<Grid.RowDefinitions>

<RowDefinition Height=»140″/>

<RowDefinition Height=»*»/>

</Grid.RowDefinitions>

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition Width=»Auto»/>

<ColumnDefinition Width=»*»/>

</Grid.ColumnDefinitions>

<Button x:Name=»backButton» Click=»GoBack»

IsEnabled=»{Binding Frame.CanGoBack, ElementName=pageRoot}»

Style=»{StaticResource BackButtonStyle}»/>

<TextBlock x:Name=»pageTitle» Grid.Column=»1″

Text=»{StaticResource AppName}»

Style=»{StaticResource PageHeaderTextStyle}»/>

</Grid>

<VisualStateManager.VisualStateGroups>

…

</VisualStateManager.VisualStateGroups>

</Grid>

</common:LayoutAwarePage>

Заголовок страницы («My Application») определен в XAML-ресурсах страницы и

отображается в текстовом блоке с именем pageTitle с помощью механизма связы-

вания данных. Кнопка перехода на предыдущую страницу (backButton) также с по-

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

Кнопка перехода на предыдущую страницу использует стиль BackButtonStyle, определенный в файле StandartStyles.xaml, поэтому она и выглядит как круг со

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

Страницы и навигация в приложениях 59

Кроме самой страницы были добавлены файлы, которые можно увидеть в папке

Common (см. рис. 4.2) проекта приложения. Поскольку эти файлы используются

рядом шаблонов (в том числе шаблоном Basic Page), их не рекомендуется переме-

щать, переименовывать или удалять. Назначение данных файлов мы рассмотрим

позже, а сейчас добавим на страницу MainPage.xaml код перехода на страницу

SecondPage.xaml.

Простейший код перехода по нажатию кнопки приведен в листинге 4.4.

Листинг 4.4. Переход на страницу SecondPage.xaml

private async void Button_Click_1(object sender, RoutedEventArgs e)

{

this.Frame.Navigate(typeof(SecondPage));

}

Страницы, в том числе MainPage.xaml, включают ссылку на объект класса Frame,

в котором находятся. Для обращения к фрейму необходимо вызвать одноименное

свойство Frame страницы.

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

элементом управления HyperlinkButton (листинг 4.5).

Листинг 4.5. Элемент управления HyperlinkButton

<HyperlinkButton Content=»Вторая страница» Click=»HyperlinkButtonClick»/>

По событию Click данного элемента управления также должен осуществляться пе-

реход на другую страницу. Код будет аналогичен приведенному в листинге 4.4.

Кроме функции Navigate класс Frame предлагает и другие полезные функции и

свойства (табл. 4.1).

Таблица 4.1. Функции и свойства класса Frame

Функция/свойство Описание

GoBack Переход к последней записи журнала переходов назад в рамках данного приложения. Если в журнале переходов назад нет записей, генерируется исключение

GoForward Переход к последней записи журнала переходов вперед в рамках данного приложения. Если в журнале переходов вперед нет запи-сей, генерируется исключение

CanGoBack Возвращает значение, показывающее, присутствует ли хоть один элемент в журнале переходов назад

CanGoForward Возвращает значение, показывающее, присутствует ли хоть один элемент в журнале переходов вперед

CurrentSourcePageType Возвращает тип страницы, отображаемой в данный момент

60 Глава 4

Анимация при переходе между страницами

При переходе на страницу SecondPage.xaml происходит анимация ее содержимого.

Достигается это благодаря тому, что основной менеджер размещения Grid, в ко-

тором находится содержимое страницы SecondPage.xaml, имеет стиль

LayoutRootStyle (листинг 4.6)

Листинг 4.6. Стиль менеджера размещения Grid

<Grid Style=»{StaticResource LayoutRootStyle}»>

…

</Grid>

Данный стиль определяется в файле StandardStyles.xaml и устанавливает цвет фона и, что еще более важно, анимацию перехода на страницу (листинг 4.7).

Листинг 4.7. Стиль LayoutRootStyle

<Style x:Key=»LayoutRootStyle» TargetType=»Panel»>

<Setter Property=»Background»

Value=»{StaticResource ApplicationPageBackgroundThemeBrush}»/>

<Setter Property=»ChildrenTransitions»>

<Setter.Value>

<TransitionCollection>

<EntranceThemeTransition/>

</TransitionCollection>

</Setter.Value>

</Setter>

</Style>

В данном случае используется анимация перехода EntranceThemeTransition, рабо-тающая при первом появлении элементов. Анимацию перехода можно применить

как к менеджерам размещения, таким как Grid, так и к отдельным элементам.

Windows 8 поддерживает достаточно большой набор стандартных анимационных

эффектов. Для анимации содержимого предназначен эффект ContentThemeTransition.

Доступны и другие анимационные эффекты:

� FadeInThemeAnimation/FadeOutThemeAnimation

� PointerUpThemeAnimation/PointerDownThemeAnimation

� RepositionThemeAnimation/RepositionThemeTransition

� PopInThemeAnimation/PopOutThemeAnimation/PopupThemeTransition

� EdgeUIThemeTransition

� PaneThemeTransition

� AddDeleteThemeTransition

Страницы и навигация в приложениях 61

� DragItemThemeAnimation/DropTargetItemThemeAnimation/ DragOverThemeAnimation

� SwipeHintThemeAnimation/SwipeBackThemeAnimation

В данной книге мы не будем подробно рассматривать стандартные анимационные

эффекты.

Передача параметров между страницами

При переходе на другую страницу ей можно передать объект теоретически любого

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

функции Navigate объекта класса Frame. Однако на практике в качестве парамет-

ров следует передавать только простые типы, такие как int, string, char, Guid

и т. д. Это связано с тем, что ссылка на объект, переданный в качестве параметра,

будет храниться в стеке навигации фрейма, занимая память. Кроме того, при при-

остановке приложения фрейм сможет сериализовать только простые типы.

В листинге 4.8 в качестве параметра передается текстовая строка.

Листинг 4.8. Передача параметра странице

this.Frame.Navigate(typeof(SecondPage), «строковый параметр»);

Для того чтобы обработать переданный параметр, необходимо переопределить ме-

тод OnNavigatedTo на странице, на которую осуществляется переход (листинг 4.9).

В данном случае это страница SecondPage.xaml.

Листинг 4.9. Обработка параметра, передаваемого странице при навигации

public sealed partial class SecondPage : LayoutAwarePage

{

public SecondPage()

{

this.InitializeComponent();

}

protected override void OnNavigatedTo(NavigationEventArgs e)

{

string parameter = e.Parameter as string;

base.OnNavigatedTo(e);

}

protected override void LoadState(Object navigationParameter,

Dictionary<String, Object> pageState)

{

}

62 Глава 4

protected override void SaveState(

Dictionary<String, Object> pageState)

{

}

}

В методе OnNavigatedTo параметр приводится к нужному типу (в нашем случае

к строке). После этого вызывается метод OnNavigateTo базового класса

base.OnNavigatedTo(e). В базовом классе страницы может быть определен код, вы-зываемый при переходе на страницу. Если мы не будем вызывать метод базового класса, данный код не отработает. Поэтому при переопределении (override) мето-дов и функций, связанных с жизненным циклом страниц и приложения в целом, вызывайте методы и функции базовых классов.

В нашем примере страница SecondPage наследуется от класса LayoutAwarePage, в ко-тором есть код, вызываемый при переходе на страницу.

Запустите приложение и перейдите на вторую страницу. После этого вернитесь на начальную страницу. Проверьте работу приложения.

Сохранение состояния страниц и приложения

Шаблон Basic Page использует в качестве базового класса страницы достаточно функциональный класс LayoutAwarePage, который сильно облегчает разработку приложения. Поскольку мы создавали приложение на основе шаблона Blank App, то для поддержки функциональности класса LayoutAwarePage необходимо выпол-нить дополнительные действия. В других шаблонах, таких как Grid App и Split App, необходимый код уже присутствует.

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

ПРИМЕЧАНИЕ

Мы подробнее рассмотрим жизненный цикл Windows Store-приложений в главе 10.

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

Страницы и навигация в приложениях 63

Сохранение и восстановление состояния приложения — сложный процесс. Но нам на помощь приходит класс SuspensionManager, который был добавлен в проект при-ложения со страницей SecondPage.xaml. SuspensionManager сохраняет данные в файл. Не обязательно использовать именно класс SuspensionManager в ваших при-ложениях. Вы можете написать другой механизм сохранения и восстановления со-

стояния при приостановке приложения, но SuspensionManager — это наиболее про-стой способ.

Инициализируем SuspensionManager в файле App.xaml.cs (листинг 4.10).

Листинг 4.10. Инициализация SuspensionManager

protected async override void OnLaunched(LaunchActivatedEventArgs args)

{

Frame rootFrame = Window.Current.Content as Frame;

if (rootFrame == null)

{

rootFrame = new Frame();

SuspensionManager.RegisterFrame(rootFrame, «AppFrame»);

if (args.PreviousExecutionState ==

ApplicationExecutionState.Terminated)

{

try

{

await SuspensionManager.RestoreAsync();

}

catch (SuspensionManagerException)

{

// Ошибка восстановления данных

}

}

// Установка объекта класса Frame

// содержимым окна приложения

Window.Current.Content = rootFrame;

}

if (rootFrame.Content == null)

{

if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))

{

throw new Exception(«Failed to create initial page»);

}

}

Window.Current.Activate();

}

64 Глава 4

private async void OnSuspending(object sender, SuspendingEventArgs e)

{

var deferral = e.SuspendingOperation.GetDeferral();

await SuspensionManager.SaveAsync();

deferral.Complete();

}

Теперь при запуске приложения состояние будет восстанавливаться, а при приос-

тановке — сохраняться. Хочется отметить, что данные не будут сохраняться при

явном закрытии приложения пользователем.

Остается ответить на вопрос, какие именно данные будут сохраняться и восстанав-

ливаться. К сожалению, эти данные необходимо задавать явно.

Шаблон Basic Page содержит методы LoadState и SaveState (листинг 4.11), в кото-

рых можно сохранять и восстанавливать состояние, передавая данные в

SuspensionManager. Сохранение и восстановление данных происходит при уходе со

страницы и переходе на страницу соответственно. Далее мы рассмотрим этот про-

цесс подробнее.

Листинг 4.11. Методы LoadState и SaveState

protected override void LoadState(Object navigationParameter,

Dictionary<String, Object> pageState)

{

}

protected override void SaveState(

Dictionary<String, Object> pageState)

{

}

Также можно добавить данные напрямую в SuspensionManager (листинг 4.12).

Листинг 4.12. Добавление данных напрямую в SuspensionManager

SuspensionManager.SessionState.Add(«ключ», «значение»);

Кэширование страниц

По умолчанию каждый раз при переходе на страницу она создается заново. Ини-

циализируется новый объект класса страницы и вызывается его конструктор. Если

пользователь, скажем, введет текст в текстовое поле на странице и перейдет на дру-

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

Страницы и навигация в приложениях 65

Добавим на страницу SecondPage.xaml текстовое поле и продемонстрируем это

(листинг 4.13).

Листинг 4.13. Добавление текстового поля на страницу

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition Width=»Auto»/>

<ColumnDefinition Width=»*»/>

</Grid.ColumnDefinitions>

<Button x:Name=»backButton» Click=»GoBack»

IsEnabled=»{Binding Frame.CanGoBack, ElementName=pageRoot}»

Style=»{StaticResource BackButtonStyle}»/>

<TextBlock x:Name=»pageTitle» Grid.Column=»1″

Text=»{StaticResource AppName}»

Style=»{StaticResource PageHeaderTextStyle}»/>

</Grid>

<Grid Grid.Row=»1″>

<TextBox x:Name=»txtMain» Width=»250″

VerticalAlignment=»Center»

HorizontalAlignment=»Center»/>

</Grid>

<VisualStateManager.VisualStateGroups>

Запустите приложение и перейдите на вторую страницу. Введите текст в текстовое поле и вернитесь на первую страницу. Перейдя снова на вторую страницу, вы об-

наружите текстовое поле пустым.

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

один и тот же экземпляр класса страницы, задайте свойство NavigationCacheMode.

Если данное свойство установлено в значение Enabled (листинг 4.14), страницы кэшируются, но до тех пор, пока в кэше есть свободное место. Если в кэш будут

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

Листинг 4.14. Установка свойства NavigationCacheMode

public SecondPage()

{

this.InitializeComponent();

this.NavigationCacheMode = NavigationCacheMode.Enabled;

}

66 Глава 4

Если установить свойство NavigationCacheMode страницы в значение Required, то страница будет находиться в кэше независимо от размера свободного места.

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

Но даже включив свойство NavigationCacheMode, при приостановке приложения и последующем его завершении данные (в нашем примере текст, введенный в тек-

стовое поле) будут потеряны. Чтобы сохранять данные при приостановке приложе-

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

Листинг 4.15. Сохранение и загрузка данных

protected override void SaveState(Dictionary<String, Object> pageState)

{

pageState[«text»] = txtMain.Text;

}

protected override void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)

{

if (pageState == null) return;

if (pageState.ContainsKey(«text»))

{

txtMain.Text = pageState[«text»] as string;

}

}

Явно приостановить, возобновить или приостановить и закрыть приложение можно

в режиме отладки с помощью соответствующих кнопок на панели Debug Location в Visual Studio (рис. 4.3). Если указанная панель не отображается, выберите опцию

VIEW | Toolbars | Debug Location.

Протестируйте сохранение данных страницы, а также приостановку и завершение

приложения.

Рис. 4.3. Панель Debug Location

Страницы и навигация в приложениях 67

Открытие ссылок из приложения

Элемент управления HyperlinkButton со свойством NavigateUri позволяет задать ссылку, на которую будет осуществляться переход (листинг 4.16). При этом откро-ется приложение по умолчанию, обрабатывающее протокол ссылки.

Листинг 4.16. Задание ссылки в элемент управления HyperlinkButton

<HyperlinkButton NavigateUri=»http://twitter.com/spugachev» Content=»@spugachev»/>

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

Открыть ссылку можно также из кода с помощью класса Launcher (листинг 4.17).

Листинг 4.17. Открытие ссылки из кода

Launcher.LaunchUriAsync(new Uri(«http://twitter.com/spugachev»));

Также можно задать параметры открытия ссылки (листинг 4.18).

Листинг 4.18. Параметры открытия ссылки

private async void HyperlinkButtonClick(object sender, RoutedEventArgs e)

{

var opts = new LauncherOptions();

opts.TreatAsUntrusted = true;

opts.DisplayApplicationPicker = true;

opts.PreferredApplicationDisplayName = «Мое приложение»;

opts.PreferredApplicationPackageFamilyName = «MyAppFamilyName»;

var success = await Launcher.LaunchUriAsync(

new Uri(«someprotocol://data»), opts);

if (success)

{

// Успешный запуск

}

else

{

// Неудачный запуск

}

}

68 Глава 4

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

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

Если ни одно приложение, обрабатывающее протокол ссылки, не установлено, можно показать диалог установки наиболее подходящего приложения из Windows

Store. Для этого нужно задать отображаемое имя приложения PreferredAppli-

cationDisplayName и имя пакета приложения PreferredApplicationPackage-

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

Класс Launcher кроме ссылок позволяет открыть файлы. Делается это с помощью

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

Возможности напрямую запустить другое приложение у Windows Store-прило-жений нет. Поэтому в большинстве ситуаций для открытия ссылок и файлов потре-

буется класс Launcher.

ПРИМЕЧАНИЕ

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

Итоги

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

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

приложениями.

В следующей главе мы рассмотрим системные темы и ресурсы. Ранее все примеры книги были выполнены в темной цветовой гамме. Далее мы выберем светлую тему оформления.

T�a�a5

Тема оформления

Вы можете явно прописать цвета для элементов управления, текста и фона страниц.

Но сделать так будет достаточно трудно, а самое главное — в большинстве случаев

незачем. Гораздо проще использовать системные стили (либо создать свои собст-

венные стили), благодаря которым все части приложения будут выполнены в еди-

ной цветовой гамме.

Если вы не знакомы с концепцией стилей в языке разметки XAML, откройте при-

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

В наших примерах из третьей и четвертой глав фон страниц задавался с помощью

системной кисти ApplicationPageBackgroundThemeBrush (листинг 5.1).

Листинг 5.1. Задание фона страниц с помощью кисти

<Grid Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

…

</Grid>

Во время работы приложений фон страниц был черным. Но системные стили и кис-

ти, а также другие ресурсы не статичны. Следовательно, цвет фона страницы, ис-

пользующей кисть ApplicationPageBackgroundThemeBrush, будет зависеть от темы,

установленной для приложения. По умолчанию определена темная тема. Рассмот-

рим, как задать светлую тему.

Если вы создавали приложения для Windows Phone, примите во внимание, что

работа с темами в Windows Phone и Windows 8 существенно различается. В Win-

dows Phone тема задается на уровне системы, а в Windows 8 — на уровне прило-

жения.

70 Глава 5

Задание темы для приложения

Создайте новое приложение на основе шаблона Grid App. В приложениях, создан-ных с использованием шаблона Grid App, есть три страницы, главной из которых

является GroupedItemsPage.xaml.

Запустим приложение и посмотрим, как оно выглядит (рис. 5.1).

Рис. 5.1. Работа приложения, использующего тему по умолчанию

Зададим для приложения светлую тему. Делается это в файле App.xaml. Для указа-

ния светлой темы необходимо установить свойство RequestedTheme в значение Light (листинг 5.2).

Листинг 5.2. Задание светлой темы

<Application

x:Class=»ThemeApp.App»

xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation»

xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»

xmlns:local=»using:ThemeApp»

xmlns:localData=»using:ThemeApp.Data»

RequestedTheme=»Light»>

Задайте светлую тему и запустите приложение (рис. 5.2). Все страницы приложе-ния получат светлую тему оформления.

Тема оформления 71

Рис. 5.2. Работа приложения, использующего светлую тему

Задать тему можно также в конструкторе класса App (листинг 5.3).

Листинг 5.3. Программное задание темы

public App()

{

this.InitializeComponent();

this.Suspending += OnSuspending;

RequestedTheme = ApplicationTheme.Light;

}

При работе с визуальным дизайнером в Visual Studio можно выбрать тему, которая

будет использоваться в нем (но не в самом приложении). Для этого откройте окно

Device, которое по умолчанию располагается слева в Visual Studio. Если окна нет,

выберите пункт DESIGN | Device Window в меню. Установите в окне Device необ-

ходимую тему (рис. 5.3).

Кроме светлой и темной тем в окне Device доступны высококонтрастные темы для

тестирования соответствующих режимов работы.

72 Глава 5

Рис. 5.3. Установка темы в окне Device

Отображение текста

Для отображения текста предусмотрен элемент управления TextBlock (листинг 5.4).

Листинг 5.4. Отображение текста

<TextBlock Text=»Какой-то текст» />

Вы можете явно задать гарнитуру, размер шрифта и другие параметры (лис-тинг 5.5).

Листинг 5.5. Явное задание гарнитуры и размера шрифта

<TextBlock Text=»Какой-то текст» FontFamily=»Times New Roman» FontSize=»24″/>

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

СОВЕТ

Одна из общих рекомендаций — не стоит широко использовать размер шрифта меньше 15 пунктов, т. к. такой текст будет трудно читать.

Зададим для текстового блока один из стандартных стилей, например

BasicTextStyle — базовый стиль текста (листинг 5.6).

Листинг 5.6. Задание базового стиля для текста

<TextBlock Text=»Какой-то текст»

Style=»{StaticResource BasicTextStyle}»/>

Тема оформления 73

На рис. 5.4 представлен текст без стиля и с базовым стилем. Старайтесь для всех текстовых блоков устанавливать подходящий стиль, поскольку текст со стилем бу-

дет выглядеть значительно лучше.

Рис. 5.4. Текст без стиля и с базовым стилем

Далее приведены все доступные по умолчанию стили для текстовых блоков:

� PageHeaderTextStyle

� PageHeaderTextStyle

� PageSubheaderTextStyle

� SnappedPageHeaderTextStyle

� HeaderTextStyle

� SubheaderTextStyle

� GroupHeaderTextStyle

� TitleTextStyle

� SubtitleTextStyle

� ItemTextStyle

� BodyTextStyle

� CaptionTextStyle

� BasicTextStyle

� BaselineTextStyle.

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

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

Все перечисленные стили определены в файле StandardStyles.xaml. Вы можете от-

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

Стиль текстовому блоку можно задать и в графическом дизайнере. Для этого выде-лите текстовый блок, в контекстном меню выберите пункты Edit Style | Apply

Resource и далее нужный стиль (рис. 5.6).

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

текстового блока можно добавить разрывы строк и блоки текста с определенными параметрами (листинг 5.7).

Листинг 5.7. Многострочный текстовый блок

<TextBlock Text=»Какой-то текст» Style=»{StaticResource BodyTextStyle}»>

<LineBreak/>

<Run Foreground=»LightGray» FontFamily=»Times New Roman»

FontWeight=»Bold» FontSize=»26″>

Times New Roman Bold 26

</Run>

<LineBreak/>

<Run Foreground=»Red» FontFamily=»Arial» FontSize=»24″>

74 Глава 5

Arial 24

</Run>

</TextBlock>

Вид текстового блока из листинга 5.7 в процессе работы приложения приведен на рис. 5.7.

Рис. 5.5. Текстовые блоки, использующие стандартные стили

Однако если вам в текстовом блоке требуется по-разному оформленный текст,

лучше воспользоваться элементом управления RichTextBlock (не путать с элемен-

том управления для редактирования текста RichEditBox), а не простым TextBlock.

RichTextBlobk также удобен, когда нужно отобразить текст в нескольких колонках.

Далее в книге мы рассмотрим многие стандартные стили, например стили для кно-пок панели приложения. Для поиска подходящего стиля мы рекомендуем открыть файл StandardStyles.xaml, а если нужный стиль является системным, то его можно

найти в документации на MSDN.

Тема оформления 75

Рис. 5.6. Задание стиля текста в графическом интерфейсе

Рис. 5.7. Многострочный текстовый блок

Итоги

В данной главе мы рассмотрели задание темы для Windows Store-приложений. Вы-

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

App.xaml и применяется ко всем страницам приложения.

76 Глава 5

Многие системные стили, например ApplicationPageBackgroundThemeBrush и

ApplicationForegroundThemeBrush, зависят от выбранной темы. Вообще, использова-

ние стилей — это хороший тон. В файле StandardStyles.xaml задано достаточно

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

Например, когда вам нужно отобразить заголовок, просто установите стиль

HeaderTextStyle, а не отдельные значения размера шрифта, начертания и отступа.

В следующей главе мы рассмотрим работу с панелью приложения. Панель прило-

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

Windows Store-приложений.

T�a�a6

Панель приложения

Панель приложения (Application Bar) — один из ключевых элементов управления в

Windows Store-приложениях. Панель приложения может открываться либо сверху страницы, либо снизу. На странице могут быть максимум две панели приложения, одна из которых открывается снизу, другая сверху. Несмотря на то, что название

панели содержит слово Application, из-за которого оно и переводится, как «панель приложения», данная панель задается индивидуально для каждой страницы, а не на

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

страницах.

Панели приложения по умолчанию скрыты и открываются в случае необходимости. Они находятся как бы «вне страницы» и при открытии «наплывают» на ее содержи-мое. Верхняя и нижняя панели приложения открываются и закрываются вместе.

Пользователь может открыть панели приложения щелчком правой кнопкой мыши на странице, либо нажав комбинацию клавиш <Windows>+<Z>, либо проведя

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

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

Используйте панели приложения для размещения элементов навигации, команд и инструментов для пользователей. Однако лучше не помещать в панель приложения критические команды, такие как, например, кнопка входа. Базовые команды долж-

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

Внутри панелей приложения могут находиться любые элементы управления. На-пример, в Internet Explorer панели приложения выполняют одну из главных ролей

во взаимодействии с пользователем (хотя это скорее исключение, чем правило).

На рис. 6.1 панели приложения в Internet Explorer видимы, на рис. 6.2 — скрыты.

78 Глава 6

Рис. 6.1. Вид Internet Explorer при раскрытых панелях приложения

Рис. 6.2. Вид Internet Explorer при скрытых панелях приложения

Панель приложения 79

Internet Explorer — это наглядный пример активного использования панелей при-ложения. Но такое встречается не часто. На большинстве страниц присутствует

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

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

Cоздание панелей приложения

Для добавления панелей приложения необходимо установить свойство

BottomAppBar или TopAppBar страницы (листинг 6.1). Сама панель приложения пред-

ставляет собой элемент управления AppBar.

Листинг 6.1. Задание панелей приложения

<Page

…

>

<Page.TopAppBar>

<AppBar x:Name=»topAppBar» Padding=»10,0,10,0″>

<!— Содержимое верхней панели приложения —>

</AppBar>

</Page.TopAppBar>

<Page.BottomAppBar>

80 Глава 6

<AppBar x:Name=»bottomAppBar» Padding=»10,0,10,0″>

<!— Содержимое нижней панели приложения —>

</AppBar>

</Page.BottomAppBar>

<Grid

Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

</Grid>

</Page>

Разместим в нижней панели приложения три кнопки слева и одну кнопку справа (листинг 6.2). Для этого в панель приложения добавим менеджер размещения Grid с двумя колонками (левая и правая).

Листинг 6.2. Размещение кнопок в панели приложения

<AppBar x:Name=»bottomAppBar» Padding=»10,0,10,0″>

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition />

<ColumnDefinition />

</Grid.ColumnDefinitions>

<StackPanel Orientation=»Horizontal»>

<Button />

<Button />

<Button />

</StackPanel>

<StackPanel Grid.Column=»1″

HorizontalAlignment=»Right» Orientation=»Horizontal»>

<Button />

</StackPanel>

</Grid>

</AppBar>

Все кнопки имеют стандартный вид. Для того чтобы кнопки панели приложения стали круглыми, как положено в соответствии с рекомендациями по дизайну Windows Store-приложений, им нужно назначить соответствующий стиль (систем-ный либо ваш собственный стиль на основе системного). Базовый стиль для кнопок

панели приложения имеет имя AppBarButtonStyle.

Кроме стиля у кнопки должна быть подпись, которую можно задать с помощью

свойства AutomationProperties.Name (листинг 6.3).

Листинг 6.3. Задание стиля и подписи кнопки панели приложения

<Button Style=»{StaticResource AppBarButtonStyle}»

AutomationProperties.Name=»Кнопка»/>

Панель приложения 81

Рис. 6.4. Кнопка со стилем AppBarButtonStyle

На рис. 6.4 изображена кнопка, к которой применен стиль AppBarButtonStyle.

В файле StandardStyles.xaml находится много стилей для кнопок. Все они заком-

ментированы. Раскомментируйте и применяйте нужный стиль. Установим для

оставшихся кнопок нашей панели приложения некоторые из стилей, содержащихся

в файле StandardStyles.xaml (листинг 6.4).

Листинг 6.4. Установка стилей для кнопок панели приложения

<AppBar x:Name=»bottomAppBar» Padding=»10,0,10,0″>

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition/>

<ColumnDefinition/>

</Grid.ColumnDefinitions>

<StackPanel Orientation=»Horizontal»>

<Button Style=»{StaticResource AppBarButtonStyle}»

AutomationProperties.Name=»Кнопка»/>

<Button Style=»{StaticResource PageAppBarButtonStyle}» />

<Button Style=»{StaticResource VideoChatAppBarButtonStyle}»/>

</StackPanel>

<StackPanel Grid.Column=»1″

HorizontalAlignment=»Right» Orientation=»Horizontal»>

<Button Style=»{StaticResource BulletsAppBarButtonStyle}» />

</StackPanel>

</Grid>

</AppBar>

Новый вид панели приложения приведен на рис. 6.5. Обратите внимание, что стили

содержат стандартную подпись к кнопкам. Переопределить подпись можно, задав

свойство AutomationProperties.Name.

Рис. 6.5. Вид панели приложения

82 Глава 6

Еще раз хочется отметить, что стили для кнопок панели приложения в файле

StandardStyles.xaml по умолчанию закомментированы. Вид некоторых из возмож-

ных стилей приведен на рис. 6.6.

На рис. 6.6 изображены далеко не все доступные стили. В реальности их намного

больше.

Рис. 6.6. Вид стилей кнопок панели приложения

Панель приложения 83

Свойство IsSticky

По умолчанию панель приложения закрывается при взаимодействии пользователя со страницей вне панели приложения. Для того чтобы панель приложения закрыва-лась только при явном действии пользователя (нажатие правой кнопки мыши

и т. д.), необходимо задать свойство IsSticky (листинг 6.5).

Листинг 6.5. Установка свойства IsSticky

<AppBar x:Name=»bottomAppBar» IsSticky=»True»>

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

мер IsOpen, регулирующее открытие и закрытие панели приложения.

Отображение всплывающих окон и меню

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

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

Рис. 6.7. Всплывающее окно создания новой плитки

84 Глава 6

ПРИМЕЧАНИЕ

Часто Popup называют Flyout по названию аналогичной концепции в Windows Store-

приложениях, написанных на JavaScript.

Отобразим всплывающее окно по нажатию на кнопку панели приложения (лис-

тинг 6.6). Графический интерфейс всплывающего окна определим в коде. Кроме

того, добавим всплывающему окну анимацию появления (PopupThemeTransition).

Листинг 6.6. Отображение всплывающего окна

private void ButtonClick(object sender, RoutedEventArgs e)

{

Popup popup = new Popup();

popup.IsLightDismissEnabled = true;

Grid panel = new Grid();

panel.Background = bottomAppBar.Background;

panel.Height = 250;

panel.Width = 150;

panel.Transitions = new TransitionCollection();

panel.Transitions.Add(new PopupThemeTransition());

Button btnMain = new Button();

btnMain.Content = «Кнопка»;

btnMain.VerticalAlignment = VerticalAlignment.Center;

btnMain.HorizontalAlignment = HorizontalAlignment.Center;

panel.Children.Add(btnMain);

popup.Child = panel;

var button = (Button)sender;

var transform = button.TransformToVisual(this);

var point = transform.TransformPoint(new Point());

popup.HorizontalOffset = point.X;

popup.VerticalOffset = Window.Current.CoreWindow.Bounds.Bottom —

bottomAppBar.ActualHeight — panel.Height — 4;

popup.IsOpen = true;

}

Вид всплывающего окна приведен на рис. 6.8. Для отображения всплывающего

окна необходимо задать его содержимое (Child), а также местоположение

(HorizontalOffset и VerticalOffset) и установить свойство IsOpen в значение true.

Панель приложения 85

Рис. 6.8. Всплывающее окно

С помощью всплывающего окна можно создать любой графический интерфейс, в том числе и меню, но это неудобно. Для отображения всплывающего меню пред-назначен специальный класс PopupMenu (листинг 6.7).

Листинг 6.7. Создание всплывающего меню

private async void ButtonClick(object sender, RoutedEventArgs e)

{

var popupMenu = new PopupMenu();

popupMenu.Commands.Add(new UICommand(«Начать»));

popupMenu.Commands.Add(new UICommand(«История»));

popupMenu.Commands.Add(new UICommand(«Контакты»));

var button = (Button)sender;

var transform = button.TransformToVisual(this);

var point = transform.TransformPoint(new Point(45, -10));

await popupMenu.ShowAsync(point);

}

Вид всплывающего меню приведен на рис. 6.9. Команды во всплывающее меню

добавляются так же, как и в случае класса MessageDialog, который мы рассматрива-ли ранее. После этого задается положение меню и меню показывается.

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

86 Глава 6

Рис. 6.9. Всплывающее меню

Итоги

Панели приложения присутствуют практически во всех Windows Store-при-

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

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

навигации.

При нажатии кнопок панелей приложения часто отображаются всплывающие окна

и меню. Для этого используются классы Popup и PopupMenu.

T�a�a7

RSS-клиент на основе шаблона Grid App

В главе 5 мы уже кратко рассматривали шаблон Grid App. Там мы меняли тему оформления с темной на светлую, не работая, по сути, с самим содержимым шаб-лона, его кодом и разметкой. В данной главе мы создадим RSS-клиент на основе шаблона Grid App.

ПРИМЕЧАНИЕ

Код RSS-клиента основан на коде из блога С. Сомасегара http://blogs.msdn.com/ b/somasegar/.

Сделать это на удивление просто. Главная страница работающего RSS-клиента приведена на рис. 7.1.

Рис. 7.1. Главная страница RSS-клиента

88 Глава 7

Создайте новый проект Windows Store-приложения на основе шаблона Grid App и назовите его RssApp. В проекте находится папка DataModel, внутри которой раз-мещен файл SampleDataSource.cs (рис. 7.2).

Рис. 7.2. Файл SampleDataSource.cs

Этот файл — один из примеров работы с данными в приложении. Обычно разра-ботчики реализуют свои классы или хотя бы переименовывают существующие. Мы же в целях демонстрации просто модифицируем имеющиеся в шаблоне классы без их переименования.

В файле SampleDataSource.cs находятся три важных класса:

� SampleDataSource

� SampleDataGroup

� SampleDataItem

Шаблон Grid App поддерживает модель приложения, работающего с данными, ко-торые разбиты на группы. В нашем случае группа — это блог, а элемент группы — запись в блоге. Соответственно блоги мы будем представлять с помощью сущест-

вующего класса SampleDataGroup, а записи блогов — с помощью класса

SampleDataItem.

Все страницы приложения будут работать с одними и теми же данными, хранящи-

мися в статическом поле AllGroups класса SampleDataSource.

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

Удалите имеющийся код из класса SampleDataSource. Добавьте статическое поле

_allGroups и свойство AllGroups для хранения блогов, а также функции GetGroup и

RSS-клиент на основе шаблона Grid App 89

GetItem (данные функции были в исходном варианте класса SampleDataSource) для получения групп и элементов группы по идентификатору (листинг 7.1).

Листинг 7.1. Код класса SampleDataSource

public sealed class SampleDataSource

{

public static ObservableCollection<SampleDataGroup> _allGroups =

new ObservableCollection<SampleDataGroup>();

public static ObservableCollection<SampleDataGroup> AllGroups

{

get

{

return _allGroups;

}

}

public static SampleDataGroup GetGroup(string uniqueId)

{

var matches = AllGroups.Where((group) =>

group.UniqueId.Equals(uniqueId));

if (matches.Count() == 1) return matches.First();

return null;

}

public static SampleDataItem GetItem(string uniqueId)

{

var matches = AllGroups.SelectMany(group =>

group.Items).Where((item) => item.UniqueId.Equals(uniqueId));

if (matches.Count() == 1) return matches.First();

return null;

}

}

Теперь необходимо реализовать код загрузки записей из блогов по RSS. Для этого

мы будем использовать класс SyndicationClient из пространства имен

Windows.Web.Syndication. Указанный класс может загружать данные из RSS- или Atom-потока, адрес которого ему передается (листинг 7.2). Но более важно то, что

SyndicationClient умеет не только загружать записи, но и разбирать их, преобразуя в соответствующие объекты. Фактически вам не нужно писать код для разбора RSS, все уже реализовано за вас. При необходимости просто загружать данные по

HTTP, можно было бы воспользоваться классом HttpClient. В случае, когда прото-кол отличается от HTTP, обычно применяется Socket API.

90 Глава 7

Windows 8 предлагает множество классов для работы с сетью. В том числе есть ме-

ханизмы работы с Web-сервисами. Выбор нужного класса зависит от имеющегося

протокола.

Листинг 7.2. Загрузка данных RSS-потока

var feedClient = new SyndicationClient();

var feed = await feedClient.RetrieveFeedAsync(new Uri(feedUrl));

Добавим в класс SampleDataSource функцию AddGroupForFeedAsync, которая будет

асинхронно загружать блоги (листинг 7.3).

Листинг 7.3. Асинхронная загрузка блогов

public static async Task<bool> AddGroupForFeedAsync(string feedUrl)

{

// Если блог уже добавлен, возвращаем false

if (SampleDataSource.GetGroup(feedUrl) != null) return false;

var feedClient = new SyndicationClient();

var feed = await feedClient.RetrieveFeedAsync(new Uri(feedUrl));

var feedGroup = new SampleDataGroup(

uniqueId: feedUrl,

title: feed.Title != null ? feed.Title.Text : null,

subtitle: feed.Subtitle != null ? feed.Subtitle.Text : null,

imagePath: feed.ImageUri != null ?

feed.ImageUri.ToString() : null,

description: null);

AllGroups.Add(feedGroup);

return true;

}

В данной функции создается объект класса SampleDataGroup и добавляется в кол-

лекцию AllGroups.

Теперь необходимо разобраться с записями в блогах. Для записей блогов (элемен-

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

ссылки на них в HTML-разметке самих записей. За поиск изображений будет отве-

чать функция GetImageFromPostContents (листинг 7.4). В ней с помощью регулярно-

го выражения ищутся HTML-теги со значениями свойств src или href, указываю-

щими на файлы с расширением png, jpg или jpeg (например, <img src=»image.jpg» />).

В результате своей работы функция возвращает адрес первого найденного изобра-

жения.

RSS-клиент на основе шаблона Grid App 91

Листинг 7.4. Поиск ссылок на изображения в тексте записей блога

private static string GetImageFromPostContents(SyndicationItem item)

{

var regex = new Regex(

«[src href]\\s*=\\s*(?:\»(?<1>[^\»]*)\»|(?<1>\\S+))»);

var matches = regex.Matches(item.Summary.Text);

return matches.Cast<Match>()

.Where(m =>

{

Uri url;

if (Uri.TryCreate(m.Groups[1].Value, UriKind.Absolute, out url))

{

string ext = Path.GetExtension(url.AbsolutePath).ToLower();

if (ext == «.png» || ext == «.jpg»

|| ext==».jpeg») return true;

}

return false;

})

.Select(m => m.Groups[1].Value)

.FirstOrDefault();

}

Теперь изменим функцию AddGroupForFeedAsync так, чтобы создавать объекты

SampleDataItem из записей блога (листинг 7.5). Для каждой записи мы находим со-ответствующее изображение, а для всего блога устанавливаем изображение первой записи.

Листинг 7.5. Загрузка записей блога

public static async Task<bool> AddGroupForFeedAsync(string feedUrl)

{

// Если блог уже добавлен, возвращаем false

if (SampleDataSource.GetGroup(feedUrl) != null) return false;

var feedClient = new SyndicationClient();

var feed = await feedClient.RetrieveFeedAsync(new Uri(feedUrl));

var feedGroup = new SampleDataGroup(

uniqueId: feedUrl,

title: feed.Title != null ? feed.Title.Text : null,

subtitle: feed.Subtitle != null ? feed.Subtitle.Text : null,

imagePath: feed.ImageUri != null ?

feed.ImageUri.ToString() : null,

description: null);

92 Глава 7

foreach (var i in feed.Items)

{

string imgPath = GetImageFromPostContents(i);

if (imgPath != null && feedGroup.Image == null)

{

feedGroup.SetImage(imgPath);

}

var dataItem = new SampleDataItem(

uniqueId: i.Id,

title: i.Title.Text,

subtitle: null,

imagePath: imgPath,

description: null,

content: i.Summary.Text,

@group: feedGroup);

feedGroup.Items.Add(dataItem);

}

AllGroups.Add(feedGroup);

return true;

}

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

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

Главная страница приложения — GroupedItemsPage.xaml. При загрузке ее состоя-

ния добавим содержимое трех блогов (листинг 7.6).

Листинг 7.6. Загрузка содержимого трех блогов на странице GroupedItemsPage.xaml

protected async override void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)

{

this.DefaultViewModel[«Groups»] = SampleDataSource.AllGroups;

// Примеры блогов

await SampleDataSource.AddGroupForFeedAsync(

«http://blogs.msdn.com/b/mikcher/rss.aspx»);

await SampleDataSource.AddGroupForFeedAsync(

«http://blogs.msdn.com/b/stasus/rss.aspx»);

await SampleDataSource.AddGroupForFeedAsync(

«http://blogs.msdn.com/b/kichinsky/rss.aspx»);

}

RSS-клиент на основе шаблона Grid App 93

Вот и все, что требуется сделать. Мы внесли необходимые изменения, чтобы при-ложение, созданное по шаблону Grid App, использовало наши данные. Запустите

приложение. Блоги будут загружены, и вы увидите нечто похожее на рис. 7.1. На-жмите на один из блогов и перейдите на страницу GroupDetailPage.xaml (рис. 7.3).

Выберите какую-либо запись из блога и перейдите на нее. Откроется страница ItemDetailPage.xaml (рис. 7.4).

Рис. 7.3. Страница GroupDetailPage.xaml

Рис. 7.4. Страница ItemDetailPage.xaml

94 Глава 7

На странице ItemDetailPage.xaml HTML-разметка записи блога отображается в виде

текста. Это не очень хорошо, т. к. HTML-теги не дают возможности нормально чи-

тать текст. Есть несколько вариантов решения данной проблемы. Можно восполь-

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

мально отображающий HTML-разметку. Также можно очистить текст от HTML-

тегов с помощью регулярных выражений.

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

записи и блоги с помощью механизма связывания данных и новых элементов

управления отображаются на экране.

ПРИМЕЧАНИЕ

Если вам не знаком механизм связывания данных, вы можете узнать о нем из прило-

жения 1.

Начнем с уже знакомого нам базового класса страниц LayoutAwarePage. В классе

реализовано свойство DefaultViewModel, которое основано на свойстве-зависимости

(Dependency Property) DefaultViewModelProperty (листинг 7.7).

Листинг 7.7. Свойство DefaultViewModel

public class LayoutAwarePage : Page

{

public static readonly DependencyProperty DefaultViewModelProperty =

DependencyProperty.Register(«DefaultViewModel»,

typeof(IObservableMap<String, Object>),

typeof(LayoutAwarePage), null);

…

protected IObservableMap<String, Object> DefaultViewModel

{

get

{

return this.GetValue(DefaultViewModelProperty)

as IObservableMap<String, Object>;

}

set

{

this.SetValue(DefaultViewModelProperty, value);

}

}

…

}

RSS-клиент на основе шаблона Grid App 95

Свойство DefaultViewModel представляет собой коллекцию «ключ — значение». При

загрузке блогов мы задавали значение для элемента Groups в коллекции

DefaultViewModel (листинг 7.8).

Листинг 7.8. Задание значения для элемента Groups в коллекции DefaultViewModel

this.DefaultViewModel[«Groups»] = SampleDataSource.AllGroups;

В XAML-разметке страницы GroupedItemsPage.xaml свойство DefaultViewModel ус-

танавливается в качестве контекста данных (листинг 7.9).

Листинг 7.9. Установка контекста данных страницы

<common:LayoutAwarePage

x:Name=»pageRoot»

x:Class=»RssApp.GroupedItemsPage»

DataContext=»{Binding DefaultViewModel,

RelativeSource={RelativeSource Self}}»

…

mc:Ignorable=»d»>

Таким образом, на странице доступны все пары «ключ — значение», имеющиеся

в коллекции. В ресурсах страницы находится объект класса CollectionViewSource,

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

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

CollectionViewSource связан с элементом Groups в коллекции DefaultViewModel

(листинг 7.10).

Листинг 7.10. CollectionViewSource

<Page.Resources>

<CollectionViewSource

x:Name=»groupedItemsViewSource»

Source=»{Binding Groups}»

IsSourceGrouped=»true»

ItemsPath=»TopItems»/>

</Page.Resources>

Для отображения данных служит элемент управления GridView, который мы под-

робно рассмотрим в следующей главе (листинг 7.11). GridView позволяет отобра-

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

нии, мы видели на рис. 7.1.

96 Глава 7

Листинг 7.11. Страница GroupedItemsPage.xaml

<common:LayoutAwarePage

x:Name=»pageRoot»

x:Class=»RssApp.GroupedItemsPage»

DataContext=»{Binding DefaultViewModel,

RelativeSource={RelativeSource Self}}»

…

mc:Ignorable=»d»>

<Page.Resources>

<CollectionViewSource

x:Name=»groupedItemsViewSource»

Source=»{Binding Groups}»

IsSourceGrouped=»true»

ItemsPath=»TopItems»/>

</Page.Resources>

<Grid Style=»{StaticResource LayoutRootStyle}»>

<Grid.RowDefinitions>

<RowDefinition Height=»140″/>

<RowDefinition Height=»*»/>

</Grid.RowDefinitions>

<GridView

x:Name=»itemGridView»

AutomationProperties.AutomationId=»ItemGridView»

AutomationProperties.Name=»Grouped Items»

Grid.RowSpan=»2″ Padding=»116,137,40,46″

ItemsSource=

«{Binding Source={StaticResource groupedItemsViewSource}}»

ItemTemplate=»{StaticResource Standard250x250ItemTemplate}»

SelectionMode=»None» IsSwipeEnabled=»false»

IsItemClickEnabled=»True» ItemClick=»ItemView_ItemClick»>

<GridView.ItemsPanel>

<ItemsPanelTemplate>

<VirtualizingStackPanel Orientation=»Horizontal»/>

</ItemsPanelTemplate>

</GridView.ItemsPanel>

<GridView.GroupStyle>

<GroupStyle>

<GroupStyle.HeaderTemplate>

<DataTemplate>

…

</DataTemplate>

</GroupStyle.HeaderTemplate>

RSS-клиент на основе шаблона Grid App 97

<GroupStyle.Panel>

<ItemsPanelTemplate>

<VariableSizedWrapGrid Orientation=»Vertical»

Margin=»0,0,80,0″/>

</ItemsPanelTemplate>

</GroupStyle.Panel>

</GroupStyle>

</GridView.GroupStyle>

</GridView>

…

</Grid>

</common:LayoutAwarePage>

Итоги

В данной главе мы создали простейший RSS-клиент на основе шаблона Grid App.

Мы модифицировали класс источника данных SampleDataSource так, чтобы можно было загружать RSS-ленты. Мы выполнили загрузку данных и отобразили блоги и записи на страницах приложения. На главной странице GroupedItemsPage.xaml

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

T�a�a8

Элементы управления GridView, ListView и FlipView

Графические интерфейсы многих Windows Store-приложений построены на основе элементов управления GridView и ListView, которые служат для отображения кол-лекций данных, наследуются от класса ItemsControl и имеют практически одинако-вый программный интерфейс. GridView отображает данные горизонтально в не-сколько строк, а ListView — вертикально (в большинстве случаев). Оба элемента управления поддерживают группировку, выделение элементов, прокрутку и т. д.

С элементом управления GridView мы уже знакомы по предыдущей главе (см. рис. 7.1). Но у GridView более широкие возможности, чем мы успели рассмот-реть ранее. Например, элементы внутри GridView не обязательно должны быть оди-накового размера. На рис. 8.1 показана страница приложения с элементом управле-ния GridView и разным размером элементов.

Рис. 8.1. Элемент управления GridView

Элементы управления GridView, ListView и FlipView 99

На рис. 8.2 приведен элемент управления

ListView, в котором отображаются те же данные,

что и в GridView на рис. 8.1.

Часто элементы управления GridView и ListView используются совместно на одной странице для

отображения одних и тех же данных. При этом

GridView показывается в обычном режиме, а

ListView — в закрепленном (Snapped). Но

ListView может существовать и отдельно от

GridView, например в почтовом приложении при выводе списка новых сообщений электронной

почты, да и в любом другом сценарии, где тре-буется отображение списков.

Рис. 8.2. Элемент управления

ListView

Элемент управления GridView

Рассмотрим работу с элементом управления GridView. Создайте новое приложение

на основе шаблона Blank App и назовите его ControlsApp.

На страницу MainPage.xaml добавим заголовок и элемент управления GridView

с именем gvMain (листинг 8.1).

Листинг 8.1. Элемент управления GridView

<Page

…

>

100 Глава 8

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»140″/>

<RowDefinition Height=»*»/>

</Grid.RowDefinitions>

<TextBlock Text=»Controls App» Margin=»120,0,30,40″

Style=»{StaticResource PageHeaderTextStyle}»/>

<GridView x:Name=»gvMain» Grid.Row=»1″ Padding=»116,37,40,46″>

</GridView>

</Grid>

</Page>

Теперь нам нужны данные, которые будут отображаться в GridView. Для демонст-

рации мы создадим класс Person, который будет описывать человека и содержать

поля для имени, фамилии и возраста: FirstName, LastName и Age соответственно (листинг 8.2).

Листинг 8.2. Класс Person

public class Person

{

public string FirstName { get; set; }

public string LastName { get; set; }

public int Age { get; set; }

}

В конструкторе страницы MainPage.xaml мы создадим ряд объектов класса Person,

которые поместим в коллекцию типа ObservableCollection<T>. Данный тип коллек-

ции в отличие от других, таких как простые массивы и списки (List<T>), удобен при связывании данных. Обычные коллекции не уведомляют о добавлении и уда-

лении элементов, поэтому если они являются источниками данных для графиче-

ских элементов управления, например для ListView или GridView, то при добавле-нии элемента в коллекцию в графическом интерфейсе новый элемент не отобразит-

ся. В случае с ObservableCollection<T> при добавлении элемента в коллекцию, связанные графические элементы управления будут оповещены. В нашем примере такая функциональность отсутствует, т. к. мы не обновляем коллекцию после ее

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

При работе с элементами управления, наследуемыми от ItemsControl, мы можем

добавлять элементы (Items) несколькими способами. Это можно делать явно, ука-

зывая элементы в коллекции Items (листинг 8.3).

Элементы управления GridView, ListView и FlipView 101

Листинг 8.3. Добавление элементов через коллекцию Items

gvMain.Items.Add(

new Person { LastName = «Иванов», FirstName = «Андрей», Age = 31 });

Но мы выберем другой способ — в конструкторе класса страницы установим

у элемента управления GridView источник данных через свойство ItemsSource (лис-тинг 8.4).

ПРИМЕЧАНИЕ

В главе 7 свойство ItemsSource устанавливалось через механизм связывания данных

в XAML-разметке:

ItemsSource=»{Binding Source={StaticResource groupedItemsViewSource}}»

Листинг 8.4. Установка источника данных у GridView

public sealed partial class MainPage : Page

{

private ObservableCollection<Person> _persons;

public MainPage()

{

this.InitializeComponent();

_persons = new ObservableCollection<Person>();

_persons.Add(new Person { LastName = «Иванов»,

FirstName = «Андрей», Age = 31 });

_persons.Add(new Person { LastName = «Пономарева»,

FirstName = «Ирина», Age = 18 });

…

_persons.Add(new Person { LastName = «Ященко»,

FirstName = «Алла», Age = 24 });

gvMain.ItemsSource = _persons;

}

}

Чтобы сэкономить место в книге, часть данных пропущена. Вы можете добавить

в коллекцию _persons столько объектов класса Person, сколько потребуется.

Запустите приложение. Данные отобразятся в GridView, но совсем не так, как бы нам хотелось (рис. 8.3).

Сейчас отображается только результат вызова функции ToString класса Person. Так как мы не переопределили данную функцию, она возвращает название класса. И на снимке экрана мы видим повторяющиеся надписи «ControlsApp.Person».

102 Глава 8

Рис. 8.3. Отображение данных в GridView

Для того чтобы иметь контроль над отображением элементов внутри GridView, нам

необходимо задать шаблон элемента (ItemTemplate). В целях демонстрации мы до-бавим в проект рисунок Avatar.png, который будет служить изображением для всех

людей. В реальных приложениях изображения будут разными, как это было в слу-чае с записями блогов в главе 7. Зададим шаблон элемента (листинг 8.5). Размер

каждого элемента составляет 160×160 единиц.

Листинг 8.5. Задание шаблона элемента

<GridView x:Name=»gvMain» Grid.Row=»1″ Padding=»116,37,40,46″>

<GridView.ItemTemplate>

<DataTemplate>

<Grid HorizontalAlignment=»Left» Width=»160″ Height=»160″>

<Border Background=»{StaticResource

Элементы управления GridView, ListView и FlipView 103

ListViewItemPlaceholderBackgroundThemeBrush}»>

<Image Source=»/Assets/Avatar.png»

Stretch=»UniformToFill»/>

</Border>

<StackPanel VerticalAlignment=»Bottom»

Background=»{StaticResource

ListViewItemOverlayBackgroundThemeBrush}»>

<TextBlock Text=»{Binding FirstName}»

Foreground=»{StaticResource

ListViewItemOverlayForegroundThemeBrush}»

Style=»{StaticResource TitleTextStyle}»

Margin=»15,0,15,0″/>

<TextBlock Text=»{Binding LastName}»

Foreground=»{StaticResource

ListViewItemOverlayForegroundThemeBrush}»

Style=»{StaticResource TitleTextStyle}»

Margin=»15,0,15,0″/>

<TextBlock Text=»{Binding Age}»

Foreground=»{StaticResource

ListViewItemOverlaySecondaryForegroundThemeBrush}»

Style=»{StaticResource CaptionTextStyle}»

TextWrapping=»NoWrap» Margin=»15,0,15,10″/>

</StackPanel>

</Grid>

</DataTemplate>

</GridView.ItemTemplate>

</GridView>

Внутри шаблона элемента данные связываются со свойствами конкретного экземп-

ляра класса Person.

Запустите приложение. Теперь элементы внутри GridView выглядят по-другому (рис. 8.4). В реальных приложениях вы можете задать такие шаблоны, которые

удовлетворяют вашим потребностям, делая вид элементов в GridView совершенно не похожим на тот, что приведен в наших примерах.

Примите во внимание, что при разном разрешении экрана число строк в GridView может быть различным.

Пришло время подумать о группировке. В главе 7 мы группировали элементы в со-

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

этого создадим класс PersonGroup (листинг 8.6).

104 Глава 8

Рис. 8.4. Отображение данных с шаблоном элемента

Листинг 8.6. Класс PersonGroup

public class PersonGroup

{

public string GroupName { get; set; }

public ObservableCollection<Person> Persons { get; set; }

public PersonGroup()

{

Persons = new ObservableCollection<Person>();

}

}

Имя группы задается свойством GroupName, элементы группы будут добавляться

в коллекцию Persons.

Для отображения групп в GridView нам потребуется класс CollectionViewSource.

Добавим экземпляр данного класса в ресурсы страницы (листинг 8.7).

Листинг 8.7. Класс CollectionViewSource

<Page

…

>

Элементы управления GridView, ListView и FlipView 105

<Page.Resources>

<CollectionViewSource

x:Name=»cvsMain»

IsSourceGrouped=»true»

ItemsPath=»Persons»/>

</Page.Resources>

…

Мы установили свойство IsSourceGrouped в значение true, т. к. хотим работать

с группировкой, а также свойство ItemsPath в значение Persons, поскольку именно

в коллекции Persons класса PersonGroup хранятся элементы группы. Установим

CollectionViewSource источником данных для GridView (листинг 8.8).

Листинг 8.8. Установка CollectionViewSource источником данных для GridView

<GridView x:Name=»gvMain» Grid.Row=»1″ Padding=»116,37,40,46″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

Теперь необходимо назначить источник данных для CollectionViewSource. Мы соз-

дадим группы и добавим в них людей (листинг 8.9).

Листинг 8.9. Инициализация данных

public sealed partial class MainPage : Page

{

private ObservableCollection<PersonGroup> _groups;

public MainPage()

{

this.InitializeComponent();

_groups = new ObservableCollection<PersonGroup>();

var developers = new PersonGroup { GroupName = «Разработчики» };

var designers = new PersonGroup { GroupName = «Дизайнеры» };

var managers = new PersonGroup { GroupName = «Менеджеры» };

_groups.Add(developers);

_groups.Add(designers);

_groups.Add(managers);

developers.Persons.Add(new Person { LastName = «Иванов»,

FirstName = «Андрей», Age = 31 });

…

managers.Persons.Add(new Person { LastName = «Рогова»,

FirstName = «Ольга», Age = 23 });

106 Глава 8

cvsMain.Source = _groups;

}

}

Если сейчас запустить приложение, вы не увидите заголовков групп (см. рис. 8.4). Для отображения заголовков групп необходимо задать соответствующий шаблон (листинг 8.10), в котором заголовок будет содержать имя группы и стрелку, обра-

зующие вместе кнопку. При нажатии на заголовок-кнопку пользователь должен попадать на отдельную страницу выбранной группы. Но данную функциональность

в этом примере мы реализовывать не будем.

Листинг 8.10. Шаблон заголовков групп

<GridView x:Name=»gvMain» Grid.Row=»1″ Padding=»116,37,40,46″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

…

<GridView.GroupStyle>

<GroupStyle>

<GroupStyle.HeaderTemplate>

<DataTemplate>

<Grid Margin=»1,0,0,6″>

<Button

Style=»{StaticResource TextPrimaryButtonStyle}» >

<StackPanel Orientation=»Horizontal»>

<TextBlock Text=»{Binding GroupName}»

Margin=»3,-7,10,10″

Style=»{StaticResource GroupHeaderTextStyle}» />

<TextBlock Text=»{StaticResource ChevronGlyph}»

FontFamily=»Segoe UI Symbol»

Margin=»0,-7,0,10″

Style=»{StaticResource GroupHeaderTextStyle}»/>

</StackPanel>

</Button>

</Grid>

</DataTemplate>

</GroupStyle.HeaderTemplate>

</GroupStyle>

</GridView.GroupStyle>

</GridView>

Запустите приложение. Несмотря на то, что заголовки групп отображаются как на-

до, само приложение выглядит не совсем так, как бы нам хотелось (рис. 8.5).

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

в группах отображались правильно, установим панель для элементов групп

Элементы управления GridView, ListView и FlipView 107

(GroupStyle.Panel). В качестве такой панели мы будем использовать менеджер раз-

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

высоты и ширины GridView (листинг 8.11). Кроме того, зададим отступ между группами (у каждой группы будет соответствующий отступ справа), равный

80 единиц (Margin=»0,0,80,0″).

Рис. 8.5. Вид приложения с заголовками групп

Листинг 8.11. Задание панели для элементов групп

<GridView.GroupStyle>

<GroupStyle>

<GroupStyle.HeaderTemplate>

<DataTemplate>

…

</DataTemplate>

</GroupStyle.HeaderTemplate>

108 Глава 8

<GroupStyle.Panel>

<ItemsPanelTemplate>

<VariableSizedWrapGrid Orientation=»Vertical»

Margin=»0,0,80,0″

ItemWidth=»160″ ItemHeight=»160″/>

</ItemsPanelTemplate>

</GroupStyle.Panel>

</GroupStyle>

</GridView.GroupStyle>

Для VariableSizedWrapGrid мы назначили размер элемента (ячейки), равный

160×160 единиц (ItemWidth=»160″ ItemHeight=»160″).

Так как мы задали размер в новом месте, удалите размер у шаблона элемента

(см. листинг 8.5). Это необходимо, чтобы шаблон мог растягиваться и включать

элементы разного размера.

Осталось задать панель для самих групп (элементов верхнего уровня внутри

GridView). Без этого все группы окажутся одинаковой ширины, а значит, группы,

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

тановим менеджер размещения VirtualizingStackPanel — панель, в которой все

элементы следуют один за другим по вертикали или по горизонтали (в нашем слу-

чае) (листинг 8.12).

СОВЕТ

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

Без группировки в качестве панели верхнего уровня можно установить

VariableSizedWrapGrid.

Листинг 8.12. Установка панели верхнего уровня для элементов в GridView

<GridView.ItemsPanel>

<ItemsPanelTemplate>

<VirtualizingStackPanel Orientation=»Horizontal»/>

</ItemsPanelTemplate>

</GridView.ItemsPanel>

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

Без установки VirtualizingStackPanel в качестве панели верхнего уровня многие

элементы обрезались бы (рис. 8.7).

Из рис. 8.7 видно, что элементы третьей группы менеджеров обрезаны, чтобы соот-

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

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

требуется больше места.

Элементы управления GridView, ListView и FlipView 109

Рис. 8.6. Финальный вид приложения

Рис. 8.7. Вид приложения без установки панели верхнего уровня

для элементов в GridView

110 Глава 8

Задание разного размера для элементов в GridView

Сделаем теперь так, чтобы отдельные элементы внутри групп в GridView могли за-

нимать несколько ячеек в VariableSizedWrapGrid (в менеджере размещения, кото-

рый мы для них установили). Сейчас размер ячейки равен 160×160 единиц. Если элемент будет занимать две ячейки по горизонтали, его длина будет составлять 320 единиц.

Добавим в класс Person свойства HorizontalSize и VerticalSize — число ячеек по вертикали и горизонтали, которое будет занимать элемент (листинг 8.13). По умол-

чанию оба свойства будут иметь значение, равное единице.

Листинг 8.13. Свойства HorizontalSize и VerticalSize

public class Person

{

public string FirstName { get; set; }

public string LastName { get; set; }

public int Age { get; set; }

private int _horizontalSize = 1;

public int HorizontalSize

{

get { return _horizontalSize; }

set { _horizontalSize = value; }

}

private int _verticalSize = 1;

public int VerticalSize

{

get { return _verticalSize; }

set { _verticalSize = value; }

}

}

Установим у некоторых объектов класса Person при их создании произвольные размеры (листинг 8.14).

Листинг 8.14. Задание размеров для объектов класса Person

developers.Persons.Add(new Person { LastName = «Иванов»,

FirstName = «Андрей», Age = 31, HorizontalSize = 2, VerticalSize = 2 });

…

designers.Persons.Add(new Person { LastName = «Ященко»,

FirstName = «Алла», Age = 24, HorizontalSize = 2, VerticalSize = 1 });

Элементы управления GridView, ListView и FlipView 111

designers.Persons.Add(new Person { LastName = «Сидоров»,

FirstName = «Сергей», Age = 42, HorizontalSize = 2, VerticalSize = 1 });

…

designers.Persons.Add(new Person { LastName = «Петров»,

FirstName = «Михаил», Age = 27, HorizontalSize = 1, VerticalSize = 2 });

Подготовка данных завершена.

Один из наиболее удобных способов установки свойств элементов в GridView —

создание своего класса, наследуемого от GridView. В таком классе переопределяется

метод PrepareContainerForItemOverride, в котором для каждого элемента задается занимаемое им число ячеек по ширине и высоте (либо другие произвольные пара-

метры). Создадим класс VariableGridView (листинг 8.15).

Листинг 8.15. Класс VariableGridView

public class VariableGridView : GridView

{

protected override void PrepareContainerForItemOverride(

DependencyObject element, object item)

{

var personItem = item as Person;

if (personItem != null)

{

element.SetValue(VariableSizedWrapGrid.ColumnSpanProperty,

personItem.HorizontalSize);

element.SetValue(VariableSizedWrapGrid.RowSpanProperty,

personItem.VerticalSize);

}

base.PrepareContainerForItemOverride(element, item);

}

}

Мы устанавливаем свойства VariableSizedWrapGrid.ColumnSpanProperty и

VariableSizedWrapGrid.RowSpanProperty для каждого элемента в соответствии с дан-

ными, определенными в объектах класса Person.

Теперь нам необходимо заменить элемент управления GridView на странице

MainPage.xaml на вновь созданный VariableGridView (листинг 8.16).

Листинг 8.16. Замена GridView на VariableGridView

<Page

x:Class=»ControlsApp.MainPage»

…

112 Глава 8

xmlns:local=»using:ControlsApp»

…

>

<Page.Resources>

…

</Page.Resources>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»140″/>

<RowDefinition Height=»*»/>

</Grid.RowDefinitions>

<TextBlock Text=»Controls App» Margin=»120,0,30,40″

Style=»{StaticResource PageHeaderTextStyle}»/>

<local:VariableGridView x:Name=»gvMain»

Grid.Row=»1″ Padding=»116,37,40,46″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

…

</local:VariableGridView>

</Grid>

</Page>

Запустите приложение и посмотрите на результат (рис. 8.8).

Рис. 8.8. Вид приложения с разными размерами элементов в GridView

Элементы управления GridView, ListView и FlipView 113

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

при разрешении экрана 2560×1440 наше приложение выглядит совсем по-другому (рис. 8.9).

Рис. 8.9. Вид приложения при разрешении экрана 2560×1440

Вы можете задавать разный размер элементов при различном разрешении экрана.

Еще один вариант — ограничение максимального числа строк (или столбцов). Для

этого у менеджера размещения VariableSizedWrapGrid необходимо установить

свойство MaximumRowsOrColumns (листинг 8.17).

Листинг 8.17. Свойство MaximumRowsOrColumns

<GroupStyle.Panel>

<ItemsPanelTemplate>

114 Глава 8

<VariableSizedWrapGrid Orientation=»Vertical» Margin=»0,0,80,0″

ItemWidth=»160″ ItemHeight=»160″

MaximumRowsOrColumns=»4″/>

</ItemsPanelTemplate>

</GroupStyle.Panel>

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

Установка разных шаблонов для элементов в GridView

В нашем примере все элементы в группах в GridView были одного и того же класса

Person. Часто в GridView добавляются элементы разных классов, которые необхо-

димо по-разному отображать. Бывают проблемы и с элементами одного класса. На-пример, может потребоваться по-разному отображать менеджеров и дизайнеров, несмотря на то, что все это — объекты одного класса (в нашем примере). Поэтому

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

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

Мы не будем здесь приводить полноценный пример выбора шаблона, а лишь опи-

шем процесс схематично. Допустим, у нас есть классы ClassA и ClassB, для которых необходимы разные шаблоны. Шаблоны для классов определяются в ресурсах при-

ложения. Выбор шаблонов в такой схеме иллюстрирует листинг 8.18.

Листинг 8.18. Класс для выбора шаблона

public class SampleTemplateSelector : DataTemplateSelector

{

protected override DataTemplate SelectTemplateCore(object item,

DependencyObject container)

{

if (item == null) return null;

if (item is ClassA)

{

return (DataTemplate)Application.Current.Resources[

«classATemplate»];

}

if (item is ClassB)

{

return (DataTemplate)Application.Current.Resources[

«classBTemplate»];

}

Элементы управления GridView, ListView и FlipView 115

return (DataTemplate)Application.Current.Resources[

«basicTemplate»];

}

}

После этого в ресурсы страницы добавляется экземпляр созданного нами класса

SampleTemplateSelector, который будет выбирать шаблон элемента в GridView (лис-

тинг 8.19).

Листинг 8.19. Использование класса SampleTemplateSelector

<Page

x:Class=»ControlsApp.MainPage»

…

xmlns:local=»using:ControlsApp»

…

>

<Page.Resources>

…

<local:SampleTemplateSelector x:Key=»templateSelector»/>

</Page.Resources>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

…

<GridView

ItemTemplateSelector=»{StaticResource templateSelector}»>

</GridView>

…

</Grid>

</Page>

Теперь мы можем задавать для каждого элемента свой шаблон.

Контекстное масштабирование (Semantic Zoom)

Контекстное масштабирование (Semantic Zoom) — одна из новых возможностей,

широко применяемая как в самом интерфейсе Windows 8, так и в Windows Store-

приложениях.

При контекстном масштабировании пользователь может увидеть данные в двух

режимах:

116 Глава 8

� низкоуровневом (приближение);

� высокоуровневом (удаление); при этом данные отображаются группами, а поль-зователь может перемещаться между группами.

Контекстное масштабирование осуществляется либо с помощью жеста (такого же, как при масштабировании карты), либо прокручиванием колесика мыши при одно-

временном удерживании клавиши <Ctrl>, либо клавишами <+> и <–> при удержи-вании нажатой клавиши <Ctrl>. Если контекстное масштабирование доступно, то

в правом нижнем углу рядом с полосой прокрутки появляется соответствующая кнопка.

Контекстное масштабирование применимо только к классам, реализующим ин-

терфейс ISemanticZoomInformation. К счастью, элементы управления GridView и

ListView этот интерфейс поддерживают.

Пример контекстного масштабирования в интерфейсе операционной системы — список всех установленных приложений (рис. 8.10).

Рис. 8.10. Список установленных приложений

В режиме приближения (по умолчанию) все приложения отображаются списком. Если у приложения есть больше одного файла (что характерно для классических

Windows-приложений), то файлы группируются по названию приложения. Умень-шив масштаб, мы увидим более высокоуровневый вид (рис. 8.11).

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

Элементы управления GridView, ListView и FlipView 117

Рис. 8.11. Список приложений в высокоуровневом режиме

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

зится соответствующее место низкоуровневого списка.

Для поддержки контекстного масштабирования предусмотрен элемент управления

SemanticZoom, у которого необходимо задать свойства ZoomedInView для низкоуров-

невого вида и ZoomedInView — для высокоуровневого (листинг 8.20).

Листинг 8.20. Элемент управления SemanticZoom

<SemanticZoom>

<SemanticZoom.ZoomedInView>

<!— Низкоуровневый вид —>

</SemanticZoom.ZoomedInView>

<SemanticZoom.ZoomedOutView>

<!— Высокоуровневый вид —>

</SemanticZoom.ZoomedOutView>

</SemanticZoom>

Добавим в наше приложение с GridView поддержку контекстного масштабирования.

Существующий элемент управления GridView будет представлять низкоуровневый

вид. Для высокоуровневого вида нам потребуется еще один элемент GridView

с именем gvZoomedOut и собственными шаблонами (листинг 8.21), т. к. вид групп

при отображении в разных режимах существенно различается.

118 Глава 8

Листинг 8.21. Контекстное масштабирование

<SemanticZoom x:Name=»semanticZoom» Grid.Row=»1″>

<SemanticZoom.ZoomedInView>

<local:VariableGridView x:Name=»gvMain» Padding=»116,37,40,46″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

…

</local:VariableGridView >

</SemanticZoom.ZoomedInView>

<SemanticZoom.ZoomedOutView>

<GridView x:Name=»gvZoomedOut» SelectionMode=»None»

Padding=»116,37,40,46″>

<GridView.ItemTemplate>

<DataTemplate>

<TextBlock

Text=»{Binding Group.GroupName}»

Style=»{StaticResource GroupHeaderTextStyle}»/>

</DataTemplate>

</GridView.ItemTemplate>

<GridView.ItemsPanel>

<ItemsPanelTemplate>

<WrapGrid ItemWidth=»200″ ItemHeight=»200″

MaximumRowsOrColumns=»1″

VerticalChildrenAlignment=»Center» />

</ItemsPanelTemplate>

</GridView.ItemsPanel>

<GridView.ItemContainerStyle>

<Style TargetType=»GridViewItem»>

<Setter Property=»Margin» Value=»4″ />

<Setter Property=»Padding» Value=»10″ />

<Setter Property=»BorderBrush» Value=»Gray» />

<Setter Property=»BorderThickness» Value=»1″ />

<Setter Property=»HorizontalContentAlignment»

Value=»Center» />

<Setter Property=»VerticalContentAlignment»

Value=»Center» />

</Style>

</GridView.ItemContainerStyle>

</GridView>

</SemanticZoom.ZoomedOutView>

</SemanticZoom>

В коде необходимо также установить источник данных для второго элемента

GridView (для высокоуровневого вида). Данные будут браться из существующего источника — объекта класса CollectionViewSource с именем cvsMain. Но мы будем использовать не все данные, а только коллекцию групп. Добавим в конструктор

страницы MainPage установку источника данных для gvZoomedOut (листинг 8.22).

Элементы управления GridView, ListView и FlipView 119

Листинг 8.22. Установка источника данных для gvZoomedOut

public MainPage()

{

this.InitializeComponent();

…

cvsMain.Source = _groups;

gvZoomedOut.ItemsSource = cvsMain.View.CollectionGroups;

}

Все, теперь наше приложение поддерживает контекстное масштабирование. Запус-тите приложение. В правом нижнем углу появится кнопка со знаком «минус» (рис. 8.12).

Рис. 8.12. Вид кнопки

для контекстного

масштабирования

Выполните масштабирование одним из способов: нажатием кнопки, жестом, про-круткой колесика мыши (при нажатой клавише <Ctrl>) или нажатием сочетания клавиш на клавиатуре. Независимо от выбранного вами способа будет осуществлен переход к высокоуровневому виду (рис. 8.13).

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

СОВЕТ

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

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

120 Глава 8

Рис. 8.13. Высокоуровневый вид

Элемент управления ListView

Работа с элементом управления ListView выглядит почти так же, как с GridView.

Создадим ListView, выводящий данные о людях и группах, которые мы отображали

в GridView. Нам необходимо задать соответствующие шаблоны: шаблон элемента и заголовка группы (листинг 8.23).

Листинг 8.23. Элемент управления ListView

<ListView x:Name=»lvMain» Grid.Row=»1″

Margin=»0,-10,0,0″ Padding=»10,0,0,60″ Width=»320″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

<ListView.ItemTemplate>

<DataTemplate>

<Grid Margin=»6″>

<Grid.ColumnDefinitions>

<ColumnDefinition Width=»Auto»/>

<ColumnDefinition Width=»*»/>

</Grid.ColumnDefinitions>

<Border Background=»{StaticResource

ListViewItemPlaceholderBackgroundThemeBrush}»

Width=»60″ Height=»60″>

<Image Source=»/Assets/Avatar.png»

Stretch=»UniformToFill»/>

</Border>

Элементы управления GridView, ListView и FlipView 121

<StackPanel Grid.Column=»1″ Margin=»10,0,0,0″>

<TextBlock Text=»{Binding FirstName}» MaxHeight=»40″/>

Style=»{StaticResource ItemTextStyle}»

<TextBlock Text=»{Binding LastName}»

Style=»{StaticResource CaptionTextStyle}»

TextWrapping=»NoWrap»/>

<TextBlock Text=»{Binding Age}»

Style=»{StaticResource CaptionTextStyle}»

TextWrapping=»NoWrap»/>

</StackPanel>

</Grid>

</DataTemplate>

</ListView.ItemTemplate>

<ListView.GroupStyle>

<GroupStyle>

<GroupStyle.HeaderTemplate>

<DataTemplate>

<Grid Margin=»7,7,0,0″>

<Button

Style=»{StaticResource TextPrimaryButtonStyle}»>

<StackPanel Orientation=»Horizontal»>

<TextBlock Text=»{Binding GroupName}»

Margin=»3,-7,10,10″

Style=»{StaticResource GroupHeaderTextStyle}» />

<TextBlock Text=»{StaticResource ChevronGlyph}»

FontFamily=»Segoe UI Symbol» Margin=»0,-7,0,10″

Style=»{StaticResource GroupHeaderTextStyle}»/>

</StackPanel>

</Button>

</Grid>

</DataTemplate>

</GroupStyle.HeaderTemplate>

</GroupStyle>

</ListView.GroupStyle>

</ListView>

Вид получившегося элемента управления ListView приведен на рис. 8.14.

Обратите внимание на режимы выделения элементов в ListView и GridView. За ре-

жим выделения отвечает свойство SelectionMode, возможные значения которого приведены в табл. 8.1.

Таблица 8.1. Значения свойства SelectionMode

Значение Описание

None Пользователь не может выбрать элементы

Single Пользователь может выбрать только один элемент

122 Глава 8

Таблица 8.1 (окончание)

Значение Описание

Multiple Пользователь может выбрать несколько элементов

Extended Пользователь может выбрать несколько элементов как по одному, так

и сразу, выбрав первый элемент последовательности, а потом, зажав клавишу <Shift>, выбрав последний элемент

Рис. 8.14. Элемент управления

ListView

Элементы управления GridView, ListView и FlipView 123

Элемент управления FlipView

Еще один элемент управления, который мы бы хотели рассмотреть в данной гла-ве, — FlipView — позволяет последовательно пролистывать коллекцию элементов. В каждый момент времени в нем отображается только один элемент коллекции. FlipView так же, как GridView и ListView наследуется от ItemsControl, поэтому у этих трех элементов управления совпадает большая часть программного интер-

фейса. При отображении элемента во FlipView по его бокам находятся кнопки в виде стрелок, которые служат для перехода на предыдущий и последующий эле-менты.

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

Отобразим во FlipView нашу коллекцию объектов класса People. Выберем такой же шаблон элемента, как и в примере с GridView (листинг 8.24).

Листинг 8.24. Элемент управления FlipView

<FlipView ItemsSource=»{Binding Source={StaticResource cvsMain}}» Grid.Row=»1″ Width=»250″ Height=»250″>

<FlipView.ItemTemplate>

<!— Шаблон элемента —>

</FlipView.ItemTemplate>

</FlipView>

Элемент управления FlipView отображает каждого человека по отдельности (рис. 8.15). На рис. 8.15 хорошо видны кнопки для перехода к предыдущему и по-следующему элементам.

ПРИМЕЧАНИЕ

В нашем примере FlipView занимает немного места на экране. Обычно под FlipView отдается бóльшая часть пространства страницы.

Рис. 8.15. Элемент управления FlipView

124 Глава 8

Итоги

Мы рассмотрели работу с элементами управления GridView, ListView и FlipView. Это очень схожие элементы управления, отображающие данные различным обра-

зом. Интерфейс многих приложений строится на основе элементов управления

GridView и ListView. Например, так построены приложения, основанные на шаблоне Grid App, рассмотренном нами в главе 7.

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

(Snapped).

T�a�a9

Закрепленный режим работы

и поддержка различной ориентации

экрана

Как мы уже говорили в главе 1, Windows Store-приложения могут работать в трех

режимах (первые три варианта на рис. 9.1):

� приложение развернуто на весь экран (Full Screen);

� приложение закреплено сбоку экрана (слева или cправа) (Snapped). Ширина

приложения в таком режиме составляет 320 пикселов;

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

занимает все оставшееся пространство (Filled).

Закрепление приложений доступно, если экран имеет разрешение как минимум

1366×768 пикселов. Кроме того, Windows Store-приложения могут работать в ландшафтной и портретной ориентации.

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

ноутбуке или настольном компьютере, воспользуйтесь симулятором, который по-зволяет установить разрешение, необходимое для работы приложений в закреплен-

ном режиме.

Рис. 9.1. Режимы работы приложений

126 Глава 9

Добавим поддержку работы в закрепленном режиме в приложение, созданное нами в главе 8.

Поддержка закрепленного режима

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

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

Например, в обычном режиме отображается элемент управления GridView, а в за-

крепленном — ListView.

Допустим, у нас на странице приложения находятся оба этих элемента управления.

Причем элементов GridView два и они располагаются внутри SemanticZoom (лис-тинг 9.1). Это приложение, с которым мы работали в главе 8.

Листинг 9.1. Разметка страницы MainPage.xaml

<Page

…

>

…

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»140″/>

<RowDefinition Height=»*»/>

</Grid.RowDefinitions>

<TextBlock Text=»Controls App» Margin=»120,0,30,40″

Style=»{StaticResource PageHeaderTextStyle}»/>

<SemanticZoom x:Name=»semanticZoom» Grid.Row=»1″>

<SemanticZoom.ZoomedInView>

<local:VariableGridView x:Name=»gvMain»

Padding=»116,37,40,46″

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

…

</local:VariableGridView >

</SemanticZoom.ZoomedInView>

<SemanticZoom.ZoomedOutView>

<GridView x:Name=»gvZoomedOut»

SelectionMode=»None» Padding=»116,37,40,46″>

…

</GridView>

</SemanticZoom.ZoomedOutView>

</SemanticZoom>

Закрепленный режим работы и поддержка различной ориентации экрана 127

<ListView x:Name=»lvMain» Grid.Row=»1″ Visibility=»Collapsed»

Margin=»0,-10,0,0″ Padding=»10,0,0,60″

Width=»320″ SelectionMode=»Extended»

ItemsSource=»{Binding Source={StaticResource cvsMain}}»>

…

</ListView>

</Grid>

</Page>

По умолчанию элемент управления ListView не виден, т. к. его свойство Visibility установлено в значение Collapsed. Перед нами стоит задача в закрепленном режиме показать элемент управления ListView с именем lvMain и скрыть элемент управле-ния SemanticZoom с именем semanticZoom. При возвращении в полноэкранный режим необходимо все вернуть обратно.

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

Value класса ApplicationView, которое принимает следующие значения:

� Snapped

� Filled

� FullScreenLandscape

� FullScreenPortrait

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

Листинг 9.2. Проверка режима работы приложения

switch (ApplicationView.Value)

{

case ApplicationViewState.Snapped:

{

}

break;

case ApplicationViewState.Filled:

{

}

break;

case ApplicationViewState.FullScreenLandscape:

{

}

break;

case ApplicationViewState.FullScreenPortrait:

{

}

break;

}

128 Глава 9

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

приложения (событие Window.Current.SizeChanged). Хочется напомнить, что в при-мерах книги мы не всегда отписываемся от событий, на которые были подписаны, в реальных приложениях это необходимо. Обычно подписка на события происхо-дит при переходе на страницу, а отписка — при уходе с нее.

Выполним настройку интерфейса в зависимости от режима работы приложения (листинг 9.3).

Листинг 9.3. Настройка интерфейса приложения

public sealed partial class MainPage : Page

{

private ObservableCollection<PersonGroup> _groups;

public MainPage()

{

this.InitializeComponent();

…

Window.Current.SizeChanged += Current_SizeChanged;

}

void Current_SizeChanged(object sender,

WindowSizeChangedEventArgs e)

{

if (ApplicationView.Value == ApplicationViewState.Snapped)

{

semanticZoom.Visibility = Visibility.Collapsed;

lvMain.Visibility = Visibility.Visible;

}

else

{

semanticZoom.Visibility = Visibility.Visible;

lvMain.Visibility = Visibility.Collapsed;

}

}

}

Запустите приложение. Теперь в полноэкранном и закрепленном режиме его ин-терфейс будет выглядеть по-разному (рис. 9.2).

В закрепленном режиме на снимке экрана видно второе приложение (Bing

Weather), работающее в режиме Filled.

Вы также можете выбрать режим работы и разрешение экрана дизайнера в Visual Studio. Для этого необходимо указать соответствующие настройки в окне Device. За режим отображения страниц в дизайнере отвечает параметр View (рис. 9.3).

Закрепленный режим работы и поддержка различной ориентации экрана 129

Рис. 9.2. Полноэкранный и закрепленный режимы работы приложения

130 Глава 9

Рис. 9.3. Выбор режима отображения приложения в дизайнере

Visual State Manager

Страницы приложений, созданные на основе сложных шаблонов, например Grid App, а также страницы, включающие такие шаблоны, как Basic Page, наследуются от базового класса LayoutAwarePage. Данный класс имеет богатую функциональ-ность, часть которой мы уже рассмотрели ранее. Сейчас для нас важно, что LayoutAwarePage, кроме всего прочего, упрощает поддержку режимов работы при-ложений.

Приложение RSS-клиент из главы 7 содержит на странице GroupedItemsPage.xaml разметку визуальных групп состояний, которые определяют вид интерфейса при-ложения в различных режимах работы (листинг 9.4).

Листинг 9.4. Определение состояний пользовательского интерфейса

<common:LayoutAwarePage

… >

…

<Grid Style=»{StaticResource LayoutRootStyle}»>

…

<GridView x:Name=»itemGridView» … >

…

</GridView>

Закрепленный режим работы и поддержка различной ориентации экрана 131

<ListView x:Name=»itemListView»

… >

…

</ListView>

<Grid>

…

<Button x:Name=»backButton» Click=»GoBack»

IsEnabled=»{Binding Frame.CanGoBack, ElementName=pageRoot}»

Style=»{StaticResource BackButtonStyle}»/>

<TextBlock x:Name=»pageTitle» Text=»{StaticResource AppName}»

Grid.Column=»1″ IsHitTestVisible=»false»

Style=»{StaticResource PageHeaderTextStyle}»/>

</Grid>

<VisualStateManager.VisualStateGroups>

<VisualStateGroup x:Name=»ApplicationViewStates»>

<VisualState x:Name=»FullScreenLandscape»/>

<VisualState x:Name=»Filled»/>

<VisualState x:Name=»FullScreenPortrait»>

<Storyboard>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»backButton»

Storyboard.TargetProperty=»Style»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»{StaticResource PortraitBackButtonStyle}»/>

</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»itemGridView»

Storyboard.TargetProperty=»Padding»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»96,137,10,56″/>

</ObjectAnimationUsingKeyFrames>

</Storyboard>

</VisualState>

<VisualState x:Name=»Snapped»>

<Storyboard>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»backButton»

Storyboard.TargetProperty=»Style»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»{StaticResource SnappedBackButtonStyle}»/>

</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»pageTitle»

132 Глава 9

Storyboard.TargetProperty=»Style»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»{StaticResource

SnappedPageHeaderTextStyle}»/>

</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»itemListView»

Storyboard.TargetProperty=»Visibility»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»Visible»/>

</ObjectAnimationUsingKeyFrames>

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»itemGridView»

Storyboard.TargetProperty=»Visibility»>

<DiscreteObjectKeyFrame KeyTime=»0″

Value=»Collapsed»/>

</ObjectAnimationUsingKeyFrames>

</Storyboard>

</VisualState>

</VisualStateGroup>

</VisualStateManager.VisualStateGroups>

</Grid>

</common:LayoutAwarePage>

За работу с состояниями и обеспечение переходов между ними отвечает Visual State

Manager (VSM, менеджер визуальных состояний). Состояния задаются декларатив-

но в XAML-разметке. Вы определяете несколько состояний, отвечающих за разные

режимы работы, а VSM возьмет всю остальную работу на себя. Базовый класс

страниц LayoutAwarePage подписывается на изменение размера окна приложения и

при смене режима работы сообщает VSM о том, что нужно перейти в новое состоя-

ние. Далее VSM сам делает всю оставшуюся работу.

Если вы хотите использовать VSM на страницах, не наследуемых от LayoutAwarePage,

то можете скопировать код работы с VSM из класса LayoutAwarePage. Сам класс

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

VisualStateManager.GoToState.

С помощью вкладки Device в Visual Studio можно выбрать текущее состояние стра-

ниц в режиме дизайна.

Итак, при работе с VSM необходимо определить одно или несколько состояний,

имя которых совпадает с одним из режимов работы приложения. В разметке со-

стояния задается раскадровка (Storyboard), содержащая произвольные анимации

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

для закрепленного состояния.

Закрепленный режим работы и поддержка различной ориентации экрана 133

Листинг 9.5. Разметка закрепленного состояния

<VisualState x:Name=»Snapped»>

<Storyboard>

…

<ObjectAnimationUsingKeyFrames

Storyboard.TargetName=»itemListView»

Storyboard.TargetProperty=»Visibility»>

<DiscreteObjectKeyFrame KeyTime=»0″ Value=»Visible»/>

</ObjectAnimationUsingKeyFrames>

…

</Storyboard>

</VisualState>

Анимация в листинге 9.5 реализована для элемента управления ListView с именем

itemListView. Для него задается свойство Visibility, которое в нулевую секунду

устанавливается в значение Visible.

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

состояния) не требуется, т. к. VSM автоматически вернет всем свойствам значения,

которые они имели до перехода в конкретное состояние. Поэтому в состоянии

FullScreenPortrait никакие свойства для элемента управления ListView не зада-

ются.

Visual State Manager широко применяется не только для определения визуальных

состояний режимов работы приложения, но и в шаблонах элементов управления,

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

стояниях. Вы можете использовать Visual State Manager везде, где в зависимости от

состояний требуется настройка внешнего вида.

Масштабирование изображений в зависимости от плотности пикселов

Разные устройства различаются не только разрешением экрана, но и плотностью

пикселов (PPI, Pixels Per Inch — число пикселов на дюйм). К примеру, 27-дюй-

мовый экран может иметь разрешение 2560×1440. Разрешение экрана одного

10-дюймового планшета может быть таким же, а другого — 1024×768, что значи-

тельно меньше. Если при одной и той же диагонали экрана разрешение одного

устройства составляет 2560×1440, а другого — 1024×768, значит, в каждом квад-

ратном сантиметре экрана первого устройства в несколько раз больше пикселов,

чем на той же площади экрана второго устройства (PPI указывают не в квадратных

сантиметрах, а в квадратных дюймах).

Windows 8 масштабирует интерфейс Windows Store-приложений так, чтобы на уст-

ройствах с одинаковым размером экрана физические размеры элементов интерфей-

134 Глава 9

са были согласованы независимо от величины PPI. Если бы Windows это не делала,

то на устройствах с высоким значением PPI элементы управления были слишком

маленькими. На сенсорных экранах в них трудно попасть пальцем. Текст неприго-

ден для чтения. Масштаб интерфейса приложений и системы может принимать

следующие значения:

� 100% — масштаб не изменяется;

� 140% — на устройствах с разрешением от 1920×1080 и PPI от 174;

� 180% — на устройствах с разрешением от 2560×1440 и PPI от 240.

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

фейс и векторные изображения, созданные на языке разметки XAML, будут авто-матически масштабированы.

СОВЕТ

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

Сложности возникают с растровыми изображениями, например в формате PNG или JPEG. Качество таких изображений ухудшается при масштабировании. Маленькие

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

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

При наличии в приложении растровой графики желательно подготовить изображе-

ния для разных масштабов. Изображения для больших масштабов должны иметь бóльшее разрешение. Например, подготовим для логотипа нашего приложения три изображения и добавим их в проект:

� logo.scale-100.png с разрешением 100×100;

� logo.scale-140.png — 210×210;

� logo.scale-180.png — 270×270.

Отобразим логотип в XAML-разметке страницы приложения (листинг 9.6).

Листинг 9.6. Отображение логотипа

<Image Source=»logo.png» Width=»100″ Height=»100″/>

ВНИМАНИЕ!

Обратите внимание, что мы в качестве файла изображения указали logo.png. Такого файла в проекте нет. Операционная система автоматически выберет файл, подходя-щий для текущего масштаба, из трех имеющихся.

Закрепленный режим работы и поддержка различной ориентации экрана 135

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

� scale-100\logo.png;

� scale-140\logo.png;

� scale-180\logo.png.

В каждой из папок должны находиться изображения для соответствующего мас-

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

Итоги

Мы рассмотрели работу приложений в закрепленном (Snapped) режиме, который

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

тельский интерфейс из кода.

Более мощный способ настройки состояний пользовательского интерфейса — ис-

пользование Visual State Manager (VSM). Базовый класс страниц LayoutAwarePage поддерживает и упрощает работу с VSM.

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

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

T�a�a10

Модель исполнения приложений. Многозадачность через фоновые задачи

Прежде чем перейти к рассмотрению многозадачности применительно к Win-

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

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

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

ский пример реализации такой многозадачности — все предыдущие версии Windows.

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

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

Логичным шагом со стороны производителя операционных систем, которые долж-

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

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

Модель исполнения приложений

В отличие от классических, Windows Store-приложения работают только тогда, когда находятся на экране. После запуска Windows Store-приложения переходят

в активное состояние и выполняются.

Модель исполнения приложений. Многозадачность через фоновые задачи 137

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

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

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

к нему. Если такого возвращения не происходит, приложение приостанавливается (Suspended). В этом состоянии приложение находится в памяти, но не исполняется.

Если системе будет не хватать ресурсов, приостановленное приложение может быть выгружено из памяти (Terminated). Состояния и переход между ними в Win-dows Store-приложениях иллюстрирует рис. 10.1.

Рис. 10.1. Состояния Windows Store-приложений

После выгрузки приложения все несохраненные данные теряются. Поэтому, как мы уже говорили в главе 4, необходимо явно сохранять и загружать данные при приос-тановке и запуске приложения. Если приложение было приостановлено и потом

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

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

События жизненного цикла обрабатываются в коде класса приложения в файле

App.xaml.cs. При обычном запуске приложения вызывается метод OnLaunched, при

приостановке — метод OnSuspending (листинг 10.1). Мы рассмотрели работу с дан-ными методами, а также сохранение состояния страниц в главе 4.

Листинг 10.1. События активизации и остановки в App.xaml.cs

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

…

}

138 Глава 10

private void OnSuspending(object sender, SuspendingEventArgs e)

{

…

}

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

приложения по значению свойства PreviousExecutionState аргумента args можно определить предыдущее состояние приложения. Далее приведены возможные зна-

чения свойства PreviousExecutionState:

� NotRunning — данное состояние является предыдущим после установки прило-жения, перезагрузки компьютера или выхода из сессии пользователем (log off), а также после прерывания выполнения приложения из диспетчера задач.

� Running — данное состояние является предыдущим, если приложение уже было запущено, но пользователь активизировал приложение еще раз, например, нажа-тием на вторичную плитку (Secondary tile).

� Suspended — приложение было активизировано при переходе или после перехо-да в приостановленное состояние.

� Terminated — приложение было успешно приостановлено и впоследствии вы-гружено. Качественно написанное приложение должно корректно восстанавли-вать данные, сохраненные при переходе в состояние Suspended, при запуске из состояния Terminated.

� ClosedByUser — приложение было закрыто пользователем.

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

вующий метод вместо OnLaunched. В случае поиска таким методом будет

OnSearchActivated (листинг 10.2).

Листинг 10.2. Метод активизации по контракту «Поиск»

protected override void OnSearchActivated(SearchActivatedEventArgs args) {

…

}

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

ПРИМЕЧАНИЕ

Работу с контрактом поиска мы рассмотрим в главе 13.

Хочется также отметить, что обычно код методов OnLaunched и OnSearchActivated в значительной степени повторяет друг друга. Это касается настройки фрейма при-ложения и обработки предыдущих состояний. Хорошая практика — вынос общего кода во вспомогательный метод.

Модель исполнения приложений. Многозадачность через фоновые задачи 139

Реализация сценариев многозадачности

Несмотря на то, что активными могут быть только находящиеся на экране Windows Store-приложения (таких может быть от одного до двух), в распоряжении разработчика есть специальные возможности платформы, позволяющие выполнять определенные задачи, даже если приложение не запущено. К ним относится созда-ние фоновых задач, возможность проигрывания музыки, загрузки/выгрузки файлов в фоновом режиме, реакция на системные события, такие как приход нового СМС-сообщения, и т. д. Также можно создавать различного рода уведомления. К ним мы вернемся позже, а сейчас кратко остановимся на задачах, которые разработчик мо-жет исполнять в фоновом режиме.

Фоновая загрузка/выгрузка файлов

Для загрузки файлов по сети применяется класс BackgroundDownloader, для выгрузки

на сервер — BackgroundUploader. Файлы загружаются (выгружаются) независимо от того, работает ли приложение, инициировавшее загрузку (выгрузку), в данный мо-мент.

Поддерживаются запросы по протоколам HTTP и HTTPS (как GET, так и POST) для загрузки (скачивания) файлов и запросы по протоколам HTTP и HTTPS (только POST) для выгрузки файлов на сервер. При этом поддерживается базовая автори- зация.

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

Создайте новый проект Windows Store-приложения на основе шаблона Blank App и назовите его DownloadApp. Добавьте на страницу MainPage.xaml кнопку с именем

btnStartDownload и текстовый блок с именем tbDownloadProgress (листинг 10.3).

Листинг 10.3. Разметка страницы MainPage.xaml

<Grid Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

<StackPanel>

<Button x:Name=»btnStartDownload» Content=»Скачать файл»

Margin=»24″ Height=»42″ Width=»126″/>

<TextBlock x:Name=»tbDownloadProgress» Margin=»24″

TextWrapping=»Wrap» Text=»Загрузка не начата»

Style=»{StaticResource HeaderTextStyle}»/>

</StackPanel>

</Grid>

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

Мы должны сообщить системе, откуда необходимо скачать файл, а также куда его требуется положить. Файл будет скачан из Интернета в локальную папку приложе-ния. Создание файла в локальной папке приложения иллюстрирует листинг 10.3.

140 Глава 10

Листинг 10.3. Создание файла в локальной папке приложения

StorageFile destinationFile = await ApplicationData.Current.LocalFolder.CreateFileAsync(«file.dat»);

С помощью объекта класса BackgroundDownloader мы создаем операцию загрузки

файла (объект класса DownloadOperation). При этом необходимо указать адрес за-

грузки и целевой локальный файл (его мы как раз и создали в листинге 10.3).

Для того чтобы начать загрузку, необходимо вызвать метод StartAsync. Код загруз-

ки файла приведен в листинге 10.4.

Листинг 10.4. Загрузка файла

public sealed partial class MainPage : Page

{

private CancellationTokenSource _cancellationTokenSource =

new CancellationTokenSource();

public MainPage()

{

this.InitializeComponent();

}

private async void btnStartDownload_Click(object sender,

RoutedEventArgs e)

{

try

{

// Адрес файла

Uri source = new Uri(«http://www.адрес_файла.ru/file.dat»);

StorageFile destinationFile = await

ApplicationData.Current.LocalFolder.CreateFileAsync(«file.dat»);

var downloader = new BackgroundDownloader();

DownloadOperation download = downloader.CreateDownload(source,

destinationFile);

var asyncOperation = download.StartAsync();

var task = asyncOperation.AsTask(

_cancellationTokenSource.Token,

new Progress<DownloadOperation>(DownloadProgress));

}

Модель исполнения приложений. Многозадачность через фоновые задачи 141

catch (Exception ex)

{

// Обработка ошибок

}

}

private void DownloadProgress(DownloadOperation obj)

{

var progress = (int)(obj.Progress.BytesReceived * 100 /

obj.Progress.TotalBytesToReceive);

tbDownloadProgress.Text = String.Format(«{0}% {1}», progress,

obj.ResultFile.Name);

}

}

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

будет отменить загрузку (листинг 10.5).

Листинг 10.5. Преобразование асинхронной операции в объект класса Task

var task = asyncOperation.AsTask(

_cancellationTokenSource.Token,

new Progress<DownloadOperation>(DownloadProgress));

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

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

Для этого создадим метод AttachToProccesses, в котором будем получать текущие

загрузки, вызывая функцию BackgroundDownloader.GetCurrentDownloadsAsync. В на-шем примере мы будем брать только одну загрузку и отображать ее статус.

Листинг 10.6. Получение текущих загрузок

public MainPage()

{

this.InitializeComponent();

AttachToProcesses();

}

142 Глава 10

private async void AttachToProcesses()

{

try

{

var downloads = await

BackgroundDownloader.GetCurrentDownloadsAsync();

var download = downloads.FirstOrDefault();

if (download != null)

{

var task = download.AttachAsync().AsTask(

_cancellationTokenSource.Token,

new Progress<DownloadOperation>(DownloadProgress));

}

}

catch (Exception ex)

{

// Обработка ошибок

}

}

Теперь после перезапуска приложения у нас снова будет отображаться статус за-

грузки, если она к этому времени еще не была завершена.

Фоновые задачи

В общем случае Windows Store-приложения не могут работать в фоновом режиме.

Вы не можете выполнять произвольный код неопределенно долго независимо от

того, работает ли пользователь с вашим приложением или нет. Но вы можете соз-

дать фоновые задачи, которые вызываются системой при наступлении определен-

ных событий (например, приход СМС-сообщения) и при заданных условиях (на-

пример, когда есть подключение к Интернету). Разработчик выбирает одно из со-

бытий — триггеров (свои триггеры определять нельзя) и может по желанию

добавить (или не добавлять) условия.

Фоновые задачи должны быть определены в отдельной сборке (Assembly, DLL-

файле). Они работают в другом процессе независимо от основного приложения, но

имеют доступ к данным приложениям (файлам, плиткам и т. д.).

Пользователь может отключить фоновые задачи, поэтому не стоит думать, что они

будут работать в любом случае. Прежде чем создавать фоновую задачу, необходи-

мо понять, действительно ли она нужна. Обновления плиток и оповещения не ре-

комендуется реализовывать посредством фоновых задач, лучше делать это по сети

с помощью WNS (Windows Push Notification Services — сервис уведомлений

Windows). Сетевые Push-уведомления будут более оперативны и надежны, чем за-

Модель исполнения приложений. Многозадачность через фоновые задачи 143

прос и обновление информации из фоновых задач (которые к тому же могут быть

отключены).

Работа и возможности фоновых задач существенно отличаются в зависимости от

того, имеет ли приложение доступ на экран блокировки (Lock Screen) или нет.

Экран блокировки отображается при блокировке компьютера, после перезагрузки и

при выходе из спящего режима (рис. 10.2).

Рис. 10.2. Экран блокировки (изображение взято из блога команды разработки Windows http://blogs.msdn.com/b/b8/archive/2012/06/14/building-the-mail-app.aspx)

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

бэйджи (индикатор событий приложения), текст последнего уведомления, отобра-

жаемый на плитке приложения, а также их всплывающие уведомления будут ото-

бражаться даже поверх экрана блокировки.

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

что одновременно такой доступ могут иметь не более семи приложений. Если сво-

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

существующих (рис. 10.3).

Так вот, в зависимости от того, имеет ли доступ приложение к экрану блокировки

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

Более того, фоновые задачи будут иметь и разные ограничения по времени выпол-

нения (табл. 10.1).

В табл. 10.1 указано не реальное время, а чистое процессорное время. Например,

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

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

144 Глава 10

к экрану блокировки, могут использовать 2 секунды процессорного времени каж-

дые 15 минут. Через 15 минут счетчик использованного процессорного времени

обнуляется.

Рассмотрим существующие типы триггеров (табл. 10.2).

Рис. 10.3. Настройка приложений, имеющих доступ к экрану блокировки

Таблица 10.1. Ограничения на время выполнения фоновых агентов

Вид приложения Квота процессорного

времени Интервал обновления квоты

Приложения, имеющие доступ к экрану блокировки

2 секунды процессорного времени

15 минут

Приложения, не имеющие доступа к экрану блокировки

1 секунда процессорного времени

2 часа

Таблица 10.2. Типы триггеров

Тип триггера Описание

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

Модель исполнения приложений. Многозадачность через фоновые задачи 145

Таблица 10.2 (окончание)

Тип триггера Описание

MaintenanceTrigger

и TimeTrigger Данные типы триггеров служат для выполнения периодических

задач в фоне. TimeTrigger работает всегда, но требует доступа

приложения к экрану блокировки. В отличие от него

MaintenanceTrigger такого доступа не требует, но при этом

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

PushNotificationTrigger Триггер, позволяющий обрабатывать Push-уведомления типа Raw (уведомления рассматриваются в главе 11). Данный тип тригге-ров требует доступа приложения к экрану блокировки

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

В табл. 10.3 приведены системные события, по которым может срабатывать

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

Таблица 10.3. События SystemEventTrigger

Событие Описание

InternetAvailable Появился доступ к Интернету

NetworkStateChange Изменилось состояние сетевого подключения. Например, подключение по Wi-Fi сменилось на подключение по 3G

OnlineIdConnectedStateChange Изменился идентификатор, связанный с аккаунтом

ServicingComplete Система завершила обновление приложения

LockScreenApplicationAdded Приложение получило доступ к экрану блокировки

LockScreenApplicationRemoved Приложение потеряло доступ к экрану блокировки

ControlChannelReset* Сброс зарегистрированного канала

SessionConnected* Пользователь вошел в систему

SmsReceived Получение СМС-сообщения

TimeZoneChange Изменилась временная зона, установленная на устройстве, включая переход на зимнее и летнее время

UserAway* Пользователь отошел

UserPresent* Пользователь вернулся

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

146 Глава 10

триггера не будет иметь смысла, если Интернет недоступен. В этом случае необхо-

димо добавить условие InternetAvailable. Перечень возможных условий приведен в табл. 10.4.

Таблица 10.4. Условия срабатывания триггеров

Условие Описание

InternetAvailable Интернет доступен

InternetNotAvailable Интернет недоступен

SessionConnected Пользователь вошел в систему

SessionDisconnected Пользователь не вошел в систему

UserNotPresent Пользователь отошел

UserPresent Пользователь на месте

Создание фоновой задачи

Создадим фоновую задачу, вызываемую при изменении временнóй зоны. Поддерж-ка фоновых задач должна быть указана в манифесте приложения, они определяют-

ся в отдельной сборке и реализуют интерфейс IBackgroundTask.

Создайте новое приложение на основе шаблона Blank App и назовите его TasksApp. Чтобы создать фоновую задачу, добавим в наше решение (solution) еще один про-

ект типа Windows Runtime Component. Для этого в окне Solution Explorer в контек-стном меню решения Solution ‘TasksApp’ (1 project) выберите пункт Add | New

Project… В открывшемся диалоговом окне укажите тип проекта — Windows Runtime Component и имя проекта — TasksComponent. Подключите в основной проект Windows Store-приложения ссылку на вновь созданный проект. Для этого в

контекстном меню раздела References основного проекта выберите пункт Add

Reference… и в открывшемся диалоговом окне укажите проект TasksComponent.

Вид окна Solution Explorer после добавления проекта фоновой задачи приведен на рис. 10.4.

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

ответствующего события операционная система не сможет найти фоновую задачу.

Добавьте в проект TasksComponent простейшую реализацию фоновой задачи (лис-

тинг 10.7).

Листинг 10.7. Простейшая реализация фоновой задачи

public sealed class SampleBackgroundTask : IBackgroundTask

{

public void Run(IBackgroundTaskInstance taskInstance)

Модель исполнения приложений. Многозадачность через фоновые задачи 147

{

var deferral = taskInstance.GetDeferral();

try

{

// Выполнение работы фоновой задачи

}

finally

{

deferral.Complete();

}

}

}

Рис. 10.4. Вид окна Solution Explorer

После этого необходимо указать фоновую задачу SampleBackgroundTask в манифесте основного приложения. Откройте файл Package.appxmanifest и на вкладке Declarations добавьте декларацию типа Background Tasks. Среди поддерживаемых типов задач выберите System Event, а в качестве входной точки (Entry point) ука-жите TasksComponent.SampleBackgroundTask (рис. 10.5).

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

Для регистрации фоновых задач предусмотрен класс BackgroundTaskBuilder. Про-цесс очень прост. При регистрации необходимо передать экземпляр триггера, кото-рый мы предварительно создадим (листинг 10.8).

148 Глава 10

Рис. 10.5. Создание декларации фоновой задачи в манифесте приложения

Листинг 10.8. Регистрация фоновой задачи

private void ButtonRegisterClick(object sender, RoutedEventArgs e)

{

var timerTrigger = new

SystemTrigger(SystemTriggerType.TimeZoneChange, false);

var builder = new BackgroundTaskBuilder();

builder.Name = «SampleBackgroundTask»;

builder.TaskEntryPoint = «TasksComponent.SampleBackgroundTask»;

builder.SetTrigger(timerTrigger);

BackgroundTaskRegistration task = builder.Register();

}

В конструкторе класса триггера SystemTrigger мы указали тип события, на которое

хотим подписаться. В данном случае это смена часового пояса (TimeZoneChange).

Модель исполнения приложений. Многозадачность через фоновые задачи 149

При построении фоновой задачи с помощью класса BackgroundTaskBuilder мы мо-жем добавить условия, например необходимость соединения с Интернетом (лис-

тинг 10.9).

Листинг 10.9. Добавление условия

private void ButtonRegisterClick(object sender, RoutedEventArgs e)

{

var timerTrigger = new

SystemTrigger(SystemTriggerType.TimeZoneChange, false);

var builder = new BackgroundTaskBuilder();

builder.Name = «SampleBackgroundTask»;

builder.TaskEntryPoint = «TasksComponent.SampleBackgroundTask»;

builder.SetTrigger(timerTrigger);

IBackgroundCondition condition = new

SystemCondition(SystemConditionType.InternetAvailable);

builder.AddCondition(condition);

BackgroundTaskRegistration task = builder.Register();

}

С помощью события Completed объекта класса BackgroundTaskRegistration в основ-ном приложении можно отследить завершение выполнения фоновой задачи.

Добавим в приложение вторую кнопку, при нажатии на которую будем отменять регистрацию всех зарегистрированных фоновых задач (листинг 10.10).

Листинг 10.10. Отмена регистрации фоновых задач

private void ButtonUnRegisterClick(object sender, RoutedEventArgs e)

{

foreach (var task in BackgroundTaskRegistration.AllTasks)

{

task.Value.Unregister(true);

}

}

Итак, мы добавили кнопку регистрации фоновой задачи, а также кнопку отмены регистрации всех фоновых задач. Запустите приложение. Зарегистрируйте фоно-

вую задачу. Проверить ее работу можно, изменив временную зону или вызвав фо-новую задачу напрямую из Visual Studio с помощью соответствующей кнопки на

панели Debug Location (рис. 10.6). На данной панели в выпадающем списке, кроме приостановки приложения (Suspend), возобновления работы приложения после приостановки (Resume), а также приостановки и выгрузки приложения (Suspend

150 Глава 10

Рис. 10.6. Запуск фоновой задачи из панели Debug Location

and shutdown), появится кнопка запуска нашей фоновой задачи с именем

SampleBackgroundTask.

Если панель Debug Location не отображается, выберите пункт меню VIEW |

Toolbars | Debug Location.

Итоги

Мы рассмотрели модель исполнения Windows Store-приложений, которая сущест-венно отличается от модели исполнения классических Windows-приложений.

Так как Windows Store-приложения не работают в фоновом режиме, для выполне-ния фоновых действий требуются различные сценарии многозадачности. Для

фоновой загрузки/выгрузки файлов используются классы BackgroundDownloader и

BackgroundUploader соответственно. Разработчики могут создать фоновые задачи, которые будут запускаться, например, при приходе СМС-сообщения, смене временнóй зоны или по таймеру (при включенном сетевом питании). Пользователь

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

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

батареи.

T�a�a11

Уведомления

Действительно ли приложениям так необходимо работать в фоне? На самом деле,

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

тить приложение, показавшее уведомление.

Способов уведомления пользователей несколько. Можно показать всплывающее уведомление (Toast Notification). Другой способ — отображение информации на

плитках (Tiles) приложения.

Уведомления могут быть сгенерированы напрямую в процессе работы приложения либо посланы в нужный момент через сервис, работающий в Интернете (Push-

уведомления).

В данной главе мы рассмотрим работу со всплывающими уведомлениями, а также Push-уведомлениями. Работе с плитками посвящена глава 12.

Всплывающие уведомления

Всплывающие уведомления — это способ показать пользователю важную и сроч-

ную информацию. При нажатии на всплывающее уведомление происходит возврат

в ваше приложение. Примеры всплывающих уведомлений: уведомление о пред-

стоящей встрече, посылаемое календарем или уведомление о приходе нового со-

общения, посылаемое приложением какой-либо социальной сети.

Существует два типа всплывающих уведомлений:

� Стандартные всплывающие уведомления — остаются на экране в течение 7 с

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

� Продолжительные всплывающие уведомления — остаются на экране в течение

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

152 Глава 11

Существует восемь шаблонов всплывающих уведомлений. От выбранного шаблона зависит внешний вид получаемого уведомления. Уведомления могут содержать

только текст, а также текст и изображение (табл. 11.1).

Таблица 11.1. Шаблоны всплывающих уведомлений

Шаблон всплывающего уведомления Вид уведомления

ToastImageAndText01

ToastImageAndText02

ToastImageAndText03

ToastImageAndText04

ToastText01

ToastText02

ToastText03

ToastText04

Всплывающие уведомления отображаются в верхнем правом углу экрана, напри-мер, как на рис. 11.1.

Уведомления 153

Рис. 11.1. Всплывающее уведомление

Чтобы посылать всплывающие уведомления (неважно, локальные или Push-

уведомления), сначала требуется указать такую возможность в манифесте прило-

жения. Для этого в разделе Application UI манифеста, в подразделе Notifications

выберите значение Yes параметра Toast capable (рис. 11.2).

Далее необходимо сформировать XML-документ, в котором будут содержаться

данные для уведомления. Сформируем такой документ для шаблона ToastText01

(листинг 11.1).

Листинг 11.1. XML-документ для шаблона ToastText01

<toast>

<visual>

<binding template=»ToastText01″>

<text id=»1″>Текст всплывающего

уведомления</text>

</binding>

</visual>

</toast>

Теперь на основе XML-документа создадим объект класса ToastNotification (уве-

домление) и отправим уведомление с помощью класса ToastNotifier (лис-

тинг 11.2).

154 Глава 11

Рис. 11.2. Указание поддержки всплывающих уведомлений в манифесте приложения

Листинг 11.2. Отправка уведомления

var xml = @»<toast>

<visual>

<binding template=»»ToastText01″»>

<text id=»»1″»>Текст всплывающего уведомления</text>

</binding>

</visual>

</toast>»;

Уведомления 155

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(xml);

var toast = new ToastNotification(xmlDocument);

ToastNotifier notifier = ToastNotificationManager.CreateToastNotifier();

notifier.Show(toast);

Уведомление будет показано сразу, что не очень интересно, т. к. в процессе работы приложения мы можем уведомить пользователя и другими способами. Поэтому создадим запланированное уведомление, которое будет показано через 10 с после его создания (листинг 11.3).

Листинг 11.3. Запланированное уведомление

var xml = @»<toast>

<visual>

<binding template=»»ToastText01″»>

<text id=»»1″»>Текст всплывающего уведомления</text>

</binding>

</visual>

</toast>»;

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(xml);

var toast = new ScheduledToastNotification(xmlDocument,

DateTimeOffset.Now.AddSeconds(10));

ToastNotifier notifier = ToastNotificationManager.CreateToastNotifier();

notifier.AddToSchedule(toast);

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

Push-уведомления

Push-уведомления (Push Notification) получили свое название благодаря методу их отправки (с сервера на клиент). Они как бы «проталкиваются» (push) сервером, а не запрашиваются (тянутся, pull) клиентом. В классических Windows-приложениях

156 Глава 11

обычным решением было периодическое опрашивание клиентом сервера в ожида-нии новых данных. Так как Windows Store-приложения, находящиеся в фоне, не выполняются, такой способ для них не подходит. Push-уведомления позволяют инициировать передачу данных на стороне сервера. Клиентское приложение при этом может быть даже не запущено. За прием Push-уведомлений отвечает операци-онная система.

Но вам не требуется писать свой сервер, выполняющий физическую доставку уве-домлений на устройства. Работу Push-уведомлений обеспечивает сервис уведомле-ний Windows (WNS, Windows Push Notification Services). Вместо дорогостоящего (в плане занятых ресурсов) постоянного подключения приложения к своему серве-ру операционная система держит подключение к WNS, и нам, как разработчикам приложений, предоставляется готовая инфраструктура для отправки уведомлений клиентам.

Для отправки Push-уведомлений в клиентском Windows Store-приложении сначала необходимо получить специальный адрес, который затем передается серверной части приложения. Теперь, когда серверной части будет необходимо отправить уведомление клиентскому приложению, она отправит запрос к WNS по получен-ному от клиентской части адресу. После этого WNS уже сам доставит уведомление на клиент.

Существует несколько типов Push-уведомлений:

� Toast — всплывающие уведомления. Аналогичны всплывающим уведомлениям, рассмотренным ранее в данной главе;

� Tile и Badge — уведомления, обновляющие плитки и бейджи. Подробнее про плитки и бейджи мы будем говорить в главе 12;

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

Авторизация на WNS-сервере. Регистрация и получение ключей в Windows Store

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

Если у вас есть аккаунт в Windows Store, то можно зарегистрировать там приложе-ние и получить необходимые ключи. Если аккаунта нет, то вы можете получить временные ключи на этапе разработки.

Уведомления 157

Процедура регистрации и получения ключей приведена в MSDN на русском языке:

http://msdn.microsoft.com/ru-ru/library/windows/apps/hh465407.aspx

На странице описано, как получить «боевые» ключи, с которыми можно опублико-вать приложение в Windows Store, а также временные ключи, пригодные на этапе разработки в том случае, если у вас еще нет аккаунта в Windows Store.

При использовании «боевых» ключей до публикации приложения вам нужно будет ассоциировать проект приложения с приложением в Windows Store. Сделать это можно с помощью меню Store | Associate with the Store в Visual Studio Express или Project | Store | Associate with the Store — в старших версиях Visual Studio.

По окончании процесса получения ключей у вас будут два основных ключа, кото-рые имеют следующий вид:

� SID (Package Security Identifier / Идентификатор безопасности пакета)

ms-app://s-1-15-2-347940726-2465832990-910876698-369105280-2399447978-

997722633-4228783870.

� Client secret / Секрет клиента (версия 1)

-a0o4J2-drcAxBUKeBA7cT06orFATHJw.

Указанные ключи безопасности нужны только для сервера. Они подтверждают то, что ваш сервер может посылать Push-уведомления клиентскому приложению. В клиентском Windows Store-приложении эти ключи прописывать не требуется.

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

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

После того вы ассоциируете приложение с Windows Store и получите ключи досту-па, можно начинать работать с Push-уведомлениями.

Push-уведомления посылаются каждому клиенту индивидуально. На серверной стороне вы должны различать клиентские приложения, которым вы посылаете уве-домления. Для этого каждое Windows Store-приложение должно получить уникаль-ный адрес URI, по которому для него (и только для него) будут отправляться уве-домления.

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

PushNotificationChannelManager (листинг 11.4).

158 Глава 11

Листинг 11.4. Получение уникального URI для приложения

PushNotificationChannel channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

var uri = channel.Uri;

Формат полученного URI:

https://db3.notify.windows.com/?token=AgUAAAC0wm%2frjhZ0ciivfeaM%2bn0c2vh8%2fuJ2NFN6PdwAzkv8KkWrwDvw7qEix%2fzkZsvbQJYt5mR45K7MP2ExP%2fSF4WF8zUuuzlDH6UYoMnwj2AKA4wadN%2bc9qGUEBYvBcVO4Qt0%3d

ПРИМЕЧАНИЕ

После получения URI вы должны передать его серверной части вашего приложения. Рассматривать этот процесс в данной книге мы не будем.

Адрес URI канала уведомлений содержится в свойстве объекта класса

PushNotificationChannel, с помощью которого мы можем получить Push-уведом-ления, если они придут в процессе работы приложения.

Теперь пришло время создать серверную часть нашего приложения. В качестве нее будет выступать консольное приложение, написанное на C#. Это сделано в целях демонстрации и намеренного упрощения. Нет никаких ограничений на применяе-мую технологию, и сервер может быть написан, например, на ASP.NET MVC, PHP, Python, Ruby, Java, node.js и т. д.

Для отправки уведомления с сервера, как и для его создания, на стороне клиента требуется сформировать соответствующий XML-документ. Код отправки всплы-вающего уведомления приведен в листинге 11.5.

Листинг 11.5. Отправка всплывающего уведомления

static void Main(string[] args)

{

var secret = «-a0o4J2-drcAxBUKeBA7cT06orFATHJw»;

var sid = «ms-app://s-1-15-2-347940726-2465832990-…»;

var url = «https://db3.notify.windows.com/?token=…»;

var xml = @»<toast>

<visual>

<binding template=»»ToastText01″»>

<text id=»»1″»>Push-уведомление</text>

</binding>

</visual>

</toast>»;

var status = PostToWns(secret, sid, url, xml, «wns/toast»);

Console.WriteLine(status);

}

Уведомления 159

Здесь в качестве значений переменных sid и secret используются значения, полу-

ченные в Windows Store, а url — адрес, переданный клиентским приложением. Ко-

нечно же, вы наверняка предпочтете хранить sid и secret в конфигурационном

файле, а адреса, получаемые от клиентских приложений, — в базе данных, но сей-

час наша цель — на практике рассмотреть принцип работы, а не создавать прило-

жения промышленного качества.

Теперь рассмотрим функцию PostToWns, которая отправляет уведомления. Прежде

чем отправить уведомление пользователю, наш сервер должен пройти авторизацию

на WNS-сервере. Для получения ответа от WNS-сервера добавим специальный

вспомогательный класс OAuthToken (листинг 11.6).

Листинг 11.6. Вспомогательный класс для получения токена авторизации от WNS-сервера

[DataContract]

public class OAuthToken

{

[DataMember(Name = «access_token»)]

public string AccessToken { get; set; }

[DataMember(Name = «token_type»)]

public string TokenType { get; set; }

}

ПРИМЕЧАНИЕ

При использовании данного кода подключите сборку System.Runtime.Serialization.dll.

Приведем полный код авторизации на WNS-сервере и отправки уведомления (лис-

тинг 11.7).

Листинг 11.7. Отправка уведомления и авторизация на WNS-сервере

private static string PostToWns(string secret, string sid,

string uri, string xml, string type)

{

try

{

var accessToken = GetAccessToken(secret, sid);

var contentInBytes = Encoding.UTF8.GetBytes(xml);

var request = WebRequest.Create(uri) as HttpWebRequest;

request.Method = «POST»;

request.Headers.Add(«X-WNS-Type», type);

request.Headers.Add(«Authorization»,

String.Format(«Bearer {0}», accessToken.AccessToken));

160 Глава 11

using (var requestStream = request.GetRequestStream())

{

requestStream.Write(contentInBytes, 0,

contentInBytes.Length);

}

using (var webResponse = (HttpWebResponse)request.GetResponse())

{

return webResponse.StatusCode.ToString();

}

}

catch (WebException webException)

{

var exceptionDetails =

webException.Response.Headers[«WWW-Authenticate»];

if (exceptionDetails.Contains(«Token expired»))

{

GetAccessToken(secret, sid);

return PostToWns(uri, xml, secret, sid, type);

}

return «EXCEPTION: » + webException.Message;

}

catch (Exception ex)

{

return «EXCEPTION: » + ex.Message;

}

}

private static OAuthToken GetAccessToken(string secret, string sid)

{

var urlEncodedSecret = HttpUtility.UrlEncode(secret);

var urlEncodedSid = HttpUtility.UrlEncode(sid);

var body = String.Format(

«grant_type=client_credentials&client_id={0}&client_secret={1}&scope=notify.windows.com», urlEncodedSid, urlEncodedSecret);

string response;

using (var client = new WebClient())

{

client.Headers.Add(«Content-Type»,

«application/x-www-form-urlencoded»);

response = client.UploadString(

«https://login.live.com/accesstoken.srf», body);

}

return GetOAuthTokenFromJson(response);

}

Уведомления 161

private static OAuthToken GetOAuthTokenFromJson(string jsonString)

{

using (var ms = new

MemoryStream(Encoding.Unicode.GetBytes(jsonString)))

{

var ser = new DataContractJsonSerializer(typeof(OAuthToken));

var oAuthToken = (OAuthToken)ser.ReadObject(ms);

return oAuthToken;

}

}

ПРИМЕЧАНИЕ

Для работы приведенного кода потребуется сборка System.Web.dll. Мы не будем под-робно рассматривать код авторизации на WNS и отправки уведомлений, т. к. этот код типовой и не меняется от приложения к приложению.

Запустите консольное приложение, и вы увидите всплывающее уведомление. Та-ким же образом, задавая соответствующий XML-шаблон, мы можем посылать и уведомления других типов, например обновлять плитку приложения. Необходимо

только указать нужный тип уведомления в качестве аргумента функции PostToWns:

� wns/toast — всплывающее уведомление;

� wns/badge — обновление бейджа приложения;

� wns/tile — обновление плитки приложения;

� wns/raw — Raw-уведомление.

Мы рассмотрели написание «с нуля» кода для работы с WNS-сервером. Если сер-верная часть вашего приложения работает на платформе .NET, вы можете задейст-вовать библиотеки, такие как WnsRecipe, которые существенно сокращают объем кода, необходимого для отправки уведомлений.

Итоги

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

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

Вы можете инициировать отправку уведомлений как из Windows Store-при-ложения, так и из серверной части вашего приложения, работающей в Интернете (в «облаке»). Отправка уведомлений из серверной части приложения осуществляет-ся с помощью WNS. Перед отправкой уведомлений через WNS необходимо пройти авторизацию, это защитит ваших пользователей от атак с использованием фальши-вых уведомлений.

T�a�a12

«Живые» плитки

Как вы уже знаете, пользовательский интерфейс Windows 8 был существенно пере-

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

видят стартовый экран, содержащий плитки (Tiles) приложений. Основное пре-

имущество плиток перед иконками — возможность их «оживления» (Live Tile)

и предоставления непосредственно на плитках важной для пользователя инфор-

мации.

Кроме того, приложения могут создавать вторичные плитки (Secondary Tiles), ко-

торые позволяют переходить не на главную страницу, а в конкретный раздел при-

ложения. В качестве примера можно привести новостное приложение, отображаю-

щее главные новости на основной плитке, а выбранные разделы новостей, напри-

мер «Спорт» или «Политика», — на вторичных плитках.

Правильная и качественная реализация поддержки плиток может существенно

улучшить функциональность ваших приложений и будет побуждать пользователей

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

пользователь, скорее всего, откроет и само приложение.

Плитки по умолчанию

Windows 8 поддерживает плитки двух размеров: квадратные 150×150 пикселов

(Square) и широкие 310×150 пикселов (Wide) (рис. 12.1).

При создании нового проекта Windows Store-приложения в манифесте

(Package.appxmanifes) в разделе Tile будет задана картинка только для квадратной

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

проект картинку размером 310×150 пикселов и указать ее в манифесте. В этом слу-

чае при выделении плитки приложения на стартовой странице операционной сис-

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

ной и широкой плитками.

«Живые» плитки 163

Рис. 12.1. Пример широкой и квадратной плиток

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

ально, когда картинки плиток имеют прозрачный фон), выбрать темный или свет-лый шрифт для текста на плитках, задать краткое имя приложения для отображения

на квадратной плитке, а также выбрать, на каких плитках будет отображаться на-звание приложения (рис. 12.2).

По умолчанию в качестве фона плиток установлен серый цвет #464646.

Рис. 12.2. Параметры плиток приложения

Шаблоны «живых» плиток

Как уже было сказано ранее, Windows 8 поддерживает «живые» плитки, которые могут отображать полезную для пользователей информацию. Предусмотрено 46 шаблонов для живых плиток. Подробное описание каждого шаблона можно най-

ти в MSDN. Существует 10 шаблонов для квадратных плиток и 36 — для широких.

Кроме того, можно разделить все шаблоны плиток на текстовые, графические и

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

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

164 Глава 12

Рис. 12.3. Квадратные плитки

Рис. 12.4. Широкие плитки

«Живые» плитки 165

Шаблоны квадратных плиток приведены на рис. 12.3, широких плиток — на рис. 12.4.

Названия шаблонов квадратных и широких приведены в табл. 12.1 и 12.2 соответ-

ственно.

Как можно заметить, выбор широких шаблонов плиток гораздо больше. При этом

графических шаблонов, не содержащих текста, всего три вида.

Таблица 12.1. Шаблоны квадратных плиток

Текстовые Графические Графика и текст (анимированные/двусторонние)

TileSquareBlock,

TileSquareText01,

TileSquareText02,

TileSquareText03,

TileSquareText04,

TileSquareImage TileSquarePeekImageAndText01

TileSquarePeekImageAndText02

TileSquarePeekImageAndText03

TileSquarePeekImageAndText04

Таблица 12.2. Шаблоны широких плиток

Текстовые Графические Текстовые и графические

TileWideBlockAndText01

TileWideBlockAndText02

TileWideText01

TileWideText02

TileWideText03

TileWideText04

TileWideText05

TileWideText06

TileWideText07

TileWideText08

TileWideText09

TileWideText10

TileWideText11

TileWideImage

TileWideImageCollection

Односторонние

TileWideImageAndText01

TileWideImageAndText02

TileWideSmallImageAndText01

TileWideSmallImageAndText02

TileWideSmallImageAndText03

TileWideSmallImageAndText04

TileWideSmallImageAndText05

Анимированные (двусторонние)

TileWidePeekImageCollection01

TileWidePeekImageCollection02

TileWidePeekImageCollection03

TileWidePeekImageCollection04

TileWidePeekImageCollection05

TileWidePeekImageCollection06

TileWidePeekImageAndText01

TileWidePeekImageAndText02

TileWidePeekImage01

TileWidePeekImage02

TileWidePeekImage03

TileWidePeekImage04

TileWidePeekImage05

TileWidePeekImage06

166 Глава 12

Обновление плитки приложения

При установке Windows Store-приложения его плитка будет содержать только кар-

тинку, заданную в манифесте. Мы можем обновить плитку приложения, используя

один из шаблонов, приведенных ранее. Можно также создать одну или несколько

вторичных плиток.

Давайте выполним вручную все шаги, необходимые для обновления основ-

ной плитки приложения, а потом посмотрим, как можно этот процесс оптимизи-

ровать.

Для обновления плитки необходимо создать XML-документ, в котором будет ука-

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

TileSquareBlock XML-документ приведен в листинге 12.1.

Листинг 12.1. XML-документ для шаблона TileSquareBlock

<tile>

<visual>

<binding template=»TileSquareBlock»>

<text id=»1″>Text Field 1</text>

<text id=»2″>Text Field 2</text>

</binding>

</visual>

</tile>

Шаблон TileSquareBlock лучше всего подходит для отображения числовой инфор-

мации. Он содержит два текстовых параметра (листинг 12.2).

Листинг 12.2. Задание значений текстовых параметров

<tile>

<visual>

<binding template=»TileSquareBlock»>

<text id=»1″>25</text>

<text id=»2″>градусов</text>

</binding>

</visual>

</tile>

Мы можем определить XML-документ (шаблон) прямо в коде и через него обнов-

лять плитки приложения. Теперь на основе XML-документа необходимо создать

объект класса TileNotification. Обновление плиток происходит с помощью класса

TileUpdater (листинг 12.3).

«Живые» плитки 167

Листинг 12.3. Обновление плитки приложения

var xml = @»<tile>

<visual>

<binding template=»»TileSquareBlock»»>

<text id=»»1″»>25</text>

<text id=»»2″»>градусов</text>

</binding>

</visual>

</tile>»;

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(xml);

var notification = new TileNotification(xmlDocument);

TileUpdater updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.Update(notification);

Механизмы обновления плиток и отправки всплывающих уведомлений (см. гла-

ву 11) схожи. Обновление плиток, так же, как и отправка всплывающих уведомле-

ний, реализуются через XML-шаблоны.

Вид плитки приложения после об- новления показан на рис. 12.5. Вы можете заметить, что на плитке так- же отображается иконка приложения (файл SmallLogo.png).

Рис. 12.5. Вид плитки приложения после обновления

168 Глава 12

Ручное задание XML-шаблона — самый простой и максимально гибкий способ. Его применение может упростить жизнь в некоторых сценариях, но все-таки он не-

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

документы с помощью класса TileUpdateManager. Сформируем XML-документ для

шаблона TileSquareBlock (листинг 12.4).

Листинг 12.4. Получение XML-документа для шаблона TileSquareBlock

var xmlDocument = TileUpdateManager.GetTemplateContent(TileTemplateType.TileSquareBlock);

var nodes = xmlDocument.GetElementsByTagName(«binding»).First().ChildNodes;

nodes[0].InnerText = «30»;

nodes[1].InnerText = «градусов»;

var notification = new TileNotification(xmlDocument);

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.Update(notification);

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

чений.

В примерах на сайте MSDN можно найти библиотеку NotificationsExtensions, кото-

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

http://code.msdn.microsoft.com/windowsapps/app-tiles-and-badges-sample-

5fc49148

Библиотека является оберткой, скрывающей от разработчика сложности построе-ния XML-документов. Пример работы с библиотекой NotificationsExtensions иллю-

стрирует листинг 12.5.

Листинг 12.5. Работа с библиотекой NotificationsExtensions

ITileSquareBlock tileContent = TileContentFactory.CreateTileSquareBlock();

tileContent.TextBlock.Text = «35»;

tileContent.TextSubBlock.Text = «градусов»;

TileUpdateManager.CreateTileUpdaterForApplication(). Update(tileContent.CreateNotification());

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

ного использования других способов.

«Живые» плитки 169

Широкие плитки

В предыдущем примере мы обновляли только квадратную плитку приложения. Широкой плитки у нас не было вовсе. Задайте в манифесте приложения картинку

для широкой плитки.

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

тинг 12.6). Для широкой плитки у нас будет шаблон TileWideText03.

Листинг 12.6. XML-документ для квадратной и широкой плиток

<tile>

<visual>

<binding template=»TileSquareBlock»>

<text id=»1″>10</text>

<text id=»2″>градусов</text>

</binding>

<binding template=»TileWideText03″>

<text id=»1″>10 градусов</text>

</binding>

</visual>

</tile>

Обновление плитки происходит так же,

как показано в листинге 12.3. Вид широ-кой плитки приведен на рис. 12.6.

Рис. 12.6. Вид

широкой плитки

170 Глава 12

Шаблоны плиток с изображениями

Графическая информация часто является основной или важной составляющей «жи-

вой» плитки. Рассмотрим шаблоны, предоставляющие возможность отображения

графики. Выберем шаблон TileWideImage для широкой плитки и TileSquareImage —

для квадратной (листинг 12.7).

Листинг 12.7. Задание графических файлов в шаблоне плитки

<tile>

<visual>

<binding template=»TileSquareImage»>

<image id=»1″ src=»Assets\SmallLogo.png» alt=»alt text»/>

</binding>

<binding template=»TileWideImage»>

<image id=»1″ src=»Assets\WideLogo.png» alt=»alt text»/>

</binding>

</visual>

</tile>

В листинге 12.7 мы указали относительные пути к файлам в проекте

Windows Store-приложения. Помимо относительных путей также есть возможность

получения доступа к ресурсам по абсолютному пути (листинг 12.8).

Листинг 12.8. Задание абсолютных путей к графическим файлам

<tile>

<visual>

<binding template=»TileSquareImage»>

<image id=»1″ alt=»alt text»

src=»ms-appx:///Assets/SquareTileLogo.png» />

</binding>

<binding template=»TileWideImage»>

<image id=»1″ alt=»alt text»

src=»ms-appx:///Assets/WideLogo.png» />

</binding>

</visual>

</tile>

Если файл находится в локальном хранилище приложения, путь к нему должен

начинаться с префикса ms-appdata:///local/. Кроме того, можно указывать ссылки

на HTTP-ресурсы, если изображение для плитки находится на сервере в Интер-

нете.

«Живые» плитки 171

Управление временем жизни плиток

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

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

нию (листинг 12.9).

Листинг 12.9. Отключение плитки

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.Clear();

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

дим отключение «живой» плитки через 10 с после создания (листинг 12.10).

Листинг 12.10. Задание времени жизни плитки

var xml = @»<tile>

…

</tile>»;

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(xml);

var notification = new TileNotification(xmlDocument);

notification.ExpirationTime = DateTimeOffset.Now.AddSeconds(10);

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.Update(notification);

После выполнения кода, приведенного в листинге 12.10, мы можем увидеть, как «живая» плитка появляется и исчезает через 10 с. Но Windows 8 позволяет не толь-

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

лась не сразу, а при наступлении события, т. е. через час.

Код, изменяющий плитку приложения через 10 с после выполнения, приведен в листинге 12.11.

Листинг 12.11. Отложенная установка плитки

var xml = @»<tile>

…

</tile>»;

172 Глава 12

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(xml);

var notification = new TileNotification(xmlDocument);

var scheduledTileNotification = new

ScheduledTileNotification(notification.Content,

DateTimeOffset.Now.AddSeconds(10));

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.AddToSchedule(scheduledTileNotification);

ПРИМЕЧАНИЕ

Можно комбинировать запуск по расписанию с установкой времени жизни плиток.

Очередь плиток

Windows 8 позволяет установить очередь, содержащую до пяти плиток, которые

будут отображаться циклически. Для этого нужно всего лишь включить поддержку

очереди с помощью метода EnableNotificationQueue экземпляра класса TileUpdater

(листинг 12.2).

Листинг 12.12. Включение очереди плиток

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.EnableNotificationQueue(true);

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

рассмотрим пример с одним и тем же шаблоном для всех плиток в цикле (лис-

тинг 12.13).

Листинг 12.13. Циклическое отображение плиток

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.Clear();

updateManager.EnableNotificationQueue(true);

for (int i = 1; i <= 5; i++)

{

var xml = @»<tile>

<visual>

<binding template=»»TileSquareBlock»»>

<text id=»»1″»>{0}</text>

<text id=»»2″»>градусов</text>

</binding>

«Живые» плитки 173

<binding template=»»TileWideText03″»>

<text id=»»1″»>{0} градусов</text>

</binding>

</visual>

</tile>»;

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(String.Format(xml, i * 10));

var notification = new TileNotification(xmlDocument);

updateManager.Update(notification);

}

После выполнения приведенного кода мы сможем увидеть, как пять плиток цикли-

чески сменяют друг друга. Метод updateManager.Clear нужен для очистки очереди,

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

с одинаковыми плитками, что приведет к периодической смене плиток на такие же

плитки.

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

устанавливаемых по расписанию, поскольку они точно так же попадают в очередь

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

Бейджи на плитках

На плитках можно отображать бейджи (индикаторы событий). Индикатор собы-

тий отображается в правом нижнем углу и может представлять собой число от 1

до 99 (например, число непрочитанных сообщений), если число больше 100, будет

отображен текст «99+» или глиф (изображение, показывающее состояние прило-

жения).

Для работы с бейджами предусмотрен класс BadgeUpdateManager, который похож на

аналогичный класс TileUpdateManager для работы с плитками. Для бейджей также

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

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

ния устанавливается бейдж с числом 42 (рис. 12.7).

Рис. 12.7. Вид бейджа для квадратной и широкой плиток

174 Глава 12

Листинг 12.14. Установка бейджа

var xmlDocument = new XmlDocument();

xmlDocument.LoadXml(@»<badge value=»»42″»/>»);

var badgeNotification = new BadgeNotification(xmlDocument);

var updateManager = BadgeUpdateManager.CreateBadgeUpdaterForApplication();

updateManager.Update(badgeNotification);

Теперь мы можем наблюдать индикатор со значением 42 как на плитке по умолча-

нию, так и на «живых» плитках.

Для того чтобы отобразить глиф, мы должны заменить в XML-документе бейджа

значение 42 на один из стандартных идентификаторов. К примеру, на attention

(листинг 12.15).

Листинг 12.15. Отображение глифа

xmlDocument.LoadXml(@»<badge value=»»attention»»/>»));

Вид плитки с глифом иллюстрирует рис. 12.8.

Рис. 12.8. Плитка с глифом

Возможные значения идентификаторов глифов приведены в табл. 12.3.

Таблица 12.3. Возможные значения идентификаторов глифов

Идентификатор Вид глифа XML-разметка

activity

<badge value=»activity»/>

alert

<badge value=»alert»/>

available

<badge value=»available»/>

away

<badge value=»away»/>

«Живые» плитки 175

Таблица 12.3 (окончание)

Идентификатор Вид глифа XML-разметка

busy

<badge value=»busy»/>

newMessage

<badge value=»newMessage»/>

paused

<badge value=»paused»/>

playing

<badge value=»playing»/>

unavailable

<badge value=»unavailable»/>

error

<badge value=»error»/>

attention

<badge value=»attention»/>

Обновление плиток с помощью удаленного сервера

Обновление плиток из приложения — полезная возможность. Однако таким обра-зом плитки не будут по-настоящему «живыми». Если пользователь не запускает приложение, то и плитки не будут обновляться. Раз плитки не обновляются, поль-зователь не увидит новую информацию и будет реже запускать приложение. Замк-нутый круг.

Использование фоновых задач — тоже не выход. Фоновые задачи могут быть во-обще отключены, поэтому обновлять плитки с их помощью не рекомендуется.

Лучше всего обновлять плитки через сеть. Есть два главных способа сетевого об-новления плиток:

� Push-уведомления;

� периодический опрос сервера операционной системой.

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

Если вы хотите, чтобы все пользователи видели примерно одинаковые, но обнов-

ляемые плитки, реализуйте второй способ. Вы можете формировать XML-документ

176 Глава 12

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

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

явно отправлять Push-уведомление каждому клиенту. Однако таким способом не стоит передавать клиентам индивидуальную информацию, т. к. это будет небезо-

пасно. Для передачи такой информации без Push-уведомлений не обойтись.

Как должны выглядеть XML-шаблоны для плиток, мы рассматривали ранее в дан-

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

Допустим, наш XML-документ из листинга 12.6 находится по адресу:

http://foo.ru/TileHandler.ashx.

Сделаем так, чтобы данный адрес опрашивался системой каждые полчаса (мини-

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

Листинг 12.16. Обновление плитки с сетевого ресурса

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.StartPeriodicUpdate(new Uri(«http://foo.ru/TileHandler.ashx»),

PeriodicUpdateRecurrence.HalfHour);

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

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

сис практически идентичен локальному созданию очереди (листинг 12.17).

Листинг 12.17. Создание очереди плиток, загружаемых с сетевых ресурсов

var updateManager = TileUpdateManager.CreateTileUpdaterForApplication();

updateManager.EnableNotificationQueue(true);

Uri[] uriCollection = new[]

{

new Uri(«http://foo.ru/TileHandler1.ashx»),

new Uri(«http://foo.ru/TileHandler2.ashx»),

new Uri(«http://foo.ru/TileHandler3.ashx»),

new Uri(«http://foo.ru/TileHandler4.ashx»),

new Uri(«http://foo.ru/TileHandler5.ashx»),

};

updateManager.StartPeriodicUpdateBatch(uriCollection, PeriodicUpdateRecurrence.HalfHour);

«Живые» плитки 177

Аналогично обновляются бейджи. Код из листинга 12.18 будет раз в полчаса за-прашивать XML-документ с сервера и обновлять состояние бейджа.

Листинг 12.18. Сетевое обновление бейджей

var updateManager = BadgeUpdateManager.CreateBadgeUpdaterForApplication();

updateManager.StartPeriodicUpdate(new Uri(«http://foo.ru/TileBadgeHandler.ashx»), PeriodicUpdateRecurrence.HalfHour);

Вторичные плитки

Вторичные плитки (Secondary Tiles) дают возможность запуска Windows Store-

приложений с определенными параметрами и могут существенно расширить функ-

циональность вашего приложения. К примеру, если вы реализуете приложение

с рецептами, то можете предоставить пользователю возможность закрепить ссылку

на рецепт на стартовом экране операционной системы.

Добавить (закрепить) вторичную плитку достаточно просто. Допустим, у нас есть

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

обработчик события нажатия этой кнопки (листинг 12.19).

Листинг 12.19. Создание вторичной плитки

private async void Button_Click(object sender, RoutedEventArgs e)

{

SecondaryTile secondaryTile = new SecondaryTile()

{

TileId = «12345»,

ShortName = «Краткое имя»,

DisplayName = «Полное имя»,

Arguments = «67890»,

TileOptions = TileOptions.ShowNameOnLogo |

TileOptions.ShowNameOnWideLogo,

Logo = new Uri(«ms-appx:///assets/SmallLogo.png»),

WideLogo = new Uri(«ms-appx:///assets/WideLogo.png»),

};

bool isPinned = await secondaryTile.RequestCreateAsync();

}

Мы создаем объект класса SecondaryTile, устанавливаем его параметры, а затем

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

При создании (закреплении) вторичной плитки пользователь увидит всплывающее

окно (рис. 12.9), в котором он должен явно нажать на кнопку закрепления. Закре-

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

178 Глава 12

Рис. 12.9. Запрос на закрепление вторичной плитки

Параметр TileId — это уникальный идентификатор плитки, необходимый в даль-нейшем для работы с конкретной плиткой (удаление, обновление, запуск и т. п.).

Для основной плитки используется уникальный идентификатор App. Данный иден-тификатор можно считать зарезервированным и закрепить вторичную плитку с та-

ким же идентификатором не получится.

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

приложения по нажатию на эту плитку. Для этого в методе OnLaunched объекта при-

ложения (файл App.xaml.cs) мы можем обработать аргументы запуска args и полу-

чить TileId плитки, с помощью которой было запущено приложение.

Реализуем сценарий, когда при нажатии на вторичную плитку с TileId, равным 12345, открывается специальная страница приложения (листинг 12.20).

Листинг 12.20. Определение плитки, с помощью которой было запущено приложение

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

Frame rootFrame = Window.Current.Content as Frame;

if (rootFrame == null)

{

…

}

var tileId = args.TileId;

if (tileId == «12345»)

{

var secondaryTileArgument = args.Arguments;

«Живые» плитки 179

rootFrame.Navigate(typeof(SecondaryTilePage),

secondaryTileArgument);

}

else if (rootFrame.Content == null)

{

if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))

{

throw new Exception(«Failed to create initial page»);

}

}

Window.Current.Activate();

}

ВНИМАНИЕ!

Обратите внимание, что при запуске по вторичной плитке стек навигации оказывается

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

предусмотрите.

У кода из листинга 12.20 есть одна особенность: после активизации приложения по

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

Вторичные плитки, как и основные, можно сделать «живыми». Для этого необхо-

димо создать экземпляр класса TileUpdater, предоставив статическому методу

CreateTileUpdaterForSecondaryTile класса TileUpdateManager свойство TileId плит-ки (листинг 12.21).

Листинг 12.21. Обновление вторичной плитки

var updateManager = TileUpdateManager.CreateTileUpdaterForSecondaryTile(«TileId»);

updateManager.Update(notification);

Итоги

Плитки — удобный способ предоставить пользователю полезную информацию или уведомить об изменениях без запуска самого приложения. Обновлять плитки мож-

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

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

пускать.

Также полезно дать пользователю возможность создавать вторичные плитки, бла-

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

T�a�a13

Контракт «Поиск»

Поиск и его интерфейс в операционной системе в целом и Windows Store-

приложениях в частности — одна из наиболее важных и интересных новых функ-

ций Windows 8 — позволяет искать файлы и документы на устройстве, а также ин-

формацию внутри установленных приложений.

Операционная система предоставляет контракт поиска и единую точку входа —

кнопку на «чудо-панели». Ваша задача, как разработчика, предоставить данные, а

также создать страницу результатов поиска. Хочется отметить, что пользователь

может искать что-либо в приложении, даже когда оно не запущено. В этом случае

при переходе на результаты поиска приложение будет запущено и появится стра-

ница с результатами.

Поиск нужной информации стал проще. Так, к примеру, набрав в поисковой строке

«San Francisco» и выбрав приложение Travel (Путешествия), можно посмотреть

достопримечательности этого города. Запустив приложение Maps (Карты), можно

увидеть Сан-Франциско на карте, а приложение Weather (Погода) позволяет узнать

прогноз погоды.

В данной главе мы рассмотрим интеграцию поиска в Windows Store-приложения,

создание контекстных подсказок (Suggestions), обработку запросов по мере ввода

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

использовании контракта поиска.

Сразу же хочется отметить, что в Windows Store-приложениях не рекомендуется

реализовывать собственные механизмы поиска информации. Так, к примеру, при-

ложение «Википедия» не предоставляет на своих страницах форму поиска, хотя эта

функция является ключевой для данного приложения. Применяется стандартный

системный механизм и контракт поиска.

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

зователь достаточно быстро привыкает искать информацию именно с помощью

общей для всех приложений панели поиска (рис. 13.1).

Контракт «Поиск» 181

Рис. 13.1. Панель поиска и поиск в приложениях

Когда мы говорим о контракте поиска, необходимо упомянуть общее понятие кон-

тракта, а также родственную концепцию расширений.

Контракты позволяют приложениям взаимодействовать с операционной системой

или с другими приложениями. К примеру, если приложение поддерживает кон-

тракт общего доступа к данным («шаринг»), то их можно прочитать в другом при-

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

При этом взаимодействие с приложением будет начинаться с нажатия кнопки на

«чудо-панели».

Расширения предоставляют возможность приложениям дополнять функциональ-

ность операционной системы. К примеру, к расширениям относятся фоновые зада-

чи. С помощью соответствующего типа расширения вы можете ассоциировать свое

приложение с определенными типами файлов и протоколов.

Контракты и расширения обеспечивают много полезных возможностей, которые

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

Контракты и расширения появились благодаря новой парадигме безопасности

Windows Store-приложений. До сих пор классические Windows-приложения рабо-

тали по схеме «можно все (и даже больше), что явно не запрещено». При переходе

от Windows XP к Windows Vista в Microsoft существенно улучшили безопасность

на уровне ОС, введя механизм под названием UAC (User Account Control — Кон-

троль учетных записей пользователей). Если для выполнения действий требуются

права администратора, UAC попросит у пользователя подтверждение.

182 Глава 13

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

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

Поддержка контракта «Поиск»

Рассмотрим на практическом примере добавление поддержки контракта «Поиск» в приложение. Создайте новое приложение на основе шаблона Blank App и назови-те его SearchApp.

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

В манифесте приложения (файл Package.appxmanifest) перейдите на вкладку Declarations. В выпадающем списке Available Declarations выберите пункт Search и нажмите кнопку Add (рис. 13.2).

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

Для обработки поисковых запросов необходимо переопределить метод OnSearchActivated в классе приложения (файл App.xaml.cs). Но перед этим добавим страницу, на которой будем отображать результаты поисковых запросов. Создайте страницу SearchPage.xaml, используя шаблон Basic Page.

Переопределим в файле App.xaml.cs метод OnSearchActivated (листинг 13.1).

Листинг 13.1. Метод OnSearchActivated

sealed partial class App : Application

{

public App()

{

…

}

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

Frame rootFrame = Window.Current.Content as Frame;

Контракт «Поиск» 183

if (rootFrame == null)

{

rootFrame = new Frame();

if (args.PreviousExecutionState ==

ApplicationExecutionState.Terminated)

{

…

}

Window.Current.Content = rootFrame;

}

if (rootFrame.Content == null)

{

if (!rootFrame.Navigate(typeof(MainPage), args.Arguments))

{

throw new Exception(«Failed to create initial page»);

}

}

Window.Current.Activate();

}

private void OnSuspending(object sender, SuspendingEventArgs e)

{

…

}

protected override void OnSearchActivated(

SearchActivatedEventArgs args)

{

Frame rootFrame = Window.Current.Content as Frame;

if (rootFrame == null)

{

rootFrame = new Frame();

Window.Current.Content = rootFrame;

}

rootFrame.Navigate(typeof(SearchPage), args.QueryText);

Window.Current.Activate();

}

}

184 Глава 13

Рис. 13.2. Добавление поиска в манифесте приложения

Система вызовет метод OnSearchActivated при отправке поискового запроса прило-жению (при нажатии кнопки поиска или клавиши <Enter>). Если приложение уже

запущено, будет осуществлен переход на страницу SearchPage.xaml и передан по-исковый запрос.

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

OnSearchActivated и OnLaunched. При запуске приложения через поиск необходимо

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

В C#-код страницы SearchPage.xaml необходимо добавить обработку поискового

запроса, переопределив метод OnNavigatedTo. В данном примере мы не будем реа-лизовывать логику поиска, а только отобразим поисковый запрос в заголовке стра-

ницы (листинг 13.2).

Листинг 13.2. Метод OnNavigatedTo

public sealed partial class SearchPage : LayoutAwarePage

{

public SearchPage()

Контракт «Поиск» 185

{

this.InitializeComponent();

}

protected override void OnNavigatedTo(NavigationEventArgs e)

{

var queryText = (string)e.Parameter;

pageTitle.Text = String.Format(«Результаты поиска для \»{0}\»»,

queryText);

base.OnNavigatedTo(e);

}

}

Теперь в созданном нами приложении (рис. 13.3) поиск доступен (но найти что-нибудь пока будет затруднительно).

Рис. 13.3. Поиск в приложении

ПРИМЕЧАНИЕ

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

Наше приложение пока страдает одним существенным недостатком. Предположим, что приложение не было запущено, а пользователь выполнил в нем поиск. В ре-

зультате приложение будет активизировано с помощью метода OnSearchActivated,

186 Глава 13

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

OnLaunched не выполнит переход на главную страницу (инициализация не проведе-на). Следовательно, единственным способом снова попасть на главную страницу остается закрытие приложения и его повторный запуск.

Мы должны предоставить пользователю возможность вернуться на главную стра-ницу приложения со страницы поиска. Добавим на страницу SearchPage.xaml

в нижнюю панель приложения кнопку возврата на главную страницу (листинг 13.3).

Листинг 13.3. Нижняя панель приложения на странице SearchPage.xaml

<Page.BottomAppBar>

<AppBar>

<Button Style=»{StaticResource HomeAppBarButtonStyle}»/>

</AppBar>

</Page.BottomAppBar>

Предварительно необходимо раскомментировать стиль HomeAppBarButtonStyle в файле StandardStyles.xaml. Добавим обработчик нажатия кнопки панели приложе-

ния (листинг 13.4).

Листинг 13.4. Обработчик нажатия кнопки возвращения на главную страницу

private void Button_Click(object sender, RoutedEventArgs e)

{

Frame.Navigate(typeof(MainPage));

}

Все! Мы выполнили необходимый минимум для поддержки контракта поиска.

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

ном элемента Search Contract, который добавляет страницу результатов поиска и

переопределяет метод OnSearchActivated в классе приложения.

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

Поиск по мере ввода текста

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

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

Контракт «Поиск» 187

Windows Runtime предоставляет класс SearchPane для взаимодействия с панелью

поиска. С помощью специального статического метода GetForCurrentView этого

класса мы можем получить объект класса SearchPane для текущей страницы. За-

тем нам необходимо подписаться на событие изменения поискового запроса

QueryChanged.

Для примера, выполним подписку на изменение поисковых запросов на странице

SearchPage.xaml (листинг 13.5).

Листинг 13.5. Подписка на изменение поискового запроса

protected override void OnNavigatedTo(NavigationEventArgs e)

{

var queryText = (string)e.Parameter;

pageTitle.Text = String.Format(«Результаты поиска для \»{0}\»»,

queryText);

var currentPane = SearchPane.GetForCurrentView();

currentPane.QueryChanged += currentPane_QueryChanged;

base.OnNavigatedTo(e);

}

protected override void OnNavigatedFrom(NavigationEventArgs e)

{

var currentPane = SearchPane.GetForCurrentView();

currentPane.QueryChanged -= currentPane_QueryChanged;

base.OnNavigatedFrom(e);

}

void currentPane_QueryChanged(SearchPane sender, SearchPaneQueryChangedEventArgs args)

{

pageTitle.Text = String.Format(«Результаты поиска для \»{0}\»»,

args.QueryText);

}

Теперь если активизировать приложение через поиск и вводить текст в поисковую

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

ре ввода запроса. Если начать поиск со страницы MainPage.xaml, то необходимо

будет заново открыть панель поиска на странице SearchPage.xaml для отслеживания

ввода поисковых запросов (поскольку подписка происходит для панели поиска

конкретной страницы).

Почему необходимо отписываться от события поиска? Дело в том, что если в стеке

навигации будет накапливаться несколько страниц (например, после неоднократ-

188 Глава 13

ной активизации вашего приложения для поиска), то на каждом экземпляре стра-

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

заться на производительности приложения.

Добавление поисковых подсказок

Кроме отображения результатов поисковых запросов, возможны также поисковые

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

Для добавления поисковых подсказок необходимо подписаться на событие

SuggestionsRequested класса SearchPane (листинг 13.6).

Листинг 13.6. Добавление поисковых подсказок

protected override void OnNavigatedTo(NavigationEventArgs e)

{

…

var currentPane = SearchPane.GetForCurrentView();

currentPane.QueryChanged += currentPane_QueryChanged;

currentPane.SuggestionsRequested += currentPane_SuggestionsRequested;

base.OnNavigatedTo(e);

}

void currentPane_SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)

{

var defferal = args.Request.GetDeferral();

for (int i = 0; i < 5; i++)

{

args.Request.SearchSuggestionCollection.AppendQuerySuggestion(

String.Format(«#{0}. {1}», i, args.QueryText));

}

defferal.Complete();

}

Мы добавим поисковые подсказки, содержащие номер, а также текст запроса

(рис. 13.4).

ВНИМАНИЕ!

Не забудьте заново открыть панель поиска на странице SearchPage.xaml.

Контракт «Поиск» 189

Рис. 13.4. Поисковые подсказки

В начале обработчика метода запроса поисковых подсказок мы вызываем метод

GetDefferral, а в конце — deferral.Complete. В рассматриваемом примере это не нужно, но без данного кода в методе запроса поисковых подсказок невозможны асинхронные операции. Обычно запросы поисковых подсказок выполняются один за другим. Если один запрос выполняется долго, следующий его ждет. Когда мы получаем defferral, то подразумеваем, что вернем результат когда-нибудь потом,

вызвав deferral.Complete. Следующие запросы при этом не будут ждать и произво-дительность существенно увеличивается.

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

Наиболее удобно это реализовать в классе приложения: в файле App.xaml.cs доба-вим методы Subscribe и Unsubscribe (листинг 13.7) и код генерации поисковых под-сказок.

190 Глава 13

Листинг 13.7. Методы подписки и отписки

public void Subscribe()

{

var currentPane = SearchPane.GetForCurrentView();

currentPane.SuggestionsRequested += currentPane_SuggestionsRequested;

}

public void Unsubscribe()

{

var currentPane = SearchPane.GetForCurrentView();

currentPane.SuggestionsRequested -= currentPane_SuggestionsRequested;

}

void currentPane_SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)

{

var defferal = args.Request.GetDeferral();

for (int i = 0; i < 5; i++)

{

args.Request.SearchSuggestionCollection.AppendQuerySuggestion(

String.Format(«#{0}. {1}», i, args.QueryText));

}

defferal.Complete();

}

Теперь нужно добавить вызов метода Subscribe в методы OnLaunched и

OnSearchActivated, а вызов Unsubscribe — в метод OnSuspending (листинг 13.8).

Листинг 13.8. Подписка на подсказки и отписка от них

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

Subscribe();

// Код метода OnLaunched

}

protected override void OnSearchActivated(SearchActivatedEventArgs args)

{

Subscribe();

// Код метода OnSearchActivated

}

Контракт «Поиск» 191

private void OnSuspending(object sender, SuspendingEventArgs e)

{

var deferral = e.SuspendingOperation.GetDeferral();

Unsubscribe();

deferral.Complete();

}

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

Подсказки результатов с графикой и текстом

Мы можем выдавать не только подсказки для поисковых запросов, но и некоторые результаты, содержащие текст и изображение, которые пользователь, возможно, сразу захочет выбрать. Чтобы добавить подсказки результатов, изменим обработ-

чик события SuggestionsRequested (листинг 13.9).

Листинг 13.9. Добавление подсказок результатов

void currentPane_SuggestionsRequested(SearchPane sender, SearchPaneSuggestionsRequestedEventArgs args)

{

var defferal = args.Request.GetDeferral();

for (int i = 0; i < 2; i++)

{

args.Request.SearchSuggestionCollection.AppendQuerySuggestion(

String.Format(«#{0}. {1}», i, args.QueryText));

}

for (int i = 0; i < 2; i++)

{

var image = RandomAccessStreamReference.CreateFromUri(

new Uri(«ms-appx:///Assets/SmallLogo.png»));

args.Request.SearchSuggestionCollection.AppendResultSuggestion(

«Имя результата», «Описание», «Id», image,

«Альтернативный текст для изображения»);

}

defferal.Complete();

}

Вид подсказок результатов иллюстрирует рис. 13.5.

192 Глава 13

Рис. 13.5. Подсказки результатов

Если при выборе поисковой подсказки выполняется поисковый запрос, то подсказ-ка результата осуществляет переход к данному результату. Для этого необходимо подписаться на событие ResultSuggestionChosen класса SearchPane (листинг 13.10).

Листинг 13.10. Подписка на событие выбора результата

public void Subscribe()

{

var currentPane = SearchPane.GetForCurrentView();

currentPane.SuggestionsRequested += currentPane_SuggestionsRequested;

currentPane.ResultSuggestionChosen += currentPane_ResultSuggestionChosen;

}

void currentPane_ResultSuggestionChosen(SearchPane sender, SearchPaneResultSuggestionChosenEventArgs args)

{

var id = args.Tag;

}

В обработчике события можно получить параметр Tag, в котором обычно передает-ся идентификатор результата. Мы передавали значение данного параметра при вы-зове метода AppendResultSuggestion.

Контракт «Поиск» 193

Итоги

Контракт поиска реализуется во многих приложениях. Есть несколько возможных

сценариев поиска. Например, можно просто реагировать на ввод поисковых запро-

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

изменение текста поисковых запросов и выдавать результаты по мере ввода запро-

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

Главное, чего не стоит делать, — реализовывать в приложении собственный ин-

терфейс поиска, отличный от системного.

T�a�a14

Контракт «Общий доступ»

Контракт общего доступа (Share) — один из важнейших в Windows Store-при-

ложениях. Не случайно кнопка для работы с общим доступом расположена второй на «чудо-панели». Фактически, возможность поделиться текущей информацией не менее востребована, чем поиск.

Общий доступ к данным между приложениями можно рассматривать как дальней-

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

Общий доступ к данным предоставляет более простую возможность поделиться

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

ные передаваемого типа (рис. 14.1).

Если далее выбрать почтовое приложение, откроется всплывающее окно для пере-

дачи ссылки по почте (рис. 14.2).

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

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

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

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

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

мы и реализуют исключительно системный контракт. Передающее предложение не должно использовать каких-либо SDK (Software Development Kit) или других

Контракт «Общий доступ» 195

Рис. 14.1. Активизация общего доступа

Рис. 14.2. Передача ссылки по почте

196 Глава 14

библиотек от принимающего приложения (кроме редких случаев разбора нестан-

дартных типов данных), как это было в случае традиционных Windows-при-

ложений. В результате, если пользователь установит приложение его любимой со-

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

информацией через эту социальную сеть (если вы, конечно, реализуете передачу

данных). Хотя никакого специального кода для поддержки данной социальной сети

вы не писали.

Реализация поставщика данных

Для демонстрации возможностей создания поставщика данных создайте новое

приложение на основе шаблона Blank App и назовите его ShareApp.

Разместим на странице MainPage.xaml многострочное текстовое поле с именем

txtMain, текст из которого будет передаваться другим приложениям (листинг 14.1).

Листинг 14.1. Разметка страницы MainPage.xaml

<Page

…

>

<Grid Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

<TextBox x:Name=»txtMain» AcceptsReturn=»True»

Width=»450″ Height=»250″

ScrollViewer.VerticalScrollBarVisibility=»Visible»/>

</Grid>

</Page>

Для поддержки общего доступа к данным предусмотрен класс DataTransferManager.

Когда пользователь нажимает кнопку общего доступа на «чудо-панели», в прило-

жении, которое находится в текущий момент на экране, генерируется событие за-

проса данных DataRequested объекта класса DataTransferManager. Подпишемся на

это событие при переходе на страницу MainPage, а также будем отписываться от

него при уходе со страницы (листинг 14.2).

Листинг 14.2. Подписка на событие DataRequested и отписка от него

public sealed partial class MainPage : Page

{

public MainPage()

{

this.InitializeComponent();

}

Контракт «Общий доступ» 197

protected override void OnNavigatedTo(NavigationEventArgs e)

{

var currentManager = DataTransferManager.GetForCurrentView();

currentManager.DataRequested += currentManager_DataRequested;

}

protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)

{

var currentManager = DataTransferManager.GetForCurrentView();

currentManager.DataRequested -= currentManager_DataRequested;

}

void currentManager_DataRequested(DataTransferManager sender,

DataRequestedEventArgs args)

{

}

}

Сейчас мы подписываемся на событие предоставления данных, но сами данные не

предоставляем. Это нормально, если приложению в конкретный момент времени

нечего передать другим приложениям. Система напишет в панели общего доступа,

что приложению нечего передать.

Передадим текст, вводимый в текстовое поле. Зададим для передаваемых данных

заголовок, описание и собственно данные, вызвав метод SetText объекта класса

DataPackage (свойство Data в args.Request.Data) (листинг 14.3).

Листинг 14.3. Передача данных

void currentManager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)

{

if (String.IsNullOrWhiteSpace(txtMain.Text)) return;

var defferal = args.Request.GetDeferral();

args.Request.Data.Properties.Title = «Важный текст»;

args.Request.Data.Properties.Description = «Этот текст очень важен»;

args.Request.Data.SetText(txtMain.Text);

defferal.Complete();

}

Теперь мы можем передать данные в одно из приложений, принимающее текст. На

рис. 14.3 показано, как мы передаем текстовое сообщение через социальную сеть

«ВКонтакте» с помощью соответствующего приложения.

198 Глава 14

Рис. 14.3. Передача текста

Кроме текста мы можем передавать и другие типы данных (табл. 14.1).

Таблица 14.1. Методы для передачи различных типов данных

Метод Тип данных Содержимое

SetUri URI Ссылки

SetRtf RTF Форматированный текст

SetHtmlFormat HTML HTML-контент

SetBitmap Bitmap Изображения

SetStorageItems StorageItems Файлы и папки

SetData Любой тип данных Бинарные данные

SetDataProvider Ссылка на поставщик данных Поставщик данных

В табл. 14.1 особо интересен последний пункт — передача не какого-либо конкрет-

ного объекта, а поставщика данных. Подробнее эту тему мы рассмотрим далее, ко-

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

Похожим образом можно работать и с традиционным буфером обмена с помощью

класса Clipboard. Задание строки в буфере обмена показано в листинге 14.4.

Контракт «Общий доступ» 199

Листинг 14.4. Задание строки в буфере обмена

var data = new DataPackage();

data.SetText(«Текст для буфера обмена»);

Clipboard.SetContent(data);

Буфер обмена поддерживает и другие типы данных, приведенные в табл. 14.1. Естественно, работать с поставщиками данных через буфер обмена не получится.

Реализация приемника данных

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

манифеста приложения Package.appxmanifest и перейдите на вкладку Declarations. В выпадающем списке Available Declarations выберите пункт Share Target и на-жмите кнопку Add.

Мы можем определить, какие типы данных принимает наше приложение. К приме-

ру, если мы укажем Text в качестве поддерживаемого формата (рис. 14.4), то наше приложение будет отображаться в списке приемников данных только при передаче текста. Можно указать сразу несколько типов данных.

Чтобы наше приложение могло принимать данные, необходимо переопределить

метод OnShareTargetActivated в классе приложения (файл App.xaml.cs) (лис-тинг 14.5). Но сначала из шаблона Blank Page добавим страницу TargetPage.xaml,

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

Листинг 14.5. Переопределение метода OnShareTargetActivated

sealed partial class App : Application

{

public App()

{

this.InitializeComponent();

this.Suspending += OnSuspending;

}

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

…

}

private void OnSuspending(object sender, SuspendingEventArgs e)

{

…

}

200 Глава 14

protected override void OnShareTargetActivated(

ShareTargetActivatedEventArgs args)

{

var frame = new Frame();

frame.Navigate(typeof(TargetPage), args.ShareOperation);

Window.Current.Content = frame;

Window.Current.Activate();

}

}

Рис. 14.4. Указание поддерживаемых форматов

В методе OnShareTargetActivated мы инициализируем фрейм и переходим на стра-

ницу TargetPage.xaml, которой в качестве параметра передаем объект типа

ShareOperation, откуда мы можем извлечь передаваемую информацию.

Заметим, что страница TargetPage.xaml будет отображаться во всплывающем окне

шириной 645 пикселов с заголовком, содержащим кнопку «Назад», а также назва-ние и логотип приложения.

Контракт «Общий доступ» 201

Разместим на странице TargetPage.xaml текстовое поле (листинг 14.6).

Листинг 14.6. Разметка страницы TargetPage.xaml

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<TextBox x:Name=»txtMain» AcceptsReturn=»True»

VerticalAlignment=»Stretch» HorizontalAlignment=»Stretch»

ScrollViewer.VerticalScrollBarVisibility=»Visible»

FontSize=»24″ TextWrapping=»Wrap»/>

</Grid>

</Page>

При переходе на страницу TargetPage.xaml отобразим в текстовом поле получаемые

данные (листинг 14.7).

Листинг 14.7. Отображение получаемых данных

public sealed partial class TargetPage : Page

{

public TargetPage()

{

this.InitializeComponent();

}

protected override async void OnNavigatedTo(NavigationEventArgs e)

{

base.OnNavigatedTo(e);

if (e.Parameter == null) return;

var shareOperation = (ShareOperation)e.Parameter;

if (shareOpertaion.Data.Contains(StandardDataFormats.Text))

{

txtMain.Text = await shareOpertaion.Data.GetTextAsync();

}

}

}

Теперь мы можем запустить наше приложение (чтобы оно было зарегистрировано

в системе) и открыть другое, например браузер, которое будет источником данных

для нашего приложения.

202 Глава 14

Откройте в браузере какую-либо страницу, выделите на ней текст и нажмите кноп-ку общего доступа на «чудо-панели». Список приложений, принимающих текст,

будет содержать и наше приложение. Выберите его. Во всплывающем окне отобра-зится страница TargetPage.xaml (рис. 14.5).

Рис. 14.5. Передача данных нашему приложению

Передача и прием изображений

Рассмотрим в качестве примера передачу и прием изображений.

При передаче изображения на самом деле передается поток класса

RandomAccessStreamReference. Данный класс потока позволяет передавать изобра-жения, расположенные как на локальной машине, так в Интернете. Передадим изо-бражение из Интернета (листинг 14.8).

Листинг 14.8. Передача изображения из Интернета

void currentManager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)

{

var defferal = args.Request.GetDeferral();

args.Request.Data.Properties.Title = «Заголовок»;

args.Request.Data.Properties.Description = «Описание»;

Контракт «Общий доступ» 203

var uri = new Uri(«http://foo.com/microsoftlogo.png»);

var streamReference = RandomAccessStreamReference.CreateFromUri(uri);

args.Request.Data.SetBitmap(streamReference);

defferal.Complete();

}

При передаче изображения, расположенного в пакете приложения, нам потребова-лось бы изменить только адрес изображения (листинг 14.9).

Листинг 14.9. Задание адреса изображения, расположенного в пакете приложения

var uri = new Uri(«ms-appx:///Assets/Logo.png»);

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

формата Bitmap. Допустим, у нас есть элемент управления Image с именем imgMain.

Отобразим в нем принимаемое изображение (листинг 14.10).

Листинг 14.10. Прием изображения

protected override async void OnNavigatedTo(NavigationEventArgs e)

{

base.OnNavigatedTo(e);

if (e.Parameter == null) return;

var shareOperation = (ShareOperation)e.Parameter;

if (shareOpertaion.Data.Contains(StandardDataFormats.Bitmap))

{

var bitmapReference = await shareOpertaion.Data.GetBitmapAsync();

var bitmapImage = new BitmapImage();

bitmapImage.SetSource(await bitmapReference.OpenReadAsync());

img.Source = bitmapImage;

}

}

Отправка и прием нестандартных типов данных

Наличие стандартных типов данных (Text, Bitmap, URI и т. п.) покрывает большин-ство возможных сценариев работы. Но иногда необходимо передать не просто про-

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

смартфон и т. д.), и мы воспользуемся форматом Text, то его примут все приложе-

204 Глава 14

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

данные о продукте, а не просто набор символов.

При передаче данных мы можем вызывать метод SetData, указывая любой формат, например «Product». Вторым параметром метода SetData необходимо передать сами данные в произвольном формате, например в XML, JSON (JavaScript Object Notation). В наших примерах будет JSON, т. к. с ним просто работать в приложени-ях, написанных как на JavaScript, так и на C#, Visual Basic и C++.

В манифесте приложения приемника необходимо указать, что приложение поддер-живает нестандартный формат (в нашем случае «Product»), и извлечь информацию о продукте, закодированную в JSON.

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

Обмен данными существенно упростился бы, если для этого у нас была возмож-ность воспользоваться каким-либо стандартом. К счастью, такой стандарт есть. Контракт общего доступа подразумевает, что мы можем воспользоваться схемами сущностей, расположенными на сайте http://schema.org.

К примеру, если мы работаем с продуктами и реализуем передачу продукта по схе-ме http://schema.org/Product, то приложение-приемник, которое тоже работает с сущностью Product, сможет получить от вас информацию о продуктах, и у вас не будет необходимости как-либо договариваться с авторами этого приложения о форматах передачи данных!

Реализуем передачу данных о продукте (листинг 14.11).

Листинг 14.11. Передача данных о продукте

void currentManager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)

{

var defferal = args.Request.GetDeferral();

var dataPackage = args.Request.Data;

dataPackage.Properties.Title = «Данные о продукте»;

var productFormat =

@»{

«»type»» : «»http://schema.org/Product»»,

«»properties»» :

{

«»name»» : «»{0}»»,

«»description»» : «»{1}»»,

«»productID»» : «»{2}»»

}

}»;

Контракт «Общий доступ» 205

var productJson = String.Format(productFormat,

«Nokia Lumia 920», «Лучший смартфон», «8410660101481»);

dataPackage.SetData(«http://schema.org/Product», productJson);

defferal.Complete();

}

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

schema.org/Product.

Реализуем прием данных и декодирование JSON (листинг 14.12).

Листинг 14.12. Прием данных и декодирование JSON

protected async override void OnNavigatedTo(NavigationEventArgs e)

{

base.OnNavigatedTo(e);

if (e.Parameter == null) return;

var dataPackageView = ((ShareOperation)e.Parameter).Data;

var productJson = await

dataPackageView.GetTextAsync(«http://schema.org/Product»);

JsonObject productObject = JsonObject.Parse(productJson);

JsonObject properties = productObject[«properties»].GetObject();

var productId = properties[«productID»];

var productName = properties[«name»];

var productDescriptions = properties[«description»];

}

Декодирование JSON осуществляется с помощью класса JsonObject из пространст-ва имен Windows.Data.Json.

Таким образом, у нас появляется очень простой механизм обмена данными, кото-рые имеют сложный формат. Мы можем обмениваться информацией о сущностях с приложениями, которые также используют форматы с сайта http://schema.org и передают данные в JSON.

ПРИМЕЧАНИЕ

Зачастую возникает необходимость передавать не просто текст или ссылку на файл, а данные в «сыром» (бинарном, двоичном) виде. Передача бинарных и нестандартных данных практически идентична. Бинарные данные передаются как второй аргумент метода SetData. Естественно, приложение-приемник должно «понимать» формат пе-редаваемых данных.

Возможно, вы захотите передавать не какие-то маленькие порции данных, а боль-

шой видеофайл или «тяжелый» файл другого формата. Передача таких данных мо-

206 Глава 14

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

Передача поставщика данных

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

Листинг 14.13. Поставщик данных

void currentManager_DataRequested(DataTransferManager sender, DataRequestedEventArgs args)

{

args.Request.Data.Properties.Title = «Заголовок»;

args.Request.Data.SetDataProvider(«product», DataHandler);

}

private async void DataHandler(DataProviderRequest request)

{

var defferal = request.GetDeferral();

try

{

}

finally

{

defferal.Complete();

}

}

В нашем примере метод BinaryDataHandler — это поставщик данных. Передадим Эс его помощью произвольные бинарные данные (числа от 1 до 10 000) (лис-тинг 14.14).

Листинг 14.14. Передача бинарных данных с помощью поставщика данных

private async void BinaryDataHandler(DataProviderRequest request)

{

var defferal = request.GetDeferral();

try

{

var stream = new InMemoryRandomAccessStream();

Контракт «Общий доступ» 207

using (var writer = new DataWriter(stream))

{

for (int i = 0; i < 10000; i++)

{

writer.WriteInt32(i);

}

await writer.StoreAsync();

await writer.FlushAsync();

writer.DetachStream();

}

stream.Seek(0);

request.SetData(stream);

}

finally

{

defferal.Complete();

}

}

Фактически мы передаем не сами данные, а ссылку на объект потока класса

InMemoryRandomAccessStream.

Пользователю не обязательно видеть процесс передачи большого объема данных.

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

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

Для скрытия панели общего доступа при начале передачи данных необходимо вос-

пользоваться методом ReportStarted объекта класса ShareOperation. После получе-

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

боту с данными, следует вызывать метод ReportCompleted (листинг 14.15). Теперь уже система сможет закрыть и приложение-приемник.

Листинг 14.15. Фоновая передача данных

protected async override void OnNavigatedTo(NavigationEventArgs e)

{

base.OnNavigatedTo(e);

if (e.Parameter == null) return;

var shareOperation = (ShareOperation)e.Parameter;

shareOperation.ReportStarted();

208 Глава 14

// Получение данных

shareOperation.ReportDataRetrieved();

// Работа с данными

shareOperation.ReportCompleted();

}

Если по какой-то причине произошел сбой при передаче данных, мы можем по-

слать уведомление об ошибке c помощью метода ReportError (листинг 14.16).

Листинг 14.16. Генерация сообщения об ошибке

shareOperation.ReportError(«Описание ошибки»);

Основное преимущество подхода с поставщиком данных заключается в том, что

данные передаются, когда они реально нужны приложению-приемнику, а не при открытии панели общего доступа (до выбора приложения-приемника). Поэтому при работе с поставщиком данных панель общего доступа открывается быстрее.

Данные большого объема можно принимать в фоновом режиме, тогда пользовате-

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

Итоги

Как видно, общий доступ — это не просто замена копирования/вставки. При пра-

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

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

Большинство приложений может стать источником данных. Меньшее число при-ложений может выступать приемниками данных.

T�a�a15

Контракт «Параметры»

На «чудо-панели» присутствует еще одна полезная кнопка — Параметры (Settings).

Работу с ней с помощью контракта параметров мы и рассмотрим в данной главе.

Традиционно в каждом Windows-приложении или игре настройки реализованы

в виде отдельного пункта меню. Windows Store-приложения не должны содержать

меню или кнопок для вызова интерфейса настроек внутри приложения. Настройки

должны выполняться с помощью кнопки на «чудо-панели».

При нажатии на кнопку параметров «чудо-панели» появляется панель, содержащая

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

ные элементы (управление громкостью и яркостью экрана), на которые мы никак

не можем повлиять. Пример панели параметров для приложения Bing Weather при-

веден на рис. 15.1.

Мы можем управлять списком пунктов параметров на уровне как отдельных стра-

ниц, так и всего приложения.

Добавление пунктов параметров

Добавим свои пункты в панель параметров. Создадим приложение из шаблона

Blank App и назовем его SettingsApp. Пункты параметров добавим на уровне всего

приложения, поэтому код будет располагаться в файле App.xaml.cs.

Для работы с панелью параметров предусмотрен класс SettingsPane. Нам необхо-

димо подписаться на событие запроса команд CommandsRequested экземпляра данно-

го класса.

Создадим методы Subscribe и Unsubscribe для подписки и отписки от события

соответственно, а также обработчик события запроса команд (листинг 15.1). Ме-

тоды подписки и отписки будут вызываться при запуске и приостановке прило-

жения.

210 Глава 15

Рис. 15.1. Панель параметров

Листинг 15.1. Подписка и отписка от события CommandsRequested

sealed partial class App : Application

{

…

protected override void OnLaunched(LaunchActivatedEventArgs args)

{

…

Subscribe();

Window.Current.Activate();

}

private void OnSuspending(object sender, SuspendingEventArgs e)

{

var deferral = e.SuspendingOperation.GetDeferral();

Unsubscribe();

deferral.Complete();

}

public void Subscribe()

{

var currentPane = SettingsPane.GetForCurrentView();

Контракт «Параметры» 211

currentPane.CommandsRequested += currentPane_CommandsRequested;

}

public void Unsubscribe()

{

var currentPane = SettingsPane.GetForCurrentView();

currentPane.CommandsRequested -= currentPane_CommandsRequested;

}

void currentPane_CommandsRequested(SettingsPane sender,

SettingsPaneCommandsRequestedEventArgs args)

{

}

}

Если сейчас запустить приложение и вызвать панель параметров, то она будет со-

держать только один системный пункт Permissions (рис. 15.2).

Добавим в список свои пункты. Каждый пункт представляет собой команду класса

SettingsCommand, которую необходимо добавлять в коллекцию args.Request.

ApplicationCommands (листинг 15.2).

Листинг 15.2. Добавление пунктов в панель параметров

void currentPane_CommandsRequested(SettingsPane sender, SettingsPaneCommandsRequestedEventArgs args)

{

var applicationCommands = args.Request.ApplicationCommands;

var newComand = new SettingsCommand(«Id_Команды», «Текст», cmd =>

{

// Обработка команды

});

applicationCommands.Add(newComand);

var aboutCommand = new SettingsCommand(«About», «О программе», cmd =>

{

Frame.Navigate(typeof(AboutPage));

});

applicationCommands.Add(aboutCommand);

var siteCommand = new SettingsCommand(«Site», «Наш сайт», cmd =>

{

Launcher.LaunchUriAsync(new Uri(«http://techdays.ru»));

});

applicationCommands.Add(siteCommand);

}

212 Глава 15

Первая команда просто демонстрирует возможности команд, вторая осуществляет переход на не существующую пока в нашем приложении страницу с информацией

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

Рис. 15.2. Вид панели параметров по умолчанию

Рис. 15.3. Вид панели параметров

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

Контракт «Параметры» 213

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

Всплывающее окно с настройками

Обычно при нажатии на один из пунктов в панели параметров открывается всплы-вающее окно с реальными настройками приложения. Создадим страницу на основе шаблона Basic Page, которая будет отображаться во всплывающем окне. Задайте для данной страницы имя SettingsFlyout.xaml.

ПРИМЕЧАНИЕ

XAML-разметку страницы мы не приводим для экономии места. Пример такой размет-ки можно скачать на MSDN:

http://code.msdn.microsoft.com/windowsapps/App-settings-sample-1f762f49.

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

воспользуемся классом Popup, с которым мы уже работали ранее (листинг 15.3). Всплывающее окно будет отображаться при нажатии на первый пункт панели па-раметров.

Листинг 15.3. Создание вскрывающего окна

private Popup _settingsPopup;

void currentPane_CommandsRequested(SettingsPane sender, SettingsPaneCommandsRequestedEventArgs args)

{

var applicationCommands = args.Request.ApplicationCommands;

var newComand = new SettingsCommand(«Id_Команды», «Текст», cmd =>

{

_settingsPopup = new Popup();

_settingsPopup.IsLightDismissEnabled = true;

_settingsPopup.Width = 646;

_settingsPopup.Height = Window.Current.Bounds.Height;

_settingsPopup.ChildTransitions = new TransitionCollection();

_settingsPopup.ChildTransitions.Add(new PaneThemeTransition()

{

Edge = (SettingsPane.Edge == SettingsEdgeLocation.Right) ?

EdgeTransitionLocation.Right :

EdgeTransitionLocation.Left

});

SettingsFlyout mypane = new SettingsFlyout();

mypane.Width = 646;

mypane.Height = Window.Current.Bounds.Height;

214 Глава 15

_settingsPopup.Child = mypane;

_settingsPopup.SetValue(Canvas.LeftProperty,

SettingsPane.Edge == SettingsEdgeLocation.Right

? (Window.Current.Bounds.Width — 646) : 0);

_settingsPopup.SetValue(Canvas.TopProperty, 0);

_settingsPopup.IsOpen = true;

});

applicationCommands.Add(newComand);

…

}

Теперь при нажатии на первый пункт панели параметров откроется всплывающее окно (рис. 15.4).

Рис. 15.4. Пример всплывающего окна настроек

Контракт «Параметры» 215

ВНИМАНИЕ!

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

Итоги

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

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

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

окна. Такое окно создается с помощью класса Popup и обычно содержит страницу

со специальной разметкой.

T�a�a16

Хранение и доступ к данным

Работа с файлами в Windows Store-приложениях отличается от того, с чем знакомы разработчики классических Windows-приложений. Одно из важных отличий — Windows Store-приложения по умолчанию не имеют доступа к файловой системе устройства, т. к. они работают в ограниченной «песочнице» (Sandbox). Поэтому вы не можете просто записать файл, например, на диск C:\ или прочитать файл оттуда.

Windows Store-приложения по умолчанию имеют доступ только к папке установки приложения, изолированному хранилищу и папке загрузок (в манифесте приложе-ния также можно задекларировать доступ к некоторым другим папкам). Для досту-па к пользовательским файлам и папкам требуются соответствующие разрешения, для работы с файлами также необходимы контракты и расширения (которые мы рассмотрим в главе 17). В данной главе мы рассмотрим хранение настроек и фай-лов, а также работу с СУБД SQLite, с помощью которой вы можете организовать локальное реляционное хранилище.

Изолированное хранилище

Каждое Windows Store-приложение имеет доступ к своему изолированному храни-лищу (индивидуальному для приложения и для пользователя, работающего с при-ложением), в котором можно хранить файлы и настройки. Изолированное храни-лище приложения содержит три папки:

� LocalFolder;

� RoamingFolder;

� TemporaryFolder.

В каждой из папок вы можете создавать вложенные папки. Также доступны два хранилища настроек:

� LocalSettings;

� RoamingSettings.

Хранение и доступ к данным 217

Работа с каждой из папок практически идентична, за исключением небольших осо-

бенностей. Главное различие между папками состоит в их предназначении и в ню-

ансах работы системы с ними.

Файлы, хранящиеся в LocalFolder, будут сохранены на устройстве, на котором ра-

ботает приложение. Данная папка предназначена для хранения служебных файлов,

необходимых приложению, например, файлов базы данных SQLite или данных, за-

груженных из сети.

Папка RoamingFolder служит для синхронизации данных между всеми компьюте-

рами, на которых работает приложение. Если пользователь работает с вашим при-

ложением на нескольких устройствах, система будет автоматически синхронизиро-

вать содержимое папки RoamingFolder между ними. Система может также синхро-

низировать настройки приложения (RoamingSettings).

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

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

RoamingFolder полные тексты книг, вместо этого можно записать последний от-

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

хранить текущее состояние прохождения игры (например, информацию о разбло-

кированных уровнях). Даже если вы захотите хранить в папке RoamingFolder

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

синхронизировать только 100 Кбайт данных и настроек. Это достаточно жесткое

ограничение, но зато использование RoamingFolder бесплатно и у вас не будет не-

обходимости содержать собственную серверную инфраструктуру!

ПРИМЕЧАНИЕ

Пробелы в именах файлов, хранящихся в RoamingFolder, недопустимы.

Ограничение на синхронизацию данных может измениться в будущем. Проверить

текущее значение можно с помощью свойства RoamingStorageQuota (листинг 16.1).

Листинг 16.1. Проверка значения квоты

ApplicationData.Current.RoamingStorageQuota

Кроме того, данные и настройки в RoamingFolder и RoamingSettings сохраняются

между переустановками приложений. Поэтому следует тщательно проектировать

логику работы с данными в этих хранилищах. Так, если из-за данных в

RoamingFolder приложение будет некорректно работать, то даже после переуста-

новки этот дефект сохранится.

Папка TemporaryFolder хорошо подходит для временных файлов. К примеру, для

приложения клиента социальных сетей в этой папке могут кэшироваться фотогра-

фии пользователей. Операционная система будет периодически удалять файлы из

этой папки.

218 Глава 16

Хранение настроек

Если вам требуется хранить информацию простых типов данных (string, bool, int,

float и т. п.) между запусками приложения, воспользуйтесь хранилищем

LocalSettings или RoamingSettings. Разница состоит в том, что данные в

RoamingSettings синхронизируются между устройствами. Эти хранилища удобны

для сохранения различных настроек (уровня громкости звука, текущей страницы

и т. п.).

Сохраним произвольные данные в LocalSettings. Данные сохраняются по строково-

му ключу (листинг 16.2).

Листинг 16.2. Сохранение данных в LocalSettings

ApplicationData.Current.LocalSettings.Values[«MyKey»] = «Значение»;

Читать данные так же просто, как и сохранять (листинг 16.3).

Листинг 16.3. Чтение данных из LocalSettings

var val = (string)ApplicationData.Current.LocalSettings.Values[«MyKey»];

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

исключение NullReferenceException для значимых типов данных (bool, int, float

и т. п.) (листинг 16.4).

Листинг 16.4. Проверка наличия ключа

var settings = ApplicationData.Current.LocalSettings;

if (settings.Values.ContainsKey(«PageNumber»))

{

var number = (int)settings.Values[«PageNumber»];

}

Работа с синхронизируемыми настройками, хранящимися в RoamingSettings, вы-

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

ных между устройствами составляет около 10–15 мин. Если вам необходимо быст-

рее синхронизировать настройки, для RoamingSettings есть служебный ключ

HighPriority, который следует указать для данных с высоким приоритетом синхро-

низации. Время синхронизации данных для этого ключа составляет около 15–30 с

(листинг 16.5).

Листинг 16.5. Запись высокоприоритетных данных

ApplicationData.Current.RoamingSettings.Values[«HighPriority»] = 42;

Хранение и доступ к данным 219

Хранение файлов

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

Вначале необходимо получить папку, с которой будет весить работа. Получим ло-кальную папку (листинг 16.6).

Листинг 16.6. Получение папки

var folder = ApplicationData.Current.LocalFolder;

//var folder = ApplicationData.Current.RoamingFolder;

//var folder = ApplicationData.Current.TemporaryFolder;

В листинге 16.6 закомментированы строчки получения синхронизируемой и вре-менной папок.

Работу с файлами удобно вести с помощью класса FileIO. Создадим файл test.txt и запишем в него строчку «Hello World!» (листинг 16.7).

Листинг 16.7. Запись текста в файл

var folder = ApplicationData.Current.LocalFolder;

var file = await folder.CreateFileAsync(«test.txt», CreationCollisionOption.ReplaceExisting);

await FileIO.WriteTextAsync(file, «Hello World!»);

Чтение текста из файла показано в листинге 16.8.

Листинг 16.8. Чтение из файла

var storageFolder = ApplicationData.Current.LocalFolder;

var file = await storageFolder.GetFileAsync(«test.txt»);

var text = await FileIO.ReadTextAsync(file);

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

на событие DataChanged (листинг 16.9).

Листинг 16.9. Обработка события синхронизации данных

ApplicationData.Current.DataChanged += (sender, args) =>

{

// Обработка синхронизированных данных

};

220 Глава 16

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

ния, и они синхронизируют данные. Любое приложение, которое продолжает раз-

виваться, со временем требует новой структуры данных. Для данных, которые хра-

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

новления данных. Но при синхронизации данных от новой версии вашего

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

Windows 8 предоставляет готовое решение для разделения данных на разные вер-

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

После этого приложение будет принимать только данные, имеющие такой же но-

мер версии. Текущую поддерживаемую версию данных вы можете получить с по-

мощью свойства ApplicationData.Current.Version. По умолчанию номер версии

равен нулю.

СОВЕТ

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

Новую версию данных можно установить с помощью метода SetVersionAsync (лис-

тинг 16.10).

Листинг 16.10. Установка новой версии данных

await ApplicationData.Current.SetVersionAsync(versionNumber, UpgradeToVersionHandler);

Здесь versionNumber — целочисленное значение номера версии, а UpgradeToVersion-

Handler — обработчик обновления данных (листинг 16.11).

Листинг 16.11. Обработчик обновления данных

private void UpgradeToVersionHandler(SetVersionRequest setversionrequest)

{

var defferal = setversionrequest.GetDeferral();

if (setversionrequest.DesiredVersion >

setversionrequest.CurrentVersion)

{

// Обновление данных на новую версию;

}

defferal.Complete();

}

В обработчике обновления данных обычно схема данных физически обновляется

на новую версию. Как и сами синхронизируемые данные, версия данных сохраня-

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

между устройствами (для каждого устройства устанавливается свой номер версии).

Хранение и доступ к данным 221

Прямой доступ к файлам в изолированном хранилище

Часто необходимо указать прямой путь к файлу в изолированном хранилище. Это

требуется, например, при задании пути к картинке в XAML-разметке. В Windows 8 появились новые префиксы для доступа к файлам:

� ms-appx:/// — доступ к файлам, включенным в проект приложения;

� ms-appdata:///local/ — к файлам в папке LocalFolder;

� ms-appdata:///roaming/ — к файлам в папке RoamingFolder;

� ms-appdata:///temp/ — к файлам в папке TemporaryFolder.

В листинге 16.12 приведен пример использования префиксов.

Листинг 16.12. Использование префиксов

LocalImage.Source = new BitmapImage(

new Uri(«ms-appdata:///local/appDataLocal.png»));

RoamingImage.Source = new BitmapImage(

new Uri(«ms-appdata:///roaming/appDataRoaming.png»));

TempImage.Source = new BitmapImage(

new Uri(«ms-appdata:///temp/appDataTemp.png»));

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

папке можно получить из свойства ApplicationData.Current.LocalFolder.Path:

C:\Users\<UserName>\AppData\Local\Packages\f7cb881e-53dd-47d9-b559-57defb00a8fb_1ajdc8xvgt2ym\LocalState\

Здесь <UserName> — имя пользователя, работающего с приложением, а f7cb881e-

53dd-47d9-b559-57defb00a8fb_1ajdc8xvgt2ym — идентификатор приложения.

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

Работа с СУБД SQLite

Часто возникает необходимость хранить не только настройки и файлы, но и струк-

турированные данные, по которым потом будет вестись поиск. Хранение данных обеспечивают базы данных (БД). Windows 8 не предоставляет встроенной системы

управления базами данных (СУБД). Но поскольку у нас есть прямой доступ к фай-ловому хранилищу, мы можем воспользоваться практически любой встраиваемой СУБД. На сегодняшний день SQLite, пожалуй, самая популярная кроссплатфор-

менная встраиваемая СУБД. Мы не будем здесь останавливаться на принципах работы баз данных и объяснять основы языка SQL. По этой тематике существует

222 Глава 16

немало хороших книг. В данной главе мы рассмотрим, как использовать SQLite в Windows Store-приложениях.

Самый простой способ для начала работы с SQLite — установка специального рас-

ширения. Для этого выберите в меню пункт Tools | Extensions and Updates и вы-полните поиск расширения SQLite for Windows Runtime (рис. 16.1).

Рис. 16.1. Установка расширения SQLite for Windows Runtime

Установите расширение и перезапустите Visual Studio. После этого можно добав-лять поддержку SQLite в Windows Store-приложения.

Создайте новое приложение на основе шаблона Blank App и назовите его SqliteApp.

В контекстном меню раздела References проекта приложения (в окне Solution

Explorer) выберите пункт Add Reference… В открывшемся окне добавьте расши-

рения SQLite for Windows Runtime и Microsoft Visual C++ Runtime Package

(рис. 16.2).

ВНИМАНИЕ!

Обратите внимание на добавление пакета Microsoft Visual C++ Runtime Package. Если мы его не добавим, наш проект будет запускаться и работать, но он не пройдет сер-тификацию в Windows Store.

После подключения расширения SQLite for Windows Runtime к проекту, он (проект)

не будет компилироваться. SQLite for Windows Runtime — это библиотека, написан-

ная на C++, поэтому ее нельзя скомпилировать под любой процессор (Any CPU), как

это происходит в случае с управляемым кодом на C#. Для того чтобы скомпилиро-

вать проект, необходимо указать конкретную процессорную архитектуру.

Для этого в главном меню Visual Studio выберите пункт BUILD | Configuration

Manager… В открывшемся диалоговом окне в выпадающем списке Active solution

Хранение и доступ к данным 223

platform укажите значение x86 (сама Visual Studio является 32-разрядным прило-

жением x86, поэтому при отладке Windows Store-приложений проще всего работать

с этой процессорной архитектурой) (рис. 16.3).

При загрузке нашего приложения в Windows Store необходимо будет добавить вер-

сии для разных процессорных архитектур (x86, x64, ARM), а не одну версию при-ложения, как при отсутствии SQLite for Windows Runtime.

Рис. 16.2. Добавление SQLite в проект приложения

Рис. 16.3. Выбор процессорной архитектуры

224 Глава 16

Многие .NET-разработчики привыкли взаимодействовать с базами данных с по-

мощью средств ORM (Object-Relational Mapping), а также строить запросы на осно-

ве LINQ (Language Integrated Quiries). Мы можем работать с SQLite знакомым спо-

собом. Для этого необходимо подключить к проекту библиотеку sqlite-net.

В контекстном меню проекта в окне Solution Explorer выберите пункт Manage

NuGet Packages…, найдите и установите пакет sqlite-net (рис. 16.4).

Рис. 16.4. Установка пакета sqlite-net

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

данных можно использовать код листинга 16.13. Если файла базы данных не было

на диске, то он будет создан.

Листинг 16.13. Подключение к БД

var dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, «data.db»);

using (var db = new SQLiteConnection(dbPath))

{

// Работа с БД

}

СУБД SQLite работает внутри процесса приложения. Этим она отличается от кли-

ент-серверных СУБД, таких как Microsoft SQL Server и Oracle Database. Файлы баз

данных хранятся в изолированном хранилище Windows Store-приложения.

Библиотека sqlite-net позволяет работать как с помощью LINQ-провайдера, так и

в стиле ADO.NET. Рассмотрим оба способа подробнее.

Хранение и доступ к данным 225

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

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

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

инкрементом и текстовое поле максимальной длиной в 250 символов (лис-

тинг 16.14).

Листинг 16.14. Модель данных для таблицы продуктов

public class Product

{

[PrimaryKey, AutoIncrement]

public int ProductId { get; set; }

[MaxLength(250)]

public string Name { get; set; }

}

Теперь нам потребуется метод для инициализации схемы базы данных. Создадим

таблицу продуктов на основе класса Product (листинг 16.15).

Листинг 16.15. Инициализация схемы базы данных

private void InitDb()

{

var dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path,

«data.db»);

using (var db = new SQLiteConnection(dbPath))

{

db.CreateTable<Product>();

}

}

При выполнении метода инициализации схемы базы данных в локальной папке бу-

дет создана база data.db. Это обычная база данных SQLite, с которой можно рабо-

тать и на других платформах, поддерживающих SQLite. Для просмотра базы по-

дойдут любые утилиты, работающие с SQLite, например бесплатная SQLite Expert

Personal:

http://www.sqliteexpert.com/download.html.

Откроем нашу базу данных в SQLite Expert Personal и посмотрим схему таблицы

Product (рис. 16.5).

Рассмотрим несколько типовых сценариев работы с базой данных. Добавим новый

продукт в таблицу Product (листинг 16.16).

226 Глава 16

Рис. 16.5. Просмотр базы данных в SQLite Expert Personal

Листинг 16.16. Добавление навой записи в таблицу

using (var db = new SQLiteConnection(dbPath))

{

var product = new Product() { Name = «Visual Studio 2012» };

db.Insert(product);

}

При выполнении кода, приведенного в листинге 16.16, свойству ProductId объекта

класса Product будет автоматически присвоен идентификатор из БД.

Выполним поиск продукта по его имени (листинг 16.17).

Листинг 16.17. Поиск продукта

using (var db = new SQLiteConnection(dbPath))

{

var products = from c in db.Table<Product>()

where c.Name == «Visual Studio 2012»

select c;

}

Извлечь запись можно, выполнив прямой SQL-запрос. Найдем продукт, идентифи-катор которого равен 2 (листинг 16.18).

Хранение и доступ к данным 227

Листинг 16.18. Выполнение SQL-запросов

using (var db = new SQLiteConnection(dbPath))

{

var products = db.Query<Product>(

«SELECT * FROM Product WHERE ProductId=?», 2);

var product = products.FirstOrDefault();

}

Можно удалить запись по идентификатору (листинг 16.19).

Листинг 16.19. Удаление записи по идентификатору

using (var db = new SQLiteConnection(dbPath))

{

db.Delete<Product>(3);

}

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

мощью SQL-запросов.

Выполним SQL-запрос, добавляющий новый продукт (листинг 16.20).

Листинг 16.20. Добавление записи с помощью SQL-запроса

using (var db = new SQLiteConnection(dbPath))

{

var command = db.CreateCommand(

«INSERT INTO Product (Name) VALUES (?)», «Windows 8»);

command.ExecuteNonQuery();

}

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

в результате выполнения запроса. Листинг 16.21 иллюстрирует запрос, возвра-

щающий число строк в таблице Product.

Листинг 16.21. Выполнение запроса, возвращающего число

using (var db = new SQLiteConnection(dbPath))

{

var command = db.CreateCommand(

«SELECT COUNT(ProductId) FROM Product»);

var count = command.ExecuteScalar<int>();

}

228 Глава 16

Итоги

Работа с файлами в Windows 8 и в предыдущих версиях Windows различается. В Windows 8 нельзя просто так записывать и читать файлы из произвольного места

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

в следующей главе.

Windows Store-приложения имеют доступ к трем папкам верхнего уровня в изоли-

рованном хранилище: LocalFolder, RoamingFolder и TemporaryFolder, в которых содержатся локальные, синхронизируемые и временные данные соответственно.

Также можно сохранять локальные и синхронизируемые настройки.

Если вам требуется хранить данные, имеющие реляционную структуру, восполь-

зуйтесь одной из доступных встраиваемых СУБД. В настоящей главе мы рассмот-рели работу с СУБД SQLite.

T�a�a17

Файловые контракты

и расширения

Как уже упоминалось, в отличие от классических приложений, Windows Store-

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

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

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

Необходимость доступа к каким-либо из пяти заранее предопределенных папок,

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

в момент установки приложения.

Расширение FileOpenPicker

Класс FileOpenPicker похож на аналоги, применяемые в других библиотеках, на-

пример, OpenFileDialog в Windows Forms. FileOpenPicker позволяет открыть один

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

Минимальный код FileOpenPicker приведен в листинге 17.1.

Листинг 17.1. Использование FileOpenPicker

var openPicker = new FileOpenPicker();

openPicker.FileTypeFilter.Add(«*»);

var file = await openPicker.PickSingleFileAsync();

При использовании FileOpenPicker мы должны указать как минимум один тип фай-

лов, который хотим открыть. Если требуется доступ к любому типу файлов (на-

230 Глава 17

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

чтобы передавать их как вложения), необходимо указать значение «*». Для того

чтобы поддерживать конкретные типы файлов, нужно указать расширение файлов,

например «.jpg». Для нескольких расширений код будет выглядеть следующим

образом (листинг 17.2).

Листинг 17.2. Фильтрация файлов по расширениям для FileOpenPicker

FileOpenPicker openPicker = new FileOpenPicker();

openPicker.FileTypeFilter.Add(«.jpg»);

openPicker.FileTypeFilter.Add(«.jpeg»);

openPicker.FileTypeFilter.Add(«.png»);

var file = await openPicker.PickSingleFileAsync();

if(file!=null)

{

…

}

Пользователь может как открыть файл, так и отказаться от его открытия. Для кор-

ректной обработки отказа необходимо проверять результат на NULL. Возможность

открыть сразу несколько файлов предоставляет метод PickMultipleFilesAsync (лис-

тинг 17.3).

Листинг 17.3. Выбор нескольких файлов

var openPicker = new FileOpenPicker();

openPicker.FileTypeFilter.Add(«*»);

var files = await openPicker.PickMultipleFilesAsync();

Полезное свойство FileOpenPicker — возможность указать папку, открываемую по

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

при открытии FileOpenPicker будет показана системная библиотека «Видео» (лис-

тинг 17.4).

Листинг 17.4. Указание папки по умолчанию

openPicker.SuggestedStartLocation = PickerLocationId.VideosLibrary;

Кроме видео, можно указать другие папки и библиотеки, такие как «Документы»,

«Загрузки» и т. д.:

� DocumentsLibrary;

� ComputerFolder;

Файловые контракты и расширения 231

� Desktop;

� Downloads;

� HomeGroup;

� MusicLibrary;

� PicturesLibrary;

� VideosLibrary.

Кроме того, мы можем выбрать, как будут отображаться файлы: в виде списка

(значение по умолчанию) или в виде иконок (листинг 17.5).

Листинг 17.5. Отображение файлов в виде иконок

openPicker.ViewMode = PickerViewMode.Thumbnail;

Можно заменить текст на кнопке открытия файлов. Например, если после выбора

изображения оно будет редактироваться, текст можно заменить на «Редактировать»

(листинг 17.6).

Листинг 17.6. Изменения текста кнопки открытия файла

openPicker.CommitButtonText = «Редактировать»;

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

как показано в листинге 17.7.

Листинг 17.7. Использование FileOpenPicker

var openPicker = new FileOpenPicker();

openPicker.FileTypeFilter.Add(«.jpg»);

openPicker.FileTypeFilter.Add(«.jpeg»);

openPicker.FileTypeFilter.Add(«.png»);

openPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;

openPicker.ViewMode = PickerViewMode.Thumbnail;

openPicker.CommitButtonText = «Редактировать»;

var file = await openPicker.PickSingleFileAsync();

if (file != null)

{

// Выполнить действия с файлом

}

Вид диалога открытия файла приведен на рис. 17.1.

232 Глава 17

Рис. 17.1. Диалог открытия файла

ВНИМАНИЕ!

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

Расширение FileSavePicker

Для работы с диалогом сохранения файлов предназначен класс FileSavePicker, ко-торый является аналогом SaveFileDialog из Windows Forms. FileSavePicker позво-ляет создавать и сохранять новые файлы.

Код сохранения файла и записи в него данных приведен в листинге 17.8.

Листинг 17.8. Сохранение файла

var savePicker = new FileSavePicker();

savePicker.FileTypeChoices.Add(«Документ», new List<string>() { «.txt» });

savePicker.SuggestedFileName = «hello»;

var file = await savePicker.PickSaveFileAsync();

if (file != null)

{

CachedFileManager.DeferUpdates(file);

await FileIO.WriteTextAsync(file, «Hello World!»);

CachedFileManager.CompleteUpdatesAsync(file);

}

Файловые контракты и расширения 233

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

чения NullReferenceException.

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

уведомить систему с помощью класса CachedFileManager.

Расширение FolderPicker

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

Можно предоставить пользователю возможность указать целевую папку с по- мощью класса FolderPicker, который является аналогом FolderBrowserDialog из Windows Forms (листинг 17.9).

Листинг 17.9. Работа с FolderPicker

var folderPicker = new FolderPicker();

folderPicker.FileTypeFilter.Add(«*»);

// Выбор одиночной папки

var folder = await folderPicker.PickSingleFolderAsync();

// Получение всех файлов в папке

var files = await folder.GetFilesAsync();

// Создание нового файла

var newFile = await folder.CreateFileAsync(«hello.txt»);

await FileIO.WriteTextAsync(newFile, «Hello World!»);

Разрешение на доступ к папкам с помощью манифеста приложения

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

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

Приведем папки, к которым можно получить доступ:

� Documents Library;

� Music Library;

234 Глава 17

� Pictures Library;

� Videos Library;

� Removable Storage.

Рис. 17.2. Декларация доступа к определенным папкам в манифесте

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

публикуемыми от учетных записей организаций. Частные лица не могут получить

доступ к Documents Library. Также при указании доступа к этой папке приложение

должно быть ассоциировано хотя бы с одним типом файлов через контракт File

Type Associations.

При указании необходимости доступа к папке в манифесте приложения получить

папку можно с помощью класса KnownFolders (листинг 17.10).

Листинг 17.10. Доступ к папке Picture Folder (при соответствующем разрешении в манифесте)

var folder = KnownFolders.PicturesLibrary;

Существуют папки, не требующие указания разрешения в манифесте:

� KnownFolders.HomeGroup;

� KnownFolders.MediaServerDevices.

Файловые контракты и расширения 235

СОВЕТ

Не следует злоупотреблять разрешениями на доступ к папкам без особой надобности (даже с благими намерениями).

Контракт File Open Picker

Классы FileOpenPicker и FileSavePicker позволяют сохранять и открывать файлы не только из файловой системы, но и из приложений. Так, у пользователя есть воз-можность читать и сохранять файлы напрямую из SkyDrive или клиента Facebook, если он установлен.

Допустим, вы храните на сервере какие-либо файлы пользователя и хотите предос-тавить приложениям возможность взаимодействовать с ними через диалог откры-тия файла. Для этого необходимо сообщить операционной системе, что приложе-ние может выступать провайдером файлов, объявив в манифесте поддержку кон-тракта File Open Picker (рис. 17.3).

Рис. 17.3. Контракт File Open Picker

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

типы файлов. Если мы хотим поддерживать все типы файлов, можно установить галочку на опции Supports any file type.

236 Глава 17

После добавления контракта необходимо создать страницу, которая будет показы-

ваться внутри диалога открытия файлов. Допустим, такой страницей будет

FileOpenPage.xaml (листинг 17.11).

Листинг 17.11. XAML-разметка страницы FileOpenPage.xaml

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<StackPanel VerticalAlignment=»Center»

HorizontalAlignment=»Center»>

<TextBlock Text=»Страница FileOpenPage.xaml» FontSize=»72″ />

<Button Content=»Выбрать файл» HorizontalAlignment=»Center»/>

</StackPanel>

</Grid>

</Page>

Теперь в классе приложения в файле App.xaml.cs переопределим метод

OnFileOpenPickerActivated, вызываемый при активизации приложения через диалог

открытия файлов (листинг 17.12).

Листинг 17.12. Переопределение метода OnFileOpenPickerActivated в App.xaml.cs

sealed partial class App : Application

{

…

protected override void OnFileOpenPickerActivated(

FileOpenPickerActivatedEventArgs args)

{

base.OnFileOpenPickerActivated(args);

var frame = new Frame();

Window.Current.Content = frame;

frame.Navigate(typeof(FileOpenPage), args);

Window.Current.Activate();

}

}

В данном случае при активизации приложения по контракту File Open Picker поль-

зователь перенаправляется на страницу FileOpenPage.xaml, которая показывается

Файловые контракты и расширения 237

в диалоге открытия файла. По умолчанию кнопка открытия файла будет отключе-

на, пока файл(ы) не будет добавлен в приложение с помощью аргумента args.

Выполним добавление файла по нажатию кнопки на странице FileOpenPage.xaml

(листинг 17.13). Выбираемым файлом будет картинка Logo.png из проекта прило-

жения.

Листинг 17.13. Добавление файла

public sealed partial class FileOpenPage : Page

{

public FileOpenPage()

{

this.InitializeComponent();

}

private FileOpenPickerActivatedEventArgs _args;

protected override void OnNavigatedTo(NavigationEventArgs e)

{

base.OnNavigatedTo(e);

_args = e.Parameter as FileOpenPickerActivatedEventArgs;

}

private async void Button_Click(object sender, RoutedEventArgs e)

{

var file = await Package.Current.InstalledLocation.GetFileAsync(

@»Assets\Logo.png»);

if (_args != null)

{

var result = _args.FileOpenPickerUI.AddFile(«fileId», file);

}

}

}

После выполнения кода листинга 17.13 любое приложение, запросившее открытие

файла, сможет прочитать файл из вашего приложения. Причем, так как в качестве

возвращаемого файла указывается реализация интерфейса IStorageFile, возвра-

щаемый файл может быть как локальным, так и удаленным, либо он вообще может

находиться в памяти.

Теперь, когда любое приложение вызывает FileOpenPicker, пользователь может

выбрать наше приложение в качестве источника файлов (рис. 17.4).

После этого в диалоге открытия файла пользователь увидит интерфейс нашего

приложения (рис. 17.5).

238 Глава 17

Рис. 17.4. Выбор источника файлов в диалоге открытия файла

Рис. 17.5. Страница FileOpenPage.xaml в диалоге открытия файла

Файловые контракты и расширения 239

Контракт File Save Picker

Приложение может не только выступать в роли поставщика файлов, но и быть хра-

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

Аналогично контракту File Open Picker для открытия файлов существует контракт File Save Picker для сохранения файлов, который требует переопределения метода

OnFileSavePickerActivated в классе приложения.

ПРИМЕЧАНИЕ

В данной книге мы не будем подробно рассматривать работу с контрактом File Save Picker.

Расширение StorageApplicationPermissions для кэширования доступа к файлам

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

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

сти повторно запрашивать к ним доступ.

Windows 8 предоставляет готовую инфраструктуру для реализации такого сценария

с помощью механизма кэширования доступа к файлам.

Рассмотрим, например, сценарий, когда запускается расширение FileOpenPicker, и после выбора определенного файла мы кэшируем доступ к нему в нашем приложе-нии (листинг 17.14).

Листинг 17.14. Кэширование доступа к файлу

var filePicker = new FileOpenPicker();

filePicker.FileTypeFilter.Add(«*»);

var file = await filePicker.PickSingleFileAsync();

var fileToken = StorageApplicationPermissions.FutureAccessList.Add(file);

Для кэширования предусмотрена функция FutureAccessList.Add, которая позволяет добавить файл в кэш, возвращая в ответ уникальный идентификатор для этого фай-

ла в кэше. По этому идентификатору мы можем получить доступ к файлу из кэша при повторном запуске приложения (листинг 17.15).

Листинг 17.15. Повторное получение доступа к файлу

var accessList = StorageApplicationPermissions.FutureAccessList;

if (accessList.ContainsItem(fileToken))

240 Глава 17

{

var file = await accessList.GetFileAsync(fileToken);

}

Также можно получить список всех файлов в кэше через свойство

FutureAccessList.Entries.

При добавлении файлов в кэш можно сохранять метаданные, в качестве которых

обычно указывают имя файла, чтобы впоследствии можно было показать пользова-

телю имена файлов в кэше (листинг 17.16).

Листинг 17.16. Добавление метаданных

var fileToken = StorageApplicationPermissions.FutureAccessList.Add(file, file.DisplayName);

Ассоциация с расширением файлов

и протоколом

Приложение может быть ассоциировано с расширением файлов. Допустим, в ва-

шем приложении принят свой формат файлов, и вы хотите, чтобы при открытии

этого файла из интерфейса операционной системы или из других приложений

запускалось ваше приложение.

Для ассоциации приложения с расширением файлов в манифесте приложения

необходимо добавить поддержку контракта File Type Associations. В контракте

мы можем указать ассоциацию с одним или несколькими расширениями, такими

как txt, png и т. п. Для примера добавим ассоциацию с расширением qwerty

(рис. 17.6).

При добавлении контракта необходимо указать логотип, который будет иконкой

для файлов при их ассоциации с нашим приложением. Зададим в качестве такой

иконки красный квадрат (файл Icon.png).

Теперь в классе приложения в файле App.xaml.cs необходимо переопределить

метод активизации при открытии файла OnFileActivated (листинг 17.17).

Листинг 17.17. Активизация при открытии файла

sealed partial class App : Application

{

…

protected override void OnFileActivated(FileActivatedEventArgs args)

{

var frame = new Frame();

Window.Current.Content = frame;

Файловые контракты и расширения 241

frame.Navigate(typeof(MainPage), args.Files);

Window.Current.Activate();

}

}

Рис. 17.6. Добавление контракта поддержки файла ассоциации с расширением

При открытии файла(ов) будет отображаться страница MainPage.xaml. Мы переда-ем странице MainPage.xaml все файлы, которые требуется открыть. Отобразим на

странице имена этих файлов (листинг 17.18).

Листинг 17.18. Отображение сообщения с именами файлов

public sealed partial class MainPage : Page

{

public MainPage()

242 Глава 17

{

this.InitializeComponent();

}

protected override void OnNavigatedTo(NavigationEventArgs e)

{

var files = e.Parameter as IReadOnlyList<IStorageItem>;

if (files != null)

{

StringBuilder sb = new StringBuilder();

foreach (var file in files)

{

sb.AppendLine(file.Name);

}

MessageDialog msg = new MessageDialog(sb.ToString());

msg.ShowAsync();

}

}

…

}

Запустите приложение, теперь файлы типа qwerty будут ассоциированы с нашим приложением (рис. 17.7). Закройте приложение. Создайте файл с расширением qwerty и откройте его. Запустится наше приложение и отобразится сообщение с именем файла.

Кроме расширения файла, приложение можно ассоциировать с протоколом. На-пример, FTP-клиенты могут быть ассоциированы с протоколом ftp, а браузеры — с http и https. В качестве примера рассмотрим ассоциацию с фиктивным протоко-лом qwerty. Для этого в манифесте приложения необходимо добавить контракт Protocol (рис. 17.8).

Для обработки активизации по протоколу необходимо переопределить метод

OnActivated в классе приложения в файле App.xaml.cs (листинг 17.19).

Листинг 17.19. Активизация по открытию ссылки

sealed partial class App : Application

{

…

protected override void OnActivated(IActivatedEventArgs args)

{

if (args.Kind == ActivationKind.Protocol)

{

var protocolArgs = args as ProtocolActivatedEventArgs;

var uri = protocolArgs.Uri;

Файловые контракты и расширения 243

Рис. 17.7. Ассоциация расширения файлов с приложением

Рис. 17.8. Добавление контракта ассоциации с протоколом

244 Глава 17

var rootFrame = new Frame();

rootFrame.Navigate(typeof(MainPage), uri);

Window.Current.Content = rootFrame;

}

Window.Current.Activate();

}

}

При активизации по протоколу мы открываем страницу MainPage.xaml и передаем ей в качестве аргумента адрес ссылки, по которой было открыто приложение.

Итоги

Для открытия и сохранения файлов можно использовать расширения FileOpenPicker

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

позволяет расширение StorageApplicationPermissions, которое кэширует права

доступа к файлам.

Если вам требуется полный доступ к одной из специальных папок, например

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

доступа в момент установки приложения.

С помощью контрактов File Open Picker и File Save Picker вы можете встроить ваше

приложение в диалоги открытия и сохранения файлов, сделав приложение источ-ником файлов.

Приложение можно ассоциировать с расширением файлов, например, txt и прото-колом, например, ftp.

T�a�a18

Работа с камерой

Во многих приложениях возникает необходимость работы с камерой (Web-

камерой) для получения фотографий и съемки видео. Сейчас почти во всех ноутбу-

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

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

сетей пользователь может сменить аватарку, не только загрузив файл из файловой

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

Windows 8 предоставляет встроенные средства работы с камерой и микрофоном.

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

файловой системы, есть и диалог получения фотографии и снятия видео. Получить

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

Чтобы иметь доступ к камере и микрофону, в манифесте приложения необходимо

это указать. Создайте приложение на основе шаблона Blank App и назовите его

Camera App.

Если вы собираетесь делать только фотографии, отметьте в манифесте приложения

пункт Webcam. Если вы будете снимать видео со звуком, необходимо отметить

еще и пункт Microphone (рис. 18.1).

Использование CameraCaptureUI

Самый простой способ работы с камерой — использование диалога съемки фо-

то/видео с помощью класса CameraCaptureUI. Требуется только указать, что мы хо-

тим получить (фото или видео), а все остальное за нас выполнит система. В резуль-

тате работы CameraCaptureUI создается файл, который доступен далее в нашем при-

ложении. Можно, например, отобразить полученную фотографию на странице

приложения или загрузить на сервер в Интернете.

246 Глава 18

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

Добавим на страницу MainPage.xaml кнопку, при нажатии на которую мы будем

получать фотографию и отображать ее в элементе управления Image. XAML-

разметка страницы MainPage приведена в листинге 18.1.

Листинг 18.1. Разметка страницы MainPage

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Button Content=»Снять фото»/>

<Image x:Name=»imgMain» Width=»640″ Height=»480″/>

</Grid>

</Page>

Добавьте обработчик нажатия кнопки. При нажатии на кнопку получим фото с по-

мощью CameraCaptureUI (листинг 18.2).

Работа с камерой 247

Листинг 18.2. Получение фотографии

private async void Button_Click(object sender, RoutedEventArgs e)

{

var camera = new CameraCaptureUI();

StorageFile file = await

camera.CaptureFileAsync(CameraCaptureUIMode.Photo);

if (file != null)

{

BitmapImage bitmapImage = new BitmapImage();

using (IRandomAccessStream fileStream = await

file.OpenAsync(FileAccessMode.Read))

{

bitmapImage.SetSource(fileStream);

}

imgMain.Source = bitmapImage;

}

}

В коде листинга 18.2 мы после получения ссылки на файл открываем его в режиме

чтения, загружая файловый поток, который мы устанавливаем источником для изо-

бражения, показываемого затем в элементе управления Image на странице.

ВНИМАНИЕ!

Не забывайте о необходимости делать проверку на NULL. Пользователь может отка-

заться от съемки и закрыть диалоговое окно камеры (нажав кнопку «Назад»). Тогда в

результате выполнения операции нам вернется NULL. В связи с этим следует обяза-

тельно проверять файловую ссылку на NULL, прежде чем выполнять с файлом какие-

либо действия.

Запустите приложение. При нажатии на кнопку откроется диалог камеры и пользо-

вателю будет задан вопрос, показываемый только при первой попытке доступа

к камере, действительно ли он хочет предоставить приложению доступ (рис. 18.2).

Предоставив доступ, пользователь увидит стандартный системный диалог, в кото-

ром он сможет выбрать нужную камеру при наличии нескольких, а также выпол-

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

полученную фотографию.

Заменив параметр CameraCaptureUIMode.Photo на CameraCaptureUIMode.Video, мы

можем получить не фотографию, а видеозапись.

Рассмотрим пример получения видеозаписи. Для воспроизведения видео восполь-

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

248 Глава 18

Рис. 18.2. Запрос доступа к камере

Листинг 18.3. Добавление элемента управления MediaElement

<Grid Background=»{StaticResource ApplicationPageBackgroundThemeBrush}»>

<Button Content=»Снять фото» Click=»Button_Click» />

<MediaElement x:Name=»meMain» Width=»640″ Height=»480″/>

</Grid>

Получим и отобразим видео на странице (листинг 18.4).

Листинг 18.4. Получение видео

private async void Button_Click(object sender, RoutedEventArgs e)

{

var camera = new CameraCaptureUI();

StorageFile file = await

camera.CaptureFileAsync(CameraCaptureUIMode.Video);

if (file != null)

{

IRandomAccessStream fileStream = await

file.OpenAsync(FileAccessMode.Read);

meMain.SetSource(fileStream, «video/mp4»);

}

}

Работа с камерой 249

Кроме параметра CameraCaptureUIMode.Video, мы также можем указать значение

CameraCaptureUIMode.PhotoOrVideo. В этом случае у пользователя появится возмож-ность переключаться между режимом съемки фото и видео.

Настройка параметров для съемки фотографий

У класса CameraCaptureUI есть свойства PhotoSettings и VideoSettings, позволяю-щие указывать настройки для фото и видео. Рассмотрим дополнительные настрой-

ки для съемки фото.

PhotoSettings.AllowCropping

Свойство AllowCropping (по умолчанию имеющее значение true) указывает, можно ли обрезать полученную фотографию (листинг 18.5). Сделав фотографию, пользо-

ватель может ее обрезать и вернуть приложению уже обрезанный вариант.

Листинг 18.5. Свойство AllowCropping

var camera = new CameraCaptureUI();

camera.PhotoSettings.AllowCropping = true;

PhotoSettings.CroppedAspectRatio

Свойство CroppedAspectRatio позволяет указать фиксированное соотношение сто-рон для фотографии. Это может быть полезно, если, например, вы собираетесь впи-

сать фотографию в рамку определенного размера.

В листинге 18.6 показано, как можно установить соотношение сторон 2 к 1 для

ширины и высоты изображения.

Листинг 18.6. Установка соотношения сторон фотографии

var camera = new CameraCaptureUI();

camera.PhotoSettings.CroppedAspectRatio = new Size(2,1);

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

если значение свойства AllowCropping установлено в false. Кроме того, нельзя за-

давать одновременно свойства CroppedAspectRatio и CroppedSizeInPixels.

PhotoSettings.CroppedSizeInPixels

В тех случаях, когда нужна фотография не просто определенных пропорций, но

конкретных размеров, мы можем воспользоваться свойством CroppedSizeInPixels,

250 Глава 18

позволяющим указать размеры, до которых будет обрезана фотография (лис-тинг 18.7).

Листинг 18.7. Установка размера фотографии

var camera = new CameraCaptureUI();

camera.PhotoSettings.CroppedSizeInPixels = new Size(200,200);

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

PhotoSettings.Format

Свойство Format типа CameraCaptureUIPhotoFormat позволяет указывать формат ко-дировки изображения. Доступны три формата: JPEG, PNG и JPEG XR.

JPEG XR — стандарт кодирования фотографий, ранее известный как Windows Media Photo. Он дает меньше артефактов, чем JPEG. При этом размер файла JPEG XR тоже будет меньше.

Установку формата JPEG XR иллюстрирует листинг 18.8.

Листинг 18.8. Установка формата

var camera = new CameraCaptureUI();

camera.PhotoSettings.Format = CameraCaptureUIPhotoFormat.JpegXR;

СОВЕТ

Применяйте JPEG XR с осторожностью, т. к. старые версии операционных систем его не поддерживают. Если вы хотите публиковать изображения в Интернете, используй-те формат JPEG (по умолчанию) или PNG.

PhotoSettings.MaxResolution

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

максимальное значение можно ограничить. Свойство MaxResolution типа

CameraCaptureUIMaxPhotoResolution принимает следующие значения:

� HighestAvailable (значение по умолчанию — максимально возможное разреше-ние камеры);

� VerySmallQvga (разрешение до 320×240);

� SmallVga (разрешение до 320×240);

Работа с камерой 251

� MediumXga (разрешение до 1024×768);

� Large3M (разрешение до 1920×1080);

� VeryLarge5M (разрешение до 5 Мпикс).

Выберем подходящее разрешение (листинг 18.9).

Листинг 18.9. Выбор разрешения

var camera = new CameraCaptureUI();

camera.PhotoSettings.MaxResolution=

CameraCaptureUIMaxPhotoResolution.MediumXga;

Настройка параметров для съемки видео

VideoSettings.AllowTrimming

По умолчанию пользователь может укоротить видеозапись, отрезав «хвосты» в на-

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

необходимости (листинг 18.10).

Листинг 18.10. Установка свойства AllowTrimming

var camera = new CameraCaptureUI();

camera.VideoSettings.AllowTrimming = false;

VideoSettings.Format

Свойство Format для видео, как и аналогичное свойство для фотографий, позволяет

указать формат кодирования (листинг 18.11). На данный момент выбор ограничен

форматами MP4 (значение по умолчанию) и WMV.

Листинг 18.11. Формат записи видеофайла

var camera = new CameraCaptureUI();

camera.VideoSettings.Format = CameraCaptureUIVideoFormat.Wmv;

VideoSettings.MaxDurationInSeconds

Свойство MaxDurationInSeconds позволяет указать максимальную длину видеороли-

ка в секундах (листинг 18.12). При установке такого ограничения пользователь

должен будет сам обрезать снятое видео до нужной длины. Данная опция не рабо-

тает при установке свойству AllowTrimming значения false. К сожалению, нет воз-

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

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

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

252 Глава 18

Листинг 18.12. Установка максимальной длины записи

var camera = new CameraCaptureUI();

camera.VideoSettings.MaxDurationInSeconds = 10;

VideoSettings.MaxResolution

Как и для фотографий, для видео можно установить ограничение по качеству изо-

бражения (листинг 18.13). Свойство MaxResolution может принимать следующие значения:

� HighestAvailable — максимально возможное качество;

� LowDefinition — низкая четкость;

� StandardDefinition — стандартная четкость;

� HighDefinition — высокая четкость.

Естественно, реальное качество видеозаписи будет зависеть от характеристик ка-

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

установлено в свойстве MaxResolution.

Листинг 18.13. Установка разрешения высокой четкости в качестве желаемого

var camera = new CameraCaptureUI();

camera.VideoSettings.MaxResolution =

CameraCaptureUIMaxVideoResolution.HighDefinition;

Использование расширения MediaCapture для прямой работы с видео/аудио

Диалог получения фото/видеозаписи подходит не во всех ситуациях. К примеру,

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

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

явно недостаточно. Здесь и пригодится расширение MediaCapture, c помощью кото-

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

видео и звук в файл и получать доступ к медиапотокам.

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

инициализировать класс MediaCapture (листинг 18.14). Во время первой инициали-

зации приложение запрашивает у пользователя разрешение на предоставление дос-

тупа к камере и микрофону.

Листинг 18.14. Инициализация MediaCapture

private MediaCapture _mediaCapture;

protected override async void OnNavigatedTo(NavigationEventArgs e)

Работа с камерой 253

{

if (_mediaCapture == null)

{

_mediaCapture = new MediaCapture();

try

{

await _mediaCapture.InitializeAsync();

_mediaCapture.RecordLimitationExceeded += async (sender) =>

{

//обработка превышения лимита записи

await _mediaCapture.StopRecordAsync();

};

}

catch (UnauthorizedAccessException)

{

// Доступ к камере и микрофону не был предоставлен

}

}

}

После инициализации у нас есть возможность записывать звук и видео в файл, ис-

пользуя метод StartRecordToStorageFileAsync, где в качестве второго параметра

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

применения CameraCaptureUI, который возвращает ссылку на уже записанный

файл). Другой метод — StartRecordToStreamAsync позволяет осуществлять запись в произвольный поток.

Рассмотрим, как можно записать звук в оперативную память и проиграть аудио-файл после завершения записи.

Добавьте три кнопки на страницу MainPage.xaml. Первая кнопка будет начинать запись, вторая — останавливать, а третья — проигрывать сделанную запись. До-бавьте обработчики событий нажатия кнопок (листинг 18.15).

Листинг 18.15. Запись звука

private InMemoryRandomAccessStream _stream;

//Начать запись

private async void Start_Button_Click(object sender, RoutedEventArgs e)

{

try

{

_stream = new InMemoryRandomAccessStream();

var encodingProfile =

MediaEncodingProfile.CreateMp3(AudioEncodingQuality.Auto);

254 Глава 18

await _mediaCapture.StartRecordToStreamAsync(encodingProfile,

_stream);

}

catch (Exception ex)

{

// Обработка ошибок

}

}

// Остановить запись

private async void Stop_Button_Click(object sender, RoutedEventArgs e)

{

await _mediaCapture.StopRecordAsync();

}

// Проиграть сделанную запись

private void Play_Button_Click(object sender, RoutedEventArgs e)

{

meMain.SetSource(_stream, «audio/mp3»);

meMain.Play();

}

То, что мы записываем звук, задается нужным медиапрофилем. В данном примере мы создали профиль для записи звука, кодируемого в формат MP3 с помощью вы-

зова функции MediaEncodingProfile.CreateMp3.

Сделанная запись проигрывается с помощью элемента управления MediaElement,

добавленного нами в примере с CameraCaptureUI для записи видео.

Теперь рассмотрим пример работы с видео. Для отображения живого видеопотока с камеры на страницах приложения предназначен элемент управления CaptureElement, добавленный на главную страницу (листинг 18.16).

Листинг 18.16. Элемент управления CaptureElement

<CaptureElement x:Name=»ceMain» Width=»1024″ Height=»768″ />

После инициализации объекта класса MediaCapture для отображения видеопотока в элементе управления CaptureElement требуется вызвать метод StartPreviewAsync (листинг 18.17).

Листинг 18.17. Запуск отображения видеопотока

ceMain.Source = _mediaCapture;

await _mediaCapture.StartPreviewAsync();

Запустите приложение и вы увидите «живой» видеопоток, отображаемый на стра-нице MainPage.xaml (рис. 18.3).

Работа с камерой 255

Рис. 18.3. Отображение «живого» видеопотока

Рассмотрим пример записи видео в файл, который будет располагаться в папке

«Видео» (листинг 18.18). Для этого в манифесте приложения следует отметить не-

обходимость доступа к этой папке. Работу с файлами и папками, и в том числе

с папкой (библиотекой) «Видео», мы рассмотрели в главе 17.

Листинг 18.18. Запись видеофайла

private StorageFile _recordVideoFile;

//Начать запись видео

private async void Start_Button_Click(object sender, RoutedEventArgs e)

{

try

{

_recordVideoFile =

await KnownFolders.VideosLibrary.CreateFileAsync(«video.mp4»,

CreationCollisionOption.GenerateUniqueName);

var encodingProfile =

MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto);

await _mediaCapture.StartRecordToStorageFileAsync(

encodingProfile, _recordVideoFile);

}

256 Глава 18

catch (Exception ex)

{

// Обработка ошибок

}

}

Класс MediaCapture позволяет также снимать фотографии с помощью методов

CapturePhotoToStorageFileAsync и CapturePhotoToStreamAsync. Таким образом, вы

можете сделать свой интерфейс, повторяющий диалог получения фотографии, если

системный диалог вас по каким-то причинам не устраивает.

Дополнительные настройки расширения MediaCapture

Если на устройстве пользователя доступно несколько камер, по умолчанию будет

работать основная камера. Диалог CameraCaptureUI позволяет пользователю пере-

ключаться между камерами из интерфейса диалога. Но что делать, если мы работа-

ем с видеопотоком напрямую?

Получить камеры и микрофоны можно с помощью класса DeviceInformation.

Сформируем список всех камер и микрофонов, а также установим первый микро-

фон и первую камеру в качестве источников звука и видео (листинг 18.19).

Листинг 18.19. Получение списка камер и микрофонов

var cameras = await DeviceInformation.FindAllAsync(DeviceClass.VideoCapture);

var microphones = await DeviceInformation.FindAllAsync(DeviceClass.AudioCapture);

var camera = cameras.FirstOrDefault();

var microphone = microphones.FirstOrDefault();

if (camera != null && microphone != null)

{

var settings = new MediaCaptureInitializationSettings()

{

AudioDeviceId = microphone.Id,

VideoDeviceId = camera.Id

};

await _mediaCapture.InitializeAsync(settings);

}

Класс MediaCapture позволяет управлять настройками камеры через свойство

VideoDeviceController.

Работа с камерой 257

Вот перечень доступных настроек:

� BacklightCompensation — управление подсветкой камеры;

� Brightness — управление яркостью;

� Contrast — настройка контраста;

� Exposure — управление выдержкой;

� Focus — управление фокусировкой;

� Hue — настройка оттенка;

� Pan — слежение камерой;

� Roll — вращение камеры;

� Tilt — управление наклоном камеры;

� WhiteBalance — настройка баланса белого;

� Zoom — настройка зуммирования.

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

CameraOptionsUI (листинг 18.20).

Листинг 18.20. Диалог настроек камеры

CameraOptionsUI.Show(_mediaCapture);

Данный диалог (рис. 18.4) позволяет настроить яркость, контрастность, фокус и другие пара-

метры камеры.

С помощью свойства AudioDeviceController можно управлять настройками микрофона:

� Muted — отключение звука (принимает зна-

чение true или false);

� VolumePercent — уровень громкости (значе-ния от 0 до 100).

Рис. 18.4. Диалог CameraOptionsUI

258 Глава 18

Итоги

Есть два подхода к работе с камерой и микрофоном в Windows Store-приложениях. Можно воспользоваться системным диалогом получения фотографии/записи видео.

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

Второй подход — прямой доступ к видеопотоку. При этом вы можете отображать

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

с CameraCaptureUI, но и возможности открываются гораздо более широкие.

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

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

T�a�a19

Работа с картами

и определение местоположения

Хотя картографические сервисы появились не так давно, они уже прочно вошли в нашу жизнь. С помощью таких сервисов, как Bing Maps от Microsoft, люди выби-рают маршруты проезда с учетом пробок, ищут ближайшее кафе, аптеку, магазин и т. д.

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

В данной главе мы рассмотрим использование сервиса определения местоположе-ния, а также работу с Bing Maps SDK, который необходим для отображения карт от Microsoft. Сервис определения местоположения входит в операционную систему Windows 8, а Bing Maps SDK поставляется отдельно. В своих приложениях вы мо-жете выбрать картографию от любого производителя, который выпустит соответ-ствующий SDK для Windows 8, а не только карты Bing.

Сервис определения местоположения

Операционная система может определять местоположение различными способами, в зависимости от того, какое аппаратное обеспечение и сетевое соединение доступ-ны в данный момент. Поддерживается работа с GPS (Global Position System), триан-

260 Глава 19

гуляция по вышкам сотовых сетей, определение местоположения по точкам досту-па Wi-Fi, а также по IP-адресу. Точность данных для каждого из этих способов раз-лична. Например, для компьютера, имеющего только проводное соединение с Ин-тернетом, точность определения местоположения по IP-адресу составляет около 50 км, для ноутбука, подключенного к публичной точке доступа Wi-Fi, — около 350 м, а для планшета/ноутбука с GPS — 10 м и менее.

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

ления местоположения доступны в некоторый момент времени на конкретном уст-

ройстве, и откуда берутся данные. Сервис определения местоположения в едином

формате предоставляет приложениям информацию о географических координатах

и точности их измерения. Вы можете использовать эти данные, если вас устраивает

их точность. При этом операционная система старается выбирать наиболее точный

источник.

Кроме того, различные источники данных могут предоставлять дополнительную

информацию, например, GPS (в отличие от определения местоположения по IP-адресу) выдает информацию о высоте и скорости перемещения.

Сведения о местоположении — конфиденциальная информация. Поэтому пользо-

ватели (на уровне операционной системы) или администраторы (на уровне домена

Active Directory) могут указать, предоставлять ли вообще приложениям данные о местоположении.

Приложениям необходимо указать в манифесте, что они используют сервис опре-

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

тель должен явно разрешить это. Но даже дав такое разрешение, пользователь

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

конкретному приложению. Таким образом, предоставление данных о местополо-

жении можно запретить как для всех приложений в целом, так и для конкретного

приложения в отдельности. Кроме того, пользователь может включить режим

Airplane Mode, после чего приложения также не смогут получать данные о место-положении.

Определение местоположения

Рассмотрим функционирование сервиса определения местоположения на практиче-

ском примере. Создайте приложение на основе шаблона Blank App и назовите его LocationApp.

В манифесте приложения Package.appxmanifest на вкладке Capabilities добавьте возможность под названием Location (рис. 19.1).

На странице MainPage.xaml добавьте разметку для отображения текущих коорди-

нат (листинг 19.1). В данном примере по нажатию кнопки мы будем отображать

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

txtLatitide, txtLongitude и txtAccuracy соответственно.

Работа с картами и определение местоположения 261

Рис. 19.1. Указание использования сервиса определения местоположения в манифесте приложения

Листинг 19.1. XAML-разметка страницы MainPage

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»Auto»/>

<RowDefinition/>

</Grid.RowDefinitions>

<Button x:Name=»btnLocation»

Content=»Определить местоположение» Grid.Row=»0″

VerticalAlignment=»Center» HorizontalAlignment=»Center»

Margin=»10″ />

<StackPanel Grid.Row=»1″

Orientation=»Vertical» VerticalAlignment=»Top»

HorizontalAlignment=»Center»>

<TextBlock x:Name=»txtAccuracy» Style=»{StaticResource

HeaderTextStyle}» Margin=»5″/>

262 Глава 19

<TextBlock x:Name=»txtLatitide» Style=»{StaticResource

HeaderTextStyle}» Margin=»5″/>

<TextBlock x:Name=»txtLongitude» Style=»{StaticResource

HeaderTextStyle}» Margin=»5″/>

</StackPanel>

</Grid>

</Page>

Как и в большинстве API для работы с сенсорами, сервис определения местополо-жения позволяет либо получить данные однократно, либо подписаться на измене-

ние данных (в нашем случае на перемещение устройства). В первом примере мы будем однократно получать данные о местоположении при нажатии на кнопку

с именем btnLocation.

Добавьте обработчик события нажатия этой кнопки.

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

Geolocator из пространства имен Windows.Devices.Geolocation. Для получения те-кущей координаты необходимо создать экземпляр данного класса и вызвать метод

GetGeopositionAsync (листинг 19.2).

Листинг 19.2. Определение текущей координаты

private async void BtnLocationClick(object sender, RoutedEventArgs e)

{

var geolocator = new Geolocator();

try

{

var position = await geolocator.GetGeopositionAsync();

txtAccuracy.Text = String.Format(«Точность {0} метров «,

position.Coordinate.Accuracy);

txtLatitide.Text = String.Format(«Широта: {0}»,

position.Coordinate.Latitude);

txtLongitude.Text = String.Format(«Долгота: {0}»,

position.Coordinate.Longitude);

}

catch (Exception)

{

// Обработка ошибок и тайм-аутов

}

}

Метод GetGeopositionAsync возвращает объект класса Geoposition, у которого есть

свойство Coordinate типа Geoсoordinate. Тип Geoсoordinate имеет следующие свой-ства (табл. 19.1).

Работа с картами и определение местоположения 263

Талица 19.1. Свойства типа Geoсoordinate

Свойство Описание

Accuracy Точность измерения широты и долготы в метрах

Latitude Широта

Longitude Долгота

Speed Скорость

Altitude Высота

AltitudeAccuracy Точность измерения высоты в метрах

Heading Ориентация в градусах относительно географического северного полюса

Timestamp Время, когда было определено местоположение

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

местоположения по IP-адресу), будут установлены в null.

Запустите приложение. При первом нажатии на кнопку btnLocation операционная система спросит у пользователя, можно ли предоставить приложению данные о ме-стоположении (рис. 19.2). Если разрешение будет получено, данные отобразятся на

странице (рис. 19.3).

Рис. 19.2. Запрос разрешения на предоставление приложению информации о местоположении

Рис. 19.3. Отображение информации о местоположении

При определении местоположения разработчик может указать, нужна ли приложе-

нию максимальная точность или нет, задав значение свойства DesiredAccuracy

объекта класса Geolocator (листинг 19.3). Можно выбрать стандартную и высокую

точность.

264 Глава 19

Листинг 19.3. Указание желаемой точности определения местоположения

var geolocator = new Geolocator();

geolocator.DesiredAccuracy = PositionAccuracy.High;

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

Запуск сервиса определения местоположения может занимать значительное время (до нескольких секунд). Поэтому при определении местоположения не стоит бло-кировать пользовательский интерфейс. Текущий статус сервиса определения ме-стоположения можно получить с помощью свойства LocationStatus объекта класса

Geolocator. Для отслеживания изменения статуса вы можете подписаться на собы-

тие StatusChanged.

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

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

ния. В нашем примере это кнопка btnLocation.

Определение изменения местоположения

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

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

PositionChanged (листинг 19.4).

Листинг 19.4. Подписка на событие изменения местоположения

public sealed partial class MainPage : Page

{

private Geolocator _geolocator;

public MainPage()

{

InitializeComponent();

}

Работа с картами и определение местоположения 265

private void BtnLocationClick(object sender, RoutedEventArgs e)

{

if (_geolocator != null) _geolocator.PositionChanged -=

GeolocatorPositionChanged;

_geolocator = new Geolocator();

_geolocator.PositionChanged += GeolocatorPositionChanged;

}

void GeolocatorPositionChanged(Geolocator sender,

PositionChangedEventArgs args)

{

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

var position = args.Position;

txtAccuracy.Text = String.Format(«Точность {0} метров «,

position.Coordinate.Accuracy);

txtLatitide.Text = String.Format(«Широта: {0}»,

position.Coordinate.Latitude);

txtLongitude.Text = String.Format(«Долгота: {0}»,

position.Coordinate.Longitude);

});

}

}

Обработчик события изменения местоположения вызывается в потоке, отличном от

потока пользовательского интерфейса, поэтому для взаимодействия с пользова-

тельским интерфейсом (для изменения содержимого текстовых блоков) такое взаи-

модействие необходимо обернуть в вызов Dispatcher.RunAsync.

Как часто будет генерироваться событие PositionChanged? Мы можем контролиро-

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

ва будет генерироваться следующий вызов. Для этого необходимо установить зна-

чение свойства MovementThreshold (в метрах) объекта класса Geolocator. В листин-

ге 19.5 мы задаем значение, равное одному километру.

Листинг 19.5. Задание значения интервала реакции на изменения местоположения

_geolocator = new Geolocator();

_geolocator.MovementThreshold = 1000;

_geolocator.PositionChanged += GeolocatorPositionChanged;

Так как местоположение определяется неточно, событие PositionChanged не обяза-

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

ством MovementThreshold, поэтому рекомендуется всегда проверять, удовлетворяет

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

266 Глава 19

Установка свойства MovementThreshold не влияет на энергопотребление. Сервис оп-

ределения местоположения через определенные промежутки времени вычисляет

координаты независимо от значения данного свойства. После этого проверяется

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

генерируется событие PositionChanged.

Для оптимизации энергопотребления необходимо задать свойство ReportInterval,

которое определяет интервал времени в миллисекундах, через который будут вы-

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

данные о местоположении, установите бóльшее значение свойства. В листинге 19.6

значение свойства ReportInterval равно одной минуте.

Листинг 19.6. Задание интервала определения координат

_geolocator = new Geolocator();

_geolocator.MovementThreshold = 1000;

_geolocator.ReportInterval = 60 * 1000;

_geolocator.PositionChanged += GeolocatorPositionChanged;

Если вы зададите для свойства ReportInterval нулевое значение, сведения о место-

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

точник данных. Если несколько приложений установили свои значения свойства

ReportInterval, местоположение будет обновляться в соответствии с минимальным

значением. При этом не гарантируется, что источник данных вообще сможет рабо-

тать с заданной частотой. Поэтому реальное время обновления может существенно

отличаться от значения свойства ReportInterval.

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

бегать по офису с ноутбуком — прямо скажем, не самое приятное занятие. Поэтому

нам на помощь может прийти симулятор, позволяющий динамически задавать ме-

стоположение. Для этого на симуляторе необходимо нажать кнопку с изображени-

ем земного шара (рис. 19.4).

Откроется диалоговое окно, в котором вы можете ввести широту, долготу, высоту и

погрешность измерения (рис. 19.5). После этого необходимо нажать кнопку Set

Location.

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

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

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

нии местоположения. Если вам необходимо отслеживать изменение местоположе-

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

воспользуйтесь фоновыми агентами. Подробнее про многозадачность и работу

с фоновыми агентами вы можете прочитать в главе 10.

Работа с картами и определение местоположения 267

Рис. 19.4. Кнопка задания местоположения симулятора

Рис. 19.5. Диалог задания местоположения симулятора

Работа с Bing Maps SDK

Элемент управления для отображения карт не входит в поставку Windows 8. Для выполнения следующего примера нам потребуется Bing Maps SDK for Windows Store apps.

Добавим поддержку отображения карты в предыдущей пример, в котором мы оп-

ределяли изменение местоположения. Скачайте последнюю версию Bing Maps SDK и запустите vsix-файл, откроется окно установки (рис. 19.6).

Нажмите кнопку Install, Bing Maps SDK будет установлен. После этого в проекте приложения LocationApp, с которым мы работали ранее, в окне Solution Explorer

в контекстном меню раздела References выберите пункт Add Reference… Откроет-ся диалоговое окно, в левой части которого в дереве выберите пункт Windows |

Extensions. Поставьте галочки напротив опций Bing Maps for C#, C++ or Visual

Basic и Microsoft C++ Runtime Package и нажмите кнопку OK. В результате Bing Maps SDK будет подключен к приложению (рис. 19.7).

После подключения Bing Maps SDK проект не будет компилироваться. Bing Maps SDK — это библиотека, написанная на C++, поэтому она не может быть скомпили-

рована под Any CPU (любой процессор), как это происходит в случае с управляе-мым кодом на C#. Чтобы скомпилировать проект, необходимо указать конкретную

процессорную архитектуру.

268 Глава 19

Рис. 19.6. Установка vsix-файла Bing Maps SDK

Рис. 19.7. Подключение Bing Maps SDK к проекту приложения

Работа с картами и определение местоположения 269

Для этого в главном меню Visual Studio выберите пункт BUILD | Configuration

Manager… В открывшемся диалоговом окне в выпадающем списке Active solution

platform укажите значение x86 (сама Visual Studio является 32-разрядным прило-жением x86, поэтому при отладке Windows Store-приложений проще всего работать

с этой процессорной архитектурой) (рис. 19.8).

Рис. 19.8. Выбор процессорной архитектуры

При загрузке нашего приложения в Windows Store нужно будет добавить версии для разных процессорных архитектур (x86, x64, ARM), а не одну версию приложе-ния, как при отсутствии Bing Maps SDK.

Мы выполнили все необходимые предварительные действия, теперь можно начать

работать с элементом управления Map. Удалим со страницы разметку текстовых блоков, а также код задания значений для них, и добавим разметку для отображе-ния карты (листинг 19.7).

Листинг 19.7. Разметка страницы MainPage с элементом управления Map

<Page

x:Class=»LocationApp.MainPage»

xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation»

xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»

xmlns:local=»using:LocationApp»

xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″

xmlns:mc=»http://schemas.openxmlformats.org/markup- compatibility/2006″

xmlns:bing=»using:Bing.Maps»

mc:Ignorable=»d»>

270 Глава 19

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»Auto»/>

<RowDefinition/>

</Grid.RowDefinitions>

<Button x:Name=»btnLocation»

Content=»Определить местоположение» Grid.Row=»0″

VerticalAlignment=»Center» HorizontalAlignment=»Center»

Margin=»10″ Click=»BtnLocationClick»/>

<bing:Map Grid.Row=»1″ x:Name=»map»/>

</Grid>

</Page>

ВНИМАНИЕ!

Обратите внимание на подключение пространства имен XML bing:

xmlns:bing=»using:Bing.Maps», а также на элемент управления Map: <bing:Map

Grid.Row=»1″ x:Name=»map»/>.

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

Обратите внимание на надпись на белом фоне в центре карты, которая говорит, что

указаны неверные данные учетной записи разработчика. Элемент управления Map

Рис. 19.9. Элемент управления Map

Работа с картами и определение местоположения 271

обращается к сервису карт Bing, и для его использования в реальном приложении требуется регистрация и получение ключа. Зарегистрироваться и получить ключ можно на портале разработки Bing Maps: http://www.bingmapsportal.com/.

После бесплатной регистрации разработчик получает строковый ключ, который нужно указать в свойстве Credentials элемента управления Map. Когда ключ будет указан, надпись в центре карты исчезнет (листинг 19.8).

Листинг 19.8. Указание ключа API для Bing Maps

<bing:Map Grid.Row=»1″ x:Name=»map»

Credentials=»AsWlUnHbvLgHlLHaRhTZLslewv1QIdGppxOqyL-6He2jxyHvLAjutrcntemUih-w9″/>

ПРИМЕЧАНИЕ

Ключ, приведенный в листинге 19.8, не настоящий. Он показан только для демонстрации.

Добавим простые элементы управления картой: уменьшение/увеличение масштаба

(кнопки ZoomIn и ZoomOut), а также смену режима отображения карты «схема/

спутник» (LayoutChange) (листинг 19.9).

Листинг 19.9. Разметка кнопок управления картой

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»>

<Grid.RowDefinitions>

<RowDefinition Height=»Auto»/>

<RowDefinition/>

</Grid.RowDefinitions>

<StackPanel Grid.Row=»0″ Orientation=»Horizontal»

HorizontalAlignment=»Center»>

<Button x:Name=»btnLocation»

Content=»Определить местоположение» Grid.Row=»0″

VerticalAlignment=»Center» HorizontalAlignment=»Center»

Margin=»10″ Click=»BtnLocationClick»/>

<Button Name=»ZoomIn» Content=»+»

HorizontalAlignment=»Center»

VerticalAlignment=»Bottom» Height=»60″ Width=»60″

FontWeight=»Bold» Padding=»0,-9,0,0″/>

<Button Name=»ZoomOut» Content=»-«

HorizontalAlignment=»Center»

VerticalAlignment=»Bottom» Height=»60″ Width=»60″

FontWeight=»Bold» Padding=»0,-9,0,0″ />

272 Глава 19

<Button Name=»LayoutChange» Content=»L»

HorizontalAlignment=»Center» VerticalAlignment=»Bottom»

Height=»60″ Width=»60″

FontWeight=»Bold» Padding=»0,-9,0,0″/>

</StackPanel>

<bing:Map Grid.Row=»1″ x:Name=»map»

Credentials=»AsWlUnHbvLgHlLHaRhTZLslewv1QIdGppxOqyL-6He2jxyHvLAjutrcntemUih-w9″/>

</Grid>

</Page>

Код обработки нажатия кнопок приведен в листинге 19.10.

Листинг 19.10. Код обработки нажатия кнопок управления картой

private void ZoomInClick(object sender, RoutedEventArgs e)

{

if (map.ZoomLevel <= 19) map.ZoomLevel++;

}

private void ZoomOutClick(object sender, RoutedEventArgs e)

{

if (map.ZoomLevel >= 2) map.ZoomLevel—;

}

private void LayoutChangeClick(object sender, RoutedEventArgs e)

{

if (map.MapType == MapType.Road)

map.MapType = MapType.Aerial;

else

map.MapType = MapType.Road;

}

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

Для этого в событии GeolocatorPositionChanged мы будем получать текущее место-

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

Листинг 19.11. Отображение участка текущего местоположения на карте

void GeolocatorPositionChanged(Geolocator sender, PositionChangedEventArgs args)

{

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

var location = new Location(args.Position.Coordinate.Latitude,

args.Position.Coordinate.Longitude);

Работа с картами и определение местоположения 273

map.SetView(location, 10);

});

}

Второй аргумент метода SetView — масштаб отображения карты. Запустите прило-

жение, нажмите кнопку Определить местоположение. Карта должна отобразить

участок вашего текущего местоположения или местоположения, заданного

в симуляторе при отладке приложения на нем.

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

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

этого в классе MainPage определим переменную типа Pushpin (листинг 19.12).

Листинг 19.12. Определение переменной Pushpin

private Pushpin _pushpin = new Pushpin();

В обработчике изменения местоположения установим переменную Pushpin в соот-

ветствии с текущей позицией и добавим текущее местоположение на карту, если

его там нет (листинг 19.13).

Листинг 19.13. Установка Pushpin

void GeolocatorPositionChanged(Geolocator sender, PositionChangedEventArgs args)

{

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

var location = new Location(args.Position.Coordinate.Latitude,

args.Position.Coordinate.Longitude);

map.SetView(location, 10);

MapLayer.SetPosition(_pushpin, location);

if (!map.Children.Contains(_pushpin))

{

map.Children.Add(_pushpin);

}

});

}

Местоположение Pushpin устанавливается с помощью статического метода

SetPosition класса MapLayer.

Проверьте новую версию приложения. Текущее местоположение будет отобра-

жаться в виде голубого круга на карте (рис. 19.10).

274 Глава 19

Рис. 19.10. Отображение текущего местоположения с помощью Pushpin

ПРИМЕЧАНИЕ

На карте можно рисовать любые геометрические фигуры и картинки, а не только голу-бые круги, как в предыдущем примере.

Итоги

В данной главе мы рассмотрели работу с сервисом определения местоположения

с помощью класса Geolocator. Узнали про принципы работы сервиса и получение как одиночных значений, так и подписку на изменение местоположения. Далее мы рассмотрели работу с Bing Maps SDK, который позволяет использовать в приложе-

ниях карты Bing. Мы узнали, как работать с элементом управления Map, а также отобразили на карте точку, соответствующую текущему местоположению.

T�a�a20

Работа с сенсорами

Устройства, на которых может работать Windows 8, существенно отличаются от прежнего традиционного представления о персональных компьютерах, как о «больших ящиках», стоящих под столом. Мир стал мобильным. Конечно, сущест-вует значительный процент пользователей, работающих на стационарных устрой-ствах, но доля планшетов и ноутбуков постоянно увеличивается, и все больше уст-ройств, включая последние поколения ноутбуков и большинство планшетов, имеют различные сенсоры.

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

В данной главе мы рассмотрим работу с такими сенсорами, как датчик света, аксе-лерометр, гироскоп, инклинометр и компас. На различных устройствах набор сен-соров может существенно отличаться. Например, на одном планшете/ноутбуке мо-жет быть доступен как акселерометр, так и гироскоп, а на другом — только акселе-рометр. API работы с сенсорами позволяет узнать, поддерживает ли устройство, на котором исполняется приложение, соответствующий сенсор.

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

Датчик света

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

276 Глава 20

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

Рис. 20.1. Отображение карты при различной освещенности

Создайте приложение на основе шаблона Blank App и назовите его LightSensorApp.

В данном приложении мы отобразим значение освещенности (в люксах), получен-ное от датчика света, в текстовом блоке на странице MainPage.xaml. В зависимости от освещенности мы будем изменять фон страницы MainPage.xaml. Ее XAML-

разметка приведена в листинге 20.1.

Листинг 20.1. XAML-разметка страницы MainPage

<Page

…

>

<Grid Background=»{StaticResource

ApplicationPageBackgroundThemeBrush}»

x:Name=»LayoutRoot»>

<TextBlock x:Name=»txtLight» Text=»Нет данных»

VerticalAlignment=»Center»

HorizontalAlignment=»Center»

Style=»{StaticResource HeaderTextStyle}»/>

</Grid>

</Page>

Менеджеру размещения Grid было присвоено имя LayoutRoot, а для отображения

значения освещенности добавлен текстовый блок с именем txtLight.

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

Для работы с датчиком света предусмотрен класс LightSensor из пространства имен

Windows.Devices.Sensors. Вначале необходимо получить датчик света по умолча-

Работа с сенсорами 277

нию, вызвав статическую функцию LightSensor.GetDefault(). Если ее возвращае-

мое значение равно null, датчик света в системе отсутствует.

Датчик света, как и другие сенсоры, позволяет получить текущее значение, а также подписаться на изменение значений. Получить текущее значение просто (лис-тинг 20.2).

Листинг 20.2. Получение текущего значения от датчика света

var lightSensor = LightSensor.GetDefault();

if (lightSensor != null)

{

var val = lightSensor.GetCurrentReading();

}

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

бытие ReadingChanged объекта класса LightSensor. Соответствующий C#-код стра-

ницы MainPage приведен в листинге 20.3.

Листинг 20.3. Заготовка обработчика изменения значений датчика света

public sealed partial class MainPage : Page

{

private LightSensor _lightSensor;

public MainPage()

{

this.InitializeComponent();

_lightSensor = LightSensor.GetDefault();

if (_lightSensor != null)

{

_lightSensor.ReadingChanged += LightSensorReadingChanged;

}

}

void LightSensorReadingChanged(LightSensor sender,

LightSensorReadingChangedEventArgs args)

{

}

}

Выведем получаемые значения в текстовое поле, а также изменим цвет фона стра-ницы в соответствии с освещенностью (листинг 20.4).

278 Глава 20

Листинг 20.4. Вывод значений освещенности

void LightSensorReadingChanged(LightSensor sender, LightSensorReadingChangedEventArgs args)

{

var reading = args.Reading;

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

LayoutRoot.Background = new SolidColorBrush(Color.FromArgb(255,

(byte)(reading.IlluminanceInLux / 2), 0, 0));

txtLight.Text = reading.IlluminanceInLux.ToString();

});

}

Как и в случае с сервисом определения местоположения, время обновления данных

датчика света задается свойством ReportInterval. Установим минимальное под-

держиваемое время обновления для датчика света (листинг 20.5).

Листинг 20.5. Установка минимального значения времени обновления датчика

_lightSensor.ReportInterval = _lightSensor.MinimumReportInterval;

При работе с сенсорами важно избежать утечки ресурсов (Resource leak), поэтому

при переходе со страницы, на которой использовались сенсоры, не забывайте отпи-

сываться от событий (листинг 20.6).

Листинг 20.6. Отписка от событий при переходе со страницы

protected override void OnNavigatedFrom(NavigationEventArgs e)

{

if (_lightSensor != null)

{

_lightSensor.ReadingChanged -= LightSensorReadingChanged;

}

base.OnNavigatedFrom(e);

}

Акселерометр

Акселерометр предоставляет разработчику трехмерный вектор ускорения устрой-

ства в гравитационных единицах (g — ускорение свободного падения), ориентиро-

ванный относительно устройства (рис. 20.2).

Работа с сенсорами 279

Рис. 20.2. Ориентация осей координат относительно устройства

Фактически данные акселерометра — это величина воздействия силы тяжести по каждой из осей координат. Если устройство лежит на столе экраном вверх, Z-компонент вектора равен –1 (по оси Z в сторону, противоположную положитель-ному направлению оси, действует сила, равная 1g). Если устройство стоит на торце, экраном к пользователю, Y-компонент вектора равен –1. Если же сила тяжести по данной оси не воздействует, значение компонента вектора будет равно нулю. Когда устройство перемещается с ускорением, по осям может воздействовать сила, пре-вышающая 1g.

Работа с акселерометром осуществляется с помощью класса Accelerometer, кото-

рый определен в пространстве имен Windows.Devices.Sensors. Для получения объ-екта акселерометра, как и в случае с датчиком света, а также другими сенсорами,

необходимо вызвать статическую функцию GetDefault().

Данные от акселерометра представляют собой объект класса AccelerometerReading,

который имеет свойства AccelerationX, AccelerationY и AccelerationZ, соответст-вующие воздействию силы тяжести по осям.

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

Листинг 20.7. Подписка на изменение значений акселерометра

public sealed partial class MainPage : Page

{

private Accelerometer _accelerometer;

public MainPage()

{

this.InitializeComponent();

_accelerometer = Accelerometer.GetDefault();

if (_accelerometer != null)

280 Глава 20

{

_accelerometer.ReadingChanged += AccelerometerReadingChanged;

}

}

void AccelerometerReadingChanged(Accelerometer sender,

AccelerometerReadingChangedEventArgs args)

{

// Взаимодействие с пользовательским интерфейсом

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

AccelerometerReading reading = args.Reading;

var x = reading.AccelerationX;

var y = reading.AccelerationY;

var z = reading.AccelerationZ;

});

}

}

Акселерометр достаточно неточный и «шумный» сенсор. Даже, когда устройство лежит на столе, показания акселерометра могут меняться (рис. 20.3).

Рис. 20.3. Отображение данных акселерометра в состоянии покоя

Поэтому, если есть выбор между работой с акселерометром и инклинометром,

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

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

ра, можно подсчитать число шагов.

Если в вашем приложении требуется реакция на встряхивание устройства, напри-

мер, для переключения трека в плеере, то здесь также поможет акселерометр. Об-

Работа с сенсорами 281

работка встряхивания — встроенная функция, поэтому напрямую обрабатывать показания акселерометра не потребуется (листинг 20.8). При встряхивании генери-

руется событие Shaken.

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

Листинг 20.8. Обработка встряхивания устройства

public MainPage()

{

this.InitializeComponent();

_accelerometer = Accelerometer.GetDefault();

if (_accelerometer != null)

{

_accelerometer.ReadingChanged += AccelerometerReadingChanged;

_accelerometer.Shaken += AccelerometerShaken;

}

}

void AccelerometerShaken(Accelerometer sender, AccelerometerShakenEventArgs args)

{

}

Гироскоп

Гироскоп — это устройство для определения ориентации в пространстве. Гироскоп

предоставляет скорость вращения устройства вокруг каждой из осей в радианах в

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

показания гироскопа по каждой из осей будут равны нулю. Чаще всего вы не буде-

те применять гироскоп напрямую, а воспользуетесь инклинометром, который объ-

единяет данные акселерометра, гироскопа и компаса.

282 Глава 20

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

ние данных от гироскопа и от акселерометра схоже. Для работы с гироскопом пре-

дусмотрен класс Gyrometer (листинг 20.9).

Листинг 20.9. Пример работы с гироскопом

public sealed partial class MainPage : Page

{

private Gyrometer _gyrometer;

public MainPage()

{

this.InitializeComponent();

_gyrometer = Gyrometer.GetDefault();

if (_gyrometer != null)

{

_gyrometer.ReadingChanged += GyrometerReadingChanged;

}

}

void GyrometerReadingChanged(Gyrometer sender,

GyrometerReadingChangedEventArgs args)

{

// Взаимодействие с пользовательским интерфейсом

Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>

{

GyrometerReading reading = args.Reading;

// Радиан в секунду

var x = reading.AngularVelocityX;

var y = reading.AngularVelocityY;

var z = reading.AngularVelocityZ;

});

}

}

Инклинометр

Инклинометр (от лат. incline — наклоняю) — это прибор, предназначенный для измерения угла наклона относительно гравитационного поля Земли. Вы не найдете инклинометр внутри устройств под управлением Windows 8, т. к. этот сенсор не является физическим устройством. Показания инклинометра рассчитываются на основе информации от акселерометра, гироскопа и магнитометра (на данных маг-

Работа с сенсорами 283

нитометра строятся показания компаса) с помощью механизма под названием Sensor Fusion (рис. 20.5). Если хотя бы одного из перечисленных трех физических сенсоров нет, инклинометр не будет доступен.

Рис. 20.5. Работа механизма Sensor Fusion

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

Рис. 20.6. Параметры Roll, Pitch и Yaw

284 Глава 20

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

рис. 20.7 изображены параметры Roll, Pitch и Yaw применительно к самолету.

Рис. 20.7. Параметры Roll, Pitch и Yaw применительно к самолету. (Материал взят из Wikipedia: http://en.wikipedia.org/wiki/Flight_dynamics_(fixed_wing_aircraft))

Представьте, что самолет летит прямо. При вращении относительно оси Z (Yaw) самолет поворачивается либо вправо, либо влево. При вращении относительно оси

X (Pitch) нос самолета поднимается, а хвост опускается, либо наоборот. При враще-нии относительно оси Y (Roll) самолет ложится на правое или левое крыло. Те же рассуждения применимы и к вращению планшета.

ПРИМЕЧАНИЕ

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

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

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

Создайте приложение на основе шаблона Blank App и назовите его InclinometerApp.

XAML-разметка страницы MainPage приведена в листинге 20.10.

Листинг 20.10. XAML-разметка страницы MainPage

<Page

…

>

<Grid Background=»{StaticResource ApplicationPageBackgroundBrush}»>

<StackPanel Orientation=»Horizontal»

HorizontalAlignment=»Center»>

Работа с сенсорами 285

<TextBlock x:Name=»txtRoll» Margin=»5″ FontSize=»60″/>

<TextBlock x:Name=»txtPitch» Margin=»5″ FontSize=»60″/>

<TextBlock x:Name=»txtYaw» Margin=»5″ FontSize=»60″/>

</StackPanel>

<Canvas VerticalAlignment=»Stretch»

HorizontalAlignment=»Stretch»>

<Rectangle x:Name=»rectMain» Fill=»Red» Width=»100″

Height=»100″ Canvas.Left=»500″ Canvas.Top=»300″/>

</Canvas>

</Grid>

</Page>

В менеджере размещения StackPanel находятся три текстовых блока, в которые бу-дут выводиться параметры Roll, Pitch и Yaw соответственно. В менеджере разме-

щения Canvas задан квадрат с именем rectMain, который и будет перемещаться.

Добавим C#-код обработки данных инклинометра. Для работы с инклинометром предусмотрен класс с «говорящим» названием Inclinometer. В рассматриваемом примере мы продемонстрируем чтение одиночных значений сенсора по таймеру (листинг 20.11).

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

public sealed partial class MainPage : Page

{

private Inclinometer _inclinometer;

private DispatcherTimer _dispatcherTimer;

public MainPage()

{

this.InitializeComponent();

_inclinometer = Inclinometer.GetDefault();

if (_inclinometer != null)

{

uint reportInterval = _inclinometer.MinimumReportInterval >

16 ? _inclinometer.MinimumReportInterval : 16;

_dispatcherTimer = new DispatcherTimer();

_dispatcherTimer.Tick += ProcessCurrentReading;

_dispatcherTimer.Interval =

TimeSpan.FromMilliseconds(reportInterval);

_dispatcherTimer.Start();

}

}

286 Глава 20

private void ProcessCurrentReading(object sender, object args)

{

InclinometerReading reading = _inclinometer.GetCurrentReading();

if (reading != null)

{

// Перемещение прямоугольника

var top = (double)rectMain.GetValue(Canvas.TopProperty);

var left = (double)rectMain.GetValue(Canvas.LeftProperty);

rectMain.SetValue(Canvas.TopProperty,

top — (reading.PitchDegrees / (double)4));

rectMain.SetValue(Canvas.LeftProperty,

left — (reading.RollDegrees / (double)4));

// Отображение данных

txtRoll.Text = String.Format(«Roll: {0,5:0.00}»,

reading.RollDegrees);

txtPitch.Text = String.Format(«Pitch: {0,5:0.00}»,

reading.PitchDegrees);

txtYaw.Text = String.Format(«Yaw: {0,5:0.00}»,

reading.YawDegrees);

}

}

}

При подписке на изменение значений пользователь бы смог наклонить планшет и

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

бытие ReadingChanged не вызывалось. Тогда при использовании нашего алгоритма

красный квадрат не двигался бы.

В нашем примере мы через определенный промежуток времени читаем текущее

значение сенсора и передвигаем квадрат в зависимости от угла наклона устройства.

Квадрат двигается, даже если угол наклона устройства не меняется. Квадрат оста-

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

Компас

Компас также получает данные с помощью механизма Sensor Fusion. Информация

от магнитометра уточняется по данным других сенсоров, и в итоге разработчики

приложений могут с достаточно высокой точностью узнать ориентацию устройства

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

Работа с компасом мало отличается от других сенсоров. Единственное, что следует

отметить, — вы можете получить направление относительно магнитного или гео-

графического северного полюса, в зависимости от того, что вам требуется.

Работа с сенсорами 287

Простой сенсор ориентации

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

ориентации. Это еще один виртуальный сенсор, как и инклинометр.

Для того чтобы изменять пользовательский интерфейс приложения в зависимости от ориентации (ландшафтная или портретная), лучше задействовать VSM (Visual State Manager), переключая состояния с помощью ApplicationView.Value (стандарт-

ный механизм, определенный в шаблонах проектов). Данный способ был рассмот-рен нами в главе 9. Но если требуется более тонкая настройка поведения при раз-

личной ориентации — без дополнительного сенсора не обойтись. Для работы

с простым сенсором ориентации предусмотрен класс SimpleOrientationSensor.

Получение текущей ориентации иллюстрирует листинг 20.12.

Листинг 20.12. Использование простого сенсора ориентации

SimpleOrientationSensor orientation = SimpleOrientationSensor.GetDefault();

if(orientation!=null)

{

var currentOrientation = orientation.GetCurrentOrientation();

}

Также можно подписаться на событие OrientationChanged объекта класса

SimpleOrientationSensor.

Значения, выдаваемые простым сенсором ориентации, приведены в табл. 20.1.

Таблица 20.1. Значения, выдаваемые простым сенсором ориентации

Значение Описание

NotRotated Устройство не повернуто

Rotated90DegreesCounterclockwise Устройство повернуто на 90° против часовой стрелки

Rotated180DegreesCounterclockwise Устройство повернуто на 180° против часовой

стрелки

Rotated270DegreesCounterclockwise Устройство повернуто на 270° против часовой

стрелки

Faceup Устройство ориентировано экраном вверх

Facedown Устройство ориентировано экраном вниз

Сравните приведенные данные со значениями, получаемыми с помощью ста-

тического свойства View класса ApplicationView: FullScreenLandscape,

FullScreenPortrait, Filled и Snapped.

288 Глава 20

ПРИМЕЧАНИЕ

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

с ним.

Итоги

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

ориентации.

Принципы работы со всеми сенсорами схожи. Вначале необходимо получить объ-

ект сенсора по умолчанию с помощью вызова статической функции GetDefault со-

ответствующего класса. Возвращаемое значение необходимо проверить на null.

Если значение равно null — сенсор в системе отсутствует.

После этого можно получить текущее значение или подписаться на изменение зна-

чений. При переходе на другие страницы необходимо отписаться от всех событий.

Мы также узнали, что не все сенсоры — это физические устройства, например, инклинометр получает данные от акселерометра, гироскопа и магнетометра, обра-батывает их с помощью механизма Sensor Fusion и выдает свои значения. За счет

этого инклинометр существенно точнее, чем акселерометр или гироскоп по отдель-ности.

T�a�a21

Интернационализация

Все разработчики хотят, чтобы их приложениями пользовалось как можно больше людей. Мир не ограничивается людьми, говорящими на одном с вами языке, в дан-ном случае на русском, если вы читаете эту книгу. Чтобы достичь максимальной аудитории, приложение должно быть адаптировано к культурным особенностям тех регионов, где будет использоваться. Такая адаптация не ограничивается исклю-чительно переводом интерфейса на какой-либо язык. Часто требуется изменить пользовательский интерфейс приложения, если надписи на нужном языке просто не влезают в отведенное им пространство. Кроме того, даты, время, символы валют и просто числа должны отображаться так, как принято в конкретном регионе. Вы-полнять весь комплекс работ по адаптации приложения для десятков языков часто бывает бессмысленно, особенно для первого релиза приложения, если вы не огром-ная корпорация. Поэтому многие разработчики сначала выпускают версию только на английском для продажи в США. Это разумно. Но небольшой объем работ по интернационализации все же стоит выполнить и в этом случае, т. к. с минимальны-ми затратами усилий такое приложение можно будет более эффективно продавать не только в США, но и в Канаде, Англии, Австралии и других англоговорящих странах.

ПРИМЕЧАНИЕ

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

Когда говорят про интернационализацию (Internationalization, i18n), часто упоми-нают про глобализацию и локализацию. Это понятия из одной предметной области, но они не взаимозаменяемые.

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

290 Глава 21

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

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

Глобализация и локализация Windows Store-приложений .NET- и Windows Phone-приложений схожи. Но, как и многое другое в Windows 8, вопросы, связанные с интернационализацией, были существенно переработаны. Появились очень мощ-ные, гибкие и удобные средства.

Глобализация

При разработке Windows Store-приложений, да и традиционных Windows-приложений и Web-сайтов, очень важно понятие культуры (Culture). Код культуры задается строкой, включающей в себя два параметра, разделенные дефисом: язык и страну. Язык всегда записывается строчными, а страна — прописными буквами.

Например, для английского в США код культуры будет «en-US». Для английского

в Великобритании код культуры «en-GB». А для русского в России — «ru-RU». Часто можно встретить ситуации, когда для культуры задают только язык, но не указы-

вают страну. Например, для русского языка можно задать значение «ru».

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

турами служит класс CultureInfo, определенный в пространстве имен

System.Globalization. Класс CultureInfo хранит сведения, связанные с культурой.

Например, у культур есть свойство NativeName, которое для культуры «ru-RU» будет

иметь значение «русский (Россия)» и DisplayName (значение «Russian»).

Объекты преобразуются в строки в соответствии с текущей культурой. Например,

преобразование даты в строку (листинг 21.1) при текущей культуре «en-US» выдаст результат формата «Sunday, September 30, 2012».

Листинг 21.1. Преобразование даты в строку

//Sunday, September 30, 2012

var date = DateTime.Now.ToString(«D»);

Для культуры «ru-RU» значение будет «30 сентября 2012 г.». Для преобразования даты и времени в строки мы можем явно задать культуру (листинг 21.2).

Интернационализация 291

Листинг 21.2. Явное задание культуры

var cultureInfo = new CultureInfo(«ru-RU»);

// 30 сентября 2012 г.

var date = DateTime.Now.ToString(«D», cultureInfo);

Переведем число в строку, форматировав его как денежную единицу (лис-тинг 21.3).

Листинг 21.3. Формат числа как денежной единицы

const double money = 127800.30;

var strMoney = money.ToString(«C»);

Для культуры «ru-RU» значение переменной strMoney будет 127 800,30 р., для «en-US» $127,800.30, для «de-DE» 127.800,30 € а для «it-IT» € 127.800,30. Обратите вни-мание, что для России, Германии и Италии разделителем целой и дробной части является точка, а для США — запятая. В России тысячи разделяют пробелом, а в Германии и Италии — точкой. В США тысячи разделяет запятая. Знак Евро в Гер-мании пишется в конце суммы, а в Италии — в начале.

Если в приложении необходима работа с данными, не зависящая от региональных параметров и настроек языка, воспользуйтесь инвариантной культурой CultureInfo.InvariantCulture, которая связана с английским языком, но не связана с какой-либо страной. Применяйте инвариантную культуру с осторожностью и только там, где нет вывода пользователю.

Культура по умолчанию и выбор культуры

Культура приложения задается в манифесте (файл Package.appxmanifest). Откройте манифест приложения и укажите параметр Default language (рис. 21.1).

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

культуру «ru-RU». Можно указать не культуру целиком, а задать только язык, на-пример «en», если ваше приложение имеет только английский интерфейс.

Изменить культуру (или язык) приложения во время выполнения можно с по- мощью статического свойства PrimaryLanguageOverride класса ApplicationLanguages (листинг 21.4).

Листинг 21.4. Изменение культуры во время выполнения приложения

ApplicationLanguages.PrimaryLanguageOverride = «de-DE»;

До Windows 8 в операционных системах семейства Windows устанавливалась одна системная культура, настройки которой использовались (по мере желания разра-

292 Глава 21

Рис. 21.1. Задание культуры приложения

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

Выбрать языки можно в Панели управления (Control Panel) в разделе Control

Panel | Language (рис. 21.2).

Рис. 21.2. Выбор системных языков

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

Если приложение не содержит локализованных ресурсов (о ресурсах мы будем го-ворить в разд. «Локализация интерфейса приложения» данной главы), то для при-

Интернационализация 293

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

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

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

Локализация интерфейса приложения

В типовом Windows Store-приложении (так же, как и в WPF, Silverlight и Windows Phone-приложениях) львиная доля статичного текста находится в XAML-разметке. Соответственно локализация текста в XAML-разметке, пожалуй, наибо-лее важная и востребованная возможность, связанная с локализацией. В Windows 8 мы можем локализовать не просто текст, а практически любое свойство каждого элемента управления в XAML.

Возьмем для примера два текстовых поля, содержащих слова «Hello!» и «World!» (листинг 21.5). Данные слова мы хотим отображать на русском или английском языке, в зависимости от настроек, установленных в системе.

Листинг 21.5. Разметка текстовых полей

<StackPanel>

<TextBlock Text=»Hello!» Width=»400″

HorizontalAlignment=»Left» Margin=»10″

Style=»{StaticResource HeaderTextStyle}» />

<TextBlock Text=»World!» Width=»400″

HorizontalAlignment=»Left» Margin=»10″

Style=»{StaticResource HeaderTextStyle}» />

</StackPanel>

Кроме текста мы хотим изменять еще и несколько других свойств: Width,

HorizontalAlignment и Margin. Для всего этого нам потребуется задать ключи лока-

лизации (x:Uid) элементов управления. Для наших текстовых полей зададим ключи

Hello и World соответственно (листинг 21.6).

Листинг 21.6. Задание ключей локализации

<StackPanel>

<TextBlock x:Uid=»Hello» Text=»Hello!» Width=»400″

HorizontalAlignment=»Left» Margin=»10″

Style=»{StaticResource HeaderTextStyle}» />

294 Глава 21

<TextBlock x:Uid=»World» Text=»World!» Width=»400″

HorizontalAlignment=»Left» Margin=»10″

Style=»{StaticResource HeaderTextStyle}» />

</StackPanel>

Теперь в проекте потребуются папки, где будут храниться файлы с ресурсами для конкретных культур. Создадим папку Languages (название папки выбрано произ-вольно) с двумя вложенными папками: en-US и ru-RU. В каждую из подпапок доба-вим файл ресурсов Resources.resw, используя шаблон Resource File (.resw) (рис. 21.3).

Рис. 21.3. Структура проекта

Файлы с расширением resw похожи на знакомые всем .NET-разработчикам файлы с расширением resx: они имеют одинаковый формат, но resw-файлы могут содер-жать только строки и пути к файлам. Добавим в файл ресурсов для культуры en-US строки, приведенные в табл. 21.1 (рис. 21.4).

Таблица 21.1. Ресурсы для культуры en-US

Имя Значение

Hello.HorizontalAlignment Left

Hello.Text Hello!

Hello.Width 400

World.Text World!

Интернационализация 295

Рис. 21.4. Задание ресурсов для культуры en-US

Добавим в файл ресурсов для культуры ru-RU строки из табл. 21.2.

Таблица 21.2. Ресурсы для культуры ru-RU

Имя Значение

Hello.HorizontalAlignment Right

Hello.Text Привет!

Hello.Width 500

World.Text Мир!

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

Если таким языком будет русский, мы увидим текст «Привет!», выровненный впра-во, и «Мир!». А при запуске приложения с английской культурой текст «Hello!», выровненный влево, и «World!».

Windows 8 позволяет организовать хранение ресурсных файлов сразу двумя основ-ными способами (третий является комбинацией первых двух).

Один из способов похож на тот, что применялся, начиная с первых версий .NET Framework, когда к имени ресурсного файла добавлялось имя культуры. В Windows 8 к имени культуры добавляется еще и приставка .lang-.

Например, для культуры ru-RU ресурсный файл может выглядеть следующим обра-зом: Resources.lang-ru-RU.resw.

296 Глава 21

Для немецкого языка может потребоваться создать от одного до трех файлов ре- сурсов:

� Resources.lang-de-DE.resw;

� Resources.lang-de-AT.resw;

� Resources.lang-de-CH.resw.

Можно указать ресурсный файл по умолчанию, задаваемый для всех культур, для которых не определен свой ресурсный файл: Resources.resw.

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

Другой способ организации хранения ресурсных файлов — создание специальных папок. К примеру, для английского языка можно предусмотреть папку «en», для русского — «ru», а для немецкого — «de». В нашем предыдущем примере мы поль-зовались данным способом хранения ресурсных файлов, создавая вложенные пап-ки, название которых содержало полное имя культуры. Хранение ресурсных фай-лов в папке «en-US» аналогично указанию .lang-en-US в названии ресурсного файла. А для папки «de-DE» аналогом будет .lang-de-DE.

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

Вот пример для немецкого языка:

� Languages\de\Resources.lang-de-DE.resw;

� Languages\de\Resources.lang-de-AT.resw;

� Languages\de\Resources.lang-de-CH.resw.

Другой вариант:

� Languages\de-DE\Resources.resw;

� Languages\de-AT\Resources.resw;

� Languages\de-CH\Resources.resw.

Локализация изображений

Способы локализации изображений, как и ресурсов, практически одинаковы. К примеру, если мы хотим локализовать изображение, находящееся в папке Images\logo.png, для нескольких культур, то можно разместить несколько версий изображения в разных папках:

� Images\en\logo.png;

� Images\ru\logo.png

и при этом код обращения к изображению не изменится (листинг 21.7).

Интернационализация 297

Листинг 21.7. Использование изображения в XAML-разметке

<Image Source=»Images/logo.png» />

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

� Images\ru\logo.scale-100.png;

� Images\ru\logo.scale-140.png;

� Images\ru\logo.scale-180.png.

Также можно указать различные файлы для разного контраста (contrast-white и contrast-black). Контраст можно задать в самом имени файла или воспользоваться папкой (контраст настраивается на уровне системы через переключатель High

Contrast в разделе PC settings | Ease of Access):

� Images\ru\contrast-black\logo.scale-100.png;

� Images\ru\logo.contrast-black_scale-100.png.

Использование локализованных ресурсов

в коде

Зачастую к ресурсам необходимо обращаться из кода. К примеру, если мы добави-

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

Листинг 21.8. Чтение строк из ресурсов по ключу

var resourceLoader = new ResourceLoader();

var message = resourceLoader.GetString(«ErrorMessage»);

Нужный файл ресурсов будет выбран автоматически в зависимости от культуры. Однако неудобно все текстовые ресурсы хранить в одном-единственном файле Resources.resw. Допустим, все сообщения об ошибках мы будем размещать в от-дельном файле Errors.resw. Для того чтобы прочитать значение из файла

Errors.resw, в коде при создании класса ResourceLoader необходимо указать имя ре-сурсного файла без расширения (листинг 21.9).

Листинг 21.9. Работа с файлом Errors.resw

var resourceLoader = new ResourceLoader(«Errors»);

var message = resources.GetString(«ErrorMessage»);

298 Глава 21

Если ресурсный файл находится в другой сборке, то доступ к нему можно полу-чить, указав имя сборки перед именем ресурсного файла. Так, если ресурс Errors.resw находится в сборке LocalizationLibrary.dll, то прочитать этот ресурс по-зволит следующий код (листинг 21.10).

Листинг 21.10. Работа с ресурсным файлом из другой сборки

var resourceLoader = new ResourceLoader(«LocalizationLibrary/Errors»);

var message = resources.GetString(«ErrorMessage»);

Локализация названия приложения

Локализовать название Windows Store-приложения очень просто. Добавим в файлы ресурсов для каждой культуры текстовые ресурсы с подходящими именами (имена выбраны произвольно):

� ApplicationDisplayName;

� ApplicationShortName;

� ApplicationDescription.

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

В манифесте приложения в соответствующих полях задаются имена ресурсов с префиксом ms-resource:, например, ms-resource:ApplicationDisplayName (рис. 21.5).

Рис. 21.5. Задание параметров манифеста приложения из ресурсов

Интернационализация 299

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

Итоги

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

Большинство разработчиков Windows Store-приложений сталкиваются с вопросом интернационализации, т. к. благодаря магазину приложений мы можем без особых усилий продавать приложения во многих странах. Усилия придется приложить, выполнив глобализацию и локализацию приложений. Но эта задача, благодаря дав-но знакомым, а также новым инструментам и подходам Windows 8, вполне разре-шима.

T�a�a22

Базовые принципы

дизайна приложений для Windows 8

Windows 8, как и практически все современные продукты Microsoft (например,

Windows Phone, Xbox 360 или Visual Studio 2012), отличаются не просто набором

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

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

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

В каждом из продуктов этот подход может выражаться по-разному — здесь многое

зависит от решаемых задач, форм-факторов используемых устройств и характер-

ных способов ввода информации. Тем не менее, во всех случаях мы непременно

будем отмечать простоту форм, четкость, особое внимание к типографике и приме-

нению сетки, важность движения и переходов и, безусловно, приоритет контента

над всем остальным.

Описываемый современный стиль имеет общие базовые принципы, о которых мы,

собственно, и поговорим в этой главе, но прежде чем перейти к ним, нам хочется

сделать еще одну важную ремарку об истоках.

Истоки нового стиля Windows 8

Прежде всего, мы уверены, что многим читателям, уже знакомым с развитием

платформы Windows Phone и следившим за первыми шагами Windows 8, известно

понятие «Metro»-дизайна. Именно по слову «Metro» вы легко найдете в Сети мно-

жество опубликованных ранее материалов, посвященных основам и тонкостям про-

ектирования приложений для Windows Phone и Windows 8.

Примерно так же, как это бывает с другими ключевыми словами, употребляемыми

до выхода финальной версии продукта (например, некоторым читателям, наверня-

ка, знакомо красивое слово «Avalon», бывшее кодовым термином для Windows

Presentation Foundation, WPF), «Metro» как синоним нового стиля дизайна приложе-

ний сегодня сходит со сцены, уступая место флагманскому слову «Windows». По-

Базовые принципы дизайна приложений для Windows 8 301

этому в данной книге мы говорим о новом или современном дизайне для Windows,

или просто о дизайне для Windows, или о дизайне для Windows 8.