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

В этой статье, основанной на руководстве по разработке поставщиков федеративного поиска в Windows 7, вы узнаете, что такое федеративный поиск и как он работает. Если вам действительно интересно, как использовать федеративный поиск или создать собственный поставщик, рекомендуем прочитать данное руководство.

Как это работает?

Windows 7 поддерживает подключение внешних источников данных к клиентской версии Windows через протокол OpenSearch. Стандарт OpenSearch v1.1 определяет простые форматы файла, которые могут быть использованы для описания запросов к веб-службе и формата, в котором веб-служба должна сформировать результаты, которые будут возвращены клиенту. По существу это означает, что вы можете указать Windows Explorer на внешний источник данных. Используя стандартный протокол OpenSearch, Windows Explorer направляет поисковый запрос, а удаленный источник данных возвращает грамотно сформированную структуру данных, которая может быть обработана и представлена пользователю.

Чтобы добавить нового поставщика OpenSearch, вы должны установить файл Search Connector Description (файл с расширением .osdx). Внутренний формат файла для .osdx – это OpenSearch Description XML. Вот содержимое .osdx-файла для поиска по Flickr:

<?xml version=«1.0» encoding=«UTF-8»?>

<OpenSearchDescription xmlns=«http://a9.com/-/spec/opensearch/1.1/"

xmlns:ms-ose=«https://schemas.microsoft.com/opensearchext/2009/">

<ShortName>Flickr Search</ShortName>

<Description>OpenSearch for Flickr via Windows 7 Search Federation.</Description>

<Url type=«text/html»

template=«http://www.flickr.com/search/?w=all&amp;amp;q={searchTerms}&amp;amp;m=text»/>

</OpenSearchDescription>

Обратите внимание, насколько прост файл. Он включает URL к поиску Flickr, который определяет условия поиска. За дополнительной информацией обращайтесь к спецификации стандарта OpenSearch v1.1. Те из вас, у кого зоркий глаз и хорошая память, могли подумать, что вышеупомянутый XML очень похож на поставщик поиска в Internet Explorer 8 (IE8) – небольшое окно поиска в верхнем правом углу IE8, позволяющее выбрать контекст, в котором выполняется поиск. Это довольно интересная тема, поэтому в будущем вы вправе ожидать статью о том, как преобразовать поставщик поиска в IE8 в поставщик федеративного поиска для Windows 7.

У конечных пользователей есть несколько вариантов установки нового удаленного источника данных с федеративным поиском Windows: они могут открыть .osdx-файл, нажимая на одну из ссылок на веб-сайте, открыть один из предоставленных кем-то в совместно используемый ресурс или через почтовое вложение. После этого в папке «Searches» в Windows (%userprofile %/Searches) создается файл .searchconnector-ms, при этом ярлык на него помещается в папку «Links» (%userprofile %/Links). Этот ярлык отображается в разделе избранного навигационной панели Windows Explorer.

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

Приступаем к практике. Загрузите поисковый коннектор для поиска на Flickr. Вам будет предложено сохранить или открыть файл. Выберите второй вариант для регистрации поставщика поиска на своем компьютере. Затем вам будет предложено добавить поисковый коннектор. Подтвердите свое намерение, нажав на кнопку «Добавить», как показано на следующем изображении:

Обратите внимание, что в навигационную панель Windows Explorer в раздел избранного добавлен новый ярлык под названием Flickr Search. Нажмите на этот ярлык и введите в окне поиска Windows Explorer запрос «Seattle». Подождите несколько секунд, поскольку результаты передаются с веб-сайта Flickr.

По мере ввода поискового запроса в поле для поиска вверху Windows Explorer запрос передается к поставщику OpenSearch (описанному в файле .searchconnector-ms), который затем пересылает запрос удаленному хранилищу данных (URL, в котором содержатся условия поиска в .osdx-файле). Удаленная веб-служба отвечает на запрос с результатами в XML-файле либо через RSS, либо через Atom. Провайдер OpenSearch преобразует элементы XML-файла в элементы, которые, в конечном счете, возвращаются в Windows Explorer, где они отображаются пользователю. Следующее изображение иллюстрирует поток данных:

Для подключения хранилища данных веб-службы к Windows 7 требуется всего три шага:

1. Разрешить поиск в хранилище данных прямо из Windows, используя OpenSearch с выводом в виде Atom или RSS.
2. Создать .osdx-файлы, описывающие процедуру подключения к веб-службе и то, как размечать любые выбранные элементы в RSS или Atom XML.
3. Установить поисковые коннекторы на клиентских машинах с Windows с помощью .osdx-файлов.

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

• Создать шаблон для начальных запросов
• Установить максимальное число результатов и создать страницы
• Настроить отображение результатов
• Привязать свойства к системе свойств Windows Explorer
• Генерировать подсказки

На самом деле, есть многое, что следует знать о создании собственных поставщиков поиска OpenSearch. Если вам интересна эта тема, ознакомьтесь с руководством по разработке поставщика федеративного поиска в Windows 7 и посмотрите вебкаст о федеративном поиске, созданный Сашей Голдштейном (Sasha Goldstein), одним из авторов книги Введение в Windows 7 для разработчиков.

До сих пор вы видели примеры использования платформы с помощью C++ и COM. Теперь давайте рассмотрим, как разработчики управляемого кода смогут использовать платформу с помощью Windows API Code Pack для .NET Framework.

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

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

Основное пространство имен для сенсоров в Windows API Code Pack – это Microsoft.WindowsAPICodePack.Sensors из сборки Microsoft.WindowsAPICodePack.Sensors.dll. Это пространство имен содержит класс SensorManager, управляющий сенсорными устройствами, подключенными к ПК. Этот класс предоставляет набор методов, схожих с методами из неуправляемого интерфейса ISensorManager. Эти методы включают GetSensorsByCategoryId, GetSensorsByTypeId и GetSensorsBySensorId, последний из которых получает в качестве входного параметра GUID, который представляет категорию сенсора, тип или идентификатор сенсора. Кроме того, вы также найдете метод GetAllSensors, который возвращает все сенсоры, подключенные к системе, независимо от типа или категории, как показано в следующем фрагменте кода.

