Иво Салмре - Программирование мобильных устройств на платформе .NET Compact Framework

//цикла и попытаемся найти сервер.

}

//Мы никогда не попадем в это место программы при выполнении

}

//Попытаться передать поток ввода-вывода (например, файл) посредством 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;

}

} //конец класса

//-------------------------------------------------------------------

//Обеспечивает прием файла через 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);

//-------------------

//Создать новый поток

//-------------------

System.Threading.ThreadStart threadEntryPoint;

threadEntryPoint =

new System.Threading.ThreadStart(WaitForIRFileDownload);

System.Threading.Thread newThread = new System.Threading.Thread(threadEntryPoint);

//Запустить поток на выполнение

newThread.Start();

}

//------------------------------------------

//Открывает порт IR и ожидает загрузки файла

//------------------------------------------

public void WaitForIRFileDownload() {

System.IO.Stream outputStream = null;

System.Net.Sockets.IrDAClient irdaClient = null;

System.IO.Stream irStreamIn = null;

try {

//=========================================================

//Задать и загрузить файл!

//=========================================================

internal WaitForIRFileDownload(ref outputStream,ref irdaClient, ref irStreamIn);

} catch

//Поглотить любые возникающие ошибки

{

setStatus(ReceiveStatus.Done_ErrorOccured);

}

//=============================================

//Освободить все ресурсы

//=============================================

//Закрыть наш входной поток

if (irStreamIn != null) {

try {

irStreamIn.Close();

} catch {} //Поглотить любые возникающие ошибки

}

//Закрытие клиента IrDA

if (irdaClient != null) {

try {

irdaClient.Close();

} catch {} //Поглотить любые возникающие ошибки

}

//Закрыть файл, в который осуществлялась запись

if (outputStream != null) {

try {

outputStream.Close();

} catch {} //Поглотить любые возникающие ошибки

}

//Закрыть прослушивающее устройство, если оно выполняется

if (m_irListener != null) {