Porting Android* Apps to Windows 8* - Overview [Eng., PDF 797 KB]

Цель

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

Введение

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

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

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

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

Рисунок 1. Главный экран Android* и список приложений (Android Emulator)

Рисунок 2. Главный экран Windows 8* (Имитатор Windows)

В новом пользовательском интерфейсе Windows 8 с главного экрана удалены все уведомления, не связанные с приложениями (такие как область уведомлений и другие значки). Во главу угла при разработке новых приложений для Windows 8 было поставлено содержимое: от классического пользовательского интерфейса приложений постарались избавиться. Кроме того, в Windows 8 появилась уникальная особенность— так называемые «плитки», которыми представлено каждое приложение на главном экране Windows 8. Содержимое плиток может динамически обновляться (на них отображаются данные приложений).

Среда и инструменты разработки

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

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

В Windows 8 разработчики могут выбрать предпочитаемый язык программирования. Поддерживается несколько языков: C++, C#, Visual Basic*, а также JavaScript*/HTML5. Все эти языки программирования являются «полноправными», то есть они имеют доступ ко всем ресурсам и компонентам системы и используют общий API Windows 8 (Windows Runtime).

Еще одна важная область — интегрированная среда разработки. Разработчики для Android используют среду Eclipse* с подключаемым модулем Android (ADT), а разработчики для Windows 8 используют среду Visual Studio* 2012, которая была обновлена для поддержки новой платформы Windows 8. Решение Blend для Visual Studio 2012 поможет при интерактивной разработке и тестировании пользовательского интерфейса приложений для Windows 8 (на базе XAML). Blend также поддерживает возможность создания пользовательского интерфейса приложений с помощью HTML5 и стилей CSS3. Перечисленные средства можно загрузить по приведенной ниже ссылке:

http://msdn.microsoft.com/en-us/library/windows/apps/hh974577.aspx

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

Аналогично шаблонам проектов приложений для Android в Visual Studio 2012 также содержатся шаблоны различных приложений для Windows 8 на разных языках программирования.

На приведенных ниже снимках экрана показаны шаблоны для приложений на языках JavaScript и C++:

Рисунок 3. Шаблоны проектов JavaScript* (снимок экрана Visual Studio* 2012)

Рисунок 4. Шаблоны проектов C++ (Visual Studio* 2012)

Для Visual C# и Visual Basic также предусмотрены аналогичные шаблоны проектов.

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

Следует рассказать о мощном средстве разработки пользовательского интерфейса для Windows 8 — это решение Blend для Visual Studio 2012. Оно полностью интегрируется в среду разработки Visual Studio и предельно упрощает цикл разработки. Blend можно вызвать непосредственно из среды разработки VS 2012. Blend поддерживает создание пользовательских интерфейсов на основе XAML, а также приложений на основе HTML5/CSS3.

Ниже приведен снимок экрана Blend при создании приложения C#/XAML:

Рисунок 5. Создание пользовательского интерфейса на базе XAML (Blend для Visual Studio*)

Blend — это исключительно мощное и функциональное средство создания пользовательского интерфейса . Поддерживается интерактивное проектирование и редактирование пользовательского интерфейса, а также быстрое тестирование. Например, в Blend для приложений HTML5/CSS3 можно «вживую» редактировать HTML DOM и стили CSS3 и сразу же видеть результат. Это очень удобно для подбора различных свойств стилей, разметок и тем.

Ниже приведен снимок экрана Blend при создании приложения HTML5/CSS3:

Рисунок 6. Редактирование пользовательского интерфейса на базе HTML5/CSS3 (Blend для Visual Studio*)

Blend для Visual Studio 2012 содержит мощные средства тестирования для различных областей экрана и различных представлений.

На следующем рисунке показаны возможности тестирования приложений Windows 8 для различных представлений и размеров экрана, поддерживаемых платформой Windows 8:

Рисунок 7. Различные представления и характеристики тестовых экранов (снимок экрана Blend для Visual Studio*)

При разработке современных приложений также используются эмуляторы или имитаторы. На платформе Android предусмотрено решение Android Emulator, поддерживающее различные конфигурации с помощью AVD. Для Windows 8 выпускается мощный имитатор, полностью интегрированный в Visual Studio 2012 IDE и в цикл разработки приложений. Имитатор воспроизводит ряд основных компонентов платформы, такие как сенсорный ввод, данные геопозиционирования, камера, датчик ориентации устройства, и поддерживает различные типоразмеры устройств с различными размерами экрана.

Имитатор Windows 8 можно вызвать непосредственно из среды разработки VS 2012. На приведенном ниже рисунке показаны компоненты и возможности имитатора:

Рисунок 8. Кнопки и различные характеристики экранов в Имитаторе Windows 8*

Также необходимо протестировать приложение не на имитаторе, а на настоящем устройстве. В Android для удаленного тестирования приложений на устройствах используется ADB и интеграция Eclipse ADT. Приложения для Windows 8 можно тестировать на удаленных устройствах с помощью средств удаленной отладки для Visual Studio. Нужно установить эти средства на целевом устройстве и настроить их, а затем использовать Visual Studio для удаленной отладки. По приведенной ниже ссылке находится подробное руководство по запуску приложений, предназначенных для Магазина Windows, на удаленной системе:

http://msdn.microsoft.com/en-us/library/hh441469.aspx

В Visual Studio можно выбрать целевую платформу для отладки: имитатор, локальный компьютер или удаленный компьютер. На следующем рисунке показаны варианты отладки в Visual Studio 2012:

Рисунок 9. Варианты целевой платформы отладки (Visual Studio* 2012)

Еще одним важным фактором при разработке является сборка приложений, их упаковка и публикация в магазинах приложений. В Android среда Eclipse с подключаемым модулем ADT интегрирует и автоматизирует процесс сборки, подписания и упаковки приложений. Для Windows 8 предоставляется всеобъемлющая поддержка всего цикла разработки приложений, от разработки и сборки до подписания, получения сертификатов, упаковки и прямой интеграции в Магазин Windows.

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

Приложения для Android и приложения для Windows 8

Для портирования приложений с Android на Windows 8 необходимо изучить различия между этими платформами. Принципы работы приложений на этих платформах совершенно различны — от низкоуровневого взаимодействия с ОС до высокоуровневых абстракций, таких как пользовательский интерфейс.

Но прежде чем погрузиться в подробности, следует остановиться на одном крайне важном вопросе. Дело в том, что Windows 8 поддерживает два типа приложений: «новые» приложения для Windows 8 (приложения для Windows Store) и «традиционные» приложения для Windows («классические» приложения).

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

На странице по приведенной ниже ссылке дано общее описание новых приложений для Windows Store:

http://msdn.microsoft.com/en-us/library/windows/apps/hh974576.aspx

Каждое приложение для Android состоит из трех основных частей:

• Компоненты приложения (действия, службы, поставщики содержимого, получатели вещания)
• Файл манифеста (определяет разрешения пользователей, объявляет используемые компоненты приложения, требования и пр.)
• Ресурсы приложения (изображения, мультимедиа, языковые строки, поддержка языков, ресурсы для различных типов устройств и пр.)

Приложения для Windows Store также состоят из схожих частей, хотя эти части могут не вполне точно соответствовать используемым в приложениях для Android:

• Различные компоненты приложения (основной компонент приложения, контракты приложения, расширения, фоновые задачи, уведомления, плитки и пр.)
• Манифест пакета приложения (определяет идентификацию пакета, его свойства, возможности и разрешения, расширения, наглядные элементы и пр.)
• Ресурсы приложения и локализация (PRI-файл с индексом ресурсов пакета; все ресурсы приложения проиндексированы и сопоставлены)

На приведенном ниже рисунке показаны возможности и доступные объявления в манифесте пакета Windows 8 для образца приложения:

Рисунок 10. Манифест пакета: возможности (слева) и объявления (справа) (Visual Studio* 2012)

Приложения для Android, как и приложения для Windows Store, обладают строго определенным жизненным циклом, то есть набором состояний, через которые приложение проходит от начала и до конца. На странице по приведенной ниже ссылке показан жизненный цикл приложений для Windows Store:

http://msdn.microsoft.com/en-us/library/windows/apps/hh464925.aspx

Как и в Android, в Windows 8 для приложений поддерживаются различные представления (книжная ориентация, альбомная ориентация), различные размеры экрана и пр. Помимо этого, в Windows 8 поддерживаются еще два представления, отсутствующие в Android «прикрепленное представление» и «заполненное представление».

На приведенном ниже рисунке показано приложение для Windows 8 в четырех представлениях: альбомная ориентация, книжная ориентация, прикрепленное представление (слева снизу) и заполненное представление (справа снизу).

Рисунок 11. Образец приложения для Windows 8* в различных представлениях (Имитатор Windows 8)

Руководство по созданию прикрепленных и заполненных представлений см. по ссылке: http://msdn.microsoft.com/en-us/library/windows/apps/hh465371.aspx

Еще одно существенное различие — общие элементы управления приложениями и элементы пользовательского интерфейса. В Android используется так называемая «панель действий», содержащая распространенные действия и кнопки приложений, а также доступ к другим функциям, например, к настройке параметров приложения, встроенный поиск и т.п. Ближайшим аналогом этого элемента в Windows 8 являются элементы «панель приложения» и « особые кнопки».

Панель приложения — это основной интерфейс команд приложений для Магазина Windows. Панель приложения, аналогично панели действий в Android, можно использовать для навигации и для других действий приложения. По умолчанию панель приложения скрыта в приложениях для Windows 8, и ее можно вызвать при помощи соответствующего жеста. Поведение панели приложения можно настраивать в соответствии с необходимостью (она может быть всегда активной, скрываться по прикосновению и пр.). На следующем рисунке показана панель приложения в Internet Explorer*:

Рисунок 12. Панель приложения в Internet Explorer* 10 (Windows 8*)

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

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

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

Рисунок 13. Панель особых кнопок в приложении Windows Store (Windows 8*)

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

Следующее существенное отличие, разумеется, это языки программирования и API платформы. Приложения для Android используют язык программирования Java, поэтому для переноса приложений на платформу Windows 8 потребуется переписать приложение на одном из языков, поддерживаемых в Windows 8. В зависимости от функциональности, требований и возможностей приложений в Windows 8 могут быть эквивалентные API, которыми можно будет воспользоваться. Например, перенести функциональность сенсорного управления и датчиков можно с помощью эквивалентных API Windows 8. Подробный справочник по API для приложений Windows см. по ссылке: http://msdn.microsoft.com/en-us/library/windows/apps/br211369

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

Пользовательский интерфейс приложений и обработка ввода

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

В Windows 8 пользовательский интерфейс приложения можно создать различными способами:

• XAML и C++/C#/VB
• HTML5/CSS3 и JavaScript
• Прямой графический интерфейс с помощью DirectX/C++ (возможно некоторое использование XAML)
• Традиционный пользовательский интерфейс классических приложений

Выбирая способ создания пользовательского интерфейса, следует внимательно изучить все аспекты приложения. Следует учитывать требования к приложению и планы по его дальнейшему расширению. Например, если существующее приложение широко использует веб-интерфейс или значительный объем кода HTML, то имеет смысл разрабатывать пользовательский интерфейс приложения с помощью JavaScript/HTML5. С другой стороны, если для приложения требуется высокопроизводительная обработка графики и полный контроль над графическим процессором, целесообразно использовать DirectX/C++. Как было отмечено выше, все языки программирования имеют одинаковый доступ ко всем ресурсам системы (с помощью общего API Windows 8 Runtime).

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

Выбрав нужную среду программирования, можно изучить остальные аспекты пользовательского интерфейса, такие как управление окнами, обработка представлений, стили, элементы управления пользовательского интерфейса, анимация и пр. Все эти возможности могут довольно сильно отличаться в зависимости от используемой среды. Например, приложения HTML5 имеют собственные методики обработки событий (согласно стандартам HTML DOM и веб-стандартам) и применения стилей (CSS3).

В приложениях для Android пользовательский интерфейс типичного приложения состоит из нескольких компонентов «действий», в которых размещаются объекты типа «представление» и «групповое представление», реализующие элементы пользовательского интерфейса, такие как кнопки и разметки. Эта платформа поддерживает весь жизненный цикл пользовательского интерфейса, его базовые технологии, ввод и обработку событий. В Windows 8 реализована крайне мощная платформа пользовательского интерфейса и модель программирования, реализующая общие для всей системы принципы пользовательского интерфейса:

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

Подробное обсуждение пользовательского интерфейса для приложений Windows Store см. по ссылке: http://msdn.microsoft.com/en-us/library/windows/apps/hh779072.aspx

При создании пользовательского интерфейса приложений для Windows 8 мы настоятельно рекомендуем разработчикам использовать решение Blend для Visual Studio 2012. Blend поддерживает создание пользовательских интерфейсов на основе XAML, а также на основе HTML5/CSS3. Это решение содержит мощные инструменты и средства работы над пользовательским интерфейсом, в том числе возможность быстрого интерактивного тестирования пользовательского интерфейса.

Разработчикам придется тщательно продумывать принципы работы своих приложений, чтобы наиболее эффективно воспользоваться всеми возможностями пользовательского интерфейса, поддерживаемыми в Windows 8. В статье (см. ссылку ниже) под названием «Design case study: iPad* to Windows Store app» рассматриваются вопросы проектирования пользовательского интерфейса, которые следует учесть при переносе приложений с других платформ: http://msdn.microsoft.com/en-us/library/windows/apps/hh868262

