How to: Make an Infrared File Transfer

  • Article

The .NET Compact Framework provides classes for infrared communications between devices. This example demonstrates how to send and receive files between devices using infrared communications. You need two Pocket PCs, one to send the file and one to receive it.

This example creates an instance of IrDAClient and uses its DiscoverDevices method to discover infrared devices within range. This method returns an array of IrDADeviceInfo objects that supply information about each device.

This example provides code for sending and receiving a file, which can be demonstrated with a Send and Receive button. Minimally, you'll need to create a Send application for one device, and a Receive application for the other device.

The Send button sends a file only to a device that has been listening for requests to be sent a file. Therefore, the Receive button must be tapped on the receiving device before the Send button is tapped on the sending device. The following tasks are performed:

  • Obtain a stream of the file to send.

  • Create an IrDAClient instance using the service name determined for this application. Infrared connections are made by specifying a service name, which can be any value provided that the participating devices refer to the same name. The service name is "IrDATest" in this example.

  • Read the stream of the file into the IrDAClient stream that sends the file.

The Receive button creates an IrDAListener instance to listen for the device with the same service name as the IrDAClient instance on the sending device.

The following tasks are performed:

  • Create a stream for writing the transferred content to a receiving file in the My Documents folder.

  • Create an IrDAEndPoint instance with the device ID and service name for the sending device.

  • Create an IrDAListener instance from the IrDAEndPoint instance and start the listening service.

  • Create an IrDAClient instance from the IrDAListener instance using the AcceptIrDAClient method.

  • Read the underlying stream of the IrDAClient instance, which contains the data of the transferred file.

  • Write that data stream into the stream for the Receive.txt file.

To create the applications

  1. Create a Pocket PC application for the sending device and add a button to the form. Name the button Send.

  2. Create a file named Send.txt in the My Documents folder.

  3. Add the following code for the Send button's Click event.

    ' Align the infrared ports of the devices. 
' Click the Receive button first, then click Send. 
Private Sub SendButton_Click(sender As Object, e As System.EventArgs) _
    Handles SendButton.Click

    Dim irClient As New IrDAClient()
    Dim irServiceName As String = "IrDATest" 
    Dim irDevices() As IrDADeviceInfo
    Dim buffersize As Integer = 256

    ' Create a collection of devices to discover.
    irDevices = irClient.DiscoverDevices(2)

    ' Show the name of the first device found. 
    If irDevices.Length = 0 Then
        MessageBox.Show("No remote infrared devices found.")
        Return 
    End If 

    Try 
        Dim irEndP As New IrDAEndPoint(irDevices(0).DeviceID, _
            irServiceName)
        Dim irListen As New IrDAListener(irEndP)
        irListen.Start()
        irClient = irListen.AcceptIrDAClient()
        MessageBox.Show("Connected!")

    Catch exSoc As SocketException
         MessageBox.Show("Couldn't listen on service " & irServiceName & ": " _
            & exSoc.ErrorCode)
    End Try 

    ' Open a file to send and get its stream. 
    Dim fs As Stream
    Try
        fs = New FileStream(".\My Documents\send.txt", FileMode.Open)
    Catch exFile As Exception
        MessageBox.Show("Cannot open " & exFile.ToString())
        Return 
    End Try 

    ' Get the underlying stream of the client. 
    Dim baseStream As Stream = irClient.GetStream()

    ' Get the size of the file to send 
    ' and write its size to the stream. 
    Dim length As Byte() = BitConverter.GetBytes(fs.Length)
    baseStream.Write(length, 0, length.Length)

    ' Create a buffer for reading the file. 
    Dim buffer(buffersize) As Byte 

    Dim fileLength As Integer = CInt(fs.Length)

    Try 
        ' Read the file stream into the base stream. 
        While fileLength > 0
            Dim numRead As Int64 = fs.Read(buffer, 0, buffer.Length)
            baseStream.Write(buffer, 0, numRead)
            fileLength -= numRead
        End While
        MessageBox.Show("File sent")
    Catch exSend As Exception
        MessageBox.Show(exSend.Message)
    End Try

    fs.Close()
    baseStream.Close()
    irClient.Close()
