Текст книги "Программирование мобильных устройств на платформе .NET Compact Framework"
Автор книги: Иво Салмре
Жанр:
Программирование
сообщить о нарушении
Текущая страница: 56 (всего у книги 69 страниц)
Под связью посредством лотка понимается либо непосредственная, либо сквозная передача данных в сеть через промежуточный компьютер, когда устройство подключено к этому компьютеру с помощью физического кабеля. Вместо установления соединения непосредственно с сетью мобильное устройство связывается с настольным компьютером или лэптопом. Устройство либо синхронизирует данные с компьютером, либо использует его в качестве средства, обеспечивающего доступ к сети. Примечание. Возможность доступа к сети через хост-компьютер должна поддерживаться программным обеспечением, при помощи которого осуществляется синхронизация данных; так, начиная с Pocket PC 2002, различные версии программного обеспечения ActiveSync компании Microsoft поддерживают туннелированный доступ устройств к Internet через настольные компьютеры. В разных технологиях работы с устройствами подобная поддержка "сквозного" доступа в сеть будет обеспечиваться разным программным обеспечением.
Преимуществом связи посредством лотка является ее относительная простота. Часто все необходимое для этого программное обеспечение и кабели уже имеются у владельцев соответствующих мобильных устройств, а владельцы компьютеров тоже, как правило, сразу же заботятся о подключении их к сети Internet. Связь через лоток особенно удобно использовать в интересах прототипирования, тестирования и отладки приложения, поскольку она обеспечивает легкий доступ к сетевым устройствам в контролируемом окружении. Кроме того, связь через лоток не является дорогой, поскольку она не зависит ни от какой другой инфраструктуры сетевого доступа кроме тех, которые уже имеются на лэптопах и настольных компьютерах.
Основным недостатком обмена данными через лоток является то, что устройство оказывается привязанным к компьютеру, который поддерживает необходимое для синхронизации данных программное обеспечение. Решение, основанное на использовании определенного набора хост-компьютеров, неспособно обеспечить доступ к данным в соответствии с принципом "связь в любое время и в любом месте". Вместе с тем, если мобильному приложению, которое вы разрабатываете, требуется не доступ к сети в любой момент, а лишь периодическая синхронизация данных, которая может быть выполнена через сетевое соединение ПК, то коммуникационная модель, использующая связь через ПК, вам вполне подойдет. Как и в случае доступа к сети Wi-Fi, связь посредством лотка может быть использована для реализации других коммуникационных механизмов; например, при работе на выезде для передачи и получения небольших объемов данных можно использовать сети мобильной телефонной связи, тогда как крупные объемы данных можно кэшировать на устройстве для последующей их синхронизации через ПК, подключенный к сети.
Сетевой кабельИспользование кабеля Ethernet для связи мобильных устройств с сетями очень похоже на использование с этой целью сети Wi-Fi. Будучи в основном схожими между собой, эти две коммуникационные модели отличаются друг от друга в следующем:
■ Сетевые кабели привязывают вас к определенному месту в большей степени, чем сеть Wi-Fi. Диаметр зоны связи вокруг базовой станции Wi-Fi составляет несколько сотен футов, что значительно превышает приемлемую для большинства случаев длину кабеля; в этом смысле Wi-Fi предоставляет более "мобильную" форму доступа. нежели сетевой кабель. Что касается практической стороны дела, то в тех случаях, когда требуется гибкий сетевой доступ в пределах ограниченной территории, например, внутри одного здания, чаще дешевле использовать Wi-Fi, чем прокладывать кабельную проводку по всему зданию. С другой стороны, наличие сетевого кабеля гарантирует возможность постоянного доступа к сети; в тех местах, куда не доходит сигнал Wi-Fi, сетевой кабель может оказаться единственно возможным выходом.
■ Сетевые кабели обладают определенными преимуществами в отношении защиты информации по сравнению с Wi-Fi. Несмотря на то что сети Wi-Fi могут быть сконфигурированы для передачи данных по шифрованным каналам, они в любой ситуации будут оставаться широковещательными радиоканалами. Сценарий, предполагающий использование кабелей, способен защитить от прослушивания радиосигналов; эту защиту нельзя считать "пуленепробиваемой", но все же – это дополнительный уровень повышения безопасности. Примечание. Если вы устанавливаете соединение с общедоступной сетью или через нее, то этот дополнительный уровень безопасности обеспечивает лишь минимальную защиту; чтобы надежно защитить свои данные, вам придется прибегнуть к шифрованию. (Придерживаться этой рекомендации не помешает в любой ситуации.)
■ Для кабельного подключения к сети может потребоваться дополнительное оборудование. В то время как для большинства современных настольных компьютеров предусмотрены встроенные возможности как проводного, так и беспроводного подключения к сети, для большинства мобильных устройств это не так. Вследствие увеличения размеров, энергопотребления и стоимости изготовления соответствующего оборудования эта ситуация, по-видимому, еще просуществует какое-то время. Для поддержки кабельного сетевого подключения вам может понадобиться дополнительная внешняя карта (обычно Compact Flash или Secure Digital).
Как и в случае связи через лоток, подключение к сети посредством физического кабеля может оказаться очень полезным при прототипировании и отладке решений для мобильных устройств. В то же время, вы должны отчетливо понимать, что при использовании многих беспроводных коммуникационных механизмов скорость подключения и характеристики надежности будут намного ниже; и хотя кабельные сетевые соединения являются полезным средством, одного его недостаточно для разработки и тестирования приложений, которые будут выполняться в беспроводных сетях.
IrDAС точки зрения абстракций низкого уровня IrDA (Infrared Data Association – Ассоциация по передаче данных через инфракрасные каналы) – это просто стандарт последовательной передачи данных по инфракрасному каналу; в рамках программных моделей более высокого уровня абстракции это понятие приобретает значительно более широкий смысл. Поверх IrDA была построена сложная многоканальная программная модель, и эту модель можно с успехом применять в качестве гибкого средства передачи данных (более подробные сведения по этому вопросу вы найдете по адресу: www.irda.org).
В силу своей дешевизны и необычайно широкой распространенности технология IrDA отлично подходит для организации связи между равноправными устройствами. Поскольку стоимость изготовления оборудования для IrDA невелика, оно имеет небольшие размеры и потребляет мало электроэнергии, оно интегрируется во многие мобильные устройства, включая устройства Pocket PC и смартфоны. Для осуществления передачи данных два устройства должны быть физически сориентированы друг относительно друга определенным образом, после чего между ними может быть установлена связь.
С точки зрения разработки мобильного приложения IrDA представляет интерес по двум причинам. Во-первых, как и Bluetooth, IrDA можно использовать для того, чтобы обеспечить возможность обмена данными между мобильным устройством с внешними сетями через другое устройство. Например, мое устройство PDA может связаться с источником данных посредством мобильного телефона; возможности такой опосредованной связи несколько ограничиваются тем фактом, что в процессе передачи данных устройства должны быть определенным образом физически ориентированы друг относительно друга – ограничение, отсутствующее в Bluetooth. Во-вторых, – и, пожалуй, это представляет даже больший интерес, – IrDA может привлекаться для организации совместного использования информации двумя различным устройствами; классическим примером этого может служить "переброска" ("beaming"), или "перекачка" ("squirting"), записи адресной книги с одного мобильного устройства на другое. Поскольку IrDA обеспечивает вполне приличную пропускную способность, с одного устройства на другое может быть "перекачано" довольно много информации.
Соединение равноправных узлов сети посредством IrDA
Сетям с соединениями равноправных узлов предшествовали сети с двухточечными соединениями, и это – парафия IrDA. Передача данных на основе IrDA предоставляет в наше распоряжение простой и относительно широкополосный механизм обмена данными между находящимися рядом с другом устройствами. Несмотря на отсутствие того "блеска новизны", который свойствен таким технологиям персональных сетей, как Bluetooth, у IrDA имеются и свои достоинства – она апробирована, тестирована и проста в использовании. Если ваши пользователи не имеют ничего против установки двух устройств друг напротив друга, то IrDA прекрасно подойдет для удовлетворения нужд вашего приложения, связанных с сетевыми технологиями, основанными на соединении равноправных узлов.
IrDA – это зрелая технология, которая часто остается незамеченной и незаслуженно мало используется разработчиками приложений. По моему мнению, это можно объяснить тем, что многие просто не знают, насколько простой в применении и гибкой является эта технология на самом деле. В .NET Compact Framework возможности программирования IrDA предоставляются посредством интерфейса сокетов, аналогичного тому, который используется при передаче данных посредством сервиса TCP/IP (Internet). Основное, что отличает использование сокетов в Internet-технологиях от использования сокетов в IrDA, – это понятие "именованного порта" ("named port").
Когда используются стек протоколов TCP/IP и сокеты, каждой машине назначаются собственный IP-адрес (например, 200.198.126.81) и номера портов, которые разрешается использовать для связи. Серверы открывают порты, которые они хотят прослушивать для получения запросов. Клиентское устройство может запросить связь с сервером путем указания IP-адреса машины и номера порта, к которому необходимо подключиться. В случае связи посредством двухточечных соединений технологии IrDA порт IrDA одного из устройств ориентируется в сторону другого устройства, в связи с чем отпадает необходимость в использовании схем адресации для установления местонахождения сервера. Если приложение желает предоставить интерфейс сокета IrDA для передачи контактной информации о своем владельце, оно может открыть сокет IrDA, которому присвоено имя OwnerContactInfo. Аналогичным образом, если приложение, играющее роль фотоальбома, должно обеспечивать возможность загрузки фотографий другими приложениями, оно может открыть сокет IrDA с именем PhotoDownloadService. Клиентские приложения на других устройствах, желающие подключиться к этим службам, запрашивают их по именам.
Сеанс связи между Web-браузером и сервером осуществляется примерно таким образом:
1. Сервер: открывает порт 80 для прослушивания поступающих запросов.
2. Браузер: "Привет, сервер номер 200.198.126.81. Я могу подключиться к порту 80?"
3. Сервер: "Да, можешь. Предлагаю соединение с портом, которое можно использовать для передачи данных."
4. Браузер: использует предложенное соединение и начинает обмен данными, в результате чего загружается несколько файлов
Аналогичный сеанс связи с использованием сокетов поверх IrDA осуществлялся бы примерно таким образом:
1. Принимающее устройство: создает именованный порт ReceiveAppXYZData.
2. Передающее устройство. "Привет, я хотело бы установить соединение с устройством, прослушивающим порт ReceiveAppXYZData."
3. Принимающее устройство: "Да, я прослушиваю этот порт. Давай установим соединение."
4. Передающее устройство: использует предоставленное соединение и начинает общение, в результате чего осуществляется передача данных.
Связь с использованием сокетов посредством IrDA является простым и эффективным способом обмена информацией, если два устройства физически располагаются рядом друг с другом.
Сокеты IrDA и .NET Compact Framework
Как ранее уже отмечалось, .NET Compact Framework предлагает интерфейс сокета для работы с IrDA Если вы знакомы с использованием сокетов для работы с сетью Internet (TCP/IP), то для того, чтобы использовать их для работы через IrDA, вам остается усвоить лишь несколько незначительных отличий. Использование сокетов IrDA для передачи данных между двумя устройствами иллюстрирует приведенный ниже код.
В настоящее время поддержка сокетов .NET для IrDA доступна лишь в .NET Compact Framework, тогда как в .NET Framework для настольных компьютеров она отсутствует
В версии 1.1 NET Compact Framework обеспечивается встроенная поддержка IrDA, но в версии 1.1 .NET Framework для настольных компьютеров она отсутствует. Это именно тот случай, когда путь к введению технологии, представляющей интерес для мобильных устройств, был проложен .NET Compact Framework. Возможно, будущие версии .NET Framework для настольных компьютеров обеспечат поддержку программирования сокетов IrDA, но до тех пор, пока это не произойдет, если вам понадобится связать между собой настольные компьютеры и .NET Compact Framework, то для доступа к функциональным возможностям IrDA на настольных компьютерах вам придется использовать вызовы функций в собственных кодах. В качестве положительного фактора можно отметить то обстоятельство, что такой собственный код для настольных компьютеров не будет слишком сложным, поскольку имеющиеся в Windows API-интерфейсы для работы с сокетами в собственных кодах поддерживают использование IrDA, причем код на С/С++ будет выглядеть примерно так же, как и коды на C# или VB.NET, которые вы использовали бы для устройства. Для более подробного изучения этого вопроса вам следует обратиться к разделам "IrDA Programming with Windows sockets" и "IrDA and Windows sockets reference" справочной документации Windows Platform SDK.
В приведенном в листингах 15.3, 15.4 и 15.6 коде показано, как организовать передачу содержимого файла с одного устройства на другое, используя IrDA. Для создания и запуска приложения необходимо выполнить следующие действия:
1. Запустите Visual Studio .NET (2003 или более позднюю версию) и выберите в качестве типа приложения C# Smart Device Application.
2. Выберите в качестве целевой платформы Pocket PC. (Для вас будет автоматически создан проект, и на экране появится окно конструктора форм Pocket PC.)
3. Добавьте в проект ссылку на System.NET.IrDA. По умолчанию ссылка на динамическую библиотеку System.NET.IrDA.DLL не включается в проект, поэтому ее необходимо добавить явно, чтобы соответствующее пространство имен стало доступным для вашего приложения.
Примечание. Библиотека System.NET.IrDA.DLL входит в основную часть .NET Compact Framework и присутствует на любом устройстве с установленной платформой .NET Compact Framework, только и того, что она не включается по умолчанию в проекты Visual .NET для устройств.
4. Добавьте в форму следующие элементы управления
а) кнопку; переименуйте ее в buttonTestFileSend.
б) кнопку; переименуйте ее в buttonTestFileReceive.
5. Выполните по отношению к каждой из вышеупомянутых кнопок следующие действия. Дважды щелкните на кнопке в окне конструктора форм. Включите в сгенерированную функцию обработчика событий код button<ИмяКнопки>_Click из листинга 15.3.Примечание. Не забудьте включить также остальную часть кода из листинга 15.3, не входящую в определения обеих указанных функций
6. Установите для свойства MinimizeBox формы значение false. Благодаря этому во время выполнения в верхней правой части формы появится кнопка OK, с помощью которой вы легко сможете закрыть форму и выйти из приложения. Эта возможность оказывается очень полезной при многократном тестировании приложения.
7. Добавьте в проект новый класс, присвойте ему имя IrDAFileSend и введите в новый класс код из листинга 15.4.
8. Добавьте в проект новый класс, присвойте ему имя IrDAFileReceive и введите в новый класс код из листинга 15.5.
9. Разверните и запустите приложение на двух различных устройствах Pocket PC (или смартфонах).
10. Щелкните на первом устройстве Pocket PC на кнопке TestFileReceive. Вы должны увидеть в заголовке окна приложения текст, говорящий о том, что ожидается поступление файла.
11. Щелкните на втором устройстве Pocket PC на кнопке TestFileSend. Вы должны увидеть в заголовке окна приложения текст, говорящий о том, что ожидается устройство, которому следует переслать файл.
12. Направьте IrDA-порты двух устройств друг на друга. Файл должен передаться с одного устройства на другое, а на обоих устройствах должны отобразиться окна сообщений, тексты которых указывают на успешное завершение передачи данных.
Результат: файл, находящийся на втором устройстве Pocket PC, передается на первое устройство. Чтобы это проверить, запустите на Pocket PC приложение File Explorer, перейдите в корневой каталог My Device и щелкните на имени файла myTestReceiveFile; это приведет к открытию и отображению файла в приложении PocketWord. После успешного тестирования приложения в синхронном режиме, попробуйте вызвать функции IrDA, обеспечивающие передачу и прием файла в асинхронном режиме. Вам придется написать код для потоков пользовательского интерфейса обоих устройств, который будет периодически опрашивать состояние классов IrDAFileSend или IrDAFileReceive, чтобы определить момент завершения пересылки файла.
В настоящее время код, использующий сокеты IrDA .NET Compact Framework, будет выполняться на таких физических устройствах, оборудованных аппаратурой IrDA, как Pocket PC и смартфоны, но не будет правильно выполняться на эмуляторах
Если вы попытаетесь создать сокет IrDA или соединиться с ним при помощи кода, выполняющегося на эмуляторах Pocket PC, смартфона или Windows СЕ, то, вероятнее всего, в процессе выполнения вашего приложения сгенерируется исключение. Это означает, что, в отличие от большинства других средств .NET Compact Framework, проектировать и тестировать код для IrDA следует с использованием реального физического устройства. Хотя эта трудность и не является непреодолимой, процесс проектирования и тестирования приложения из-за этого усложняется, поскольку для тестирования кода, обеспечивающего работу с IrDA, вам потребуется два физических устройства, одно из которых действует в качестве IrDA-сервера, а второе – IrDA-клиента. Вследствие этой дополнительной сложности код для обмена данными через IrDA рекомендуется писать и тестировать отдельно от остальной части приложения с использованием максимально упрощенной модели приложения, чтобы исключить любые возможные просчеты в организации процесса передачи данных. После устранения всех возможных неполадок из кода, обеспечивающего работу с IrDA, его можно будет перенести в полную версию приложения.
Листинг 15.3. Тестовый код, который необходимо поместить в класс формы для тестирования передачи и приема данных посредством механизма IrDA
//Имя, которое мы хотим присвоить сокету IrDA
const string myIrDASocketName = "IrDaTestFileTransmit";
private void buttonTestFileSend_Click(object sender, System.EventArgs e) {
//Создать простой текстовый файл, который мы хотим передать
const string fileName = "\myTestSendFile.txt";
System.IO.StreamWriter textFileStream;
textFileStream = System.IO.File.CreateText(fileName);
textFileStream.WriteLine("Today...");
textFileStream.WriteLine("is а nice day");
textFileStream.WriteLine("to go swim");
textFileStream.WriteLine("in the lake");
textFileStream.Close(); IrDAFileSend irdaFileSend;
irdaFileSend = new IrDAFileSend(fileName, myIrDASocketName);
//Имеется 2 режима: 1 – Sync (синхронный), 2 – Async (асинхронный)
//1. Вызвать функцию в синхронном режиме
//и блокировать поток выполнения до тех пор,
//пока файл не будет передан
//1a. Вызвать функцию в синхронном режиме
//и блокировать поток выполнения до тех пор,
//пока файл не будет передан
this.Text = "Trying to send...";
//1b. Подождать, пока клиент не будет найден, а затем передать файл
irdaFileSend.LoopAndAttemptIRSend();
//1c. Информировать пользователя о том, что файл передан
System.Windows.Forms.MessageBox.Show("File sent!");
this.Text = "IrDA: Sent!";
//2. Вызвать функцию в асинхронном режиме и поручить
//передачу файла фоновому потоку
//irdaFileSend.LoopAndAttemptIRSendAsync();
//ПРИМЕЧАНИЕ: Если мы вызываем функцию в асинхронном режиме, то должны
//периодически проверять, не завершила ли она выполнение, путем
//вызова метода 'irdaFileSend.Status'
}
private void buttonTestFileReceive_Click(object sender, System.EventArgs e) {
//Если файл назначения уже существует, уничтожить его
const string fileName = "\myTestReceiveFile.txt";
if (System.IO.File.Exists(fileName)) {
System.IO.File.Delete(fileName);
}
IrDAFileReceive irdaFileReceive;
irdaFileReceive = new IrDAFileReceive(fileName, myIrDASocketName);
//Имеется 2 режима: 1 – Sync (синхронный), 2 – Async (асинхронный)
//1. Вызвать функцию в синхронном режиме
//и блокировать поток выполнения до тех пор,
//пока файл не будет получен
//1a. Информировать пользователя о том, что мы ожидаем получения файла
this.Text = "Waiting to receive...";
//1b. Ожидать, пока не будет сделана попытка установления с нами связи
//и передачи файла
irdaFileReceive.WaitForIRFileDownload();
//1c. Информировать пользователя о том, что мы получили переданный файл
this.Text = "IrDA: received!";
System.Windows.Forms.MessageBox.Show("File received!");
//2. Вызвать функцию в асинхронном режиме и поручить
//получение файла фоновому потоку
//irdaFileReceive.WaitForIRFileDownloadAsync();
//ПРИМЕЧАНИЕ: Если мы вызываем функцию в асинхронном режиме, то должны
//периодически проверять, не завершила ли она выполнение, путем
//вызова метода 'irdaFileReceive.Status'
}
Листинг 15.4. Класс IrDAIrDAFileSend
//====================================================================
//Этот класс является клиентом IrDA. Он осуществляет поиск сервера
//IrDA, имя которого совпадает с именем службы IrDA, и после того, как
//он найден, направляет ему поток данных файла.
//====================================================================
class IrDAFileSend {
private string m_descriptionOfLastSendAttempt;
private string m_IrDAServiceName;
private string m_fileToSend;
private bool m_wasSenderStopped;
public enum SendStatus {
AttemptingToSend,
Finished_Successfully,
Finished_Aborted,
Finished_Error
}
private SendStatus m_SendStatus;
public SendStatus Status {
get {
//Блокировка выполнения параллельных операций чтения/записи в m_SendStatus
lock(this) {return m_SendStatus;}
}
}
private void setStatus(SendStatus newStatus) {
//Блокировка выполнения параллельных операций чтения/записи в m_SendStatus
lock(this) {m_SendStatus = newStatus;}
}
public string ErrorText {
get {return m_descriptionOfLastSendAttempt;}
}
//–
//КОНСТРУКТОР
//–
public IrDAFileSend(string fileToSend,string irdaServiceName) {
//Имя сокета IrDA, поиск которого мы хотим осуществить
m_IrDAServiceName = irdaServiceName;
//Файл, который мы хотим передать
m_fileToSend = fileToSend;
}
//–
//Запускает новый поток для осуществления попытки отправки файла
//–
public void LoopAndAttemptIRSendAsync() {
//Мы находимся в режиме передачи
setStatus(SendStatus.AttemptingToSend);
//Пользователь пока что не отменил выполнение операции
m_wasSenderStopped = false;
//Это функция, которую должен запустить на выполнение новый поток
System.Threading.ThreadStart threadEntryPoint;
threadEntryPoint = new System.Threading.ThreadStart(LoopAndAttemptIRSend);
//–
//Создать новый поток и запустить его
//–
System.Threading.Thread newThread = new System.Threading.Thread(threadEntryPoint);
newThread.Start(); //Вперед!
}
//–
//Входит в цикл и пытается передать файл посредством IR
//–
public void LoopAndAttemptIRSend() {
System.Net.Sockets.IrDAClient irDASender;
System.IO.Stream streamOutToIrDA;
System.IO.Stream streamInFromFile;
//Пользователь пока что не отменил выполнение операции
m_wasSenderStopped = false;
setStatus(SendStatus.AttemptingToSend);
//–
//Непрерывное выполнение цикла, пока не удастся отправить сообщение
//–
while(true) {
//Значения всех этих переменных должны быть нулевыми до и после
//вызова 'sendStream(...)', если не было сгенерировано исключение!
irDASender = null;
streamOutToIrDA = null;
streamInFromFile = null;
//Попытаться передать поток
bool bSuccess;
try {
bSuccess = sendStream(
out m_descriptionOfLastSendAttempt, ref streamOutToIrDA,
ref irDASender, ref streamInFromFile);
} catch (System.Exception eUnexpected) //Неожиданная ошибка!!!
{
setStatus(SendStatus.Finished_Error); //Отметить возникновение сбоя
m_descriptionOfLastSendAttempt =
"Unexpected error in IR send loop. " + eUnexpected.Message;
//–
//Освободить все распределенные нами ранее ресурсы
//–
if (streamOutToIrDA != null) {
try {
streamOutToIrDA.Close();
} саtch{};//Поглотить любую ошибку
streamOutToIrDA = null;
}
if (streamInFromFile != null) {
try {
streamInFromFile.Close();
} catch{};//Поглотить любую ошибку
streamInFromFile = null;
}
if (irDASender != null) {
try {
irDASender.Close();
} catch{}; //Поглотить любую ошибку
irDASender = null;
}
return; //Выход
}
//Проверить успешность выполнения
if (bSuccess == true) {
m_descriptionOfLastSendAttempt = "Success!";
setStatus(SendStatus.Finished_Successfully);
return;
}
//Проверить, не была ли операция отменена пользователем
if (m_wasSenderStopped == true) {
m_descriptionOfLastSendAttempt = "User Aborted.";
setStatus(SendStatus.Finished_Aborted);
return;
}
//B противном случае... Нам пока не удалось обнаружить сервер IrDA,
//имя которого совпадает с именем службы. Мы продолжим выполнение
//цикла и попытаемся найти сервер.
}
//Мы никогда не попадем в это место программы при выполнении
}
//Попытаться передать поток ввода-вывода (например, файл) посредством IR
//[возвращаемое значение]:
// true: успешная передача файла
// false: файл не был успешно передан
private bool sendStream(
out string errorDescription, ref System.IO.Stream streamOutToIrDA,
ref System.Net.Sockets.IrDAClient irDASender, ref System.IO.Stream streamInFromFile) {
errorDescription = "";
//–
//Создание нового клиента IRDA
//–
try {
//–
//Возврат произойдет довольно быстро. Клиент будет выбран
//и возвращен, если прослушивающие клиенты отсутствуют.
//–
irDASender = new System.Net.Sockets.IrDAClient(m_IrDAServiceName);
} catch (System.Exception eCreateClient) {
//B данном случае могло возникнуть несколько ситуаций:
//#1: отсутствуют прослушивающие устройства
//#2: прослушивающее устройство существует, но не реагирует
// (может отказаться от разговора)
errorDescription = eCreateClient.Message;
return false;
}
//B данном случае могло возникнуть несколько ситуаций:
//#1: Мы получили соединение от приемного устройства IR
//#2: IR-запрос был отменен (кто-то вызвал функцию STOP).
if (m_wasSenderStopped == true) {
irDASender.Close();
irDASender = null;
return false;
}
//==========================================
//ПЕРЕДАТЬ ДАННЫЕ!
//==========================================
//Открыть файл, который мы хотим передать
streamInFromFile = System.IO.File.OpenRead(m_fileToSend);
//Открыть сокет IrDA, которому мы хотим передать данные
streamOutToIrDA = irDASender.GetStream();
const int BUFFER_SIZE = 1024;
byte[] inBuffer = new byte[BUFFER_SIZE];
int bytesRead;
int iTestAll = 0;
int iTestWrite = 0;
do {
//Считать байты из файла
bytesRead = streamInFromFile.Read(inBuffer, 0, BUFFER_SIZE);
iTestAll = iTestAll + 1;
//Записать байты в наш выходной поток
if (bytesRead > 0) {
streamOutToIrDA.Write(inBuffer, 0, bytesRead);
iTestWrite = iTestWrite + 1;
}
} while (bytesRead > 0);
//Сбросить выходной поток
streamOutToIrDA.Flush(); //Закончить запись любых данных
streamOutToIrDA.Close(); //Закрыть поток
streamOutToIrDA = null;
//Освободить локальный файл
streamInFromFile.Close();
streamOutToIrDA = null;
//Освободить порт IrDA
irDASender.Close();
irDASender = null;
//Успешное завершение!!!
return true;
}
} //конец класса
Листинг 15.5. Класс IrDAFileReceive
//–
//Обеспечивает прием файла через IrDA (инфракрасный порт).
//
//Этот класс НЕ является реентерабельным и не должен вызываться более
//чем одной функцией за один раз. Если необходимо иметь несколько
//сеансов связи через IR, это необходимо делать путем создания
//нескольких различных экземпляров данного класса.
//–
public class IrDAFileReceive {
private bool m_wasListenerStopped;
private string m_IrDAServiceName;
private string m_fileNameForDownload;
private string m_errorDuringTransfer;
private System.Net.Sockets.IrDAListener m_irListener;
private ReceiveStatus m_ReceiveStatus;
public string ErrorText {
get {
return m_errorDuringTransfer;
}
}
//–
//Различные состояния приема
//–
public enum ReceiveStatus {
NotDone_SettingUp,
NotDone_WaitingForSender,
NotDone_Receiving,
Done_Success,
Done_Aborted,
Done_ErrorOccured
}
//–
// Возвращает состояние передачи
//–
public ReceiveStatus Status {
get {
//Обеспечить многопоточную безопасность для предотвращения
//параллельного выполнения операций чтения/записи
lock(this) {
return m_ReceiveStatus;
} //конец lock
} //конец get
} //конец свойства
private void setStatus(ReceiveStatus newStatus) {
//Обеспечить многопоточную безопасность для предотвращения
//параллельного выполнения операций чтения/записи
lock(this) {
m_ReceiveStatus = newStatus;
} //конец lock
}
//–
// [in] filename: желаемое имя для входного файла IR
//–
public IrDAFileReceive(string filename, string irdaServiceName) {
//Имя сокета IrDA, который мы хотим открыть
m_IrDAServiceName = irdaServiceName;
//Имя файла, в котором мы хотим сохранить полученные данные
m_fileNameForDownload = filename;
}
//–
//Обеспечивает асинхронный прием файла через IR
//
// [in] filename: имя файла, в который осуществляется запись
//–
public void WaitForIRFileDownloadAsync() {
//Заметьте, что сейчас мы находимся в режиме подготовки
setStatus(ReceiveStatus.NotDone_SettingUp);
//–