private void PrintAllSensors()

{

    SensorList<Sensor> sensorList =  SensorManager.GetAllSensors();

    foreach (var sensor in sensorList)

    {

        StringBuilder sb = new  StringBuilder();

        sb.Append("Sensor Information:");

        sb.Append(Environment.NewLine);

        sb.Append(sensor.FriendlyName);

        sb.Append(Environment.NewLine);

        sb.Append(sensor.CategoryId);

        sb.Append(Environment.NewLine);

        sb.Append(sensor.State);

        sb.Append(Environment.NewLine);

        Console.WriteLine(sb.ToString());

    }

}

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

Sensor Information:

Legacy GPS Driver

AccessDenied

bfa794e4-f964-4fdb-90f6-51056bfe4b44

Sensor Information:

Skyhook Wireless XPS Location Sensor

bfa794e4-f964-4fdb-90f6-51056bfe4b44

AccessDenied

Sensor Information:

Ambient Light Sensor

17a665c0-9063-4216-b202-5c7a255e18ce

Ready

Так как Windows API Code Pack включает строго типизированный класс сенсоров Sensor, получить список сенсоров и вывести их свойства достаточно просто. Неуправляемый API имеет интерфейс Sensor, через который вы и будете работать с сенсорами, но помимо интерфейса ISensor требуется использовать GUID. В Windows API Code Pack присутствует список всех GUID, которые доступны в Sensors.h. Классы SensorPropertyKeys и SensorCategories содержат публичное свойство «только для чтения» для объектов GUID, которые соответствуют тем же самым значениям в файле Sensors.h. Однако, это не самая используемая и предпочтительная модель программирования, к которой привыкли .NET-разработчики, и в основном потому, что неуправляемые объекты сенсора в определены не строго и вы вынуждены использовать более универсальную систему GUID для обращения к данным сенсора. Это не позволяет использовать весь спектр возможностей .NET, например, привязку данных, безопасность типов и свойства. Таким образом, пространство имен Microsoft.WindowsAPICodePack.Sensors, структура которого приведена на изображении ниже, включает несколько строго типизированных классов сенсора, позволяющих осуществлять привязку к их свойствам. Например, AmbientLightSensor, у которого одно публичное свойство, CurrentLuminousIntensity, отображающее текущее количество света (яркость), измеренное сенсором. Пространство имен также включает уровень совместимости, который охватывает неуправляемый интерфейс, всю информацию о метаданных и объектную модель, с которой имеют дело разработчики.

Обратите внимание, что пространство имен Microsoft.WindowsAPICodePack.Sensors предлагает модель расширения, позволяющую создавать любой строго типизированный сенсор. Вместе с возможностями расширения, предлагаемыми неуправляемыми API, вы можете создать любой тип сенсора, какой только захотите, с любыми значениями данных. Дополнительную информацию о модуле расширения платформы Sensor and Location вы можете найти на веб-узле платформы: https://www.microsoft.com/whdc/device/sensors/.

Со строго типизированным классом сенсора Windows API Code Pack может определить версию .NET Generics методов Get. Например, GetSensorsByTypeId<S>, где S – производный тип от базового класса Sensor. Прототип выглядит следующим образом:

public static SensorList<S> GetSensorsByTypeId<S>( ) where S: Sensor

При использовании данной функции вы должны предопределить SensorList <> желаемого типа сенсора, (в нашем примере AmbientLightSensor), а затем вызвать метод, запрашивающий у менеджера сенсора возврат сенсоров типа AmbientLightSensor. Следующий фрагмент кода иллюстрирует этот процесс:

// Строготипизированный SensorList типа AmbientLightSensor

SensorList<AmbientLightSensor> alsList = null;

try

{

    alsList = SensorManager.GetSensorsByTypeId<AmbientLightSensor>();

}

catch (SensorPlatformException) 

{

    // Обработка ошибки, когда отсутствует доступ к сенсорному устройству 

}

Класс SensorManager содержит одно событие, называемое SensorChanged, эквивалентное неуправляемому событию ISensorManager:: OnSensorEnter. Единственным различием между реализациями на неуправляемом и управляемом коде является то, что реализация на управляемом коде в дополнение к получению события при подключении нового устройства генерирует событие при отключении сенсора. Таким образом, SensorsChangedEventArgs, параметры которого переданы обработчику события SensorManager.SensorChanged, включает SensorAvailabilityChange, определяющий тип изменения для каждого сенсора, который может принимать значение Addition для вновь подключенных сенсоров и Removal при отключении сенсоров от ПК.

SensorManager_SensorsChanged представляет собой функцию, которая обрабатывает событие SensorsChanged в нашем приложении и это выглядит следующим образом:

void SensorManager_SensorsChanged( SensorsChangedEventArgs change )

{

    // Событие SensorsChanged происходит в потоке, отличном от потока приложения.

    // Анонимный делегат осуществляет обновление интерфейса приложения.

    BeginInvoke( new MethodInvoker( delegate

    {

        PopulatePanel( );

    } ) );

}

Событие SensorsChanged обрабатывается в ином потоке, отличном от основного потока приложения (UI). Windows Forms не позволяют обновлять интерфейс приложения из таких потоков. Поэтому для любого Windows-приложения с оконным интерфейсом мы настоятельно рекомендуем использовать поток, отличный от основного потока UI, для выполнения сложных вычислений или любого процесса ввода/вывода (также как в нашем примере синхронного чтения данных сенсора). Для того чтобы правильно осуществлять обработку обновлений для не-UI потоков, следует использовать BeginInvoke, позволяющий выполнить определенный делегат асинхронно в потоке, в котором был создан основной обработчик формы. Это также верно для любого приложения WPF. Метод PopulatePanel выполняет итерации через все сенсоры и обновляет интерфейс приложения по мере проверки состояния сенсора и чтения его данных. Об этом мы расскажем в следующих статьях.

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