End Sub

    // Align the infrared ports of the devices. 
// Click the Receive button first, then click Send. 
private void SendButton_Click(object sender, System.EventArgs e)
{
    IrDAClient irClient = new IrDAClient();
    string irServiceName = "IrDATest";
    IrDADeviceInfo[] irDevices;
    int buffersize = 256;

    // Create a collection of devices to discover.
    irDevices = irClient.DiscoverDevices(2);

    // Show the name of the first device found. 
    if ((irDevices.Length == 0)) 
    {
        MessageBox.Show("No remote infrared devices found.");
        return;
    }
    try 
    {
        IrDAEndPoint irEndP = 
            new IrDAEndPoint(irDevices[0].DeviceID, irServiceName);
        IrDAListener irListen = new IrDAListener(irEndP);
        irListen.Start();
        irClient = irListen.AcceptIrDAClient();
        MessageBox.Show("Connected!");
    }
    catch (SocketException exSoc) 
    {
        MessageBox.Show(("Couldn\'t listen on service "
                        + (irServiceName + (": " + exSoc.ErrorCode))));
    }

    // Open a file to send and get its stream.
    Stream fs;
    try 
    {
        fs = new FileStream(".\\My Documents\\send.txt", FileMode.Open);
    }
    catch (Exception exFile) 
    {
        MessageBox.Show(("Cannot open " + exFile.ToString()));
        return;
    }

    // Get the underlying stream of the client.
    Stream baseStream = irClient.GetStream();

    // Get the size of the file to send 
    // and write its size to the stream. 
    byte[] length = BitConverter.GetBytes(fs.Length);
    baseStream.Write(length, 0, length.Length);

    // Create a buffer for reading the file. 
    byte[] buffer = new byte[buffersize];
    int fileLength = (int) fs.Length;
    try 
    {
        // Read the file stream into the base stream. 
        while ((fileLength > 0)) 
        {
            Int64 numRead = fs.Read(buffer, 0, buffer.Length);
            baseStream.Write(buffer, 0, Convert.ToInt32(numRead));
            fileLength = (fileLength - Convert.ToInt32(numRead));
        }
        MessageBox.Show("File sent");
    }
    catch (Exception exSend) 
    {
        MessageBox.Show(exSend.Message);
    }
    fs.Close();
    baseStream.Close();
    irClient.Close();
}

  4. Create a Pocket PC application for the receiving device and add a button to the form. Name the button Receive.

  5. Add the following code for the Receive button's Click event.

    ' Align the infrared ports of the devices. 
' Click the Receive button first, then click Send. 
Private Sub ReceiveButton_Click(sender As Object, e As System.EventArgs) _
    Handles ReceiveButton.Click

    Dim irDevices() As IrDADeviceInfo
    Dim irClient As New IrDAClient()
    Dim irServiceName As String = "IrDATest" 

    Dim buffersize As Integer = 256

    ' Create a collection for discovering up to 
    ' three devices, although only one is needed.
    irDevices = irClient.DiscoverDevices(2)

    ' Cancel if no devices are found. 
    If irDevices.Length = 0 Then
        MessageBox.Show("No remote infrared devices found.")
        Return 
    End If 

    ' Connect to the first IrDA device 
    Dim irEndP As New IrDAEndPoint(irDevices(0).DeviceID, irServiceName)
    irClient.Connect(irEndP)

    ' Create a stream for writing a Pocket Word file. 
    Dim writeStream As Stream
    Try
        writeStream = New FileStream(".\My Documents\receive.txt", _
            FileMode.OpenOrCreate)
    Catch
        MessageBox.Show("Cannot open file for writing.")
        Return 
    End Try 

    ' Get the underlying stream of the client. 
    Dim baseStream As Stream = irClient.GetStream()

    ' Create a buffer for reading the file. 
    Dim buffer(buffersize) As Byte 

    Dim numToRead, numRead As Int64

    ' Read the file into a stream 8 bytes at a time. 
    ' Because the stream does not support seek operations, 
    ' its length cannot be determined.
    numToRead = 8

    Try     
        While numToRead > 0
            numRead = baseStream.Read(buffer, 0, numToRead)
            numToRead -= numRead
        End While 
    Catch exReadIn As Exception
        MessageBox.Show("Read in: " & exReadIn.Message)
    End Try 

    ' Get the size of the buffer to show 
    ' the number of bytes to write to the file.
    numToRead = BitConverter.ToInt64(buffer, 0)

    Try 
        ' Write the stream to the file until 
        ' there are no more bytes to read. 
        While numToRead > 0
            numRead = baseStream.Read(buffer, 0, buffer.Length)
            numToRead -= numRead
            writeStream.Write(buffer, 0, numRead)
        End While
        writeStream.Close()
        MessageBox.Show("File received.")
    Catch exWriteOut As Exception
        MessageBox.Show("Write out: " & exWriteOut.Message)
    End Try

     baseStream.Close()
     irClient.Close()
