Export (0) Print
Expand All
0 out of 1 rated this helpful - Rate this topic

How to: Make an Infrared File Transfer

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 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 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.

This example requires references to the following namespaces:

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback

Community Additions

ADD
Show:
© 2014 Microsoft. All rights reserved.