Sensor API (равно как и Location API) базируется на COM. Все необходимые API и определения GUID можно найти в файлах Sensorsapi.h и Sensors.h из Windows 7 SDK. Файл Sensors.h содержит массу GUID, которые определяют различные категории сенсоров, типов и данных. API и интерфейсы находятся в файле Sensorsapi.h. Более пристальный взгляд на файл Sensorsapi.h открывает три основных COM-интерфейса, о которых вам необходимо знать, работая с сенсорами:

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

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

Интеграция сенсоров в приложение

Для интеграции сенсоров в приложение, вам необходимо выполнить следующие шаги:

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

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

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

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

Обнаружение сенсоров

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

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

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

// CAmbientLightAwareSensorManagerEvents

CComPtr<ISensorManager> m_spISensorManager;

HRESULT hr;

// Создаем менеджер сенсора

hr = m_spISensorManager.CoCreateInstance(CLSID_SensorManager);

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

• GetSensorsByID – первый метод возвращает определенный сенсор по его идентификатору (ID), который представляет собой обычный GUID. Это не самая используемая функция, поскольку GUID сенсора генерируется автоматически при первоначальном подключении к системе для обеспечения поддержки нескольких сенсоров одного и того же производителя и одинаковой модели.
• GetSensorsByCategory – эта функция возвращает набор сенсоров, совместно использующих одну категорию. Например, может быть несколько сенсоров местоположения, включая GPS и триангуляцию Wi-Fi, включенных в платформу, и вы не хотите отказываться от их использования.
• GetSensorsByType – эта функция возвращает набор сенсоров одного и того же типа.

Как можно заметить, имена функций показывают, что к компьютеру одновременно подключено множество сенсоров. Технически возможно, чтобы несколько сенсоров одной и той же категории были подключены к одному и тому же ПК. Например, на моем компьютере установлен один датчик освещения, установленный в корпус ПК, и еще один из состава Sensor Development Kit. Имеет смысл использовать световой датчик, встроенный в корпус, так как он обеспечивает самое точное определение условий освещения. Для приложения наилучшим способом обнаружения сенсоров является использование типа интерфейса и категорий функции Sensor Manager с последующим выбором из списка нужного сенсора.

В этом цикле статей мы будем использовать очень простое приложение Microsoft Foundation Classes (MFC), являющееся частью Windows 7 SDK. Следующий код взят из метода Initialize класса CAmbientLightAwareSensorManagerEvents. В этом классе реализованы уведомления ISensorManagerEvents при обнаружении нового датчика.

Метод Initialize вызывают во время процесса инициализации главного диалога (у нас есть только один):

HRESULT CAmbientLightAwareSensorManagerEvents::Initialize()