Подробное пошаговое руководство по переносу пользовательского интерфейса и сенсорного ввода с Android на Windows 8 см. в статье «Porting Android Touch to New Windows* 8 UI (C#)» на сайте Intel Developer Zone (IDZ).

Итоги

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

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

Примечания

ИНФОРМАЦИЯ В ДАННОМ ДОКУМЕНТЕ ПРИВЕДЕНА ТОЛЬКО В ОТНОШЕНИИ ПРОДУКТОВ INTEL. ДАННЫЙ ДОКУМЕНТ НЕ ПРЕДОСТАВЛЯЕТ ЯВНОЙ ИЛИ ПОДРАЗУМЕВАЕМОЙ ЛИЦЕНЗИИ, ЛИШЕНИЯ ПРАВА ВОЗРАЖЕНИЯ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ. КРОМЕ СЛУЧАЕВ, УКАЗАННЫХ В УСЛОВИЯХ И ПРАВИЛАХ ПРОДАЖИ ТАКИХ ПРОДУКТОВ, INTEL НЕ НЕСЕТ НИКАКОЙ ОТВЕТСТВЕННОСТИ И ОТКАЗЫВАЕТСЯ ОТ ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ ГАРАНТИЙ В ОТНОШЕНИИ ПРОДАЖИ И/ИЛИ ИСПОЛЬЗОВАНИЯ СВОИХ ПРОДУКТОВ, ВКЛЮЧАЯ ОТВЕТСТВЕННОСТЬ ИЛИ ГАРАНТИИ ОТНОСИТЕЛЬНО ИХ ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ, ОБЕСПЕЧЕНИЯ ПРИБЫЛИ ИЛИ НАРУШЕНИЯ КАКИХ-ЛИБО ПАТЕНТОВ, АВТОРСКИХ ПРАВ ИЛИ ИНЫХ ПРАВ НА ИНТЕЛЛЕКТУАЛЬНУЮ СОБСТВЕННОСТЬ.

КРОМЕ СЛУЧАЕВ, СОГЛАСОВАННЫХ INTEL В ПИСЬМЕННОЙ ФОРМЕ, ПРОДУКТЫ INTEL НЕ ПРЕДНАЗНАЧЕНЫ ДЛЯ ИСПОЛЬЗОВАНИЯ В СИТУАЦИЯХ, КОГДА ИХ НЕИСПРАВНОСТЬ МОЖЕТ ПРИВЕСТИ К ТРАВМАМ ИЛИ ЛЕТАЛЬНОМУ ИСХОДУ.

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

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

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

Номерные копии документов, на которые имеются ссылки в данном документе, а также другие материалы Intel можно заказать по телефону 1-800-548-4725 или загрузить по адресу: http://www.intel.com/design/literature.htm

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

Данный документ и описываемое в нем программное обеспечение предоставляются по лицензии и могут использоваться и распространяться только согласно условиям лицензии. Intel, Ultrabook и эмблема Intel являются товарными знаками корпорации Intel в США и в других странах.

Copyright © 2012 Intel Corporation. All rights reserved.
*Другие наименования и торговые марки могут быть собственностью третьих лиц.

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

Реализация самых современных серверных технологий в корпоративном ПО

Для создания мощных серверных программных решений корпоративного уровня необходимо знать и уметь использовать все возможности платформы. При этом потребуется изучить множество непростых вопросов, но для удобства можно применять рекомендации, инструменты и методики Server Developer Communityв сети Intel Developer Zone.

В современных корпоративных серверах используются процессоры Intel® Xeon® семейства E5 (двухпроцессорные системы среднего уровня) и семейства E7 (мощные масштабируемые системы, до 8 процессоров). Сотрудничество с ведущими поставщиками других компонентов серверных решений, таких как операционные системы, программы виртуализации, базы данных и промежуточное ПО, позволяет добиться высокой производительности.

Возможности для разработчиков

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

• Производительность при любом масштабе систем.Серверы на основе процессоров Intel Xeon (от 2 до 8 процессоров) поддерживают вертикальное и горизонтальное масштабирование, в том числе и расширенные возможности (виртуализация и облачные вычисления).
• Реализация потребностей заказчиков при умеренных затратах.Производители программного обеспечения могут выполнять самые разные требования, от повышения экономичности до обеспечения надежности серверов на базе процессоров Intel Xeon с собственной архитектурой.
• Бескомпромиссная безопасность.Серверные платформы Intel® для корпоративного сегмента помогут реализовать возможности шифрования и другие серверные функции без снижения производительности.

Советы и полезные ресурсы в сети Intel Developer Zone

Производители программ должны предложить своим клиентам наиболее выгодные и мощные решения для корпоративных серверов на процессорах Intel Xeon E5 и E7. Для корпоративных приложений следует рассмотреть оптимизацию в следующих основных областях:

• Повышение производительности за счет многопоточных вычислений.Для эффективного использования всех возможностей многоядерных процессоров и гиперпотоковости программы должны поддерживать многопоточные вычисления, как описано в руководстве “Intel Guide for Developing Multi-threaded Applications.”
• Ускорение шифрования Intel® стандарта AES (Intel® AES-NI).Теперь можно реализовать шифрование без снижения производительности системы. Для начала рекомендуется ознакомиться со статьей Intel AES-NI technology overview.
• Оптимизация вычислений с плавающей запятой с помощью Intel® Advanced Vector Extensions (Intel® AVX).Простой и эффективный подход к этой технологии описывается в статье “Using AVX Without Writing AVX Code.”

Разработка корпоративного ПО с использованием технологии Intel® vPro™

Бизнес-ПК на основе технологии Intel® vPro™ продолжают пользоваться заслуженной популярностью, поскольку они обладают рядом существенных преимуществ, особенно с точки зрения управляемости, безопасности, экономичности и производительности. Процессоры семейства Intel® Core™ второго поколения, которыми оснащаются эти системы, дают возможность развертывать самые мощные бизнес-приложения.

Настольные ПК и ноутбуки на основе технологии Intel vPro производятся ведущими OEM-производителями в больших количествах. Сообщество разработчиков Intel vProпоможет производителям программ добиться конкурентного преимущества, оптимизировав корпоративные приложения для этих высокопроизводительных систем.

Возможности для разработчиков

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

• Управление при отсутствии подключения.Технология Intel® AMT дает возможность управляющим программам удаленно обнаруживать, восстанавливать и защищать клиентские ПК, даже если они отключены от сети или не имеют ОС.
• Защита важной для бизнеса информации.Решение Intel AES-NI ускоряет шифрование данных, а технология Intel® TXT защищает оборудование системы и установленные программы от подмены.
• Повышение производительности при невысоком потреблении электроэнергии.Параллельная архитектура оборудования и технология Intel® Turbo Boost позволяют существенно повысить вычислительную мощность приложений при сохранении невысокого потребления электроэнергии.

Советы и полезные ресурсы в сети Intel Developer Zone

• Поддержка Intel AMT.Концепция применения этой технологии для поддержки нового уровня управляемости описана в наборе примеров использования; для реализации этой концепции можно использовать руководство Intel AMT Start Here Guide.
• Ускорение шифрования с помощью Intel AES-NI. Полезное описание преимуществ этих инструкций для ПО и сведения об использовании их в корпоративных приложений содержатся в информационном документе “Securing the Enterprise with Intel® AES-NI.”
• Применение многопоточных вычислений в приложениях. Создание многопоточного кода согласно рекомендациям, приведенным в статье “Intel Guide for Developing Multi-threaded Applications”, необходима для использования всех возможностей аппаратных параллельных вычислений технологии Intel vPro.

Преимущества внедрения ультрабуков в корпоративной среде

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

Многие ОЕМ-производители (причем их число постоянно растет) выпускают огромное количество устройств, созданных на базе эталонного проекта, выпущенного корпорацией Intel в 2011 году. В сообществе разработчиков решений для ультрабуковразработчики найдут все необходимые ресурсы для создания удачных решений, предназначенных для этой платформы.

Возможности для разработчиков

Распространение ультрабуков идет очень быстро. По сообщению центрального агентства новостей Тайваня,¹компания Merrill Lynch опубликовала прогноз, согласно которому в 2013 году будет продано 50 миллионов ультрабуков, что составит 20 % от общего количества проданных ноутбуков. Эти показатели означают великолепную перспективу для разработчиков ПО, поскольку корпоративные пользователи весьма положительно реагируют на уникальные возможности и характеристики этих устройств:

• Исключительная мобильность.Ультрабуки отличаются компактным размером, их толщина в сложенном состоянии не превышает 21 мм, но при этом они оснащаются полноразмерной физической клавиатурой, что позволяет удобно работать в поездках.
• Высокая производительность.Благодаря применению процессоров Intel Core второго поколения ультрабуки не уступают по скорости «большим» компьютерам, а технология Intel® Rapid Start обеспечивает практически мгновенное пробуждение систем для быстрого доступа к данным и приложениями.
• Значительное время работы от аккумулятора.Ультрабуки отличаются исключительно низким потреблением электроэнергии, благодаря чему можно работать от аккумуляторов без подзарядки в течение целого дня, даже если из-за поездок или по другим причинам пользователи не могут подзарядить аккумуляторы от сети в течение длительного времени.

Советы и полезные ресурсы в сети Intel Developer Zone

The Intel® Developer Zone has established a clear set of best practices to optimize software for the strengths and specific capabilities of the Ultrabook category. To position your products for success on this new class of devices, consider incorporating the following related resources in your development process:

• Оптимизация потребления электроэнергии.Рекомендации по наиболее рациональному использованию электроэнергии в ультрабуках см. в информационном документе “Energy-Efficient Software Guidelines” is an excellent place to start.
• Повышение производительности за счет многопоточных вычислений.Для эффективного использования всех возможностей многоядерных процессоров Intel Core второго поколения программы должны поддерживать многопоточные вычисления, как описано в “Intel Guide for Developing Multithreaded Applications.”
• Поддержка встроенной графики.Системные платы ультрабуков оснащаются весьма мощными графическими процессорами. Для использования всех возможностей таких ГП следует использовать рекомендации, приведенные в документе Intel Graphics Developer's Guides.

Создание приложений Android* корпоративного уровня

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

В сентябре 2011 года корпорации Intel и Google объявили о планах по оптимизации Android для процессоров Intel® Atom™, что поможет создать перспективную платформу разработки ПО корпоративного уровня. Отслеживать развитие совместной экосистемы Intel и Android можно с помощью тега Intel Newsroom Android tag.

Возможности для разработчиков

• Высокая производительность для мобильных бизнес-пользователей.Исключительная мобильность тонких, легких и современных устройств на основе мощных процессоров Intel Atom открывает путь к созданию нового поколения бизнес-приложений.
• Новые возможности мультимедиа на переносных системах.Социальные сети и другие материалы мультимедиа хорошо приспособлены для таких устройств, что дает возможность создавать новые программные решения.
• Повышение мощности платформы без сокращения времени работы от аккумулятора.Высокая вычислительная мощность процессора Intel Atom позволяет мобильным приложениям Android справляться с полномасштабной нагрузкой офисных приложений в течение длительного времени без подзарядки аккумуляторов.

Советы и полезные ресурсы в сети Intel Developer Zone

Для начала разработчики могут ознакомиться со статьей “Android 3.2 on Intel® Architecture,” в которой описываются возможности запуска ОС Android на устройствах с процессорами Intel Atom. Другие полезные ресурсы:

• “Installing the Android* SDK for Intel® Architecture.” Эта статья поможет построить среду разработки, в том числе интегрировать SDK с различными инструментами, такими как Eclipse* и Apache Ant*..
• Android technical articles from Intel Developer Zone. Здесь можно найти все технические статьи Intel, относящиеся к платформе Android, от общих рекомендаций до советов по решению конкретных задач.
• Android blogs from Intel Developer Zone. Разработчики и инженеры по оборудованию Intel постоянно публикуют заметки о программных средствах, советы и методики, помогающие наиболее эффективно работать с Android на процессорах Intel.

¹ http://focustaiwan.tw/ShowNews/WebNews_Detail.aspx?Type=aALL&ID=201202010015, retrieved March 26, 2012.

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

API Windows* RT поддерживает датчик ориентации, который отслеживает изменения положения устройства. Он также предоставляет более подробную информацию о различных ориентациях, таких как лицевой стороной вверх или вниз, книжная вниз и т. д. Возьмем, к примеру, приложение «Photo». Его элементы интерфейса могут менять местоположение при различных положениях устройства, чтобы максимально эффективно использовать доступное пространство экрана. Ниже показаны снимки экранов этого приложения при альбомной и книжной ориентации. На иллюстрации видно, что элементы интерфейса скомпонованы по-разному, обеспечивая максимальное удобство.

Расположение элементов интерфейса на экране приложения «Photo» в альбомной ориентации

ПРИМЕЧАНИЕ. Данное приложение разработано на платформе Windows 8 Release Preview. Мы установили, что оповещения об ориентации, получаемые от операционной системы, могут противоречить ожиданиям пользователя. Например, судя по данным на информационной панели, в случае верхнего снимка экрана система предположила, что используется книжная ориентация (Portrait). В таких случаях в приложении «Photo» мы выводим вариант интерфейса для альбомного расположения, если обнаружена книжная ориентация, и наоборот.

Расположение элементов интерфейса на экране приложения «Photo» в книжной ориентации

Реализация

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

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

Шаг 1

Объявите в классе MainWindowViewModel private переменную типа SimpleOrientationSensor, а также строковую переменную _orientationMode для хранения значения текущей ориентации в виде строки.

 //ViewModelBase is the base class for all view models. It provides INotifyPropertyChanged implementation to all its derived classes. class MainWindowViewModel : ViewModelBase { //Member variables //declare variable of SimpleOrientationSensor class private SimpleOrientationSensor orientationSensor; //String variable to store current orientation sensor value private string _orientationMode; //Declare public orientation changed event raised when current orientation changes //This is raised when SetOrientationModeProperty is called public event EventHandler<OrientatationChangedEventArgs> OrientationChanged; ..... } 

Шаг 2

В конструкторе MainWindowViewModel() получите простой датчик ориентации устройства по умолчанию и установите отслеживание события OrientationChanged. Затем получите текущее значение датчика вызовом метода "GetCurrentOrientation()".

 class MainWindowViewModel : ViewModelBase { public MainWindowViewModel() { //Get default SimpleOrientationSensor. orientationSensor = SimpleOrientationSensor.GetDefault(); //Register for the event to get the orientation changed notification. orientationSensor.OrientationChanged += orientationSensor_OrientationChanged ; //Get the current orientation and set the string to show the current orientation SetOrientationModeProperty(orientationSensor.GetCurrentOrientation()); ..... } ..... } 

Шаг 3

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

 class MainWindowViewModel : ViewModelBase { //Event handler notified when orientation changed void orientationSensor_OrientationChanged(SimpleOrientationSensor sender, SimpleOrientationSensorOrientationChangedEventArgs args) { SetOrientationModeProperty(args.Orientation); } ..... } 

Шаг 4

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

 public enum ViewOrientationMode { OrientationModeUnknown = -1, OrientationModePortraitUp , OrientationModePortraitDown , OrientationModeLandScapeRight , OrientationModeLandScapeLeft , OrientationModeFaceUp , OrientationModeFaceDown }; 

Шаг 5

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

 class MainWindowViewModel : ViewModelBase { //Create public property public string OrientationMode { get { return _orientationMode; } set { if (_ orientationMode != value) { _ orientationMode = value; //Raises notification when new value is set for this variable. OnNotifyPropertyChanged("OrientationMode"); } } } ..... } 

Шаг 6

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

 class MainWindowViewModel : ViewModelBase { void SetOrientationModeProperty( SimpleOrientation orientation ) { ViewOrientationMode vOrientation = ViewOrientationMode.OrientationModeUnknown; switch(orientation) { case SimpleOrientation.NotRotated: { OrientationMode = “Portrait”; vOrientation = ViewOrientationMode.OrientationModePortraitUp; break; } case SimpleOrientation.Roated90DegreesCounterclockwise: { OrientationMode = “Landscape”; vOrientation= ViewOrientationMode.OrientationModeLandScapeLeft; break; } ..... default: break; } //Send Notification to view to change the layout. If (OrientationChanged != null) OrientationChanged(this, new OrientationChangedEventArgs(vOrientation)); } ..... } 

Шаг 7. Изменение компоновки

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

 class MainWindow: ViewModelBase { MainWindow() { //Register for receiving orientation changed notification vm.OrientationChanged = vm_OrientationChanged; ….. } //OrientationChanged Event Handler void vm_OrientationChanged(object sender, OrientationChangeEventArgs e) { //Do all re-layouting work in background and once ready for rendering, give it to main UI thread Dispatcher.BeginInvoke(new Action(() => ChangeLayout(e.viewOrientation)), null); } void ChangeLayout(ViewOrientationMode currentOrientationMode) { //Portrait mode if (currentOrientationMode == ViewOrientationMode.OrientationModeFaceUp || currentOrientationMode == ViewOrientationMode.OrientationModeFaceDown || currentOrientationMode == ViewOrientationMode.OrientationModePortraitUp || currentOrientationMode == ViewOrientationMode.OrientationModePortraitDown) { //Change the layouts for controls. Grid.SetRow(debugPanel, 0); Grid.SetColumn(debugPanel, 1); debugGraphicaPanel.Orientation = Orientation.Vertical; Grid.SetRow(listBoxGrid, 0); Grid.SetColumn(listBoxGrid, 0); Grid.SetColumnSpan(listBoxGrid, 1); Grid.SetRow(controlsGrid, 0); Grid.SetColumn(controlsGrid, 1); Grid.SetColumn(controlsBtnPanel, 0); Grid.SetColumn(cameraBtn, 1); imagesListBox.Height = lbActualHeight; //Reset the orientation for camera button & controls panel. controlsGrid.HorizontalAlignment = HorizontalAlignment.Right; cameraBtn.HorizontalAlignment = HorizontalAlignment.Right; //Change the scrollbar visibility. if (imageScrollViewer != null) imageScrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Hidden; } else if (currentOrienationMode == ViewOrientationMode.OrientationModeLandScapeLeft || currentOrientationMode == ViewOrientationMode.OrientationModeLandScapeRight) //LandScape mode { //Change the layouts for controls. Grid.SetRow(debugPanel, 1); Grid.SetColumn(debugPanel, 0); debugGraphicaPanel.Orientation = Orientation.Horizontal; Grid.SetRow(listBoxGrid, 1); Grid.SetColumn(listBoxGrid, 0); Grid.SetColumnSpan(listBoxGrid, 2); Grid.SetRow(controlsGrid, 0); Grid.SetColumn(controlsGrid, 0); //Set the image list box to show only 2 rows. imagesListBox.Height = 275; //Set the orientation for camera button & controls panel accordingly. if (currentOrientationMode == ViewOrientationMode.OrientationModeLandScapeRight) { controlsGrid.HorizontalAlignment = HorizontalAlignment.Right; Grid.SetColumn(controlsBtnPanel, 0); Grid.SetColumn(cameraBtn, 1); } else { controlsGrid.HorizontalAlignment = HorizontalAlignment.Left; Grid.SetColumn(controlsBtnPanel, 1); Grid.SetColumn(cameraBtn, 0); } //Change the scrollbar visibility to hide the multiple rows in list. if (imageScrollViewer != null) imageScrollViewer.HorizontalScrollBarVisibility = ScrollBarVisibility.Disabled; } } ….. } 

Варианты интерфейса приложения «Photo» при различной ориентации:

Устройства-трансформеры Ultrabook имеют два режима работы: 1) планшет; 2) ноутбук. Если дисплей и клавиатура находятся в одной плоскости, значит устройство используется как планшет. Если они расположены перпендикулярно друг другу, это режим ноутбука.

Режим ноутбука лицевой стороной вверх

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

Режим планшета в книжной ориентации

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

Режим ноутбука в альбомной ориентации

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

Режим планшета в альбомной ориентации

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

*Другие наименования и товарные знаки могут быть собственностью третьих лиц.

Скачать статью

Скачать статью Porting iOS* Apps to Windows* 8 - Overview [Eng., PDF 841KB]

Цель

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

Содержание

1. Введение
2. Среды разработки и инструменты
3. Приложения для iOS и приложения для Windows 8
4. Пользовательский интерфейс приложений и обработка ввода
5. Выводы

1. Введение

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

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

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

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

Ниже приведено несколько снимков экрана iOS и Windows 8, где прекрасно видны различия:

Рисунок 1:«Домашний экран» в iOS*. (Источник изображения: www.apple.com/iphone)

Рисунок 2:Главный экран Windows 8* (снимок экрана Windows Simulator)

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

2. Среда разработки и инструменты

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

Разработчики, обладающие опытом создания приложений для платформы iOS и решившие перенести свои приложения на платформу Windows 8, обнаружат, что для Windows 8 существуют крайне мощные и полнофункциональные среды и средства разработки. Корпорация Apple требует приобретать лицензию разработчика для развертывания приложений, написанных в среде разработки XCode*, но в Windows 8 такого требования нет. В среде разработки Visual Studio* 2012 можно создавать локальные пакеты для тестирования на устройствах. Но для развертывания приложений в Windows Store корпорация Microsoft, как и Apple, требует приобретения платной лицензии. На следующем снимке экрана среды разработки Visual Studio показаны возможности развертывания:

Рисунок 3:Развертывание приложения для Windows 8* (снимок экрана среды разработки VS)

В Windows 8 разработчики могут выбрать предпочитаемый язык программирования. Поддерживается несколько языков программирования: C++, C#, Visual Basic* и JavaScript*/HTML5. Все эти языки программирования являются «полноправными», то есть они имеют доступ ко всем ресурсам и компонентам системы и используют общий API Windows 8 (Windows Runtime).

Еще одна важная область — интегрированная среда разработки. Разработчики для iOS используют среду XCode, а разработчики для Windows 8 используют среду Visual Studio* 2012, которая была обновлена для поддержки новой платформы Windows 8. Решение Blend для Visual Studio 2012 поможет при интерактивной разработке и тестировании пользовательского интерфейса приложений для Windows 8 (на базе XAML). Blend также поддерживает возможность создания пользовательского интерфейса приложений с помощью HTML5 и стилей CSS3. Перечисленные средства можно загрузить по приведенной ниже ссылке:

http://msdn.microsoft.com/en-us/library/windows/apps/hh974577.aspx

Для разработки приложений, предназначенных для публикации в Windows Store, следует использовать Visual Studio 2012 и Windows 8, поскольку новые приложения используют платформу и интерфейсы API Windows 8.

Аналогично шаблонам проектов приложений для iOS в Visual Studio 2012 также содержатся шаблоны различных приложений для Windows 8 на разных языках программирования.

На приведенных ниже снимках экрана показаны шаблоны приложений на языках JavaScript и C++:

Рисунок 4:Шаблоны проектов JavaScript* (снимок экрана Visual Studio* 2012)

Рисунок 5:Шаблоны проектов Visual C++* (снимок экрана Visual Studio* 2012)

Для Visual C#* и Visual Basic также предусмотрены аналогичные шаблоны проектов.

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

Следует рассказать о мощном средстве разработки пользовательского интерфейса для Windows 8 — это решение Blend для Visual Studio 2012. Оно полностью интегрируется в среду разработки Visual Studio и предельно упрощает цикл разработки. Blend можно вызвать непосредственно из среды разработки VS 2012. Blend поддерживает создание пользовательских интерфейсов на основе XAML, а также приложений на основе HTML5/CSS3.

Ниже показан снимок экрана Blend с выбранным шаблоном «Разделенное приложение (XAML)» для Visual C#:

Рисунок 6:Редактирование пользовательского интерфейса на базе XAML (снимок экрана Blend для Visual Studio*)

Blend — это исключительно мощное и функциональное средство создания пользовательского интерфейса . Поддерживается интерактивное проектирование и редактирование пользовательского интерфейса, а также быстрое тестирование. Например, в Blend для приложений HTML5/CSS3 можно «вживую» редактировать HTML DOM и стили CSS3 и сразу же видеть результат. Это очень удобно для подбора различных свойств стилей, разметок и тем.

Ниже приведен снимок экрана Blend при создании приложения HTML5/CSS3:

Рисунок 7:Редактирование пользовательского интерфейса на базе HTML5/CSS3 (снимок экрана Blend для Visual Studio*)

Blend для Visual Studio 2012 содержит мощные средства тестирования для различных областей экрана и различных представлений.

На следующем рисунке показаны возможности тестирования приложений Windows 8 для различных представлений и размеров экрана, поддерживаемых платформой Windows 8:

Рисунок 8:Различные представления и характеристики тестовых экранов (снимок экрана Blend для Visual Studio*)

При разработке современных приложений также используются различные эмуляторы. Для iOS в XCode используется эмулятор устройств iOS с поддержкой различных конфигураций. Можно выбрать, какие устройства должно поддерживать приложение: iPad* и iPhone* одновременно или только один из типов устройств. Для Windows 8 был создан эмулятор, полностью интегрированный в среду разработки Visual Studio 2012 и в цикл разработки приложений. Он воспроизводит ряд основных компонентов платформы, таких как сенсорный ввод, данные геопозиционирования, камера, датчик ориентации устройства, и поддерживает различные типоразмеры устройств с различными размерами экрана.

Эмулятор Windows 8 можно вызвать непосредственно из среды разработки VS 2012. На приведенном ниже рисунке показаны его компоненты и основные возможности:

Рисунок 9:Кнопки и различные характеристики экранов в Windows* 8 Simulator (снимок экрана Windows 8 Simulator).

Также необходимо протестировать приложение не на эмуляторе, а на настоящем устройстве. В XCode можно выбрать «iOS Device» (Устройство iOS) в соответствующем раскрывающемся меню среды разработки. Приложения для Windows 8 можно тестировать на удаленных устройствах с помощью средств удаленной отладки для Visual Studio. Нужно установить эти средства на целевом устройстве и настроить их, а затем использовать Visual Studio для удаленной отладки. По приведенной ниже ссылке находится подробное руководство по запуску приложений, предназначенных для Windows Store, на удаленной системе:

http://msdn.microsoft.com/en-us/library/hh441469.aspx

В Visual Studio можно выбрать целевую платформу для отладки: эмулятор, локальный компьютер или удаленный компьютер. На следующем рисунке показаны варианты отладки в Visual Studio 2012:

Рисунок 10:Варианты целевой платформы отладки (снимок экрана Visual Studio* 2012)

Еще одним важным фактором при разработке является сборка приложений, их упаковка и публикация в магазинах приложений. В случае с iOS в среде разработки XCode интегрирован и автоматизирован процесс сборки, подписания и упаковки приложений с помощью доверенного сертификата ключа разработчика. Аналогичным образом для Windows 8 предоставляется всеобъемлющая поддержка всего цикла разработки приложений, от разработки и сборки до подписания, получения сертификатов, упаковки и прямой интеграции в Windows Store.

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

3. Приложения для iOS и приложения для Windows 8

Для переноса приложений с iOS на Windows 8 необходимо изучить различия между этими платформами. Принципы работы приложений на этих платформах совершенно различны — от низкоуровневого взаимодействия с ОС до высокоуровневых абстракций, таких как пользовательский интерфейс.

Но прежде чем погрузиться в подробности, следует остановиться на одном крайне важном вопросе. Дело в том, что Windows 8 поддерживает два типа приложений: «новые» приложения для Windows 8 («приложения для Windows Store») и «традиционные» приложения для Windows («классические» приложения).

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

На странице по приведенной ниже ссылке дано общее описание новых приложений для Windows Store:

http://msdn.microsoft.com/en-us/library/windows/apps/hh974576.aspx

Каждое приложение для iOS состоит из трех основных частей:

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

Приложения для Windows Store также состоят из схожих частей, хотя эти части могут не вполне точно соответствовать используемым в приложениях для iOS:

• Различные компоненты приложения (основной компонент приложения, контракты приложения, расширения, фоновые задачи, уведомления, плитки и пр.).
• Манифест пакета приложения (определяет идентификацию пакета, его свойства, возможности и разрешения, расширения, наглядные элементы и пр.).
• Ресурсы приложения и локализация (PRI-файл с индексом ресурсов пакета; все ресурсы приложения проиндексированы и сопоставлены).

На приведенном ниже рисунке показаны возможности и доступные объявления в манифесте пакета Windows 8 для образца приложения:

Рисунок 11:Манифест пакета: возможности (слева) и объявления (справа). (Снимок экрана Visual Studio* 2012)

Приложения Apple, как и приложения для Windows Store, обладают строго определенным жизненным циклом, то есть набором состояний, через которые приложение проходит от начала и до конца. На странице по приведенной ниже ссылке показан жизненный цикл приложений для Windows Store:

http://msdn.microsoft.com/en-us/library/windows/apps/hh464925.aspx

Как и в iOS, в Windows 8 для приложений поддерживаются различные представления (книжная ориентация, альбомная ориентация), различные размеры экрана и пр. Помимо этого, в Windows 8 поддерживаются еще два представления, отсутствующие в iOS: «прикрепленное представление» и «заполненное представление».

На приведенном ниже снимке экрана показано приложение для Windows 8 в четырех представлениях: альбомная ориентация, книжная ориентация, прикрепленное представление (слева снизу, приложение Windows Store в заполненном представлении) и заполненное представление (справа снизу, приложение Windows Store в прикрепленном представлении).

Рисунок 12:Образец приложения для Windows 8* в различных представлениях (снимок экрана Windows 8 Simulator)

Руководство по созданию прикрепленных и заполненных представлений см. по ссылке:

http://msdn.microsoft.com/en-us/library/windows/apps/hh465371.aspx

Еще одно существенное различие — общие элементы управления приложениями и элементы пользовательского интерфейса. В iOS для выполнения различных задач предусмотрены разные панели — панель переходов, панель поиска и т. д. В Windows 8 панель приложения служит основным интерфейсом команд приложений для Windows Store. Панель приложения аналогично панели переходов в iOS можно использовать для навигации и для других действий приложения. По умолчанию панель приложения скрыта в приложениях для Windows 8, и ее можно вызвать при помощи соответствующего жеста. Поведение панели приложения можно настраивать в соответствии с необходимостью (она может быть всегда активной, скрываться по прикосновению и пр.). На следующем рисунке показана панель приложения Internet Explorer в Windows 8*.

Рисунок 13:Панель приложения в Internet Explorer* 10 (снимок экрана Windows* 8 Internet Explorer).

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

Чудо-кнопки — это новый уникальный элемент приложений Windows 8. Это определенный набор кнопок, общих для всех приложений. Для их вызова используется соответствующий жест. Вот эти кнопки: «Поиск», «Общий доступ», «Подключение к устройствам» и «Параметры».

На следующем рисунке показана панель чудо-кнопок, открытая в приложении Windows Store:

Рисунок 14:Панель чудо-кнопок в приложении Windows Store

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

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

http://msdn.microsoft.com/en-us/library/windows/apps/br211369

В этом разделе мы перечислили основные области, требующие работы при переносе приложений iOS на платформу Windows 8. Как видно, многие высокоуровневые концепции очень похожи. Разработчики могут сопоставить схему и логику своих приложений соответствующим и эквивалентным механизмам в Windows 8. Иногда такое сопоставление будет неточным из-за отсутствия определенных компонентов или применения совершенно другого механизма реализации. Например, в iOS Storyboard разработчики могут перетаскивать объект DatePicker (календарь) в макет приложения. При разработке приложений для Windows 8 аналогичная операция перетаскивания доступна в Java, но отсутствует в C#. Разработчикам потребуется создавать собственный элемент выбора даты.

Удобный способ создания элемента выбора даты в C# описывается в этом блоге: http://software.intel.com/en-us/blogs/2012/12/14/how-to-make-a-date-picker-calendar-for-c-sharp-in-windows-8

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

4. Пользовательский интерфейс приложений и обработка ввода

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

В Windows 8 пользовательский интерфейс приложения можно создать различными способами:

• XAML и C++/C#/VB
• HTML5/CSS3 и JavaScript
• Прямой графический интерфейс с помощью DirectX/C++ (возможно некоторое использование XAML)
• Традиционный пользовательский интерфейс классических приложений

Выбирая способ создания пользовательского интерфейса, следует внимательно изучить все аспекты приложения. Следует учитывать требования к приложению и планы по его дальнейшему расширению. Например, если существующее приложение широко использует веб-интерфейс или значительный объем кода HTML, то имеет смысл разрабатывать пользовательский интерфейс приложения с помощью JavaScript/HTML5. С другой стороны, если для приложения требуется высокопроизводительная обработка графики и полный контроль над графическим процессором, целесообразно использовать DirectX/C++. Как было отмечено выше, все языки программирования имеют одинаковый доступ ко всем ресурсам системы (с помощью общего API Windows 8 Runtime).

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

Выбрав нужную среду программирования, можно изучить остальные аспекты пользовательского интерфейса, такие как управление окнами, обработка представлений, стили, элементы управления пользовательского интерфейса, анимация и пр. Все эти возможности могут довольно сильно отличаться в зависимости от используемой среды. Например, приложения HTML5 имеют собственные методики обработки событий (согласно стандартам HTML DOM и веб-стандартам) и применения стилей (CSS3).

В приложениях для iOS пользовательский интерфейс типичного приложения состоит из нескольких компонентов «представлений» с «переходами» между ними. В этих компонентах размещаются объекты типа «представление» и «групповое представление», реализующие элементы пользовательского интерфейса, такие как кнопки и разметки. Эта платформа поддерживает весь жизненный цикл пользовательского интерфейса, его базовые технологии, ввод и обработку событий. В Windows 8 реализована крайне мощная платформа пользовательского интерфейса и модель программирования, реализующая общие для всей системы принципы пользовательского интерфейса:

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

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

http://msdn.microsoft.com/en-us/library/windows/apps/hh779072.aspx

При создании пользовательского интерфейса приложений для Windows 8 мы настоятельно рекомендуем разработчикам использовать решение Blend для Visual Studio 2012. Blend поддерживает создание пользовательских интерфейсов на основе XAML, а также на основе HTML5/CSS3. Это решение содержит мощные инструменты и средства работы над пользовательским интерфейсом, в том числе возможность быстрого интерактивного тестирования пользовательского интерфейса.

Руководство по коду сенсорного ввода Windows 8 (C#) см. в статье «Поддержка сенсорного ввода в Metro-приложениях Windows 8* с помощью C#»:

http://msdn.microsoft.com/en-us/library/windows/apps/hh868262

For a full step-by-step dive into the details of Windows 8 touch code (C#), take a look at this article titled "Enabling Touch in Windows 8* Style UI Apps with C#":

http://software.intel.com/en-us/articles/enabling-touch-in-windows-8-metro-style-apps-with-c

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

5. Заключение

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

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

*Другие наименования и товарные знаки могут быть собственностью третьих лиц.

© Intel Corporation, 2012. Все права защищены.

OpenGL является охраняемым товарным знаком, а OpenGL ES является товарным знаком корпорации Silicon Graphics Inc. Товарные знаки используются с разрешения Khronos..

Эта статья описывает, как построить простое приложение для магазина Windows используя Intel® Threading Building Blocks (Intel® TBB).

Мой предыдущий пост  “Windows* 8 Tutorial: Writing a Multithreaded Application for the Windows Store* using Intel® Threading Building Blocks” описывает экспериментальную поддержку для приложений для магазина Windows. Обновление 3 для Intel TBB 4.1, так же как стабильный релиз tbb41_20130314oss содержит динамические библиотеки для таких приложений.

Для создания простого приложения создайте новый проект Blank App (XAML), используя шаблон Visual C++> Windows Store.  В статье используется имя проекта tbbSample0321. 

Добавьте пару кнопок для основную страницу (tbbSample0321.MainPage class). После этого добавления XAML-файл страницы будет выглядеть примерно так

<Page
    x:Class="tbbSample0321.MainPage"    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"    xmlns:local="using:tbbSample0321"    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}">
        <Button Name="SR" Margin="167,262,0,406" Height="100" Width="300" Content="Press to run Simple Reduction" Click="SR_Click"></Button>
        <Button Name="DR" Margin="559,262,0,406" Height="100" Width="300" Content="Press to run Determenistic Reduction" Click="DR_Click"></Button>   
     </Grid>
</Page>

И добавьте в заголовочный файл основной страницы  (MainPage.xaml.h) объявления методов обработки нажатия на кнопки:

#pragma once
#include "MainPage.g.h"
namespace tbbSample0321
{
 public ref class MainPage sealed
 {
 public:
 MainPage();
 protected:
 virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;
 private:
 void SR_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e);
 void DR_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); 
 };

Затем добавьте вызовы функций библиотеки Intel TBB в в эти обработчики событий. Как пример, используйте алгоритмы редукции (tbb::parallel_reduce) и детерминистической редукции (tbb::parallel_deterministic_reduce).  Для этого добавьте следующий код в основной исходний главной страницы MainPage.xaml.cpp: 

#include "tbb/tbb.h"
void tbbSample0321::MainPage::SR_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    int N=100000000;
    float fr = 1.0f/(float)N;
    float sum = tbb::parallel_reduce(
        tbb::blocked_range<int>(0,N), 0.0f,
        [=](const tbb::blocked_range<int>& r, float sum)->float {
            for( int i=r.begin(); i!=r.end(); ++i )
                sum += fr;
            return sum;
    },
        []( float x, float y )->float {
            return x+y;
    }
    ); 
    SR->Content="Press to run Simple ReductionnThe answer is " + sum.ToString();
}


void tbbSample0321::MainPage::DR_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    int N=100000000;
    float fr = 1.0f/(float)N;
    float sum = tbb::parallel_deterministic_reduce(
        tbb::blocked_range<int>(0,N), 0.0f,
        [=](const tbb::blocked_range<int>& r, float sum)->float {
            for( int i=r.begin(); i!=r.end(); ++i )
                sum += fr;
            return sum;
    },
        []( float x, float y )->float {
            return x+y;
    }
    ); 
    DR->Content="Press to run Deterministic ReductionnThe answer is " + sum.ToString();
}

Затем сконфигурируйте Intel TBB в странице свойств проекта

В Visual Studio, Project > Properties > Intel Performance Libraries, установите Use TBB в Yes:

Если Вы используете стабильный релиз, то сконфигурируйте проект вручную: добавьте папку <TBB_folder>/include в свойства проекта Additional Include Directories и добавьте каталог, где лежит библиотека tbb.lib в Additional Library Directories.  

Затем добавьте динамические библиотеки tbb.dll и tbbmalloc.dll в контейнер приложения. Для этого добавьте файлы в проект через Project> Add Existing Item… 

и установите свойство Content в Yes. В этом случае файлы будут скопированы в контейнер приложения (AppX) и затем могут быть загружены во время старта приложения или позже.

Вот и всё! Простое приложение для магазина Windows готово и это должно быть хорошим стартом для написания более сложных многопоточных приложений используя Intel® Threading Building Blocks.

*Другие наименования и товарные знаки являются собственностью своих законных владельцев.

Загрузить статью

app-communication-ccefinal.pdf [Eng., 228.17 KB)

Аннотация

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

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

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

Общие сведения

Плиточные приложения Windows 8 должны быть компактными, надежными и быстрыми, а также должны поддерживать сенсорное управление. Для таких приложений действует ряд ограничений на доступ к различным компонентам файловой системы, ОС и оборудования. При обновлении существующих приложений до плиточной модели возникают некоторые препятствия. Часть функциональности приложений невозможно реализовать с помощью API WinRT API. Одно из возможных решений: создать интерфейс в стиле Windows 8, который будет обмениваться данными с десктопным приложением, чтобы выполнять действия, которые не поддерживаются в API WinRT. Есть несколько способов это сделать, но использование магазина Windows накладывает ряд ограничений.

Если компания разрабатывает собственные плиточные приложения Windows 8 для внутреннего использования, нет необходимости распространять их через магазин Windows. Значит, на эти приложения не действует запрет совместного доступа к локальным ресурсам. Дополнительные сведения см. по адресу http://blogs.msdn.com/b/windowsstore/archive/2012/04/25/deploying-metro-style-apps-to-businesses.aspx.

Соображения

Направление обмена данными

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

Переключение между приложениями или фоновый обмен данными

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

Подключения

Если оба приложения находятся на одном и том же компьютере, количество возможных вариантов резко сокращается: многие способы обмена данными между процессами, доступные в прежних системах, не могут соединить WinRT с приложениями Win32. При добавлении интрасети появляется несколько дополнительных вариантов. Файлы можно хранить в локальном облаке или на серверном облачном хранилище, уведомления можно передавать через службу push-уведомлений Windows, можно использовать веб-службы. При наличии доступа в Интернет можно использовать крупные облачные хранилища и внешние веб-службы.

Автономная работа

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

Возможные подходы

Веб-служба

Десктопное приложение может выполняться в качестве внутренней системы и предоставлять свои данные через веб-службу, что дает возможность плиточному приложению Windows 8 подключаться и обмениваться данными. Десктопное приложение также может служить посредником: обрабатывать взаимодействие и получать запросы по подключению. Пример использования веб-служб со стороны Windows 8 см. по адресу http://www.codeproject.com/Tips/482925/Accessing-Data-through-Web-Service-in-Windows-8-St.

Локальные файлы

Когда оба приложения находятся на одном и том же компьютере и пытаются обмениваться данными без использования сети, набор возможных вариантов весьма ограничен, но и эта задача решаема. Если приложение развертывается внутри компании, а магазин Windows не нужен, обмен данными можно осуществлять через локальные файлы, доступные для обоих приложений. Если десктопному приложению удастся обойти некоторые блокировки записи, оно сможет изменить общие файлы и обеспечить обмен информацией почти в реальном времени (если читать файлы быстро и часто). Пакет Intel Energy Checker SDK использует аналогичную модель (дополнительные сведения см. в разделе справочных материалов). В Windows 8 отключены именованные каналы, общая память и другие стандартные способы обмена данными между процессами. Поэтому остается, по сути, только использование локальных общих файлов. Опасность в этом случае заключается в раскрытии данных пользователям: поскольку файлы находятся в общей папке, пользователи могут получать к ним доступ, просматривать их и изменять. При этом возникают проблемы безопасности, если файлы не зашифрованы, и проблемы функциональности, если пользователь вдруг решит заблокировать, изменить или удалить файлы. Этот подход подробно описывается по адресу http://stackoverflow.com/questions/7465517/how-can-a-metro-app-in-windows-8-communicate-with-a-backend-desktop-app-on-the-s.

Облако: хранение и уведомления

При наличии доступа в сеть приложения могут обмениваться файлами с помощью удаленного сервера или облака. В большинстве облачных служб предусмотрены защитные механизмы, исключающие конфликты при доступе к файлам и утрату данных. Если настроить сервер push-уведомлений Windows (WNS), десктопное приложение сможет отправлять сообщения и обновления плиточному приложению Windows 8 в виде уведомлений. Это могут быть всплывающие уведомления, обновления динамических плиток; они могут обрабатываться кодом для настраиваемого обмена информацией. Примеры использования всплывающих уведомлений см. по адресу http://code.msdn.microsoft.com/windowsapps/Toast-notifications-sample-52eeba29Сведения об использовании облака см. по адресу http://www.windowsazure.com/en-us/develop/mobile/tutorials/get-started.

Имитация стиля

Если все перечисленные варианты неприменимы (например, используется один компьютер с ограниченными подключениями), можно полностью отказаться от реализации плиточного приложения Windows 8 и использовать только его плитку в качестве ярлыка для полноэкранного классического приложения, дизайн которого будет близок к стилю Windows 8. При этом не будут доступны все возможности Windows 8, но можно разрабатывать полнофункциональное приложение без ограничений, связанных с WinRT. Сведения и примеры таких приложений см. по адресу http://stackoverflow.com/questions/12881521/desktop-application-in-metro-style.

Тупики

Локальное замыкание веб-подключения

Локальное замыкание веб-подключения можно использовать приложениями в других ОС для подключения через веб-сокет к другой программе на этом же компьютере. В Windows 8 реализация этого подхода затруднена: механизмы безопасности Windows 8 отключают замыкание на себя. Эти механизмы безопасности можно отключить вручную, но лишь в режиме отладки. При этом приложение будет не только непригодно для распространения в коммерческих целях, но и никогда не пройдет сертификацию для магазина Windows.

Обмен данными в Win32

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

Обзор возможных подходов

Заключение

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

Прочие справочные материалы

Требования для сертификации приложений для Windows 8 http://msdn.microsoft.com/en-us/library/windows/apps/hh694083.aspx
Требования для сертификации классических приложений для Windows 8 http://msdn.microsoft.com/en-us/library/windows/desktop/hh749939.aspx
Требования для сертификации приложений для Windows Server http://msdn.microsoft.com/en-us/library/windows/desktop/hh848078(v=vs.85).aspx

Об авторе

Брэд Хилл (Brad Hill) — инженер по программному обеспечению в подразделении Developer Relations корпорации Intel. Брэд занимается изучением новых технологий на оборудовании Intel и обменивается лучшими методиками с разработчиками ПО на форумах Intel Developer Zone и на конференциях разработчиков. В настоящее время он работает над получением степени Ph.D по компьютерным наукам в Университете штата Аризона.

API выполняемого модуля Windows* WinRT является новым основным API приложений для Windows 8 Store*. Этот API раскрывает разработчикам все новые возможности Windows 8* с использованием высокоэффективного объектно-ориентированного принципа.

Этот API написан на C++ на основе Win32 и интерфейса COM. Доступ для других языков (в частности, C++/CX, C#, Visual Basic * и Javascript *) предоставляется посредством файлов метаданных API (с расширением *.winmd).

Может сложиться мнение, что API WinRT доступен только для приложений для магазина Windows 8*, но и классические приложения также имеют к нему доступ. Более того, некоторые компоненты API, например PackageManager, доступны только для классических приложений, поскольку их необходимо выполнять вне песочницы приложений для магазина Windows 8*. Получить сведения о доступности компонентов API можно непосредственно в библиотеке MSDN. В верхней части большинства классов указываются сведения о совместимости.

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

WinRT предоставляет доступ к своему содержимому для других языков посредством двух основных WINMD-файлов:

• Windows.winmd: C:\Program Files (x86)\Windows Kits\8.0\References\CommonConfiguration\Neutral
• Platform.winmd: C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\Microsoft.VCLibs\11.0\References\CommonConfiguration\neutral

Они соответствуют пространствам имен Windows и Platform. Пространство имен Windows предоставляет доступ к большинству функций среды выполнения Windows, а пространство имен Platform содержит важные типы, например String.

Вот некоторые полезные компоненты среды выполнения Windows, которые можно использовать из десктопных приложений:

• Windows.Sensors (акселерометр, гирометр, датчик освещенности, датчик ориентации и пр.)
• Windows.Networking.Proximity.ProximityDevice (NFC)
• Windows.Device.Geolocation (GPS)
• Windows.UI.Notifications.ToastNotification
• Windows.Globalization
• Windows.Security.Authentication.OnlineId (в том числе интеграция LiveID)
• Windows.Security.CryptographicBuffer (полезные функции кодирования и декодирования двоичных данных)
• Windows.ApplicationModel.DataTransfer.Clipboard (доступ к буферу обмена Windows 8 * и наблюдение за ним)

В этой статье вы узнаете, как использовать WinRT из десктопных проектов C#, а также из проектов C++/CXи на стандартном языке C++.

Использование среды выполнения Windows из проекта C#/.NET

По умолчанию среда разработки Visual Studio * 2012 не предоставляет доступ к среде выполнения Windows из обычных проектов десктопных приложений C#.

Прежде всего, необходимо объявить, что проект предназначен для Windows 8.

К сожалению, в VS2012 для этого не предусмотрен графический пользовательский интерфейс, поэтому сначала придется выгрузить проект C#:

Затем можно вручную отредактировать CSPROJ-файл, добавив в него следующее:

  <PropertyGroup>
    <TargetPlatformVersion>8.0</TargetPlatformVersion>
  </PropertyGroup>

Перезагрузите проект:

Теперь проект предназначен для Windows 8*. Из проекта можно ссылаться на WINMD-файлы:

В диспетчере ссылок должна появиться новая вкладка Windows:

Щелкните Windows, чтобы добавить Windows.winmd в качестве ссылки в проект. Если этот элемент отсутствует, можно вручную указать ссылку на его расположение (C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0\ExtensionSDKs\Microsoft.VCLibs\11.0\References\CommonConfiguration\neutral) с помощью кнопки «Обзор».

Теперь можно использовать среду выполнения Windows из классического приложения с полной поддержкой Intellisense:

Также может потребоваться добавить ссылку на System.Runtime.WindowsRuntime.dll, если вы используете сопоставленные типы , такие как обработчики событий среды выполнения Windows

Эта сборка находится в папке C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETCore\v4.5 .

Пример работы с акселерометром с помощью WinRT C#/.NET

using System;
using Windows.Devices.Sensors;
namespace CSApp
{
    class Program
    {
        static void Main()
        {
            Accelerometer accelero = Accelerometer.GetDefault();
            accelero.ReadingChanged += (Accelerometer sender, AccelerometerReadingChangedEventArgs args) =>
                {
                    Console.WriteLine(args.Reading.AccelerationX);
                };
            Console.Read();
        }
    }
}

Использование среды выполнения Windows из проекта C++

Можно использовать API WinRT из C++/CX или из стандартного C++. При использовании стандартного C++ потребуется использовать WRL (библиотеку шаблонов C++ среды выполнения Windows) и напрямую обрабатывать объекты COM.

Оба решения создают собственный код, но использование WRL отличается намного более высокой трудоемкостью по сравнению с C++/CX.

Решение C++/CX

Решение C++/CX во многом близко к C++/CLI. Основное отличие от C++/CLI заключается в том, что C++/CX вообще не создает управляемый код; образуется только собственный код.

Общую документацию по C++/CX см. в библиотеке MSDN. Для начала можно использовать краткий справочник.

#using <Windows.winmd>
 #using <Platform.winmd>

#include <iostream>
#using <Windows.winmd>
using namespace Windows::Devices::Sensors;
#using <Platform.winmd>
using namespace Platform;

[MTAThread]
int main(void)
{
 Accelerometer^ accelero = Accelerometer::GetDefault();
 accelero->ReadingChanged += ref new Windows::Foundation::TypedEventHandler<Accelerometer^,AccelerometerReadingChangedEventArgs^>(
 [](Accelerometer^ sender, AccelerometerReadingChangedEventArgs^ args){
 std::cout << args->Reading->AccelerationX << std::endl;
 });
 std::cin.get();
 return 0;
}

Загрузить статью

Загрузить статью Camera Usage and Features, from iOS* to Windows* 8 Store App [Eng., PDF 1.26MB]

Аннотация

Современные приложения, задействующие камеры, могут выполнять новые задачи и предоставляют пользователям более широкие возможности. В этой статье рассматриваются возможности использования камеры в приложениях для магазина Windows* 8 для съемки фотографий и процесса преобразования этих фотографий в кодировку base64, позволяющую передавать их как данные JSON по сети в серверную или локальную базу данных. Мы также обсудим отличия в использовании камеры между iOS* и Windows 8 и предложим несколько советов по портированию вашего кода.

Общая информация

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

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

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

Элементы управления камеры и пользовательский интерфейс

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

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

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

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

Медицинское приложение из магазина Windows

Как мы уже делали в других статьях на сайте Intel Developer Zone, рассмотрим ситуацию на примере медицинского приложения из магазина Windows. Мы добавим в приложение функции съемки фотографии и обновления профиля пациента.

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

Рис. 1. На странице Patients медицинского бизнес-приложения представлен список всех пациентов. При выборе пациента открывается его история болезни.

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

Портирование кода, использующего камеру, с iOS на Windows 8

Платформа iOS предоставляет как стандартные элементы управления камерой, так и расширенное решение с более гибкими возможностями. API-интерфейс UIImagePickerControllerобеспечивает простой стандартный набор распространенных функций съемки фотографий с помощью камеры, тогда как объединенная платформа AV является полностью настраиваемым решением. Дополнительные сведения можно найти в следующем документе:

http://developer.apple.com/library/ios/documentation/AudioVideo/Conceptual/CameraAndPhotoLib_TopicsForIOS/Introduction/Introduction.html

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

http://msdn.microsoft.com/EN-US/library/windows/apps/windows.media.capture.cameracaptureui.aspx

Использование пользовательского интерфейса камеры в Windows 8 и советы по делегированию кода

В этой статье приводится краткая ознакомительная информация о разработке приложений магазина Windows. В приложениях Windows 8, как и в других современных операционных системах (например, iOS), функции камеры необходимо декларировать в файле манифеста приложения. Дважды щелкните Package.appxmanifestв проекте Visual Studio* 2012, чтобы открыть редактор манифеста и изменить параметры. На рис. 2 показано, что в манифесте включена функция веб-камеры, что позволяет использовать данную функцию.

Рис. 2. Манифест приложения с функцией веб-камеры (снимок экрана получен в Visual Studio* 2012)

Теперь наш проект поддерживает доступ к функции камеры.

Когда приложение в первый раз получает доступ к камере, Windows 8 открывает диалоговое окно с запросом разрешения пользователя на доступ к камере. На рис. 3 показан пример.

Рис. 3. Диалоговое окно с запросом разрешения на доступ к камере (снимок экрана получен в Windows* 8)

Как указывалось ранее, приложения Магазина Windows в большинстве случаев могут использовать стандартный системный элемент управления камерой (класс CameraCaptureUI в пространстве имен Windows.Media.Capture). Преимуществом данного подхода является то, что пользователю уже знакомы элементы управления, жесты и принцип использования.

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

На рис. 4 показана панель приложения с кнопкой камеры, имеющей метку Photo.

Рис. 4. Кнопка и значок камеры (снимок экрана получен в Windows* 8)

Для кнопки камеры можно выбрать стандартный значок Windows (PhotoAppBarButtonStyle). На рис. 5 показан пример кода XAML для кнопки камеры, расположенной на панели приложения.

<Button x:Name="button_take_photo" Grid.Column="1" HorizontalAlignment="Left" Margin="0,0,0,0"
Style="{StaticResource PhotoAppBarButtonStyle}" Height="87" VerticalAlignment="Top" 
DataContext="{Binding Patient}" Command="{Binding PatientPicCmd}" RenderTransformOrigin="0.5,0.5" 
Visibility="Visible"/>

Рис. 5. Код XAML для кнопки камеры и стандартный значок на панели приложения ++

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

При написании кода для приложений на основе XAML обычно рекомендуется реализовать шаблон MVVM. Дополнительные сведения о шаблоне MVVM см. в следующей статье:

http://msdn.microsoft.com/en-us/magazine/dd419663.aspx

Это позволит нам реализовать логику обработчика события кнопки внутри модели вида (View) пациента и использовать ту же модель вида и логику на всех страницах пользовательского интерфейса приложения путем простой привязки к свойствам. На рис. 6 показана другая страница пользовательского интерфейса с другой кнопкой камеры. Повторно реализовывать обработчик нажатия кнопки в коде XAML не нужно, так как мы просто выполняем привязку к тому же классу модели вида (ViewModel) пациента (в котором уже присутствует логика обработчика нажатия кнопки камеры).

Рис. 6. Другая страница пользовательского интерфейса с кнопкой камеры (снимок экрана получен в Windows* 8)

Вызов диалогового окна камеры в Windows 8 выполняется очень просто. Достаточно создать экземпляр класса CameraCaptureUI, определить его параметры и отобразить диалоговое окно пользовательского интерфейса камеры с помощью метода CaptureFileAsyncэтого экземпляра. Поскольку данный метод реализован в виде асинхронной модели, для его вызова необходимо использовать ключевое слово await.

Дополнительные сведения об асинхронном программировании в приложениях магазина Windows 8 см. в следующей статье.

http://msdn.microsoft.com/EN-US/library/vstudio/hh191443.aspx

На рис. 7 показан пример кода для вызова стандартного пользовательского интерфейса камеры в Windows 8.

private async void DoPatientPicCmd(object sender)
        {
            try
            {
                CameraCaptureUI dialog = new CameraCaptureUI();
               
                dialog.PhotoSettings.CroppedAspectRatio = new Size(4, 3);

                // fix the photo size to 300x300
                //dialog.PhotoSettings.CroppedSizeInPixels = new Size(300, 300);

                StorageFile photo = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo);
                if (photo == null) return;
              
                // custom process the photo
            }
            catch (Exception ex)
            {
// custom exception handling code

            }
        }

Рис. 7. Пример кода для вызова диалогового окна пользовательского интерфейса камеры ++

Класс CameraCaptureUIсодержит два основных свойства: PhotoSettingsи VideoSettings. Для вызова диалогового окна камеры в фоторежиме необходимо во время вызова указать параметр CameraCaptureUIMode.Photo.

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

http://msdn.microsoft.com/EN-US/library/windows/apps/windows.media.capture.cameracaptureuiphotocapturesettings.aspx

В нашем примере кода выбрана обрезка с соотношением сторон 4 : 3. На рис. 8 показано диалоговое окно пользовательского интерфейса камеры по умолчанию. Функция видеозаписи в нем отключена, поскольку этот элемент управления вызван в фоторежиме. Доступны функции смены камеры (для переключения на заднюю, переднюю или другие камеры), изменения параметров камеры (например, разрешение) и таймера.

Рис. 8. Диалоговое окно пользовательского интерфейса камеры по умолчанию (снимок экрана получен в Windows* 8)

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

Рис. 9. Пользовательский интерфейс камеры с базовыми функциями редактирования (снимок экрана получен в Windows* 8)

Если пользователь доволен снятой фотографией, он может либо нажать кнопку OK, либо переснять фотографию. После успешного выполнения действия (съемки фотографии и нажатия кнопки OK) диалоговое окно пользовательского интерфейса камеры возвращает фотографию, сохраненную как файл изображения (экземпляр класса StorageFile в пространстве имен Windows.Storage), и можно продолжить ее обработку или оставить как есть в модели данных.

Преобразование файла фотоизображения в буфер изображения

Чтобы передать фотоизображение в виде данных JSON в серверную базу данных (наиболее распространенная задача в приложениях для организаций), необходимо преобразовать его в строку с кодировкой base64. Для такого преобразования сначала необходимо преобразовать файл фотографии в буфер изображения, поскольку в функциях API, выполняющих кодирование и декодирование, должен использоваться буфер.

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

Мы получаем доступ к файлу с использованием потока произвольного доступа и копируем его в буфер с помощью интерфейса DataReader. На рис. 10 показан пример кода.

                StorageFile photo = await dialog.CaptureFileAsync(CameraCaptureUIMode.Photo);
                if (photo == null) return;
              
                byte[] photoBuf = null;

                using (IRandomAccessStream photostream = await photo.OpenReadAsync())
                {
                    photoBuf = new byte[photostream.Size];
                    using (DataReader dr = new DataReader(await photo.OpenReadAsync()))
                    {
                        await dr.LoadAsync((uint)photostream.Size);
                        dr.ReadBytes(photoBuf);
                    }
                } 

Рис. 10. Пример кода, преобразующего файл фотографии в буфер ++

Кодирование буферов изображений в строки формата base64 и декодирование

Для кодирования и декодирования строк формата base64 можно использовать класс Convertв пространстве имен System. В предыдущем разделе рассматривалось преобразование фотоизображения в байтовый буфер, который можно использовать в функциях API, выполняющих преобразование в формат base64. Метод ToBase64String описан в следующем документе:

http://msdn.microsoft.com/EN-US/library/dhx0d524.aspx

Ниже приведен фрагмент кода, преобразующий буфер photoBuf, созданный в предыдущем разделе, в строку с кодировкой base64.

                Pic = Convert.ToBase64String(photoBuf, 0, photoBuf.Length);

Pic— это открытая (public) переменная-член класса модели вида пациента, который был описан ранее.

Обратное преобразование строки в буфер:

                var photoBuf = Convert.FromBase64String(pic);

Отображение изображения путем привязки элемента управления Image к объекту BitmapImage

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

http://msdn.microsoft.com/EN-US/library/windows/apps/windows.ui.xaml.controls.image.aspx

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

<Image  Margin="0,40,20,0"            
                            DataContext="{Binding Patient}"
                            Source="{Binding Image}"></Image>

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

http://msdn.microsoft.com/EN-US/library/windows/apps/windows.ui.xaml.media.imaging.bitmapimage.aspx

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

Объект BitmapImageпозволяет напрямую использовать идентификатор URI или настроить буфер фотографии в качестве входного потока с помощью метода SetSourceAsync. Мы используем метод SetSourceAsyncдля создания изображения профиля, если оно доступно, или для установки произвольно выбранного аватара (из ресурсов приложения) в зависимости от пола пациента. См. фрагмент кода на рис. 10 далее.

    public class PatientsViewModel : BindableBase
    {
        public PatientsViewModel() 
        {
            this.PatientPicCmd= new DelegateCommand(DoPatientPicCmd);
        }

        private string pic = string.Empty;
        public string Pic 
        { 
            get { return pic; } 
            set { 
                this.SetProperty(ref pic, value);                
            } 
        }

        private BitmapImage image = null;
        public BitmapImage Image
        {
            get
            {
                if (image == null) GetImageAsync();
                return image;
            }
        }

        public async Task GetImageAsync()
        {
            image = new BitmapImage();
            if (pic.Length > 1)
            {
                var photoBuf = Convert.FromBase64String(pic);
                using (InMemoryRandomAccessStream mrs = new InMemoryRandomAccessStream())
                {
                    using (DataWriter dw = new DataWriter(mrs.GetOutputStreamAt(0)))
                    {
                        dw.WriteBytes(photoBuf);
                        await dw.StoreAsync();
                    }
                    await image.SetSourceAsync(mrs);
                }
            }
            else
            {
                Random rand = new Random();
                String url = "ms-appx:///Assets/" + gender.ToLower() + rand.Next(1, 4).ToString() + ".png";
                StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(url));                
                using (IRandomAccessStream fileStream = await file.OpenAsync(Windows.Storage.FileAccessMode.Read))
                {
                    await image.SetSourceAsync(fileStream);
                }
            }
            OnPropertyChanged("Image");
        }
         …
         …

Рис. 10. Пример кода для отображения фотографии в элементе управления Image с помощью объекта BitmapImage и метода SetSourceAsync ++

В строковом свойстве Picхранится строка с кодировкой base64, в которую мы преобразовали файл снятой фотографии. Это свойство можно передать в локальную или серверную базу данных. Свойство Image (с типом BitmapImage), привязанное к нашему элементу управления Image в XAML, просто возвращает экземпляр BitmapImageв зависимости от значения переменной Pic. Если переменная пуста, возвращается произвольно выбранный аватар; в противном случае строка base64 из переменной Picпреобразуется обратно в байтовый буфер, и возвращается содержащий его экземпляр BitmapImage.

На рис. 11 показан обновленный экран пациентов, который уже приводился на рис. 1.

Рисунок 11. Обновленная страница пользовательского интерфейса со списком пациентов (снимок экрана получен в Windows* 8)

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

Выводы

Мы рассмотрели процесс портирования кода, использующего камеру, из приложений iOS в приложения Windows 8. В том числе мы рассмотрели вызов элемента управления, используемого по умолчанию для работы с камерой, обработка результата, использование моделей асинхронного программирования и вывод изображения в пользовательском интерфейсе приложения магазина Windows с помощью элемента управления Image. Кроме того, мы ознакомились с кодированием изображений в строки формата base64 и декодированием для удобства передачи изображений в службы RESTful в виде данных JSON.

Copyright © 2013 Intel Corporation. Все права защищены.

*Другие наименования и торговые марки могут быть собственностью третьих лиц.

++This sample source code is released under the Intel OBL Sample Source Code License (MS-LPL Compatible), Microsoft Limited Public License, and Visual Studio* 2012 License.

Загрузить статью

Windows* 8 Desktop App - Low Power Audio Playback [Eng., PDF]

Введение

Один из распространенных сценариев использования планшетов с процессорами Intel® Atom™ под управлением Microsoft Windows 8* — воспроизведение музыки в режиме пониженного энергопотребления. Эта возможность позволяет пользователям продолжать слушать музыку после перехода устройства в состояние пониженного потребления электроэнергии, которое называется Connected Standby. Connected Standby — это сценарий «всегда включен, всегда подключен», реализованный в Microsoft Windows и запускаемый с помощью новых состояний пониженного потребления электроэнергии процессоров Intel Atom S0ix. В этом состоянии устройства могут гораздо дольше работать от аккумуляторов, при этом пользователи по-прежнему могут слушать музыку.

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

Общие сведения о режиме Connected Standby

(Автор описания: Priya Vaidya)

Connected Standby предназначен главным образом для снижения энергопотребления и для продления времени работы устройств от аккумулятора. Этот режим сертифицируется Microsoft; устройства должны соответствовать требованиям корпорации. Устройство переходит в режим Connected Standby при нажатии кнопки питания или после бездействия в течение определенного времени. В текущих тестах потребляемая мощность составляет < 100 мВт¹ , потребляемая мощность процессора Intel Atom Z2760 (кодовое название Clover Trail) — около 45 мВт (что соответствует работе в режиме ожидания с подключением в течение примерно 30 дней). Это требование корпорации Microsoft. Согласно требованию «мгновенного включения», должно пройти не более 300 мс¹с момента нажатия кнопки до включения экрана. С точки зрения системы в целом платформа находится в спящем режиме, только изредка запускаются отдельные приложения.

Connected Standby — последовательность действий

Написание кода приложения HTML5

Один из самых простых способов написания кода для воспроизведения звука с пониженным энергопотребления на планшетах с процессорами Intel Atom под управлением Windows 8 — использование нового тега HTML5 audio. По умолчанию тег audio НЕ продолжает воспроизведение при переходе в режим Connected Standby. Чтобы включить воспроизведение звука в этом состоянии, тег HTML должен содержать атрибут категории звука. Имя этого атрибута — msAudioCategory, для него необходимо задать значение BackgroundCapableMedia. Этого достаточно, чтобы все было готово для воспроизведения в режиме Connected Standby.

Кроме того, для правильной работы воспроизведения звука с пониженным энергопотреблением необходимо изменить манифест приложения. Требуется добавить объявление Background Tasks. В этом объявлении также нужно задать свойство для audio. При использовании Visual Studio* это делается очень просто: нужно открыть package.appxmanifest, перейти на вкладку «Объявления», добавить объявление Background Tasksиз раскрывающегося списка «Доступные объявления», а затем выбрать тип задачи Audioв разделе «Свойства».

Этот способ создания кода показан в образце приложения Low-Power в файлах default.html и default.js. Правильное объявление также содержится в файле package.appxmanifest. В примере также использован атрибут Controlдля автоматического добавления простых элементов управления воспроизведением.

Воспроизведение аудиофайлов с аппаратным ускорением обработки

Говоря о воспроизведении звука на платформе Intel Atom с пониженным потреблением электроэнергии, следует упомянуть и об аппаратном ускорении декодирования звука. Платформа Clover Trail обладает аппаратной поддержкой кодирования и декодирования целого ряда форматов аудиофайлов.

Итоги

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

Writing Energy-Efficient Windows* Store Applications for Mobile Devices [Eng., PDF 753KB]

1. Введение

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

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

Различные приложения могут влиять на энергопотребление различными компонентами оборудования: CPU, GPU, устройством хранения данных, сетевым адаптером, датчиками и пр. В серии статей, посвященных экономии электроэнергии, мы обсудим правила проектирования энергоэффективных приложений для различных аппаратных компонентов. Это руководство основано на серии лучших методик для примеров приложений для магазина Windows с реализацией функций и классов в новом наборе API — среде выполнения Windows (WinRT).

В этой статье мы рассматриваем влияние потребления питания центральным процессором. Сначала мы поговорим о состояниях энергопотребления процессора, а затем обсуждим влияние определенных API WinRT на работу CPU.

2. Состояния энергопотребления процессора

Современные процессоры поддерживают несколько состояний энергопотребления. Все эти состояния можно разделить на две категории: активные состояния и состояния сна. Активное состояние включает несколько рабочих состояний (P-состояний), которые различаются напряжением питания и частотой процессора. Состояние сна включает несколько C-состояний (Cx-состояний), которые различаются уровнем экономии энергии. Подробные определения активных состояний и состояний сна см. в технических спецификациях процессоров на базе архитектуры IA.

2.1 Активное состояние

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

P = C_dynV²F

где P— динамическое потребление электроэнергии в определенном P-состоянии. C_dyn— динамическая нагрузка на CPU. Vи F, соответственно, напряжение питания и частота CPU в данном P-состоянии. Из этого уравнения следует, что в более высоком P-состоянии CPU потребляет больше электроэнергии.

2.2 Состояние сна

Бездействующий процессор переходит в состояние сна для экономии электроэнергии. Многие процессоры на основе архитектуры IA поддерживают несколько состояний сна (так называемых Cx-состояний), например C1, C2/C3, C5, C6 и C7. В состоянии C1 процессор обычно остановлен, поскольку не нужно выполнять никакие инструкции. Состояние C2/C3, если поддерживается, обеспечивает пониженное потребление электроэнергии по сравнению с состоянием C1. В состоянии C2/C3 кэш процессора остается включенным, а основные функции отключены. Состояния C5/C6/C7 (если поддерживаются) — дополнительные состояния глубокого сна. По мере перехода из состояния C1 в состояние C7 потребляемая процессором мощность снижается, но увеличивается задержка при пробуждении процессора.

2.3 Управление состояниями энергопотребления

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

2.4 Проведение эксперимента

Мы провели тесты с использованием типового таймера в приложении для магазина Windows. Тесты были проведены на ультрабуке с процессором Intel® Core™ 3-го поколения и с чистой установкой коммерческой версии Windows 8. Для измерения потребляемой мощности мы использовали Intel® Power Gadget. Скорость обновления экрана платформы — 60 кадров в секунду (кадр/с).

3. Влияние таймеров

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

3.1 Создание и отмена таймера пула потоков

Среда выполнения Windows включает класс ThreadPoolTimer. Программные таймеры в приложениях можно создавать путем вызова функций CreateTimerили CreatePeriodicTimerв этом классе. Таймеры широко используются для создания потоков в приложениях для магазина Windows. Мы реализовали периодический таймер путем вызова функции CreatePeriodicTimer.

В примере кода показано использование API для создания периодического таймера.

private void CreatePeriodicTimer(object sender, RoutedEventArgs args)
{
     if (int.TryParse(PeriodMs.SelectionBoxItem.ToString(), 
         out ThreadPoolSample.PeriodicTimerMilliseconds))
     {
      ThreadPoolSample.PeriodicTimer = ThreadPoolTimer.CreatePeriodicTimer(
          (timer) => {
          System.Threading.Interlocked.Increment(ref   
              ThreadPoolSample.PeriodicTimerCount);
              Dispatcher.RunAsync(
                  CoreDispatcherPriority.High, () =>
                  {                                  
                       ThreadPoolSample.PeriodicTimerScenario.UpdateUI(
                       Status.Completed);
                  });
      },
      TimeSpan.FromMilliseconds(
          ThreadPoolSample.PeriodicTimerMilliseconds));
      UpdateUI(Status.Started); //Do nothing or update XAML textbox
}

Образец кода 1. Создание периодического таймера с помощью класса ThreadPoolTimer **

В примере кода показано использование API для отмены периодического таймера.

private void CancelPeriodicTimer(object sender, RoutedEventArgs args)
{
     if (ThreadPoolSample.PeriodicTimer != null)
     {
         ThreadPoolSample.PeriodicTimer.Cancel();
         ThreadPoolSample.PeriodicTimerCount = 0;
         UpdateUI(Status.Canceled);
     }
}

Образец кода 2. Отмена периодического таймера с помощью класса ThreadPoolTimer **

3.2 Влияние интервала периодического таймера

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

Рисунок 1. Влияние интервала периодического таймера на потребляемую мощность CPU

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

3.3 Резидентность P- и C-состояний

Резидентность P- и C-состояний указывает процент времени, в течение которого процессор остается в определенном Р- или С-состоянии. Как правило, сумма всех резидентностей С-состояний (С0–С7) равна 100 %, как и сумма всех резидентностей Р-состояний. Для примера с периодическим таймером, срабатывающим для простого обновления XAML, данные о резидентности Р- и С-состояний приведены в таблице 1.

Таблица 1. Резидентность P- и C-состояний для периодического таймера, срабатывающего для обновления пользовательского интерфейса

В таблице 1 видно, что при небольшом значении интервала таймера (5 или 16 мс) резидентность состояния C7 равна нулю: из-за слишком частого срабатывания таймеров процессор вообще не переходит в состояние глубокого сна. Для обновления пользовательского интерфейса процессор должен пробудиться из состояния С6. Если увеличить интервал таймера (20 или 100 мс), процессор проводит около 70 % времени в состоянии C7. Таким образом, потребляемая мощность процессора снижается в состоянии сна.

Значение резидентности P-состояния указывает, что при кратких интервалах таймера процессор работает 100 % активного времени с номинальной частотой. Обратите внимание, что режим работы с номинальной частотой отнюдь не является наиболее низким Р-состоянием. Если же увеличить интервал таймера, процессор может перейти в более низкое Р-состояние. Таким образом, потребляемая мощность процессора снижается в активном состоянии.

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

4. Сравнение ThreadPoolTimerи DispatcherTimer

Среда выполнения Windows предоставляет еще один таймер в классе Windows.UI.Xaml.DispatcherTimer. Сравним работу этих двух классов при простом обновлении пользовательского интерфейса XAML. Класс DispatcherTimer предоставляет таймер, интегрированный в очередь диспетчера, которая обрабатывается с заданным интервалом времени и с заданным приоритетом.

4.1 Создание и отмена таймера диспетчера

DispatcherTimerсоздается, как показано в приведенном ниже образце кода.

private void CreateDispatcherTimer(object sender, RoutedEventArgs args)
{        
    if (int.TryParse(PeriodMs.SelectionBoxItem.ToString(), 
         out ThreadPoolSample.PeriodicTimerMilliseconds))
         {
             dispatcherTimer = new DispatcherTimer();
             dispatcherTimer.Tick += UpdateUIwithDispatcherTimer;
             dispatcherTimer.Interval = TimeSpan.FromMilliseconds(
                 ThreadPoolSample.PeriodicTimerMilliseconds);
             dispatcherTimer.Start();
         }
}

Образец кода 3. Создание периодического таймера с помощью класса DispatcherTimer **

private void CancelDispatcherTimer(object sender, RoutedEventArgs args)
{
    dispatcherTimer.Stop();
}

Образец кода 4. Отмена таймера с помощью класса DispatcherTimer **

4.2 Кадровая скорость потока пользовательского интерфейса и сравнение энергопотребления

Мы реализуем два таймера в приложении для магазина Windows, чтобы обновлять простое текстовое поле XAML с различными периодическими интервалами. Сравнение кадровой скорости потока пользовательского интерфейса и потребляемой мощности процессора показано на рис. 2. Ломаные линии представляют среднюю потребляемую мощность процессора по сравнению с потреблением в режиме простоя. Столбцы представляют кадровую скорость потока пользовательского интерфейса, с этой скоростью обновляется текстовое поле XAML.

Рисунок 2. Сравнение кадровой скорости потока пользовательского интерфейса и потребляемой мощности CPU для двух реализаций в приложении для магазина Windows*

Из графика видно, что при определенном интервале таймера процессор потребляет меньше электроэнергии при использовании таймера DispatcherTimer. Это обусловлено тем, что класс DispatcherTimer ограничивает кадровую скорость потока пользовательского интерфейса (30 кадр/с) половиной скорости обновления экрана (60 кадр/с). Поэтому мы рекомендуем разработчикам приложений использовать класс DispatcherTimer для обновления пользовательского интерфейса.

5. Итоги

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

6. Дальнейшее обсуждение

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

7. Об авторе

Сушу Чжанг (Sushu Zhang) работает программистом в подразделении Intel по разработке ПО и обслуживанию. Она занимается вопросами интеграции платформ на базе Intel с ОС Android и Windows в ISV. Ею разработан инструмент Intel® Power Monitoring Tool для устройств Android. В последнее время Сушу принимала участие в нескольких проектах Intel по оптимизации энергопотребления. До перехода в Intel она работала в корпорации Майкрософт и занималась энергоэффективностью Windows. Сушу получила степень доктора наук по компьютерным наукам в Университете штата Аризона. Областью ее научных интересов были энергопотребление систем и управление рабочими температурами.

Copyright© 2012 Intel Corporation. All rights reserved.

КРАТКИЙ БИЗНЕС-ОБЗОР
Intel® Developer Zone
Процессор Intel® Atom™ серии Z3700
Microsoft Windows* 8.1

Усовершенствования ОС Microsoft Windows 8 и внедрение разработок SoC (system-on-chip) на основе процессоров Intel® Atom™ серии Z3700 предоставляют разработчикам программного обеспечения возможность создавать инновационные приложения.

Быстрое внедрение планшетных ПК меняет технологическую инфраструктуру. Отчет Дженнифера Кента (Jennifer Kent), аналитика Parks Associates Research, за третий квартал 2013 г.: "Всего за три года планшетные ПК заняли около трети американского потребительского рынка широкополосной связи, наряду с расширением спектра устройств и цен, из года в год стимулирующих рост продаж".¹

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

Как показано на рисунке 1, прогнозируемый приход на рынок планшетных ПК под управлением Windows составляет ежегодно 42-процентный прирост (CAGR) до 2016,²демонстрируя, в целом, максимум преимуществ от использования планшетных устройств.

Рисунок 1.Тенденции: планшеты под управлением Windows*.

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

Вкладом в дальнейшее развитие планшетных ПК на основе Window также является разработка систем SoC (system-on-chips), основанных на процессорах Intel® Atom™ серии Z3700.

Системы SoC содержат такие элементы, как интегрированное решение HD-графики Intel®, технология Intel® Wireless Display,³и широкие возможности подключения с помощью 4G LTE. Технология ISP 2.0 (Image Signal Processing) помогает упростить вызовы библиотечных функций, например, Intel® Integrated Performance Primitives, давая разработчикам свободу в создании особенно необходимых и ценных функциональностей.

Тенденции возможностей потребителей в праздничном сезоне 2013 года

Разработчики сейчас работают над созданием приложений, которые в этот праздничный сезон предложат пользователям самые новые возможности интерфейсов взаимодействия. Системы SoC, создаваемые на основе следующего поколения процессоров Intel Atom на базе 22-нм технологии, предлагают беспрецедентные возможности для планшетных ПК, в числе которых:

• Удивительная производительность.Быстрота и оперативность выполнения приложений для настольных ПК и приобретаемых в магазине Windows Store.
• Невероятная продолжительная автономная работа от батареи.Высочайшая энергоэффективность для долгой автономной работы от батареи.
• Великолепные видеовозможности.Ускоренная HD-графика и видео, технология Intel Wireless Display.³
• Многоуровневая безопасность.Аппаратная и программная защита для устройств, данных и персональной информации.

Узнайте больше о разработках для ОС Windows и процессоров Intel Atom на сайте software.intel.com/windows

¹ Parks Associates, "Планшетные ПК: Пришествие мобильных вычислений и цифровой дом"Дженнифер Кент (Jennifer Kent) и Кристофер Кофман (Christopher Coffman), третий квартал 2013 г.

² Strategy Analytics, 2013 г.

³Требуется система с поддержкой технологии Intel® Wireless Display (Intel® WiDi), совместимый адаптер и телевизор Воспроизведение данных в формате 1080p и Blu-Ray* или другого защищенного содержимого доступно только на системах на базе процессоров Intel® Core™ со встроенным графическим решением, совместимым адаптером и медиапроигрывателем, а также с помощью ПО, имеющего поддержку технологии Intel® WiDi и установленного драйвера графики. Проконсультируйтесь с производителем ПК. Для получения дополнительной информации см. страницу http://www.intel.ru/content/www/ru/ru/architecture-and-technology/intel-wireless-display.html.

Содержание

1. Введение
2. Алгоритм портирования приложений
3. Создание приложения HTML5 в Visual Studio 2012*
4. Необходимые файлы
5. Выбор возможностей устройства, необходимых для приложений HTML5
6. Структура каталогов и тестирование приложений HTML5 в Visual Studio 2012
7. Обнаруженные проблемы

Введение

Эта статья предназначена для начинающих разработчиков HTML5. В ней описывается процесс портирования приложений HTML5, входящих в состав среды разработки Intel(R) HTML5. Тем, кто никогда не работал с HTML5, можно для начала ознакомиться со следующими материалами: http://software.intel.com/en-us/html5.
Мы портировали следующие приложения HTML5 для Windows 8* Store:

• Counting Beads
• RPN Calculator
• Towers of Hanoi
• jQM Springboard Nav

На момент написания этой статьи приложение PhoneGap Build* не поддерживало размещение в Windows 8 Store.

Алгоритм портирования приложений

Портирование приложений HTML5 для Windows 8* Store несложно, если приложения уже были преобразованы для Internet Explorer* 10 (IE10). Впрочем, может потребоваться немало времени, чтобы добиться работоспособности приложения во всех браузерах. Мы реализуем следующие шаги:

1. Сначала нужно преобразовать приложение для IE10
   Проверьте, какие функции поддерживаются в IE10, открыв ссылку http://html5test.com/в IE10. Узнайте, какие проблемы могут возникнуть.
   Встреченные нами проблемы перечислены в разделе советов.
2. Создание пустого приложения JavaScript в Visual Studio 2012*
   Мы использовали Visual Studio 2012 Express Edition на компьютере с Windows 8. Подробные описания использованных средств см. в разделе Microsoft MSDN Get the tools (Windows Store apps).
3. Добавление файлов в пустой проект JavaScript
4. Выбор нужных функций устройства
5. Тестирование

Создание приложения HTML5 в Visual Studio 2012

Приложение HTML5 в Windows 8 может быть создано следующим образом:

1. Создайте новый проект JavaScript — BlankApp
   Будет создан проект JavaScript с пустым содержимым и множеством файлов по умолчанию.
2. Переименуйте default.html в index.html.
   Файл default.html — это начальная страница, создаваемая по умолчанию. Чтобы переименовать файл, щелкните его правой кнопкой мыши и выберите команду «Переименовать».
3. Установите файл index.html в качестве начальной страницы пакета.
   Дважды щелкните файл package.appxmanifest. Он будет открыт в редакторе манифеста. Измените значение свойства «Начальная страница» с default.html на index.hmtl:
   
4. Переименуйте папку images в win8-images и обновите следующие изображения образца приложения HTML5
   • logo.png
   • smalllogo.png
   • storelogo.png
   • splashscreen.png
5. Удалите ненужные файлы: default.css и default.js.
6. Скопируйте файлы из образца приложения HTML5 в корневую папку проекта.
7. Добавьте файлы из образца приложения HTML5.
   Это может занять некоторое время, поскольку для правильной упаковки приложения нужно добавить все папки и файлы.
8. Щелкните «Run on Local Machine» или «Run on Simulator».

При этом вам может пригодиться информация со следующей страницы MSDN: Create your first Windows Store app using JavaScript .

Необходимые файлы

При создании приложений Windows 8 Store следует соблюдать ряд требований. Полный контрольный список для отправки приложений находится на странице MSDN.

При разработке и тестировании требуются 4 файла с логотипом:

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

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

Функции устройств для приложений Windows 8 Store объявляются в файле манифеста package.appxmanifest. Этот файл создается по умолчанию в Visual Studio 2012. Функции устройств в приложениях Windows 8 Store отличаются от функций устройств в приложениях PhoneGap. Поэтому нужно аккуратно перенести их из файла config.xml приложения PhoneGap в файл package.appxmanifest.
На следующем рисунке показан список функций устройств в Visual Studio 2012.

Ниже перечислены все функции устройств, использованные в файле "config.xml"приложения PhoneGap's :

<!-- If you do not want any permissions to be added to your app, add the
    following tag to your config.xml; you will still have the INTERNET
    permission on your app, which PhoneGap requires. -->
<preference name="permissions" value="none"/>

<!-- to enable individual permissions use the following examples -->
<feature name="http://api.phonegap.com/1.0/battery"/>
<feature name="http://api.phonegap.com/1.0/camera"/>
<feature name="http://api.phonegap.com/1.0/contacts"/>
<feature name="http://api.phonegap.com/1.0/file"/>
<feature name="http://api.phonegap.com/1.0/geolocation"/>
<feature name="http://api.phonegap.com/1.0/media"/>
<feature name="http://api.phonegap.com/1.0/network"/>
<feature name="http://api.phonegap.com/1.0/notification"/>

Например, для приложения HTML5, записывающего и воспроизводящего звук, файл package.appxmanifest должен содержать следующие функции:

• Микрофон
• Библиотека музыки

Для файла config.xml приложения PhoneGap требуется только следующее:

• <feature name="http://api.phonegap.com/1.0/media"/>

Структура каталогов и тестирование приложений HTML5 в Visual Studio 2012

Добавление всех необходимых папок и файлов в проекты занимает немало времени. Поэтому для вашего удобства мы включили файлы проектов Visual Studio 2012* в образцы приложений HTML5, преобразованных для Windows 8 Store. Структура папок выглядит следующим образом:

Сборка приложения в Visual Studio 2012 для магазина Windows 8:

1. Скопируйте файлы проекта из win8-proj в корневую папку
2. Загрузите JSPPROJ-файл в Visual Studio 2012 и запустите его в среде разработки

Обнаруженные проблемы

1. При преобразовании приложений для IE10 большая часть обнаруженных проблем была связана с градиентом в каскадных таблицах стилей, например, при добавлении -ms-linear-gradient в следующем случае:
   

       background: -moz-linear-gradient(top,#7A987E 0%,#000000);
       background: -webkit-gradient(linear, left top, left bottom, from(#7A987E),to(#000000));
       background: -ms-linear-gradient(top, #7A987E, #000000);  /* IE10 */
   
   

2. 3. Следующая проблема относится к jQuery-1.8.x.js. При использовании обычного компонента jQuery со страницы "http://jquery.com/download/"появится следующая ошибка Visual Studio 2012:
   "HTML1701: Unable to add dynamic content". Сценарий попытался внедрить динамическое содержимое или элементы, которые ранее изменялись динамически, что может быть небезопасно. Например, использование свойства innerHTML или метода document.write для добавления элемента сценария вызовет это исключение. Используйте метод toStaticHTML для фильтрации динамического содержимого или явным образом создайте элементы и атрибуты таким методом как createElement. Дополнительные сведения см. по ссылке "http://go.microsoft.com/fwlink/?LinkID=247104".
   
   Мы столкнулись с этой проблемой в jqm-springboard-nav. Версию jQuery для приложений Windows 8 Store можно загрузить по адресу "https://github.com/appendto/jquery-win8". В приложении jqm-springboard-nav мы использовали следующий код:
   

   <script>
       function includeJavaScript( url ){
           var tag = document.createElement( 'script' );
           tag.type = "text/javascript";
           tag.src = url;
   
           // Insert it to the <head>
           document.getElementsByTagName("head")[0].appendChild( tag );
       }
       </script>
   
       <!-- note: use jquery-1.8.0.min.js & jquery.mobile-1.1.1.min.js for production -->
       <script>
   	if (deviceCheck.windows8) {
   	    includeJavaScript("vendor/jquery/jquery-1.8.2-win8-1.0.js");
   	}
   	else {
   	    includeJavaScript("vendor/jquery/jquery-1.8.0.js");
   	}
       setTimeout(function(){
       	includeJavaScript("vendor/jquery.mobile/jquery.mobile-1.1.1.js");
   		includeJavaScript("app/springboard.js");
           }, 100);
       </script>
   
   

Но при преобразовании приложения HTML5 Counting Beads возникли более серьезные проблемы, поскольку это приложение изначально работает только в Chrome. Подробные сведения о преобразовании образца приложения Counting Beads приведены в этой статье.

Скачать статью

Скачать статью Porting Advanced User Interfaces From iOS* To Windows 8* [Eng., PDF 620KB]

Аннотация

В этой статье описывается процесс портирования сложных пользовательских интерфейсов с iOS на Windows 8. В качестве примера мы используем приложение для обработки электронных медицинских карт (EMR).

1 Введение

За последние годы планшеты как новая разновидность мобильных компьютерных платформ быстро вышли за пределы потребительского рынка и активно используются в бизнесе и в корпоративных системах. После выпуска операционной системы Windows 8 мы решили предложить разработчикам несколько кратких руководств, которые помогли бы перенести существующие приложения с других платформ, таких как iOS, на Windows 8, а также начать разработку новых приложений для ультрабуков, планшетов и других устройств с архитектурой Intel под управлением Windows 8. Данная статья также преследует эту цель и описывает расширенные возможности пользовательских интерфейсов.

Для iOS основным языком разработки является Objective-C. Для приложений для магазина Windows можно использовать различные средства и языки разработки, в том числе Visual C#, HTML/JavaScript * и прочее. В этом примере мы используем Visual C#* в качестве языка разработки.

1.1 От Xcode * 4 к Visual Studio * 2012

Аналогично тому, как разработчики приложений для iOS используют пакет средств разработки Xcode под управлением OS X *, разработчики приложений для Магазина Windows используют интегрированную среду разработки Visual Studio 2012. Есть аналог и поддерживающему раскадровку средству проектирования интерфейсов Interface Building, применяемому в Xcode 4 (рис. 1): в состав Visual Studio 2012 входит средство XAML Designer (рис. 2).

Рисунок 1. Interface Builder в Xcode 4

Рисунок 2. XAML Designer в Visual Studio 2012

1.2 Пример проекта

Это одна из статей, в основе которых лежит пример проекта. В проекте (ссылка на папку и другие статьи на основе этого проекта) мы перенесли приложение для управления электронными медицинскими картами с iOS на Windows 8. Вот основные требования к приложению:

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

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

2 Общие принципы устройства пользовательского интерфейса и навигации

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

Рисунок 3. Интерфейс в iOS: контроллер раздельного представления, общее табличное представление и подробное табличное представление

Рисунок 4. Используйте раскадровку Xcode для создания раздельного представления, общего и подробного табличного представлений

В приложении для магазина Windows мы можем получить такой же результат, используя иерархическую систему навигации (рис. 5). На странице первого уровня показано табличное представление с плиткой для каждого пациента (рис. 6). Страница второго уровня содержит сгруппированные элементы — медицинские записи пациента, выбранного на странице первого уровня (рис. 7). Страница третьего уровня содержит сгруппированные данные — определенную категорию медицинских записей, выбранных на странице второго уровня (рис. 8). Также может быть страница четвертого уровня с подробной информацией каждого элемента, например с фактическим изображением рентгеновского снимка, выбранного на странице третьего уровня.

Рисунок 5. Иерархическая система навигации в приложении для магазина Windows.

Рисунок 6. В приложении для магазина Windows в представлении корневого уровня находятся плитки списка пациентов.

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

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

В проектах Visual Studio 2012 страница пользовательского интерфейса определяется в XAML-файле, с которым связан файл кода C# (CS-файл). Поскольку переходы с одной страницы на другую обычно вызваны действиями пользователей, например при нажатии элемента табличного представления, для управления навигацией целесообразно использовать прослушиватели событий. На рис. 9 показана страница первого уровня PatientsListPage, где мы определяем прослушиватель событий ItemsGridView_ItemClick.

[xml]
<common:LayoutAwarePage
x:Name="pageRoot"
x:Class="PRApp.PatientsListPage"
DataContext="{Binding DefaultViewModel, RelativeSource={RelativeSource Self}}"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:PRApp"
xmlns:common="using:PRApp.Common"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">

…
<GridView
x:Name="itemGridView"
AutomationProperties.AutomationId="ItemsGridView"
AutomationProperties.Name="Items"
TabIndex="1"
Grid.RowSpan="2"
Padding="116,136,116,46"
ItemsSource="{Binding Source={StaticResource itemsViewSource}}"
ItemTemplate="{StaticResource PatientsItemStyle1}"
SelectionMode="None"
IsSwipeEnabled="false" IsItemClickEnabled="True" ItemClick="ItemsGridView_ItemClick"/>

…
</common:LayoutAwarePage>
[/xml]

Рисунок 9. GridView в XAML-файле PatientsListPage включает прослушиватель событий ItemGsGridView_ItemClick (**)

На рис. 10 показано, что в PatientsListPage.xaml.cs мы реализуем метод ItemsGridView_ItemClick, который вызывает метод Windows Runtime Frame.Navigate() для создания объекта страницы второго уровня PatientGroupItemsPage и отображает ее на экране в качестве текущей страницы. При создании объекта PatientGroupItemsPage мы передаем элемент, получивший щелчок, то есть объект PatientsViewModel.

[cpp]
namespace PRApp
{
/// <summary>
/// A page that displays a collection of item previews.
/// In the Split Application this page
/// is used to display and select one of the available groups.
/// </summary>

public sealed partial class PatientsListPage : PRApp.Common.LayoutAwarePage
{
…
void ItemsGridView_ItemClick(object sender, ItemClickEventArgs e)
{
this.Frame.Navigate(typeof(PatientGroupItemsPage), ((PatientsViewModel)e.ClickedItem));
}
…
}
}
[/cpp]

Рисунок 10. В PatientsListPage.cs реализован прослушиватель событий ItemsGridView_ItemClick (**)

В методе LoadState method в PatientGroupItemsPage.xaml.cs (рис. 11) мы получаем объект пациента из этого параметра и создаем коллекцию Groups для модели данных табличного представления.

[cpp]
/// <summary>

/// Populates the page with content passed during navigation. Any saved state is also

/// provided when recreating a page from a prior session.

/// </summary>

/// <param Title="navigationParameter">The parameter value passed to

/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.

/// </param>

/// <param Title="pageState">A dictionary of state preserved by this page during an earlier

/// session. This will be null the first time a page is visited.</param>

protected override void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)

{
// TODO: Assign a collection of bindable groups to this.DefaultViewModel["Groups"]

PatientsViewModel patient = (PatientsViewModel)navigationParameter;
this.DefaultViewModel["Groups"] = pgipvm.GetGroups(_patient.id);
}
[/cpp]

Рисунок 11. Метод LoadState в PatientGroupItemsPage.xaml.cs

3 Шаблоны проектов Windows и привязка данных

На рис. 7 и 8 элементы сгруппированы и показаны в удобных табличных представлениях. Шаблоны проектов приложений для магазина Windows в Visual Studio 2012 обеспечивают удобную основу для создания таких страниц пользовательского интерфейса. Готовые шаблоны проектов включают страницу сгруппированных элементов, страницу сведений о группе, страницу сведений об элементе и т. п. В качестве примера мы используем страницу сведений о группе рентгеновских снимков.

В окне обозревателя решений Visual Studio 2012 щелкните имя проекта правой кнопкой мыши и выберите в раскрывающемся меню «Добавить» -> «Создать элемент…». Выберите «Visual C#» в области слева. В середине отображается список готовых шаблонов страниц. Среди этих шаблонов выберите Group Item Page. Область справа предназначена для предварительного просмотра выбранного шаблона. Нужно ввести имя страницы в текстовом поле в нижней части окна (рис. 12) и нажать кнопку «Добавить». Visual Studio 2012 создаст в проекте файлы XRayImagesGroupDetailPage.xaml и XRayImagesGroupDetailPage.xaml.cs.

Рисунок 12. Диалоговое окно добавления нового элемента с шаблонами проектов приложений для магазина Windows (**).

Если изучить созданный файл XRayImagesGroupDetailPage.xaml, мы увидим, что эта страница привязана к контексту данных DefaultViewModel, а элементы табличного представления на этой странице привязаны к Items как к источнику представления коллекции (рис. 13).

[xml]
<common:LayoutAwarePage
x:Name="pageRoot"
x:Class="PRApp.XRayImagesGroupDetailPage"
DataContext="{Binding DefaultViewModel, RelativeSource={RelativeSource Self}}"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:PRApp"
xmlns:common="using:PRApp.Common"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<Page.Resources>

<!-- Collection of items displayed by this page -->
<CollectionViewSource
x:Name="itemsViewSource"
Source="{Binding Items}"/>
</Page.Resources>
…
[/xml]

Рисунок 13. В файле XRayImagesGroupDetailPage.xaml указывается исходный объект привязки данных (**)

В XRayImagesGroupDetailPage.xaml.cs мы видим, что XRayImagesGroupDetailPage происходит от PRApp.Common.LayoutAwarePage (рис. 14).

[cpp]
namespace PRApp

{

/// <summary>

/// A page that displays an overview of a single group, including a preview of the items

/// within the group.

/// </summary>

public sealed partial class XRayImagesGroupDetailPage : PRApp.Common.LayoutAwarePage

{…
[/cpp]

Рисунок 14. XRayImagesGroupDetailPage происходит от LayoutAwarePage

Если в Visual Studio 2012 развернуть папку Common внутри проекта (рис. 15), то мы увидим, что в ней создана группа файлов. Среди этих файлов LayoutAwarePage.cs будет содержать класс, производный от XRayImagesGroupDetailPage.

Рисунок 15. Папка Common в проекте.

Папка Common также содержит файл BindableBase.cs. Модель данных для представления образуется от этого класса. На рис. 16 приводится класс XRayImagesGroupDetailPageViewModel.

[cpp]
…

namespace PRApp.ViewModels
{
public abstract class XRayImageDataCommon : BindableBase
{
}

public class XRayImageDataItem : XRayImageDataCommon
{
}

public class XRayImageDataGroup : XRayImageDataCommon
{
…
private ObservableCollection<XRayImageDataItem> _items = new ObservableCollection<XRayImageDataItem>();
public ObservableCollection<XRayImageDataItem> Items
{
get { return this._items; }
}
…

}

public sealed class XRayImagesGroupDetailPageViewModel
{
…
public static XRayImageDataGroup GetGroup(string uniqueId)
{
…
}
…
}

}
…
[/cpp]

Рисунок 16. XRayImagesGroupDetailPageViewModel.cs: классы группы и элементов, производные от класса BindableBase (**)

Для соединения представления с источниками данных мы в методе LoadState класса XRayImagesGroupDetailPage.xaml передаем производный объект группы и элементов контексту DefaultViewModel (рис. 17).

[cpp]
…
/// <summary>
/// Populates the page with content passed during navigation. Any saved state is also
/// provided when recreating a page from a prior session.
/// </summary>
/// <param name="navigationParameter">The parameter value passed to
/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested.
/// </param>
/// <param name="pageState">A dictionary of state preserved by this page during an earlier
/// session. This will be null the first time a page is visited.</param>
protected override void LoadState(Object navigationParameter, Dictionary<String, Object> pageState)
{
// TODO: Assign a bindable group to this.DefaultViewModel["Group"]
// TODO: Assign a collection of bindable items to this.DefaultViewModel["Items"]
var group = XRayImagesGroupDetailPageViewModel.GetGroup((String) navigationParameter);
this.DefaultViewModel["Group"] = group;
this.DefaultViewModel["Items"] = group.Items;
}
…
[/cpp]

Рисунок 17. В файле XRayImagesGroupDetailPage.cs элементы представления связаны с источником данных в методе LoadState (**)

4 Итоги

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

Об авторе

Мяо Вей (Miao Wei) работает инженером по программному обеспечению в отделе корпорации Intel по разработке ПО и обслуживанию. В настоящее время он работает в области масштабирования и внедрения процессоров Intel Atom™. Он обладает более чем 15-летним опытом разработки мобильных платформ. веб-браузеров, приложений и услуг в области геопозицирования, баз данных цифровых карт и других программных продуктов.

*Другие наименования и торговые марки могут быть собственностью третьих лиц.

© Intel Corporation, 2012. Все права защищены.

OpenGL является охраняемым товарным знаком, а OpenGL ES является товарным знаком корпорации Silicon Graphics Inc. Товарные знаки используются с разрешения Khronos.

Загрузить статью

Optimizing Windows* 8 Applications for Connected Standby [Eng., PDF 1.4MB]

Аннотация

В данной статье описывается проверка и анализ поведения приложений Windows 8 * в режиме Connected Standby. Поддержка этого режима является одним из требований Microsoft * WHQL для Windows 8 [1]. Поясняется, как выявить приложения, расходующие слишком много электроэнергии в режиме Connected Standby, и как устранить эту проблему. Этот документ предназначен для разработчиков программного обеспечения, изготовителей оборудования и технических пользователей.

Введение

Режим Connected Standby позволяет системе получать обновления и оставаться на связи при наличии любых сетевых подключений. Этот режим аналогичен принципу работы сотовых телефонов: телефон остается подключенным к сотовой сети, даже если его экран выключен. Подобным образом и приложения Windows 8, поддерживающие режим Connected Standby, запускаются в обновленном состоянии сразу после перехода в активный режим. Дополнительные сведения о режиме Connected Standby на ПК см. на сайте Microsoft [1].

При выключении экрана на всех системах, поддерживающих режим Connected Standby, все запущенные программы (включая и приложения, и ОС) начинают работать в соответствии с новым набором ограничений. Средство Windows Desktop Activity Moderator (DAM) отключает выполнение устаревших приложений, действуя аналогично режиму сна. Для этого выполняется приостановка всех приложений пользовательского сеанса и регулированиевсех сторонних служб. Эти меры позволяют добиться предсказуемого расхода электроэнергии на время бездействия. Это дает возможность системам, поддерживающим режим Connected Standby, свести к минимуму использование ресурсов и долго работать от аккумулятора. При этом приложения Windows 8 смогут поддерживать нужные возможности подключения. Кроме того, при повышении чувствительности аппаратных состояний питания программные службы должны правильно работать, чтобы не пробуждать систему без необходимости, так как при этом будет израсходована дополнительная энергия.

В оставшейся данной статьи описываются средства и методики для понимания поведения системы в режиме Connected Standby. Затем приведены два примера приложений, работу которых в этом режиме можно оптимизировать.

Средства

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

Windows PowerCfg

Windows PowerCfg — это программа командной строки для управления параметрами электропитания. Эта программа применяет трассировку событий Windows (ETW) для создания профилей систем. Пользователи могут запускать Windows Powercfg для просмотра и изменения планов и параметров электропитания, например времени сна, таймера пробуждения и схем электропитания. Если запустить Powercfg с параметром -energy, будет проведен анализ основных проблем энергоэффективности и работы от аккумулятора: изменения параметров таймеров платформы, изменения таймеров процессами и библиотеками приложений, использование ЦП каждым процессом. При использовании этого параметра также будет проверено, поддерживает ли система режим Connected Standby; будут перечислены параметры управления энергопотреблением оборудования и ОС. Для запуска Windows Powercfg требуются права администратора.

Два параметра командной строки используются для проверки и получения информации о поведении в режиме Connected Standby:

Powercfg –a: Этот параметр выводит все доступные состояния сна системы. Чтобы выполнить эту команду, откройте в Windows командную строку. В командной строке введите: % powercfg –a

Система, поддерживающая режим Connected Standby, сообщит о поддерживаемых состояниях сна, одним из которых будет этот режим. На рис. 1 показаны выходные данные команды powercfg –a для системы, поддерживающей режим Connected Standby.

Рисунок 1. Powercfg -a output

Powercfg -batteryreport

Параметр -batteryreport предоставляет информацию о поддержке режима Connected Standby и другие связанные данные. Создается отчет (в формате HTML) о статистике работы системы от аккумулятора путем сбора профиля на основе постоянно запущенной встроенной трассировки системы. Этот отчет содержит сводные данные об установленном аккумуляторе, версии BIOS, поддержке режима Connected Standby, а также о сроке работы от аккумулятора на основе фактического использования системы. На рис. 2 показан пример выходных данных команды с параметром -batteryreport, если ПК поддерживает режим Connected Standby.

Рисунок 2. Отчет о состоянии аккумулятора с поддержкой режима Connected Standby

В отчете также указывается использование аккумулятора в активном состоянии, в приостановленном состоянии и в режиме Connected Standby, как показано на рис. 3.

Рисунок 3. Использование аккумулятора в различных состояниях

Дополнительные сведения о решении Windows Powercfg см. на Microsoft website [2].

Microsoft Windows Performance Analyzer

Средство Windows Performance Analyzer (WPA), также известное под названием xperf, представляет собой набор инструментов мониторинга для составления подробных профилей производительности и электропитания Microsoft Windows и приложений. WPA удобно использовать для устранения проблем с утечкой энергии.

Перед переходом к примерам давайте разберемся с терминологией WPA. Вот определения основных терминов и названий столбцов WPA, взятые из документации System Internals, находящейся по адресу [3]:

• Ready Thread:поток в готовом состоянии, ожидающий выполнения или готовый к переключению после завершения ожидания. При поиске потоков для выполнения диспетчер рассматривает только пул потоков в готовом состоянии.
• Standby: поток в ждущем режиме, выбранный для последующего запуска на определенном процессоре. При возникновении подходящих условий диспетчер выполняет переключение контекста к этому потоку. Только один поток может быть в ждущем режиме для каждого процессора в системе. Обратите внимание, что поток может быть выгружен из ждущего состояния еще перед выполнением (например, если поток с более высоким приоритетом запускается перед началом выполнения ждущего потока).
• Waiting: поток может перейти в состояние ожидания несколькими способами: поток может дожидаться, пока будет выполнена синхронизация объекта; операционная система может ждать от имени потока (например, при операции ввода-вывода); подсистема среды может дать команду потоку на приостановку. Когда состояние ожидания потока завершается, то, в зависимости от приоритета, поток либо начинает выполняться сразу же, либо возвращается в состояние готовности.
• CPU Precise:график CPU Usage (Precise) содержит информацию, связанную с событиями переключения контекста. Каждая строка соответствует набору данных, связанному с одним переключателем контекста при начале выполнения потока.
• % CPU Usage: использование ЦП новым потоком после его включения выражается в виде процента общего времени ЦП в отображаемом диапазоне времени.
• Count: количество переключателей контекста в строке (всегда 1 для одиночных строк).
• NewThreadId: идентификатор нового потока.
• NewThreadStack: стек нового потока после его подключения.
• ReadyingProcess: процесс, владеющий готовым потоком.
• SwitchInTime(s): время переключения в новый поток.
• LastSwitchOutTime (s): время последнего переключения из нового потока.
• TimeSinceLast (s): SwitchInTime(s) - LastSwitchOutTime (s)

На рис. 4 показаны имена столбцов в пользовательском интерфейсе WPA.

Рисунок 4. Общий вид WPA

Generic Events:предоставленные пользователем события заполняются для анализа данных трассировки ядра.

• OneShotTimer : может входить в состав всегда включенного таймера в режиме ожидания с подключением. Операционная система запускает OneShotTimer через каждые 30 секунд. Приложения могут создавать таймер, вызывая SetTimer или SetEvent.
• PeriodicTimer: эти таймеры срабатывают после истечения указанного времени, а затем сбрасываются в исходное состояние.

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

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

Сбор данных трассировки

• Выполните команду powercfg.exe –a, чтобы убедиться, что система поддерживает режим Connected Standby.
• Установите Windows Performance Analyzer из Windows ADK [4].
• Запустите сбор данных трассировки, создав пакетный файл со следующей командной строкой:
  • xperf -on PROC_THREAD+LOADER+INTERRUPT+DPC+CSWITCH+IDLE_STATES+POWER+TIMER+CLOCKINT+IPI+DISPATCHER+DISK_IO -stackwalk TimerSetPeriodic+TimerSetOneShot -clocktype perfcounter -buffering -buffersize 1024 -MinBuffers 128 -MaxBuffers 128

• PROC_THREAD+LOADER: предоставляет информацию о прерываниях устройства и таймере.
• INTERRUPT: используется для анализа событий прерывания. Предоставляет информацию, связанную с аппаратными прерываниями.
• DPC: используется для анализа источников прерывания. Предоставляет информацию, связанную с журналами DPC.
• CSWITCH: используется для анализа источников прерывания. Предоставляет информацию, связанную с переключателями контекста.
• IPI: предоставляет информацию, связанную с прерываниями между процессорами.
• TimerSetPeriodic+TimerSetOneShot: Required требуемые стеки для анализа таймера и анализа прерываний устройства.
• Дайте системе войти в состояние Connected Standby (например, нажав кнопку питания)
  • Подождите, пока средство xperf соберет данные трассировки в течение не менее 4 часов. При большей длительности трассировки можно лучше изучить действия программного обеспечения в режиме Connected Standby.
  • Пробудите систему из состояния Connected Standby (например, нажав кнопку питания).

• Остановите трассировку.

xperf -flush xperf -stop xperf -merge \kernel.etl MyTrace.etl

После завершения трассировки в текущей папке будет создан файл Mytrace.etl.

Постобработка трассировки

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

xperf -symbols -i mytrace1.etl -o cleanCS_diag.csv -a energydiag –verbose

Можно обработать определенную область трассировки, указав диапазон

Xperf –symbols –I mytrace1.etl –o cleanCS_diag.csv –a energygdiag –range T1 T2

Например: xperf -symbols -i -o EnergyDiag.csv -a energydiag -verbose -range 1000000 15000000000

На рис. 5 показаны файлы, созданные после постобработки.

cleanCS_diag: содержит все события и действие пробуждения системы.

MyTrace1: содержит необработанную информацию о трассировке.

Рисунок 5. Пример выходных данных трассировки

cleanCS_diag:

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

Рисунок 6. Выходные данные сценария постобработки

Общее число прерываний устройства (рис. 6) является суммой количества прерываний всех модулей устройства в собранных данных трассировки. Суммарное истечение таймеров — подмножество прерываний, вызванных срабатываниями таймеров. В режиме ожидания с подключением истечение таймеров включает системные таймеры, события, а также oneshottimer и periodictimer, связанные с регулировкой.

Теперь следует понять, чем занимается система в режиме Connected Standby. Можно прокрутить отчет вниз до схемы Busy Enter/Exit Time, на которой нужно найти группу All CPUs. Значение Busy Percent позволяет точно оценить деятельность системы в режиме Connected Standby. Это дает возможность понять, насколько занята система. Чем выше показатель занятости по отношению к базовому значению, тем сильнее влияние на потребление электроэнергии. На рис. 7 показана трассировка базового значения занятости без тестовых приложений. На рис. 8 показана трассировка с несколькими запущенными приложениями и фоновой службой. Сравнение рисунков 7 и 8 показывает повышение занятости в 150 раз из-за пробуждений, вызванных приложениями, и фоновой службы.

Рисунок 7. Базовые выходные данные

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

Анализ необработанных данных трассировки:

Также можно изучить файл трассировки непосредственно в Windows Performance Analyzer. На рис. 9 показано средство Graph Explorer в составе WPA.

Рисунок 9. Окно WPA после открытия файла трассировки

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

Рисунок 10. Общее представление системы в режиме Connected Standby

Чтобы проверить вызовы OneShotTimer из системы, перетащите события из группы действий системы в окно анализа. Загрузить символы можно с сервера Майкрософт или из папки символов приложения, выбрав команду Load Symbols в меню Trace. На рис. 11 показан этот элемент в меню Trace.

Рисунок 11. Загрузка символов

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

Рисунок 12. График и таблица WPA

Теперь следует включить столбцы, как показано на рис. 12, чтобы проанализировать работу стека OneShotTimer.

Расположите столбцы таблицы анализа, чтобы найти действия пробуждения, запущенные системой или службами приложений. На рис. 13 показан процесс System с идентификатором потока 68, запускающий таймер OneShotTimer 36 раз в течение отображаемого отрезка времени. Пробуждение запускается системным процессом через каждые 30 секунд.

Рисунок 13. Работа стека таймера OneShotTimer в WPA

«Хорошее» и «плохое» поведение:

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

Хорошее поведение: служба приложения выполняется внутри процесса System. Т. е. служба приложения переходит в состояния сна до того, как процесс System перейдет в состояние сна. Такой подход помогает выполнить требование WHQL для режима Connected Standby в Microsoft Windows 8: в течение 16 часов ожидания с подключением может быть израсходовано не более 5 % заряда аккумулятора.

Плохое поведение: приложение работает независимо от процесса System или входит в состояние сна после того, как процесс System переходит в состояние сна. Несогласованные пробуждения могут вызвать излишний расход электроэнергии в режиме Connected Standby, из-за чего выполнить требование Microsoft WHQL будет невозможно.

На рис. 14 показано «хорошее» и «плохое» поведение в режиме ожидания с подключением.

Рисунок 14. «Хорошее» и «плохое» поведение в режиме Connected Standby

Пример 1. Доступ к хранилищу.

В программных службах, например в антивирусах и службах обновления программного обеспечения, широко распространен доступ к локальному хранилищу. Когда эти службы запущены в режиме Connected Standby, доступ к локальному хранилищу должен быть отложен до пробуждения процесса System. На рис. 15 показан сценарий доступа к хранилищу в течение примерно 65 секунд в режиме Connected Standby. Приложение пробуждается, когда процесс System (выделен оранжевым), переходит в активное состояние сна. ProcessX.exe запускает доступ к хранилищу в System32, из-за чего система не может перейти в режим Connected Standby. Можно оптимизировать приложение, исключив длительный доступ к хранилищу. Если приложению нужен доступ к хранилищу в режиме ожидания с подключением, можно объединить работу приложения с работой системы и перейти в состояние ожидания путем широковещательного уведомления об изменении состояния электропитания.

Рисунок 15. Доступ службы приложения к хранилищу в режиме Connected Standby

После этого изменения процесс доступа к хранилищу и процесс System будут объединены в режиме Connected Standby (см. рис. 16). Это пример хорошего поведения: приложение не влияет на энергопотребление системы.

Рисунок 16. Оптимизированный доступ к хранилищу в режиме Connected Standby

Пример 2. Пробуждение потоков приложения.

Оптимизация пробуждения приложения, вызванного ОС, — непростая задача. Необходимо понимать события ЦП Precise и Generic, чтобы узнать, происходит ли OneShotTimer при пробуждении процесса System. На рис. 16 показано пробуждение потоком приложения, когда процесс System находится в состоянии сна. Это образец неправильного написания служб процессов, которые без необходимости поддерживают систему в пробужденном состоянии. ProcessX.exe (ID: 2440) создает несколько потоков. В таблице на рис. 16 видны два потока, не согласованных с процессом System. Используя общую таблицу событий, можно сопоставить идентификатор потока с setTimer и прерываниями часов. Как показано на рис. 16, существуют задачи потока Timer Set, которые следует рассмотреть (идентификаторы потоков 3432 и 1824). Теперь следует сопоставить идентификатор потока, полученный на предыдущем шаге (Thread ID 3432 и Thread ID 1824) с таблицей CPU Usage (Precise), чтобы найти деятельность, связанную с этими потоками. Деятельность может быть связана с Timer Set, с расписанием потоков или с действиями ввода-вывода. Для наглядного отображения можно построить несколько графиков в одном представлении.

Рисунок 17. Потоки приложений поддерживают систему активной в состоянии сна

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

UINT_PTR WINAPI SetTimer(
  _In_opt_  HWND hWnd,
  _In_      UINT_PTR nIDEvent,
  _In_      UINT uElapse,
  _In_opt_  TIMERPROC lpTimerFunc
);

Окно приложения (HWND) используется для обработки уведомлений посредством процедуры window, которую следует вызвать через количество микросекунд, заданное значением uElapse, даже после перехода процесса System в режим Connected Standby.

Если в приложении есть окно (HWND) и нужно обрабатывать эти уведомления посредством процедуры window, чтобы это исправить, вызовите RegisterSuspendResumeNotification для регистрации этих сообщений (или UnregisterSuspendResumeNotification для отмены регистрации). Можно использовать DEVICE_NOTIFY_WINDOW_HANDLE в параметре Flags и передавать значение окна HWND в параметре Recipient. Получено сообщение WM_POWERBROADCAST.

Если приложение не имеет обработчика HWND или если нужен прямой обратный вызов, вызовите PowerRegisterSuspendResumeNotification для регистрации на эти сообщения (или PowerUnregisterSuspendResumeNotification для отмены регистрации). Можно использовать DEVICE_NOTIFY_WINDOW_HANDLE в параметре Flags и передавать значение типа PDEVICE_NOTIFY_SUBSCRIBE_PARAMETERS в параметре Recipient.

Заключение

Реализация режима ожидания с подключением в приложениях крайне важна для продления времени работы от аккумулятора. Системы, поддерживающие режим Connected Standby, должны отвечать требованиям сертификации оборудования Windows Hardware Certification (WHCK) в отношении потребления электроэнергии. Согласно этим требованиям, все системы в режиме Connected Standby должны израсходовать не более 5 % заряда аккумулятора в течение 16-часового периода бездействия в фабричной конфигурации по умолчанию. Сертификационный тест находится на сайте Microsoft WHCK.

Об авторе

Мануж Сабарвал (Manuj Sabharwal) работает инженером по программному обеспечению в отделе Software Solutions Group корпорации Intel. Мануж изучает возможные способы повышения эффективности расхода электроэнергии программами в активном состоянии и в состоянии простоя. Он обладает высокой научно-технической квалификацией в области эффективности расхода электроэнергии; им разработан ряд учебных и технических справочников, применяющихся в данной отрасли. Также он работает над поддержкой клиентских платформ путем оптимизации программного обеспечения.

Справочные материалы

[1] Microsoft WHCK: http://msdn.microsoft.com/en-US/library/windows/hardware/jj128256

[2] PowerCfg: http://technet.microsoft.com/en-us/library/cc748940(WS.10).aspx

[3] Windows Internals: http://technet.microsoft.com/en-us/sysinternals/bb963901.aspx

[4] Windows Assessment Toolkit: http://www.microsoft.com/en-us/download/details.aspx?id=30652

*Другие наименования и торговые марки могут быть собственностью третьих лиц.

Copyright ©2013 Intel Corporation.

Одна из наиболее известных многопоточных  библиотек C++ Intel® Threading Building Blocks (Intel® TBB) была недавно обновлена на новую версию – 4.2. Обновленная версия содержит несколько важных нововведений по сравнению с версией 4.1. Некоторые из них уже стали доступны в обновлениях Intel TBB 4.1..

Новый примитив синхронизации speculative_spin_mutexобеспечивает поддержку спекулятивной блокировки. Это стало возможно благодаря использованию аппаратной функции Transactional Synchronization Extensions (Intel® TSX), доступной в процессорах Intel® Core™ четвертого поколения. В процессорах, поддерживающих транзакционную память (таких как Intel® TSX), спекулятивные мьютексы позволяют нескольким потокам занять одну блокировку, пока не появятся "конфликты", которые могут привести к результатам, отличным от неспекулятивной блокировки. Таким образом, последовательная обработка исключается в случаях, когда не возникает конфликтов. Это может значительно повысить производительность и масштабируемость для "коротких"и важных критических секций. Если нет аппаратной поддержки транзакционной памяти, спекулятивные мьютексы работают подобно своим неспекулятивным аналогам, но, вероятно, с худшей производительностью.

Intel TBB теперь поддерживает C++11 exception_ptr. Используя exception_ptr, объекты исключений могут безопасно копироваться между потоками. Это обеспечивает гибкость в обработке исключений в многопоточной среде. Сейчас использование exception_ptr доступно в бинарных файлах для всех платформ: OS X*, Windows* и Linux*. В системе OS X есть два набора бинарных файлов: первый слинкован со стандартной библиотекой gcc, которая используется по умолчанию и не поддерживает exception_ptr. Для использования этой функции вы должны применять второй набор двоичных файлов, связанных с libc++, стандартной библиотекой C++ в Clang. Для их использования нужно настроить переменные окружения и построить Intel TBB следующим образом:

$ tbbvars.sh libc++
$ clang++ -stdlib=libc++ -std=c++11 concurrent_code.cpp -ltbb

В дополнение к контейнерам concurrent_unordered_setи concurrent_unordered_mapтеперь добавлены concurrent_unordered_multisetи concurrent_unordered_multimap, основанные на прототипе Microsoft* PPL. Контейнер concurrent_unordered_multisetимеет возможность вставки элементов более одного раза, что невозможно в concurrent_unordered_set. Аналогично, concurrent_unordered_multimapпозволяет вставлять более одной пары <ключ,значение> с одним значением ключа. Для обоих “мульти”-контейнеров функция поиска вернет первый элемент (или пару <ключ,значение>) в таблице с соответствующим значением ключа.

Контейнеры Intel Threading Building Blocks теперь можно удобно инициализировать списками значений, как это делается в C++ 11 (списки инициализации):

tbb::concurrent_vector<int> v ({1,2,3,4,5} );

В настоящее время списки инициализации поддерживаются следующими контейнерами:

concurrent_vector
concurrent_hash_map
concurrent_unordered_set
concurrent_unordered_multiset
concurrent_unordered_map
concurrent_unordered_multimap
concurrent_priority_queue

Аллокатор памяти Intel TBB (scalable memory allocator) имеет кэш для выделенной памяти в каждом потоке. Это делается ради производительности, но часто за счет увеличения использования памяти. Хотя аллокатор пытается избежать чрезмерного использования памяти, в сложных ситуациях Intel TBB 4.2 предлагает программистам больше контроля: теперь можно уменьшить использование памяти посредством очистки кэшей потоков с помощью функции scalable_allocation_command(). Также было сделано ещё несколько улучшений для повышения общей производительности аллокатора.

Intel TBB широко используется на различных платформах. Сейчас разработчики мобильных систем могут найти готовые бинарные модули для Android в пакете ОС Linux. В пакет ОС Windows были добавлены бинарные модули для приложений Windows Store.

Атомарные переменные tbb::atomic<T>теперь имеют конструкторы при использовании C++11. Это позволяет разработчикам инициализировать их значениями во время объявления, с поддержкой константных выражений (const expressions). В настоящее время это работает с компиляторами gcc и Clang:

tbb::atomic<int> v=5;

Новая экспериментальная функциональность (community preview feature) позволяет ожидать завершения всех потоков. Это может потребоваться, если приложений создаёт процессы или, если динамическая библиотека Intel TBB может быть выгружена во время выполнения (например, если библиотека является частью плагина). Для ожидания завершения потоков-обработчиков нужно инициализировать объект task_scheduler_initследующим образом:

#define TBB_PREVIEW_WAITING_FOR_WORKERS 1
tbb::task_scheduler_init scheduler_obj (threads, 0, /*wait_workers=*/true);

Обновлённую библиотеку Intel Threading Building Blocks 4.2 можно скачать на коммерческом сайтеи на сайте open source сообщества. Загружайте и пользуйтесь новыми возможностями!

Егор Чураев

Файлы для загрузки

Инструментальные средства Intel® HTML5 для разработки мобильных приложений [PDF 821,98 КБ]
Исходный код iOS [файл .ZIP, 168 КБ]
Результирующий исходный код средств разработки HTML5 [файл .ZIP, 86 КБ]

HTML5 – это новый стандарт HTML. Не так давно корпорация Intel объявила о выпуске комплекта инструментальных средств HTML5 для разработки мобильных приложений. В этой статье представлено использование этих средств для процесса переноса приложения акселерометра Apple iOS* в среду HTML5. Имейте в виду, что код, создаваемый автоматически с помощью комплекта XDK Intel®, может содержать лицензионный код, разработанный на условиях одной или нескольких лицензий, представленных в приложении A к настоящему документу. Пожалуйста, изучите выходные данные комплекта Intel XDK для получения информации о том, какие библиотеки используются для создания вашего приложения.

Средство переноса приложений Intel® HTML5 App Porter

Первое, что мы сделаем, это возьмем приложение акселерометра для iOS и преобразуем его исходный код Objective-C* в формат HTML5. Мы сделаем это с помощью средства переноса приложений Intel® HTML5 App Porter и исходного кода, который можно найти в файле: [iOS_source.zip] (Примечание. Пример кода IOS_source предоставляется на условиях лицензии на примеры кода ПО Intel, которая подробно описывается в приложении B).Вы можете скачать средство Intel HTML5 App Porter на вкладке Tool сайта: http://software.intel.com/ru-ru/html5. После заполнения и отправки формы с вашим адресом электронной почты вы получите ссылки для загрузки этого средства. Инструкции по его использованию можно найти на следующем сайте: http://software.intel.com/ru-ru/html5/articles/tutorial-creating-an-html5-app-from-a-native-ios-project-with-intel-html5-app-porter-tool

Когда вы закончите все действия, вы получите исходный код HTML5.

Intel XDK

Вы можете открыть код HTML5 в любом средстве IDE. Корпорация Intel предлагает для вас удобное средство для разработки приложений HTML5: Intel XDK - комплект разработчика кроссплатформенных приложений (http://software.intel.com/ru-ru/html5/tools). Используя комплект Intel XDK, разработчики могут создавать единый исходный код для установки на многих устройствах. Что особенно удобно, так это отсутствие необходимости установки средства на вашем компьютере. Вы можете установить его в качестве расширения браузера Google Chrome*. Если вы используете другой браузер, вы должны загрузить и запустить файл JavaScript*. Иногда может потребоваться обновить среду Java*.

После установки комплекта Intel XDK вы увидите главное окно:

Если вам нужно выполнить перенос существующего кода, нажмите большую кнопку "Start new".

Если вы создаете новый проект, введите имя проекта и установите флажок "Create your own from scratch", как это показано на следующем снимке экрана.

Установите флажок "Use a blank project". Через некоторое время отобразится сообщение "Application Created Successfully!"

Нажмите "Open project folder".

Удалите все файлы из этой папки и скопируйте перенесенные файлы. На этом перенос приложения акселерометра не закончен. Мы все еще должны написать для него интерфейс. Можно удалить методы, созданные средством Intel HTML5 App Porter. Удалите следующие файлы:

• todo_api_application__uiaccelerometerdelegate.js
• todo_api_application_uiacceleration.js
• todo_api_application_uiaccelerometer.js
• todo_api_js_c_global.js

Для обновления проекта в Intel XDK перейдите в окно редактора в эмуляторе Windows.

Откройте файл index.htmlи удалите строки слева от включенных файлов.

Откройте файл todo_api_application_appdelegate.jsи примените неназначенное свойство представителя "window".

application.AppDelegate.prototype.setWindow = function(arg1) {
    // ================================================================
    // REFERENCES TO THIS FUNCTION:
    // line(17): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: [*js.APT.View]
    //    Expected return type: [unknown type]
    //
    //if (APT.Global.THROW_IF_NOT_IMPLEMENTED)
    //{
        // TODO remove exception handling when implementing this method
       // throw "Not implemented function: application.AppDelegate.setWindow";
    //}
this._window = arg1;
};

application.AppDelegate.prototype.window = function() {
    // ================================================================
    // REFERENCES TO THIS FUNCTION:
    // line(20): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: none
    //    Expected return type: [unknown type]
    //
    // line(21): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: none
    //    Expected return type: [unknown type]
    //
    //if (APT.Global.THROW_IF_NOT_IMPLEMENTED)
    //{
        // TODO remove exception handling when implementing this method
       // throw "Not implemented function: application.AppDelegate.window";
    //}
return this._window;
};

Откройте файл viewcontroller.js. Удалите все функции, используемые для работы с акселерометром в старом приложении iOS. По завершении мы получим следующий файл:

APT.createNamespace("application");

document.addEventListener("appMobi.device.ready",onDeviceReady,false);

APT.ViewController = Class.$define("APT.ViewController");

application.ViewController = Class.$define("application.ViewController", APT.ViewController, {
    __init__: function() {
        this.$super();
    };>});

В файле ViewController_View_774585933.cssнужно изменить стили цвета элементов с черного на белый для возможности прочтения на черном фоне: color: rgba(0,0,0,1);на color: rgba(256,256,256,1);. В результате мы получим:

div#Label_590244915
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 320px;
	top: 0px;
	opacity: 1;
}
div#Label_781338720
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 29px;
	opacity: 1;
}
div#Label_463949782
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 51px;
	opacity: 1;
}
div#Label_817497855
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 74px;
	opacity: 1;
}
div#Label_705687206
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 29px;
	opacity: 1;
}
div#Label_782673145
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 51px;
	opacity: 1;
}
div#Label_1067317462
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 74px;
	opacity: 1;
}
div#View_774585933
{
	left: 0px;
	height: 548px;
	position: absolute;
	width: 320px;
	top: 20px;
	opacity: 1;
}

После обновления окна эмулятора вы должны увидеть:

 

Для написания кода функций акселерометра мы должны использовать библиотеку appMobi JavaScript. Документация для этой библиотеки находится здесь. Она устанавливается во время загрузки комплекта Intel XDK.

Откройте файл index.htmlи добавьте следующую строку в список сценариев:

<script type="text/javascript" charset="utf-8" src="http://localhost:58888/_appMobi/appmobi.js"></script>

Откройте файл ViewController_View_774585933.html. Мы должны переименовать поля так, чтобы они имели логически приемлемые имена:

<div data-apt-class="Label" id="Label_705687206">0</div>
<div data-apt-class="Label" id="Label_782673145">0</div>
<div data-apt-class="Label" id="Label_1067317462">0</div>

на:

<div data-apt-class="Label" id="accel_x">0</div>
<div data-apt-class="Label" id="accel_y">0</div>
<div data-apt-class="Label" id="accel_z">0</div>

То же самое должно быть сделано в файле ViewController_View_774585933.css, где мы должны переименовать имена стилей.

Откройте файл viewcontroller.jsи напишите несколько функций для использования акселерометра.

function suc(a) {
    document.getElementById('accel_x').innerHTML = a.x;
    document.getElementById('accel_y').innerHTML = a.y;
    document.getElementById('accel_z').innerHTML = a.z;
}

var watchAccel = function () {
    var opt = {};
    opt.frequency = 5;
    timer = AppMobi.accelerometer.watchAcceleration(suc, opt);
}

function onDeviceReady() {
    watchAccel();
}
document.addEventListener("appMobi.device.ready",onDeviceReady,false);

Обновите проект, и он будет отображен в окне эмулятора:

Работу акселерометра в среде Intel XDK можно увидеть, используя панель "ACCELEROMETER":

Приложение должно выглядеть следующим образом:

Полный исходный код приложения можно найти здесь.
Приложение A: Лицензионные соглашения для кода комплекта Intel® XDK

Приложение B: Лицензионное соглашение на примеры кода ПО Intel

Intel и логотип Intel являются товарными знаками корпорации Intel в США и/или в других странах.
© Корпорация Intel, 2013 г. Все права защищены.
*Другие наименования и товарные знаки являются собственностью своих законных владельцев.

Download source code

Download paper as PDF

Introduction

Taking panoramic pictures has become a common scenario and is included in most smartphones’ and tablets’ native camera applications. Instagram alone has close to 1 million pictures tagged as panoramas, and flickr.com has over 1.2 million uploads tagged as panoramas. Traditionally the user will pan the device using a single camera to acquire images and the application will stitch the images together to create the panorama. Since most devices have both front and rear facing cameras, we could potentially utilize both cameras simultaneously to quickly capture a large panorama.

Current panorama applications on the market only support a ~180 to 270 degree maximum rotation, but using two cameras allows us to capture a full 360 degrees with only a 180 degree rotation of the device. There is a lot of value in decreasing the device rotation because it is very difficult to keep a phone or tablet steady when trying to rotate a large amount. Rotating only 180 degrees allows users to complete acquisition much faster by rotating the device in their hands without the need for a full body rotation. This will enable a more consistent and easy experience for the user.

First, I will go through a general overview of the implementation, then talk about challenges and our results. Please note: All sample software in this document is provided under the Intel Sample Software License. See Appendix A for details.

Implementation

In this section, we will discuss the steps necessary to capture images using both cameras and stitch them together to make a complete panorama picture. For reference, I will include code samples in C++ that utilize Microsoft DirectShow* APIs, but you can choose to develop with other APIs such as Microsoft Media Foundation.

First, we need to initialize the cameras and sensors. The method for doing so will depend on the APIs available for your target platform.

	const int VIDEO_DEVICE_0 = 0; // zero based index of video capture device to use
	const int VIDEO_DEVICE_1 = 1;

	Capture frontCam = new capture(VIDEO_DEVICE_0);
	Capture rearCam = new capture(VIDEO_DEVICE_1);

	Gyrometer _gyrometer = new gyrometer();
	Compass _compass = new compass();

 

Here we should also specify capture resolution. The images acquired from each camera should be the same resolution. You may also want to control other things, like exposure or autofocus.

Now we will create a function to capture and save images:

void acquireImages(int imageNumber)
{
	//save raw captures in memory
   	_frontImage = frontCam.Click();        
	_rearImage = rearCam.Click();

	//turn raw image into a readable format
	Bitmap front = new Bitmap(_frontImage);
	Bitmap rear = new Bitmap(_rearImage);

	//You may need to rotate the images based on your platform
	front.RotateFlip(RotateFlipType.RotateNoneFlipY);
	rear.RotateFlip(RotateFlipType.RotateNoneFlipY);

	//Save images to working directory
	front.Save("images/" + imageNumber + "_front.jpeg");               
	rear.Save("images/" + imageNumber + "_rear.jpeg");
}

 

Next we create a function to acquire images. We tested multiple ways to implement acquisition: timer-based, gyro-based, and compass-based. Different platforms have different sensors available, which may determine what method you can use. In these samples I use NUM_IMAGES to denote the number of images we take with each camera. The number of images varies depending on the field of view of the platform’s cameras. If you have too few images, the images won’t have enough overlap and won’t stitch together well. If you have too many images, you will have duplicates and processing time will be much higher than it needs to be. It takes experimentation to determine the ideal number of images you need to take.

Using a timer is a simple and reliable way to control capture and does not require any special sensors. It is, however, restricting to users since they must follow precise timing intervals for image capture.

for (int currentImage = 0; currentImage < NUM_IMAGES; currentImage++ )
	{ 
		acquireImages(currentImage);

		//specify interval between captures
		Thread.Sleep(750);  
	}

Using a gyroscope is another potential method; however, it can produce inconsistent results. It does allow the user to have control of the speed at which they capture. The gyroscope reports the angular frequency of the device. Since we want to know the angular position of the device, we can use this formula to get angular position:

new angular position = angular position + (angular velocity * sampling interval)

The angular position becomes more accurate as the sampling interval gets smaller. Unfortunately we can’t sample at a high enough rate to maintain a perfectly accurate angular position, so acquisition intervals can be inconsistent when rotating at different speeds. This leads to inconsistent amounts of overlap on our captured images, which may cause stitching to fail.

Gyro-Based Acquisition:

position = 0;
while (currentImage < NUM_IMAGES)
{
	position += _gyrometer.GetCurrentReading() * GYRO_SAMPLE_INTERVAL;

	//capture image when position is at desired position +/- error
	if(position > ((currentImage*angleBetweenImages)-angleErrorTolerance) &&
		position < ((currentImage*angleBetweenImages)+angleErrorTolerance))
	{
		acquireImages(currentImage);
		currentImage++;
	}
	thread.sleep(GYRO_SAMPLE_INTERVAL); 
}

We found the best method to use is the compass sensor. This method can capture images at very accurate intervals, which means our images will overlap the optimal amount every time. The compass is not available on all devices, however.

Compass-Based Acquisition:

while (currentImage < NUM_IMAGES)
{
	if (currentImage == 0)
	{
		//initialize position at first image capture
		startPos = _compass.GetCurrentReading().HeadingMagneticNorth;
	}

	position = startPos - _compass.GetCurrentReading().HeadingMagneticNorth;

	if (position < 0)
	{
		//forces value to be betweeen 0 and 360
		position = 360 + position;
	}

	//capture image when position is at desired position +/- error
	if(position > ((currentImage*angleBetweenImages)-angleErrorTolerance) &&
		position < ((currentImage*angleBetweenImages)+angleErrorTolerance))
	{
			acquireImages(currentImage);
			currentImage++;
	}
}

After we have captured our images, we can stitch the images together. Because panorama stitching is a complex topic in itself, I can only give a high level overview. We used the stitching library in an open source project called OpenCV to do processing.

We will store our images in the “images” folder in our working directory. We can now load the images into our application and call the stitching function.

	string[] imgs = Directory.GetFiles("images");
	stitch(imgs, result);
	result.save(“images/result.jpg”);

Assuming image stitching was successful, we now have our result panorama.

Challenges

Several issues arise when we tried to implement this idea on different platforms. We ran into issues with camera angle and unsupported camera features. There are workarounds for these issues, but there are some platforms that do not support simultaneous use of both cameras, which makes the application impossible to implement.

On some platforms the manufacturer decided to mount the front camera facing at an upward angle and the rear camera facing a downward angle with the intention of the cameras being used when the tablet is at an angle, similar to a laptop. This mismatch in angles between the front and rear cameras will make it so the acquired images do not overlap and cannot produce a quality panorama when used in landscape mode. The best workaround for this issue is to use the device in portrait orientation, which will make the vertical fields of view equal, which eliminates the issue.

This is an uncropped example of a landscape capture. You can see there is slight mismatch in the camera angles and leaves much of the image unusable after cropping.

Because of the mismatch, we must waste most of the image height during cropping. The original pictures were 1080px tall and the final panorama was 705px tall. We lost 35% of the vertical pixels.

This is an uncropped example of a portrait capture. You can see the images match up well.

Since the images match up well, we don’t have to waste much of the height. The original images were 1920px tall and the result is 1640px tall. We only lost 14% of the height.

Even on the same platform, the front and back cameras often have different focal length, sensor size, and available capture modes. The maximum resolution of the resulting panorama is limited by the resolution of the smaller of the two cameras. The different focal lengths can create stitching issues if the difference is too large and also determine how many images need to be taken. A camera with a very wide field of view will be able to take fewer pictures and require less rotation than one with a narrow field of view. On different cameras, the manufacturer will allow different usage modes to be supported like “preview” for fast and low quality streaming, and “capture” for high quality but slow acquisition speed. We found that these features are not available on all platforms, so the application must be tested and modified for each target platform.

Conclusion

Utilizing dual cameras to capture large panoramas is a valuable and worthwhile concept that works well provided the correct hardware and driver support. On a platform with cameras directed perpendicular to the device and a compass sensor available, the application will work with little modification. On a platform with offset cameras and/or missing sensors, it may require additional work to get the application working. Due to the huge amount of variation between platforms, it is difficult to create a one-size-fits-all application, so we must develop and test the application on each target platform. Despite some potential implementation challenges, the concept improves greatly on current panorama capture applications and enables easier and faster image capture and better user experience.

Resources

Microsoft DirectShow API (Camera Interfacing/Streaming)
Microsoft Sensor API (Sensors)
OpenCV (Panorama Stitching)

Intel, the Intel logo, Atom, and Core are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.

Download Article

Download Retargeting a BayTrail* Windows* 8 Store Sample Application to Windows 8.1 [PDF 602KB]

Abstract

This article discusses the process of retargeting an existing healthcare sample app from Windows 8 to Windows 8.1. In particular, using special features that were added to Visual Studio 2013 for retargeting/importing windows store apps, build errors, and challenges faced. In addition, using 3^rd party libraries and newly available UI controls & features are discussed.

Overview

• Abstract
• Overview
• Retargeting Windows Store Apps to Windows 8.1
• A Healthcare Windows Store App
• Retargeting sample healthcare app
  • Using Visual Studio 2013 to import the app
  • Fixing build errors and 3rd party library issues
• Summary

Overview

Windows 8.1 brings new features, APIs, UI, and performance enhancements to the windows platform. It is up to the developer to take advantage of new features and re-implement some parts of an app that will benefit from the new Windows 8.1 enhancements. Even a simple retarget and compile can result in benefits such as quick app startup time and automatic windows store app updates.

This article will look at migrating a sample healthcare app to Windows 8.1.

For an in-depth and general technical discussion of migrating a Windows Store App to Windows 8.1, please refer to the following white paper.

http://msdn.microsoft.com/en-us/library/windows/apps/dn376326.aspx

Retargeting Windows Store Apps to Windows 8.1

Depending on the functionality and complexity of your app, the process of retargeting Windows Store Apps to Windows 8.1 is relatively a straight forward process.

Developers can plan their retargeting process to be incremental. Initially, the app can be recompiled to resolve any build errors so the app takes advantage of the Windows 8.1 platform. Subsequently, developers can review any functionalities in the app that will benefit from re-implementation using the newly available APIs. Finally, the retargeting process gives the developer an opportunity to review the compatibility of 3^rd party libraries in Windows 8.1.

When the healthcare sample app was migrated to Windows 8.1, the simple recompile option, checking usage of 3^rd party libraries, and re-implementing the settings control using the new Windows 8.1 XAML control was performed.

For reference, Microsoft Developer Network has extensive documentation that covers all facets of migrating an app to Windows 8.1. Please refer the following link.

http://msdn.microsoft.com/en-us/library/windows/apps/dn263114.aspx

A Healthcare Windows Store App

As seen in several other articles in this forum, we will use a sample healthcare Line of Business Windows Store app.

Some of the previous articles include:

• Porting App Life Cycle, Settings and Search Features from iOS* to Windows* 8 -
• Porting the User Interface from an iOS* Basic App to Windows* 8
• Porting Advanced User Interface from iOS* to Windows* 8
• Porting iOS* Custom Charts and Graphs to Windows* 8 UI

   

The application allows the user to login to the system, view the list of patients (Figure 1), access patient medical records, profiles, doctor’s notes, lab test results, and vital graphs.

Figure 1: The “Patients” page of the Healthcare Line of Business app provides a list of all patients. Selecting an individual patient provides access to the patient’s medical records.

Retargeting sample healthcare app

Before the sample app is retargeted, it is useful to review different components, UI features, and 3^rd party libraries that are used.

The UI and the core app life cycle handling of the app were implemented using the templates available in Windows 8. Windows 8.1updated the project & page templates and included a brand new Hub pattern template. The app uses sqlite* as its backend database to store all patient records. WinRTXamlToolkit* is used for charts and the 3^rd party library Callisto* is used for implementing the Settings Control. The Settings Control is invoked by the charms bar. Windows 8.1 has a new XAML based settings controls that can be used instead of a 3^rd party library.

The app has search functionality implemented using the charms bar integrated in Windows 8. Windows 8.1 has a new in-app search UI control that could be used to extend the search experience to different UI pages of the app, depending on the requirements.

The sample app has several other functionalities like camera usage, NFC and audio recording that will continue to function in Windows 8.1 without any changes.

As mentioned earlier, Visual Studio 2013 was used to recompile the sample app for Windows 8.1, 3^rd party library build issues were fixed, and parts of the app were re-implemented using new Windows 8.1 features. The app can be refined further in the future by re-implementing more pieces of the app that benefit from the Windows 8.1 platform. For example, new page templates, view models for different screen sizes, the new in-app search, or the new tile sizes and templates could be utilized.

Using Visual Studio 2013 to import the app

To retarget the app for windows 8.1, first download and install Visual Studio 2013 on a Windows 8.1 host machine. After the installation, ensure any 3^rd party libraries are updated to the latest version inside the Visual studio extensions.

The project was opened in Visual Studio 2013 and no errors were seen when compiling the project out of the box. To retarget the project to Windows 8.1, right-click the project name in the solutions explorer and the option for retargeting the project to Windows 8.1 is shown in the list (Figure 2)

Figure 2: Option for retargeting the project (captured from Visual Studio* 2013)

Clicking on this option brings up a dialog box asking for confirmation. Verify that the project selected is correct and press the OK button.

Figure 3: Confirmation Dialog for retargeting (captured from Visual Studio 2013*)

After Visual Studio completes the action, you should see the project now has “Windows 8.1” next to the project name in the solution explorer (Figure 4).

Figure 4: Solution Explorer shows the project is retargeted to Windows 8.1 (captured from Visual Studio 2013*)

When trying to compile the project, build errors may occur. Figure 4 also shows some 3^rd party libraries showing build issues. In the next section, resolving build errors and 3^rd party library issues is discussed.

Fixing build errors and 3rd party library issues

Updating the 3^rd party libraries to latest version resolves some of the problems. The Visual Studio* extensions dialog can be used to check for the latest library version available. For Sqlite*, it was updated to the Windows 8.1 version as shown Figure 5.

Figure 5: Extensions dialog (captured from Visual Studio 2013*)

The usage of some of the 3^rd party libraries in the app were re-evaluated after migrating to Windows 8.1. As mentioned earlier, the Settings UI control has been added to Windows 8.1. It was decided that it would be best to remove the 3^rd party library Callisto* from the app and utilize the native Windows 8.1 control. To migrate to the native control, all source code references to the Callisto* library were removed. Please see Figure 6 to see the updated project references in the solutions explorer.

Figure 6: Project references in sample app after retargeting to Windows 8.1* (captured from Visual Studio 2013*)

WinRTXamlToolkit* is still being utilized for charts and other features, so it has been updated to the Windows 8.1 version.

By using the newly available Windows 8.1 XAML settings control, the app maintains the same look and feel as when using the 3^rd party library. Figure 7 shows the settings control in design mode.

Figure 7: Settings Flyout UI in design mode (captured from Visual Studio 2013*)

Using the new XAML based settings control, SettingsFlyout, is similar to other XAML controls. The following snippet shows the XAML code used for the sample app’s settings UI.

<SettingsFlyout
    x:Class="PRApp.Views.PRSettingsFlyout"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:PRApp.Views"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    IconSource="Assets/SmallLogo.png"
    Title="PRApp Options"
    HeaderBackground="{StaticResource StandardBackgroundBrush}"
    d:DesignWidth="346"
    xmlns:c="using:PRApp.ViewModels">

    <SettingsFlyout.Resources>
        <c:SessionSettingsViewModel x:Key="myDataSource"/>
    </SettingsFlyout.Resources>
    <!-- This StackPanel acts as a root panel for vertical layout of the content sections -->
    <StackPanel VerticalAlignment="Stretch" HorizontalAlignment="Stretch">


        <StackPanel Orientation="Horizontal"  Margin="5">
            <TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=SessionSettings.Loginuser.Login}" Margin="0,0,5,0" />
            <TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=SessionSettings.Loginuser.Loginmsg}" />
        </StackPanel>
        <Button Content="User Home" Margin="5" Command="{Binding Source={StaticResource prAppUtil}, Path=UserHomeCmd}"/>
        <Button Content="Logout" Margin="5" Click="Button_Click_1" />
        <ToggleSwitch Header="Show Deceased Patients" Margin="5" IsOn="{Binding Mode=TwoWay, Source={StaticResource myDataSource}, Path=SessionSettings.ShowDeceased}"/>
        <StackPanel Orientation="Horizontal"  Margin="5">
            <ToggleSwitch Header="Use Cloud Service" Margin="5,0,0,0" IsOn="{Binding SessionSettings.UseCloudService, Mode=TwoWay, Source={StaticResource myDataSource}}"/>
        </StackPanel>
        <StackPanel Orientation="Vertical"  Margin="5">
            <TextBlock Margin="5" FontSize="14" Text="Server Address:" Width="97" HorizontalAlignment="Left" VerticalAlignment="Center" />
            <TextBox HorizontalAlignment="Stretch" FontSize="12" Margin="5" Text="{Binding SessionSettings.ServerUrl, Mode=TwoWay, Source={StaticResource myDataSource}}"  />
        </StackPanel>


        <Button HorizontalAlignment="Right"  Click="Button_Click_Test_Connection" Content="Test Connection"/>
        <TextBlock  TextWrapping="Wrap"  x:Name="StatusText" HorizontalAlignment="Left" Text="{Binding SessionSettings.TestConnectionStatus, Source={StaticResource myDataSource}}"  />

    </StackPanel>
</SettingsFlyout>

Figure 8: XAML code snippet for settings flyout in sample app

Configuring and initializing the SettingsFlyout is done in the app’s main point of entry (App.xaml.cs file). SettingsFlyout is added to the ApplicationCommands collection. Please see the following code snippet in Figure 9 for reference.

protected override void OnWindowCreated(WindowCreatedEventArgs args)
{
    Windows.UI.ApplicationSettings.SettingsPane.GetForCurrentView().CommandsRequested += Settings_CommandsRequested;
}

void Settings_CommandsRequested(Windows.UI.ApplicationSettings.SettingsPane sender, Windows.UI.ApplicationSettings.SettingsPaneCommandsRequestedEventArgs args)
{
    Windows.UI.ApplicationSettings.SettingsCommand PRSettingsCmd =
        new Windows.UI.ApplicationSettings.SettingsCommand("PRAppOptions", "PRApp Options", (handler) =>
        {
            PRSettingsFlyout PRSettingsFlyout = new PRSettingsFlyout();
            PRSettingsFlyout.Show();

        });

    args.Request.ApplicationCommands.Add(PRSettingsCmd);
}

Figure 9: Code snippet showing the settings flyout initialization

SettingsFlyout is an excellent feature in Windows 8.1 that iseasy to use and it comes with all the design best practices recommended for Windows Store Apps. In addition, the effort to transition to this native control was painless.

Summary

This article discussed retargeting a sample health care Windows Store App from Windows 8 to Windows 8.1. The steps involved in the retargeting process were covered in detail with relevant screenshots and code snippets. The article concluded with a discussion about replacing a 3^rd party library with a native Windows 8.1 control.

Intel, the Intel logo are trademarks of Intel Corporation in the US and/or other countries.

Copyright © 2013 Intel Corporation. All rights reserved.

*Other names and brands may be claimed as the property of others.

++This sample source code is released under the Intel OBL Sample Source Code License (MS-LPL Compatible), Microsoft Limited Public License, and Visual Studio* 2013 License.

Downloads

Implementing multi-user multi-touch scenarios using WPF in Windows* 8 Desktop Apps [PDF 602KB]
Multiuser-Multitouch-Codesample.zip [ZIP 206KB]

Summary

In this paper we walk through a sample application (in this case a game that quizzes people on the Periodic Table) that enables multi-user, multi-touch capability and is optimized for large touchscreen displays. By using User Controls and touch events, we can enable a scenario where multiple users can play the game at the same time.

Windows Presentation Foundation (WPF) provides a deep touch framework that allows us to handle low-level touch events and support a multitude of scenarios from simple touch scrolling to a multi-user scenario. This game has two areas where users can touch, scroll, and click using their fingers simultaneously while the remainder of the UI remains responsive. Finally, this application was designed and built using XAML and C# and follows the principles of the Model-View-ViewModel software development pattern.

Supporting Large Touch Displays and multiple users in Windows Presentation Foundation

WPF is an excellent framework for building line-of-business applications for Windows desktop systems, but it can also be used to develop modern and dynamic applications. You can apply many of the same principles you use for designing applications in WPF with some small tweaks to make them friendly and easy to use on a large format display.

The XAML markup language has, as a foundational principle, lookless controls. This means that the appearance and styling of a control is separate from the control’s implementation. The control author may provide a default style for the control, but this can easily be overridden. If you place a style in your XAML (inferred or explicit), it will append the base style that ships with the framework. You can also use the template extraction features in Visual Studio* 2012 to make a copy of styles and templates that ship with the .NET framework to use as a starting point.

Let’s look at an example:

To create a window with a custom close button, I created an empty WPF project in Visual Studio and edited the MainWindow.xaml file as follows:

<Window x:Class="ExampleApplication.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525" WindowStyle="None">
    <Grid>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Content="Close" Click="Close_Window" />
    </Grid>
</Window>

I then wrote a C# method to handle closing the window:

        private void Close_Window(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

This created a Window like the one below:

Since we are on the Windows 8 platform, we can use the Segoe UI Symbol font to put the close symbol in the button. You can browse for the symbol you want to use in the Windows Character Map under the Segoe UI Symbol font:

Now that I have the character code, I can begin customizing the button. To start, I added the close symbol to the button:

<Button HorizontalAlignment="Right" VerticalAlignment="Top" FontFamily="Segoe UI Symbol" Content="" Click="Close_Window" />

I also want to style the button to make it touch-friendly by applying an XAML style. This can be done by creating an inherit style that is anywhere above the button in its Visual hierarchy. I will add the Button style to the Window’s resources so that it’s available to any button within the Window:

<Style TargetType="Button">
            <Setter Property="BorderBrush" Value="White" />
            <Setter Property="Background" Value="Transparent" />
            <Setter Property="Foreground" Value="White" />
            <Setter Property="BorderThickness" Value="2" />
            <Setter Property="Padding" Value="12,8" />
            <Setter Property="FontSize" Value="24" />
            <Setter Property="FontWeight" Value="Bold" />
        </Style>

To illustrate this effect, I changed the Window’s background color to white. The above style will result in a button that appears like this:

You can always change the style to have a larger icon and less padding, for example. With buttons and text content, you may find yourself using static padding, margin, and size values since they rarely change. If you want text content to be truly responsive, you can always put text content in a VIewBox so that it scales in size relative to the Window. This isn’t necessary for most large-screen applications, but it is something to consider if your application will operate at very extreme resolutions.

For most UI elements, you will want to base your padding and margins off of relative sizes. This can be accomplished by using a Grid as your layout system. For example, in the demo application, we wanted a very thin amount of space around each periodic table element. I could use a 1px padding around each item, but the appearance of the width of that padding will differ between users on large displays and small displays. You also have to consider that your end users might be using much larger monitors and resolutions than your development environment may support. To resolve this issue, I use the grids to create rows and columns to represent the padding. For example, I can create a grid with 3 rows and 3 columns like below:

<Grid x:Name="tableRoot">
            <Grid.RowDefinitions>
                <RowDefinition Height="0.01*"/>
                <RowDefinition Height="0.98*"/>
                <RowDefinition Height="0.01*"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="0.01*"/>
                <ColumnDefinition Width="0.98*"/>
                <ColumnDefinition Width="0.01*"/>
            </Grid.ColumnDefinitions></Grid>

In grid definition sizing you have three options available. You can do static sizing using an absolute height or width, auto sizing that depends on the content to measure and determine size or relative sizing or you can mix and match the different options. In our example, we make heavy use of the relative sizing. The XAML engine sums the values for the relative sizing and assigns sizing that is equivalent to the ratio of that individual value to the whole. For example, if you have columns sized like below:

<Grid.ColumnDefinitions>
                <ColumnDefinition Width="4*"/>
                <ColumnDefinition Width="7*"/>
                <ColumnDefinition Width="9*"/>
            </Grid.ColumnDefinitions>

The sum of the column widths (4, 7, and 9) is 20. So each width is the ratio of each value to the total of 20. The first column would be 4/20 (20%), the second column would be 7/20 (35%), and the final column would be 9/20 (45%). While this works fine, it’s considered a good practice to have all of your columns (or rows) sum up to either 100 or 1 for simplicity’s sake. In the first example, we make sure that the heights and widths add up to a value of 1. The column and row indexes are zero-based so we can put the content in Column 1 and Row 1 and it will have a 1% padding all around. This is 1% regardless of the resolution and will appear relatively the same to users regardless of their resolution. A padding set to a static size will be much thinner on a large touchscreen display with a high resolution than you expect it to be during development. In the periodic table application, you can see this 1% padding when browsing the table itself:

You can also enable touch scrolling for your application to make it more responsive. Out of the box, WPF allows you to use your finger to scroll through a list element. The ScrollViewer does lock your scrolling to each element so it’s more like flicking between elements. If you want to enable “smooth” scrolling, you should set the PanningMode of the ScrollViewer. By default, the PanningMode is set to None. By setting it to VerticalOnly or HorizontalOnly, you will enable smooth scrolling through items in a list view. In the Periodic table application, the ScrollViewer.PanningMode attached property is used to enable this scenario on a typical ListView. I also set the ScrollViewer.CanContentScroll property to false so that the items will not snap and the user can use their finger to hover between items.

<ListView x:Name="SecondBox" Background="Transparent" ItemsSource="{Binding Source={StaticResource PeriodicData}}" 
                  ScrollViewer.VerticalScrollBarVisibility="Disabled" 
                  ScrollViewer.HorizontalScrollBarVisibility="Visible"
                  ScrollViewer.PanningMode="HorizontalOnly" 
                  ScrollViewer.CanContentScroll="False"></ListView>

The ListView mentioned is used in the application for viewing Periodic table items like below:

Finally, WPF allows us to use the built-in touch support that has been around since Windows 7. Windows recognizes touch input as a mouse when you don’t specifically handle the touch events such as Tapped, ManipulationDelta, and ManipulationEnded. This allows you to handle the event where users tap any of the above items by using the Click event handler. This also minimizes the amount of code necessary to support both touch and a mouse.

Since touch support is implemented on a very low-level, the WPF platform does not group touches by user or clusters. To get around this, you typically see control authors use visual cues (such as a border or a box) to indicate to users that they should touch within a specific area. To support multiple users, we can put the touch-supported controls within a UserControl. The browsable Periodic table that is used to find the Periodic elements as part of this game is a UserControl so we can put as many or as few as we want on a screen by putting the logic into a UserControl.

The Model-View-ViewModel Pattern

When building the application, it would be easy to write the code in the xaml.cs file and call it a day, but we want to maximize code reuse and build an application that is truly modular. We can accomplish this by leveraging the MVVM design pattern. In the Periodic Table application, every screen is bound to a ViewModel. This holds information for data-binding and controls the behaviors of the different Views. We also have a data source that uses XAML and need to manipulate the data source to run the game. The data source will be discussed in greater detail later in this article.

Since MVVM is a popular design pattern, it is possible to use it in the WPF, Windows Store, and Windows Phone platforms. To support this scenario, we can put our Models and ViewModels into Portable Class Libraries (PCLs) that can be referenced by all of those platforms. The PCLs contain the common functionality and namespaces between all of those platforms and allow you to write cross-platform code. Many tools and libraries (such as Ninject, PRISM’s EventAggregator, and others) are available via NuGet and can be referenced in a PCL so you can create large-scale applications. If you need to support a new platform, you simply create new Views and reference the existing ViewModels and Models.

This application is parsing a static data file that contains information about how to render the Periodic table. The Models are aware of the classes in WPF so PCLs would not be appropriate in this example.

In this application, we use the PRISM framework to leverage the already well-built modules for MVVM development.

For the home page, we have a BaseViewModel that has one command. The ExitCommand closes the application when executed. We can bind this command to the button mentioned earlier in the article by applying a data binding to the Button’s Command dependency property.

    public class BaseViewModel : NotificationObject
    {
        public BaseViewModel()
        {
            this.ExitCommand = new DelegateCommand(ExitExecute);
        }

        public DelegateCommand ExitCommand { get; private set; }

        private void ExitExecute()
        {
            Application.Current.Shutdown();
        }
    }

First, the ViewModel inherits from PRISM’s NotificationObject class. This class contains all of the logic to let the View know when a ViewModel’s property is updated. This is accomplished by implementing the INotifyPropertyChanged interface. If you ever want to look at a very solid best-practices implementation of INotifyPropertyChanged, view the source code for the PRISM project to see how the team at Microsoft implemented the interface.

Next, we use the DelegateCommand class from the PRISM framework. DelegateCommand is an implementation of the ICommand interface that is the heart of commanding in WPF. This class can be used to handle a button’s click event and the logic for determining whether a button is enabled. This support not only applies to buttons, but is the primary case when the ICommand is used.

In our BaseViewModel class, we create a new instance of the DelegateCommand class and pass in the ExitExecute action to be executed when the Command is invoked (by pressing the button).

Because you can close the application from any screen, all of the other pages inherit from the BaseViewModel class. To keep all of the game-related logic together, both the 1-player and 2-player games use ViewModels that inherit from a GameViewModel class which in-turn inherits from BaseViewModel.

The GameViewModel class implements publically accessible properties that are used in a game. Below are a couple of example fields that are shown on a game screen:

For example, we have a RoundTimeLeft property that shows how much time you have left in a round. The property is of type TimeSpan and it uses a private backing field. When you set the property, we use a method of the NotificationObject class to notify the View layer that a ViewModel property has been updated.

        private TimeSpan _roundTimeLeft;
        public TimeSpan RoundTimeLeft
        {
            get { return _roundTimeLeft; }
            private set
            {
                _roundTimeLeft = value;
                RaisePropertyChanged(() => RoundTimeLeft);
            }
        }

This is especially useful in situations where you want the View to refresh multiple properties when you update a single field/property. Also, as a performance improvement for advanced applications, it is very common to check if the value has been changed before notifying the view that your property has changed. Below is an example of the HintItem property and Hint property that are used in the ViewModel. The Hint property is the symbol that is shown in the center, and we want to update that text anytime we store a new HintItem in the ViewModel. This is done by letting the View know that the Hint property has been updated:

        private PeriodicItem _hintItem;
        public string Hint
        {
            get
            {
                return this.HintItem != null ? this.HintItem.Abbreviation : string.Empty;
            }
        }

        public PeriodicItem HintItem
        {
            get { return _hintItem; }
            private set
            {
                _hintItem = value;
                RaisePropertyChanged(() => Hint);
                RaisePropertyChanged(() => HintItem);
            }
        }

The Model-View-ViewModel pattern is very powerful and allows testability and expanded code re-use when working with an application. The pattern is also applicable whether you are working on a line-of-business application or a touch application. The GameViewModel class uses a timer and a loop to handle the execution of the game. Both OnePlayerViewModel and TwoPlayersViewModel  inherit from the GameViewModel and add specific logic for each type of game. The application also has a DesignGameViewModel that has a set of static properties so that we can see how the game will look at design time without having to run the application:

Tips & Tricks for building immersive applications in WPF

There are a couple of XAML tricks that are used throughout this application to make it visually appealing and touch friendly. Some are very common, but there are a couple worth highlighting as they use some of the best features of WPF and XAML.

First, the PeriodicTable itself is a WPF UserControl. This allows maximum code re-use as the control can simply be placed on any WPF Window. Within the control, Dependency Properties are used so that you can set features of the control and expose those features externally for data-binding. For example, the PeriodicTable has two states. ZoomedOut is when you see the entire table:

ZoomedIn is when you see the detailed list. When clicking on a Periodic Group from the ZoomedOut view, the game jumps to that group on the ZoomedIn list. There is also a button in the bottom-right corner to zoom back out:

To implement this, there are two list views representing each of the “Views.” A dependency property is created that will expose a property that anybody can set. A PropertyChanged event handler is then created so that the control can respond to changes from both code and data-bindings all in one location:

        public static readonly DependencyProperty IsZoomedInProperty = DependencyProperty.Register(
            "IsZoomedIn", typeof(bool), typeof(PeriodicTable),
            new PropertyMetadata(false, ZoomedInChanged)
        );

        public bool IsZoomedIn
        {
            get { return (bool)GetValue(IsZoomedInProperty); }
            set { SetValue(IsZoomedInProperty, value); }
        }

        public void SetZoom(bool isZoomedIn)
        {
            if (IsZoomedIn)
            {
                FirstContainer.Visibility = Visibility.Collapsed;
                SecondContainer.Visibility = Visibility.Visible;
            }
            else
            {
                FirstContainer.Visibility = Visibility.Visible;
                SecondContainer.Visibility = Visibility.Collapsed;
            }
        }

This dependency property is used in the TwoPlayerView so that we can bind the Second Player’s zoomed in state to a Boolean in the ViewModel called PlayerTwoZoomedIn:

<local:PeriodicTable x:Name="playerTwoTable" IsZoomedIn="{Binding PlayerTwoZoomedIn, Mode=TwoWay}"></local:PeriodicTable>

This implementation loses the flexibility to tie custom features from the control to anything in the ViewModel. In our application, we need to set PlayerTwoZoomedIn (and PlayerOneZoomedIn) to false when a round or the game is reset.

XAML is also heavily used to store the data in this application. While a database or a text file could be created, it seemed to be much more readable to store the Periodic table’s data as XAML. Since XAML is just an XML representation of CLR objects, we could create model classes and corresponding XAML elements. We can then store this in a XAML resource dictionary and load it as data at runtime (or design time if you wish).

For example, we have a class for PeriodicItems that has a very simple definition and is represented by even simpler XAML:

    public class PeriodicItem
    {
        public string Title { get; set; }

        public string Abbreviation { get; set; }

        public int Number { get; set; }
    } 

<local:PeriodicItem Abbreviation="Sc" Title="Scandium" Number="21" />
<local:PeriodicItem Abbreviation="Ti" Title="Titanium" Number="22" />

This made defining the Periodic table easy and readable. You can find all of the Periodic elements used in the application in the PeriodicTableDataSource.xaml file located in the Data folder. Here is an example of a Periodic Group defined in that file.

<local:PeriodicGroup Key="Outer Transition Elements">
                <local:PeriodicGroup.Items>
                    <local:PeriodicItem Abbreviation="Ni" Title="Nickel" Number="28" />
                    <local:PeriodicItem Abbreviation="Cu" Title="Copper" Number="29" />
                    <local:PeriodicItem Abbreviation="Zn" Title="Zinc" Number="30" />
                    <local:PeriodicItem Abbreviation="Y" Title="Yttrium" Number="39" />
                </local:PeriodicGroup.Items>
            </local:PeriodicGroup>

Because of this, the Periodic data is dynamic and can be modified by simply updating the .xaml file. You can also use the same data in both design and runtime Views since it’s compiled and available as a resource for XAML.

Summary

Building an application that supports a large amount of data and advanced touch scenarios is definitely possible in the Windows 8 desktop environment. XAML is a powerful markup language that allows you to not only define dynamic views, but also model your data in a common format that is very easy to read, understand, and parse. You can build touch applications today using the mature WPF platform.

Intel and the Intel logo are trademarks of Intel Corporation in the U.S. and/or other countries.

Copyright © 2013 Intel Corporation. All rights reserved.

*Other names and brands may be claimed as the property of others.

Download article

Using Intel® Graphics Performance Analyzers to Optimize Splinter Cell*: Blacklist* [PDF 559KB]

For the most recent installment of Tom Clancy’s* Splinter Cell series, engineers from Ubisoft and Intel analyzed the game to make it run smoothly and achieve the best performance on Intel® hardware. Using Intel® Graphics Performance Analyzers (Intel® GPA), we found some bottlenecks in the frame. Ubisoft was then able to optimize the draw calls we identified, tripling the frame rate. The expensive rendering passes we found were the lighting environment pass and the shadow pass. On a 4^th generation Intel® Core™ i7 processor-based desktop, a frame rate of 43 frames per second (fps) was achieved at 1366x768 resolution with low settings, 35 fps on medium settings.

Specifying a Workload

Optimizing a game is full of experiments—changing shaders, using different textures, trying new approaches—to find troublesome components or rendering passes and increase the speed. As with any experiment, an analytical approach is vital in determining the quality of the results. An in-game workload (representative scene where performance is lacking) should be chosen for the analysis. Figure 1 shows one such scene: numerous objects, multiple light sources, and several characters.

Figure 1. Scene chosen for analysis.

Identifying and Addressing the Problems

To see what’s going on here, we used the Intel GPA Monitor to remotely capture a frame for analysis. Loading that in the Intel GPA Frame Analyzer, the problematic ergs (units of work, from the Greek ἔργον (ergon) meaning “work”) can be identified by their charted size, the amount of time the GPU spends on them. By inspecting the ergs individually and mapping them to stages in the game’s pipeline, we isolated two main issues (figure 2): the SeparableSSS pass and the lighting environment pass. The SeparableSSS pass was removed due to the extremely high cost.

Figure 2. Erg view of Intel® GPA frame capture before optimization

This definitely helped the overall performance. With these two ergs out of the way, the lighting environment pass was our next area to tackle. It was problematic not solely because of the amount of time spent on each erg, but the large number of ergs used, combining to constitute a prohibitive amount of total GPU time: ~100 x 1500 μs = 150,000 μs! Figure 3 makes this painfully clear.

Figure 3. Lighting environment pass grows prohibitive

Figure 4 shows the gains after optimizing the lighting environment pass.

Figure 4. Removing the lighting environment pass sped things up significantly

The two ergs tied for second place in height are the ShadowPass.Composite function. These were also optimized.

Final Results

After these changes, combining the highly effective shadow compositing into the rendering passes brought processing costs still lower (figure 5).

Figure 5. Intel® GPA frame capture after optimization

Overall, the performance approximately tripled, achieving 43 fps at 1366x768 resolution with low settings (35 fps on medium settings) on a 4^th generation Intel Core i7 processor-based desktop.

Conclusion

Approaching optimization like a series of experiments is useful in finding the root causes of your performance problems. The issues outlined here represent just a few ways to use Intel GPA to streamline your applications. Many more can be found through the documentation, online forums, and articles on Intel® Developer Zone.

About the Author

Brad Hill is a Software Engineer at Intel in the Developer Relations Division. Brad investigates new technologies on Intel hardware and shares the best methods with software developers via the Intel Developer Zone and at developer conferences. He also runs Code for Good Student Hackathons at colleges and universities around the country.

Intel, the Intel logo, and Core are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.