End Sub

    // Align the infrared ports of the devices. 
// Click the Receive button first, then click Send. 
private void ReceiveButton_Click(object sender, System.EventArgs e)
{
    IrDADeviceInfo[] irDevices;
    IrDAClient irClient = new IrDAClient();
    string irServiceName = "IrDATest";
    int buffersize = 256;

    // Create a collection for discovering up to 
    // three devices, although only one is needed.
    irDevices = irClient.DiscoverDevices(2);

    // Cancel if no devices are found. 
    if ((irDevices.Length == 0)) 
    {
        MessageBox.Show("No remote infrared devices found.");
        return;
    }

    // Connect to the first IrDA device
    IrDAEndPoint irEndP = 
        new IrDAEndPoint(irDevices[0].DeviceID, irServiceName);
    irClient.Connect(irEndP);

    // Create a stream for writing a Pocket Word file.
    Stream writeStream;
    try 
    {
        writeStream = new FileStream(".\\My Documents\\receive.txt", 
            FileMode.OpenOrCreate);
    }
    catch (Exception Ex)
    {
        MessageBox.Show("Cannot open file for writing. " + Ex.Message);
        return;
    }

    // Get the underlying stream of the client.
    Stream baseStream = irClient.GetStream();

    // Create a buffer for reading the file. 
    byte[] buffer = new byte[buffersize];
    Int64 numToRead;
    Int64 numRead;

    // Read the file into a stream 8 bytes at a time. 
    // Because the stream does not support seek operations, its 
    // length cannot be determined.
    numToRead = 8;
    try 
    {
        while ((numToRead > 0)) 
        {
            numRead = baseStream.Read(buffer, 0, 
                Convert.ToInt32(numToRead));
            numToRead = (numToRead - numRead);
        }
    }
    catch (Exception exReadIn) {
        MessageBox.Show(("Read in: " + exReadIn.Message));
    }

    // Get the size of the buffer to show 
    // the number of bytes to write to the file.
    numToRead = BitConverter.ToInt64(buffer, 0);
    try 
    {
        // Write the stream to the file until 
        // there are no more bytes to read. 
        while ((numToRead > 0)) {
            numRead = baseStream.Read(buffer, 0, buffer.Length);
            numToRead = (numToRead - numRead);
            writeStream.Write(buffer, 0, Convert.ToInt32(numRead));
        }
        writeStream.Close();
        MessageBox.Show("File received.");
    }
    catch (Exception exWriteOut) 
    {
        MessageBox.Show(("Write out: " + exWriteOut.Message));
    }
    baseStream.Close();
    irClient.Close();
}

To run the applications

  1. Deploy the applications to the devices and start them.

  2. Align the infrared ports of the devices.

  3. Tap the Receive button on the receiving device.

  4. Tap the Send button on the sending device.

  5. Check to see if Receive.txt has been created in the My Documents folder.

Compiling the Code

This example requires references to the following namespaces:

See Also

Concepts

Infrared Connections

.NET Compact Framework How-to Topics