{

    HRESULT hr;

    // Создаем менеджер сенсора

    hr = m_spISensorManager.CoCreateInstance(CLSID_SensorManager);

    if (SUCCEEDED(hr))

    {

        hr = m_spISensorManager->SetEventSink(this);

        if (SUCCEEDED(hr))

        {

            // Ищем сенсоры внешнего освещения

            CComPtr<ISensorCollection> spSensors;

            hr = m_spISensorManager->GetSensorsByType

                        (SENSOR_TYPE_AMBIENT_LIGHT, &spSensors);

            if (SUCCEEDED(hr) && NULL != spSensors)

            {

                ULONG ulCount = 0;

                hr = spSensors->GetCount(&ulCount);

                if (SUCCEEDED(hr))

                {

                    for(ULONG i=0; i < ulCount; i++)

                    {

                        CComPtr<ISensor> spSensor;

                        hr = spSensors->GetAt(i, &spSensor);

                        if (SUCCEEDED(hr))

                        {

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

                            // для заданного сенсора

                            hr = AddSensor(spSensor);

                            if (SUCCEEDED(hr))

                            {

                                // Проверка текущего состояния сенсора.

                                SensorState state = SENSOR_STATE_READY;

                                hr = spSensor->GetState(&state);

                                if(SUCCEEDED(hr))

                                {

                                      if(state == SENSOR_STATE_READY)

                                     {

                                        // Читаем данные с сенсора и обновляем 

                                        // интерфейс приложения

                                        hr = m_pSensorEvents->GetSensorData

                                                                (spSensor);

                                     }

                            }

                        }

                    }

                }

            }

        }

    }

    return hr;

}

Как видите, после успешного получения интерфейса ISensorManager вы вызываете ISensorManager::GetSensorsByType, используя SENSOR_TYPE_AMBIENT_LIGHT и указатель на набор ISensorCollection, spSensors. SENSOR_TYPE_AMBIENT_LIGHT указывает, что мы хотим получить только сенсор внешнего освещения (ALS). В то же время можно опросить все сенсоры типа SENSOR_TYPE_VOLTAGE из электрической категории или SENSOR_TYPE_ACCELEROMETER_3D из категории акселерометров.

В случае успешного выполнения функция GetSensorsByType заполняет ISensorCollection списком ALS-сенсоров. Затем вы повторяете эту процедуру для всего набора и вызываете вспомогательную функцию AddSensor для каждого сенсора. Она устанавливает обработчик события (делегат), регистрируя сенсор в m_pSensorEvents, являющийся реализацией класса SensorEvents предназначенного для перехвата событий, но об этом я расскажу позже. Наконец, вы вызываете другой вспомогательный метод, GetSensorData, чтобы считать данные с сенсора и обновить значение освещенности в интерфейсе приложения. Мы расскажем о чтении данных сенсора в следующих статьях.

В течение всего времени выполнения приложения к компьютеру могут быть подключены новые сенсоры, таким образом, требуется механизм уведомления приложения при подключении новых сенсоров. Интерфейс ISensorManager содержит метод SetEventSink для задания класса реализующего обработчик событий, то есть делегат, который обрабатывает события. Эта функция получает интерфейс обратного вызова ISensorManagerEvents, получающий уведомления о подключении новое сенсора. Это событие выступает в качестве приемника, обрабатывающего OnSensorEnter – единственное событие, которое есть у интерфейса ISensorManagerEvents.

Если вы посмотрите на вышеприведенный пример, то увидите, что SetEventSink вызывается после успешного создания интерфейса ISensorManager и передает его в качестве входного параметра, а затем локальный класс CAmbientLightAwareSensorManagerEvents использует интерфейс ISensorManagerEvents.

Таким образом, в этом классе вы найдете реализацию для обработчика события ISensorManager:: OnSensorEnter, которая выглядит следующим образом:

HRESULT CAmbientLightAwareSensorManagerEvents::OnSensorEnter

                                    (ISensor* pSensor, SensorState state)

{

    HRESULT hr = S_OK;

    if (NULL != pSensor)

    {

        SENSOR_TYPE_ID idType = GUID_NULL;

        hr = pSensor->GetType(&idType);

        if (SUCCEEDED(hr))

        {

            // Здесь нас интересуют лишь сенсоры освещения

            if (IsEqualIID(idType, SENSOR_TYPE_AMBIENT_LIGHT))

            {

                hr = AddSensor(pSensor);

                if (SUCCEEDED(hr))

                {

                    if (SENSOR_STATE_READY == state)

                    {

                        hr = m_pSensorEvents->GetSensorData(pSensor);

                    }

                }

            }

        }

    }

    else

    {

        hr = E_POINTER;

    }

    return hr;

}

В этом фрагменте кода метод OnSensorEnter получает указатель на недавно подключенный сенсор и его статус. Если указатель не NULL, считывается тип сенсора с помощью метода GetType интерфейса ISensor. Поскольку мы работаем со светочувствительным приложением и интересуемся только световыми сенсорами, мы проверим, является ли недавно подключенный сенсор световым, определив его тип. Помните, что ISensorManager получает уведомление о любом типе сенсора, подключенного к ПК. Если сенсор является датчиком освещенности, тогда вы вызываете ту же вспомогательную функцию AddSensor, которую использовали в методе Initialize, устанавливая перехватчик для специфичных сенсоров. Не перепутайте с перехватчиком для ISensorManager. Последнее, что нужно сделать, – проверить, находится ли сенсор в состоянии готовности. Если да, вы просто читаете данные с сенсора и обновляете интерфейс приложения.

Но чтение данных с сенсора мы оставим для следующих статей.

За дополнительными ресурсами по платформе Windows 7 Sensor and Location обращайтесь к учебному центру на Channel 9.

Прежде, чем мы погрузится в API, я должен объяснить, что двигало нами, когда мы разрабатывали платформу Sensor and Location для Windows 7. Про местоположение я расскажу в будущих публикациях.

Почему сенсоры?

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

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

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

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

Сенсоры изнутри

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

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

Каждому сенсору требуется драйвер, обеспечивающий взаимодействие между Windows 7 и устройством. Эта интеграция достигается через драйвер User-mode Device (UMD), отмеченный на рисунке номером 2.

Для облегчения процесса написания драйвера устройства, который обеспечивает общение сенсора с Windows 7, в платформе предусмотрено расширение класса сенсоров, отмеченное номером 3. По сути, это библиотека драйвера, в которой реализован общий код, необходимый для драйверов сенсора. Хотя в сегодняшней статье мы не будем говорить об устройствах или драйверах, у нас есть два превосходных видео (Windows 7 Sensor and Location – Разработка драйверов (ч.1) и Windows 7 Sensor and Location – Разработка драйверов (ч.2)) с Гэвином Гиром (Gavin Gear), объясняющим, как написать драйвер для сенсора.

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

Одно из главных преимуществ платформы Sensor and Location в Windows 7 состоит в том, что она позволяет различным приложениям получать данные от одного и того же сенсора в одно и то же время – эта возможность обозначена номером 5. В предыдущих версиях Windows для взаимодействия с системой устройства использовали виртуальные COM-порты. Одной из проблем работы с виртуальными COM-портами было то, что они не масштабировались и не поддерживали работу с несколькими приложениями одновременно, поэтому наличие платформы, поддерживающей параллельную работу нескольких приложений, является большим преимуществом.

Последний компонент платформы – это диалог «Location and Other Sensors», который является частью панели управления Windows. Этот диалог, отмеченный номером 6, позволяет пользователям управлять настройками разрешений и другими параметрами, которыми обладают сенсоры. Ниже расположен снимок этой панели управления. Как вы видите, в настоящее время у меня установлен два сенсора – Sensor Development Kit и виртуальный датчик освещенности, при этом оба они разрешены для использования.

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

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

• Категория (Category) – набор сенсоров, определенным образом связанных между собой. Например, погодная станция могла бы измерять температуру, атмосферное давление, скорость ветра и другие сенсоры, имеющие отношение к погоде.
• Тип (Type) – определение физических явлений, которые могут измеряться, например, скорость ветра или количество света.
• Свойства (Properties) – метаданные, которые может содержать сенсор, например, дружелюбное для сенсора название. Они могут быть «только для чтения» или для «чтения-записи». Название сенсора и его серийный номер являются примеров свойств «только для чтения», а интервал опроса сенсора – пример свойства «чтения – записи».
• Типы данных (Data Types) – фактические типы данных, которые сенсор передает после измерения. Например, освещенность измеряется в люксах, которые сенсор передает в качестве переменной с плавающей точкой. Информация о местоположении включает широту и долготу, и при этом обе характеристики – переменные с плавающей точкой. Однако, как вы скоро узнаете, информация о местоположении может включать и адрес, являющийся набором из нескольких строк. Типы данных меняются от сенсора к сенсору и предполагается, что вы знаете, какие типы данных возвращает используемый тип сенсора.
• События (Events) – основной способ взаимодействия платформы Sensor and Location с приложением, благодаря которому приложение знает, что приняты новые данные или состояние сенсора изменилось.
• Состояние (State) – определение возможных рабочих состояний для сенсоров, отвечающих на вопросы: «действительно ли сенсор готов к использованию» или «активировал ли пользователь сенсор?"

Вооруженные этой информацией, мы готовы начать работу с сенсорами и погрузиться в API. Но прежде еще нужно прочитать следующую статью о платформе Sensor and Location.

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

Марк Руссинович (Mark Russinovich), технический специалист Microsoft и человек, стоящий за приложениями SysInternals и массой изменений в Windows 7, открыл день с краткого введения в работу, проделанную командой Windows Kernel, послужившей базой для следующих двух сессий. Вы можете посмотреть запись презентации Марка (время – 00:00:00 – 00:13:45) и скачать презентацию.

Арун Кишан (Arun Kishan), главный архитектор компонентов управления процессом, описал свою работу о распределении потоков и процессов, которое освобождает ядро от блокировок диспетчера потоков и дает Windows 7 возможность грамотно задействовать до 256 ядер. Арун также рассказал о новом планировании пользовательского режима в Windows 7, позволяющем быстрее переключать контекст между потоками (когда потоки запускаются в пользовательском режиме), в то же время, позволяя ядру управлять блокировками потоков и, таким образом, не терять указатели LP вне зоны контроля. Вы можете посмотреть запись презентации Аруна (время – 00:13:45 – 00:54:26) и скачать презентацию.

Последним докладчиком в открывающей части мероприятия был Ленди Вонг (Landy Wang), инженер в команде Windows Kernel. Ленди действительно разбирается в изменениях в управлении памятью Windows 7, большая работа была проделана командой для уменьшения объема памяти, заставляя операционную систему работать быстро (очень быстро). Ленди описал работу, выполненную для оптимизации рабочих наборов памяти, демистифицировал некоторые из вопросов о главном экране диспетчера задач и том, как диспетчер показывает рабочий набор памяти наряду с другой полезной информацией. Вы можете посмотреть запись презентации Ленди (время – 00:54:26 – 01:50:43) и скачать его презентацию.

После обеда мы рассмотрели программный интерфейс приложения для некоторых элементов пользовательского интерфейса Windows 7. Хайме Родригес (Jaime Rodriguez) начал вторую часть дня с доклада о панели задач Windows 7, показывая различные пути ( применяя неуправляемый и управляемый код, соответственно, используя Window API Code Pack и WPF 4) добавления функциональных возможностей панели задач к вашему приложению. Вы можете посмотреть запись презентации Хайме (время – 00:00:00 – 00:44:07).

Далее следовал мой доклад с кратким обзором библиотек Windows. Акцент был сделан только на вещах, которые вы должны помнить как разработчики, так как библиотеки иногда могут нарушить работу вашего приложения. Здесь презентация библиотеки Windows 7 и демонстрационный код. Вы можете посмотреть запись презентации (время – 00:44:07 – 01:19:05).

Моя вторая презентация в тот день была о платформе Sensor and Location в Windows 7. Мне нравится эта платформа, поскольку она дает разработчикам возможность научить их приложения реагировать на изменения в окружении компьютера. Демонстрация светового индикатора для оптимизации MSDN Reader и гоночная игра всегда заставляют аудиторию бурно реагировать. Вы можете посмотреть запись сессии (время – 01:20:04 – 02:10:43) и скачать презентацию.

Затем Майкл Онеппо (Michael Oneppo) рассказал об изменениях в графическом стеке Windows 7. Презентация Майкла очень интересная, поскольку она описывает часть программного интерфейса приложения DirectX, перенесенную в Windows 7 как часть обновления платформы для Windows Vista и обновления платформы для Windows Server 2008. Вы можете посмотреть запись выступления Майкла (время – 00:00:00 – 00:50:03) и скачать презентацию.

Заключительным докладчиком дня был Хайме, рассказавший о поддержке мультисенсорного ввода в Windows 7. Хайме разъяснил понятие мультисенсорного ввода, на примере неуправляемого API, но затем переключился на среду WPF 4.0, поддерживающую одновременные касания. Вы можете посмотреть видеозапись презентации Хайме (время 00:53:50 – 01:34:37).

Напоследок я хотел бы выразить свою признательность и поблагодарить всех, кто участвовал и помог провести Windows 7 Boot Camp. В первую очередь Хайме Родригесу, сделавшим это мероприятие возможным и помогавшего в его организации, замечательным докладчикам Марку Руссиновичу, Аруну Кишану, Ленди Вонгу, Майклу Онеппо и всей команде PDC. Увидимся на следующем PDC! Я уверен, я буду снова рассказывать о Windows …

Большинство презентаций этого дня основаны на тренировочных курсах Windows 7, доступных в учебном центре Channel 9.

Идея, лежащая в основе TestDrive-лаборатории, – познакомить разработчиков с процессом создания программ для Windows 7. Это бесплатный инструмент, который вы можете использовать всякий раз, когда не желаете устанавливать специальное программное обеспечение (за исключением ActiveX). Все что вам нужно – это Windows Live ID, несколько свободных часов и сайт Windows 7 Test Drive. Небольшие лабораторные работы со вспомогательными видеороликами дадут вам возможность исследовать особенности Windows 7 без ее установки. Попробуйте уже сегодня выполнить несколько виртуальных лабораторных работ и посмотреть несколько видеороликов, чтобы узнать, как и почему вы должны использовать Windows.

Первая версия Windows 7 Test Drive включает большинство тем из Windows 7 Training Kit, однако содержит не все лабораторные работы. К примеру, Test Drive включает в себя следующие темы:

• Панель задач (без миниатюр)
• Библиотеки
• Контроль версии
• Проверка версии
• Платформа устранения неполадок
• Ленточный интерфейс
• Платформа Sensor and Location
• IE8

Этот ресурс наряду с тренировочными курсами по Windows 7 в учебном центре Channel 9 является отличным источником информации для разработчиков.

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

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

Отличным примером является панель миниатюр Windows Media Player, показанная ниже. Если подвести указатель мыши к иконке Media Player, когда приложение запущено, вы увидите три кнопки на дисплее: Play/Pause, Next и Previous. Нажатие на каждую кнопку выполнит соответствующую команду.

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

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

• Можно отобразить до семи кнопок с фиксированным размером в 16x16 пикселей (или в 24x14 пикселей для высокого DPI);
• Можно назначить кнопку панели миниатюр для каждого активного окна в приложении (это значит, что в приложении имеется несколько окон, собранных вместе, и вы желаете использовать разные панели миниатюр для каждого из них);
• Как только кнопки назначены (как правило, к моменту, когда создана иконка в панели задач), вы более не можете добавлять или удалять кнопки из панели миниатюр; однако, при желании, можно кнопки скрыть.

Как обычно, начнем с реализации в неуправляемом коде (Win32). Данный пример вы найдете в Windows 7 SDK.

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

• ThumbBarAddButtons – добавляет панель миниатюр (панель, встроенная в миниатюру окна в панели задач) с указанным набором кнопок к изображению миниатюры окна на панели задач.
• ThumbBarSetImageList – определяет список изображений, который содержит изображения кнопок для панели задач, встроенной в изображение окна на панели задач.
• ThumbBarUpdateButtons – отображает, включает, отключает или скрывает кнопки в панели миниатюр в зависимости от текущего состоянием окна.

Как в случае с любой иной операцией, предполагающей взаимодействие с иконкой, вы должны убедиться, что у вас есть иконка панели задач; для этого необходимо зарегистрировать "TaskbarCreatedMessage" с помощью метода RegisterWindowMessage. Затем нужно дождаться сообщения для метода WndProc. Как только приложение получит это сообщение, вы можете без опаски идти вперед и создавать кнопки панели миниатюр. Этот же метод WndProc будет получать сообщение WM_COMMAND при нажатии любой из кнопок панели миниатюр, которые вы создали. Младшее слово параметра wParam содержит абсолютный идентификатор кнопки, определяющий, какая именно кнопка была нажата, в то время как старшее слово установлено в THBN_CLICKED. Следующий фрагмент кода иллюстрирует этот процесс:

LRESULT CALLBACK WndProc(

                    HWND hWnd, UINT message,

                    WPARAM wParam, LPARAM lParam)

{

    static UINT s_uTBBC = WM_NULL;


    if (s_uTBBC == WM_NULL)

    {

        // Вычисляем значение для сообщения TaskbarButtonCreated

        s_uTBBC = RegisterWindowMessage(L"TaskbarButtonCreated");


        // Если приложение запущено с привилегиями администратора, разрешаем

        // TaskbarButtonCreated and WM_COMMAND messages through.

        ChangeWindowMessageFilter(s_uTBBC, MSGFLT_ADD);

        ChangeWindowMessageFilter(WM_COMMAND, MSGFLT_ADD);

    }


    if (message == s_uTBBC) //wmTaskbarButtonCreated)

    {

        // Как только получено сообщение TaskbarButtonCreated, мы можем создать

        // панель миниатюр для окна.

        CreateThumbnailToolbar(hWnd);

    }

    else switch (message)

    {

        case WM_COMMAND:

        {

            int const wmId = LOWORD(wParam);

            switch (wmId)

            {

                case IDTB_BUTTON1:

                case IDTB_BUTTON2:

                case IDTB_BUTTON3:

                {

                    WCHAR szMsg[100];

                    StringCchPrintf(

                            szMsg, ARRAYSIZE(szMsg),

                            L"Thumbnail toolbar button clicked,

                            ID=%d", wmId);


                    MessageBox(hWnd, szMsg, L"Application", MB_OK);

                    break;

                }

                case IDM_EXIT:

                    DestroyWindow(hWnd);

                    break;


                default:

                    return DefWindowProc(hWnd, message, wParam, lParam);

            }

            break;

        }

        case WM_DESTROY:

            PostQuitMessage(0);

            break;

        default:

            return DefWindowProc(hWnd, message, wParam, lParam);

    }

    return 0;

}

Обратите внимание, что сразу после регистрации на получение сообщения TaskbarCreatedMessage, вызывается метод ChangeWindowMessageFilter. Этот метод добавляет или удаляет сообщение из фильтра сообщений User Interface Privilege Isolation (UIPI). Это следует делать в том случае, если приложение выполняется с повышенными привилегиями. Одним словом, панель задач является частью процесса explorer.exe, которая выполняется при среднем уровне целостности, то есть от имени стандартного пользователя. Начиная с Windows Vista и включения в ее состав UIPI, приложения с более низким уровнем привилегий не смогут посылать сообщения Windows-приложениям более высокого уровня. Поэтому вы должны изменить фильтр, чтобы разрешить получение определенного типа сообщений от отправителей с более низким уровнем привилегий, в частности, речь идет о результатах TaskbarCreatedMessage и WM_COMMAND. Но это, пожалуй, послужит темой для отдельной статье об UIPI.

Возвращаясь к нашей теме, можно видеть, что WM_COMMAND обрабатывается очень простым способом, извлекая определенный идентификатор кнопки из младшего слова параметра wParam. На самом деле, с ним мы ничего не делаем (переключатель – один и тот же для всех кнопок); это всего лишь пример.

Теперь поговорим о том, как зарегистрировать панель миниатюр. В вышеприведенном фрагменте кода мы вызываем вспомогательный метод CreateThumbnailToolbar. Фрагмент кода будет выглядеть так:

HRESULT CreateThumbnailToolbar(HWND hWnd)

{

    ITaskbarList4 *pTaskbarList;

    HRESULT hr = CoCreateInstance(

                    CLSID_TaskbarList,

                    NULL,

                    CLSCTX_INPROC_SERVER,

                    IID_PPV_ARGS(&pTaskbarList));


    if (SUCCEEDED(hr))

    {

        hr = pTaskbarList->HrInit();

        if (SUCCEEDED(hr))

        {

            // Определяем, какое изображение использовать

            // для кнопок панели миниатюр – наше решение

            // основано на минимальном системном размере иконки.

            // Это позволит сделать их дружелюбными к DPI.

            struct

            {

                PCWSTR pbmp;

                int cx;

            }

            const bitmaps[3] =

            {

                { MAKEINTRESOURCE(IDB_BUTTONIMAGES_96),  16 },

                { MAKEINTRESOURCE(IDB_BUTTONIMAGES_120), 20 },

                { MAKEINTRESOURCE(IDB_BUTTONIMAGES_144), 24 }

            };


            int const cxButton = GetSystemMetrics(SM_CXSMICON);


            int iButtons = 0;

            for (int i = 0; i < ARRAYSIZE(bitmaps); i++)

            {

                if (bitmaps[i].cx <= cxButton)

                {

                    iButtons = i;

                }

            }


            HIMAGELIST himl = ImageList_LoadImage(

                    g_hInstance,

                    bitmaps[iButtons].pbmp,

                    bitmaps[iButtons].cx,

                    0,

                    RGB(255,0,255),

                    IMAGE_BITMAP,

                    LR_CREATEDIBSECTION);


            if (himl)

            {

                hr = pTaskbarList->ThumbBarSetImageList(hWnd, himl);

                if (SUCCEEDED(hr))

                {

                    THUMBBUTTON buttons[3] = {};


                    // Первая кнопка

                    buttons[0].dwMask = THB_BITMAP | THB_TOOLTIP | THB_FLAGS;

                    buttons[0].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;

                    buttons[0].iId = IDTB_BUTTON1;

                    buttons[0].iBitmap = 0;

                    StringCchCopy(buttons[0].szTip,

                                    ARRAYSIZE(buttons[0].szTip), L"Button 1");


                    // Вторая кнопка

                    buttons[1].dwMask = THB_BITMAP | THB_TOOLTIP | THB_FLAGS;

                    buttons[1].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;

                    buttons[1].iId = IDTB_BUTTON2;

                    buttons[1].iBitmap = 1;

                    StringCchCopy(buttons[1].szTip,

                                    ARRAYSIZE(buttons[1].szTip), L"Button 2");


                    // Третья кнопка

                    buttons[2].dwMask = THB_BITMAP | THB_TOOLTIP | THB_FLAGS;

                    buttons[2].dwFlags = THBF_ENABLED | THBF_DISMISSONCLICK;

                    buttons[2].iId = IDTB_BUTTON3;

                    buttons[2].iBitmap = 2;

                    StringCchCopy(buttons[2].szTip,

                                    ARRAYSIZE(buttons[2].szTip), L"Button 3");


                    // Размещаем кнопки на панели миниатюр

                    hr = pTaskbarList->ThumbBarAddButtons(

                                            hWnd,

                                            ARRAYSIZE(buttons),

                                            buttons);

                }

                ImageList_Destroy(himl);

            }

        }

                pTaskbarList->Release();

    }

    return hr;

}

Во-первых, необходимо создать COM-интерфейс ITasbarList4. Затем следует вызвать HrInit для инициализации объекта списка Taskbar. Этот метод должен быть вызван перед любыми другими вызываемыми методами ITaskbarList. Далее выбираем список изображений, с которым будем работать. Обратите внимание, что необходимо проверить ширину (в пикселях) маленькой иконки на соответствие рекомендуемому: настройки DPI могут изменить ее. И наконец, вызываем ThumbBarSetImageList, чтобы назначить иконки кнопкам. После загрузки исходного кода попытайтесь закомментировать эту строку и запустить приложение. Как вы думаете, что произойдет?

Далее, мы создаем массив из трех кнопок THUMBBUTTON и для каждой устанавливаем растровое изображение, всплывающую подсказку и флаги. Они используются для настройки кнопки панели миниатюр. Например, значение Bitmap указывает, что значение поля iBitmap (часть THUMBBUTTON) доступно. THB_FLAGS более интересен, поскольку его можно использовать для определения состояния и поведения кнопки – включена, выключена или скрыта. В SDK вы можете найти дополнительную информацию по теме. Мы также устанавливаем ID кнопки для того, чтобы различать нажатия на разные кнопки; этот идентификатор отправляется с сообщением WM_COMMAND.

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

Вы можете использовать Windows API Code Pack, чтобы создать панели миниатюр для приложения на управляемом коде. Собственно, об этом подробно рассказано в Windows 7 Training Kit, который доступен в учебном центре Channel 9. Демо-приложение, созданное Хайме Родригесом (Jaime Rodriguez), является WPF-приложением, которое демонстрирует все мельчайшие особенности новой панели задач. Мы лишь изучим лишь часть, касаемую панели миниатюр, остальное оставим для вашего самостоятельного изучения. Время от времени мы будем использовать это как основу для наших примеров на управляемом коде.

Как всегда, используя Windows API Code Pack, вам не стоит переживать о регистрации или обработке любых сообщений Windows. Только используйте TaskbarManager. В частности, если вы хотите работать с ThumbnailToolbars, который содержит метод AddButtons, который необходим для добавления объектов ThumbnailToolbarButton. ThumbnailToolbarButton представляет кнопку миниатюры панели задач, через которую вы можете включить или отключить кнопку панели задач, изменить ее значок или подсказку, и управлять ее видимостью. Вы можете также прикрепить обработчик событий к событию кнопки Click, что вполне соответствует ожиданиям разработчиков управляемого кода. Вы можете найти следующий фрагмент кода в файле ToolbarButtons.xaml.cs. Он показывает, насколько просто добавить панель миниатюр в приложение на управляемом коде:

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

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

Теперь попытаюсь объяснить, почему в панели миниатюр приложения Fishbowl шесть кнопок, а не пять (см. изображение выше). Если вы внимательно посмотрите на изображение, то обратите внимание, что четыре левых кнопки непосредственно влияют на поведение приложения, а единственная правая кнопка просто запускает браузер по умолчанию и автоматически загружает сайт Facebook. Поэтому имеет смысл использовать графический разграничитель между двумя наборами кнопок. Приложение создает шесть кнопок, но пятая кнопка скрыта, что создает иллюзию разделения кнопок. В Win32-приложениях для этого следует использовать ThumbBarUpdateButtons.

Разработчик управляемого кода увидит, что для сокрытия кнопки гораздо проще использовать ThubmnailButton. Тщательно изучив Windows API Code Pack, вы обнаружите, что класс ThubmnailButton имеет свойство Visible для управления видимостью конкретной кнопки панели. В конце раздела Visible Set вы найдете функцию UpdateThumbnailButton(), которая является оберткой для неуправляемого метода ThumbBarUpdateButtons.

Загрузить пример на неуправляемом коде (Win32) >>>

Загрузить пример на управляемом коде (WPF) >>>

Обучающие материалы по разработке для панели задач Windows 7 вы можете найти в учебном центре Channel 9.

И хотя Windows 7 является превосходной операционной системой, более быстрой и менее требовательной к ресурсам, чем ее предшественница, в ней присутствует целый ряд новых функций и возможностей, которыми могут насладиться и пользователи, и разработчики. Новая панель задач, платформы Sensor and Location, библиотеки, мультисенсорный ввод, новые возможности DirectX и визуальные улучшения – это лишь некоторые из технологий и функций Windows 7, которые новая ОС дает разработчикам, чтобы те могли заставить свои приложения сиять в Windows 7.

Список приложений, которые используют различные технологии Windows 7, слишком велик, чтобы все их перечислить, но есть ряд популярных приложений, которые мы продемонстрировали в ходе PDC: iTunes, Kindle, Autodesk Project Cooper и Seesmic Desktop.

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

• Fishbowl for Facebook является отличным примером поразительных возможностей новой панели задач (видео 00:05:02 – 00:07:41);
• Photo View (AKA XP2Win7) является другим примером приложения, демонстрирующего большое количество новых функций Windows 7;
• Kindle for PC представляет собой Windows-версию Amazon Kindle, которую вы сможете загрузить сегодня. В частности, я показал интеграцию с панелью задач и поддержку мультисенсорного ввода.

Теперь углубимся в примеры использования Windows API Code Pack. Для каждого приложения я включил программный код:

• Jump Lists Demo – простое WinForm-приложение, демонстрирующее основные возможности использования Taskbar API и, в частности, списках переходов (00:26:30 – 00:34:27);
• Zoobar (часть 1 и часть 2) – немного более функциональное WPF-приложение, которое демонстрирует, как панель задач может быть использована для того чтобы показывать больше окон и документов. Это приложение использует ряд таких элементов управления панели задач, как например многослойный иконки, прогресс-бары, миниатюры и.т.д (00:35:15 – 00:40:50);
• Library Manager – один из примеров, используемых в тренировочном курсе Windows 7. В нем продемонстрированы все API-методы, которые Windows Shell API использует для работы с библиотеками (00:43:04 – 00:42:27);
• MSDN Reader – WPF-приложение, которое использует датчик освещенности для управления отображением информации. MSDN Reader показывает статьи из MSDN, в основном текст с рисунками. Когда используется датчик освещения, приложение может менять размер шрифта и контрастность для улучшения читаемости текста (00:50:14 – 00:51:36);
• Racing Game – отличная XNA-игра, в которой вы с помощью акселлерометра, измеряющего силу тяжести и определяющего положение устройство по отношению к земле, можете управлять красной машинкой. Пример весьма прост и показателен (00:51:55 – 00:57:15);
• Сессия вопросов и ответов (01:00:24 – 01:07:32)

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

Дополнительную информацию о вышеупомянутых технологиях и разработке под Windows 7 вы можете почерпнуть из Windows 7 Training Kit или видео на канале Channel 9.

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

И демо-приложение на Silverlight 4, и Fishbowl имеют прекрасных механизм взаимодействия с пользователем и увеличивают производительность. Скотт Гатри (Scott Guthrie) также анонсировал Facebook SDK для приложений на управляемом коде, сочетающий в себе последние инновации в веб- и клиентской платформах с ведущими социальными технологиями (службами) с целью помочь разработчикам влиться в Facebook. Кроме того, что Fishbowl является примером использования Facebook SDK и обладает удобным интерфейсом, приложение является отличным примером использования WPF (версии 3.5), который показывает, как нужно создавать приложения, блистающие в Windows 7.

И как любое WPF-приложение, Fishbowl работает на нескольких версиях Windows, включая Windows XP, Windows Vista и Windows 7, при этом оно интегрируется в панель задач Windows 7 и поддерживает технологию мультисенсорного ввода. Одной из идей, лежащих в основе новой панели задач, является предоставление пользователям быстрого и простого доступа к контенту, помощь в выполнении задач и быстром перемещении между открытыми окнами. Так, к примеру, списки переходов являются отличным инструментом для решения рабочих вопросов и задач. Если у вас есть задача, которая выполняется один или два раза в день, с помощью двух-трех щелчков, ничего страшного. Однако если у вас есть задачи, которые приходится выполнять 10, 20 или даже более раз в день, списки переходов сэкономят массу времени. Пользователи Facebook часто проверяют свои доски, пишут сообщения, просматривают картинки друзей и так далее. Поэтому в некоторых сценариях списки переходов, значки уведомлений, миниатюры и другие функциональные возможности становятся основными инструментами в приложении.

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

Панель задач Fishbowl позволяет выполнить несколько задач еще до запуска приложения. Вы можете перейти на страницу Facebook.com или сразу прыгнуть к своей доске, просмотреть фотографии друга и многое другое, как показано на следующем изображении:

Одной из удивительных возможностей Fishbowl для Facebook является то, что функциональность изменяется в зависимости от различных режимов приложения. Возможность по-разному использовать панель задач в различных сценариях открывает совершенно новые горизонты.

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

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

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

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

Мы рассмотрели большинство уникальных возможностей Fishbowl для Windows 7, а в следующей статье мы поговорим об API, которые позволили реализовать мультисенсорный интерфейс. Если вас заинтересовало приложение, вы можете загрузить исходные коды для Fishbowl отсюда.