Mobile

public class UDPConnection extends Activity { <br />
    /** Called when the activity is first created. */ <br />
    @Override <br />
    public void onCreate(Bundle icicle) { <br />
        super.onCreate(icicle); <br />
        setContentView(R.layout.main); <br />
        <br />
        Thread sThread = new Thread(new Server()); <br />
        Thread cThread = new Thread(new Client()); <br />
        <br />
        sThread.start(); <br />
        try { <br />
               Thread.sleep(500); <br />
          } catch (InterruptedException e) { } <br />
        <br />
          cThread.start(); <br />
    } <br />
}

public class Server implements Runnable{ <br />
     public static final String SERVERIP = "127.0.0.1"; <br />
     public static final int SERVERPORT = 4444; <br />
           <br />
     @Override <br />
     public void run() { <br />
          try { <br />
               Log.d("UDP", "S: Connecting..."); <br />
               InetAddress serverAddr = InetAddress.getByName(SERVERIP); <br />
               DatagramSocket socket = new DatagramSocket(SERVERPORT,serverAddr); <br />
               byte[] buf = new byte[17]; <br />
               DatagramPacket packet = new DatagramPacket(buf, buf.length); <br />
               Log.d("UDP", "S: Receiving..."); <br />
               socket.receive(packet); <br />
               Log.d("UDP", "S: Received: '" + new String(packet.getData()) + "'"); <br />
               Log.d("UDP", "S: Done."); <br />
          } catch (Exception e) { <br />
               Log.e("UDP", "S: Error", e); <br />
          } <br />
     } <br />
}

public class Client implements Runnable { <br />
     @Override <br />
     public void run() { <br />
          try { <br />
               Log.d("UDP", "C: Connecting..."); <br />
               DatagramSocket socket = new DatagramSocket(); <br />
               byte[] buf = ("Hello from Client").getBytes(); <br />
               InetAddress serverAddr = InetAddress.getByName(Server.SERVERIP); <br />
               DatagramPacket packet = new DatagramPacket(buf, buf.length, serverAddr, Server.SERVERPORT); <br />
               Log.d("UDP", "C: Sending: '" + new String(buf) + "'"); <br />
               socket.send(packet); <br />
               Log.d("UDP", "C: Sent."); <br />
               Log.d("UDP", "C: Done."); <br />
          } catch (Exception e) { <br />
               Log.e("UDP", "C: Error", e); <br />
          } <br />
     } <br />
}

RegistryKey rkNewDevice = null;
    RegistryKey rkPortsDevice = null;
    RegistryKey rkPortsDeviceUnimodem = null;
    IntPtr contextPtr = IntPtr.Zero;


        string regString = string.Format("\\SOFTWARE\\Microsoft\\Bluetooth\\Device\\modem\\{0}",
             Address.ToString().ToLower());

        rkNewDevice = Registry.LocalMachine.CreateSubKey(regString);

        if (Authenticate)
            rkNewDevice.SetValue("auth", 1, RegistryValueKind.DWord);
        else
            rkNewDevice.SetValue("auth", 0, RegistryValueKind.DWord);

        if (Encrypt)
            rkNewDevice.SetValue("encrypt", 1, RegistryValueKind.DWord);
        else
            rkNewDevice.SetValue("encrypt", 0, RegistryValueKind.DWord);

        // check if name is set
        if (rkNewDevice.GetValue("name", "").ToString() == "")
        {
            rkNewDevice.SetValue("name", FriendlyName);
        }


        // set settings in registry ports
        regString = string.Format("\\SOFTWARE\\Microsoft\\Bluetooth\\Device\\ports\\{0}", FriendlyName);
        rkPortsDevice = Registry.LocalMachine.CreateSubKey(regString);
        rkPortsDevice.SetValue("dll", "btd.dll", RegistryValueKind.String);
        rkPortsDevice.SetValue("prefix", "BSP", RegistryValueKind.String);

        int index = FindFreePort();
        rkPortsDevice.SetValue("index", index, RegistryValueKind.DWord);

        PORTEMUPORTPARAMS pep = new PORTEMUPORTPARAMS();
        pep.uiportflags = RFCOMM_PORT_FLAGS.REMOTE_DCB;

        if (Encrypt)
            pep.uiportflags |= RFCOMM_PORT_FLAGS.ENCRYPT;

        if (Authenticate)
            pep.uiportflags |= RFCOMM_PORT_FLAGS.AUTHENTICATE;

        pep.flocal = false;
        pep.device = Address.ToInt64();
        pep.channel = Channel;

        int size = Marshal.SizeOf(typeof(PORTEMUPORTPARAMS));

        contextPtr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(pep, contextPtr, false);

        rkPortsDevice.SetValue("context", contextPtr.ToInt32(), RegistryValueKind.DWord);

        if (DeviceType == DeviceTypes.MODEM ||
            DeviceType == DeviceTypes.LAP ||
            DeviceType == DeviceTypes.ASYNC)
        {
            regString = string.Format("\\SOFTWARE\\Microsoft\\Bluetooth\\Device\\ports\\{0}\\unimodem",
                FriendlyName);

            rkPortsDeviceUnimodem = Registry.LocalMachine.CreateSubKey(regString);
            rkPortsDeviceUnimodem.SetValue("friendlyname", FriendlyName, RegistryValueKind.String);
            rkPortsDeviceUnimodem.SetValue("tsp", "unimodem.dll", RegistryValueKind.String);

            int devicetype = DeviceType == DeviceTypes.MODEM ? 1 : 0;
            rkPortsDeviceUnimodem.SetValue("devicetype", devicetype, RegistryValueKind.DWord);
        }

        regString = string.Format("\\SOFTWARE\\Microsoft\\Bluetooth\\Device\\ports\\{0}", FriendlyName);

        rkNewDevice.Flush();
        rkPortsDevice.Flush();
        rkPortsDeviceUnimodem.Flush();

        IntPtr devHandle = WinNative.ActivateDevice(regString, 0);

if (devHandle != IntPtr.Zero &&
            devHandle.ToInt32() != -1)
        {

            active = true;
            Handle = devHandle.ToInt32();
            rkNewDevice.SetValue("handle", Handle, RegistryValueKind.DWord);
            rkNewDevice.SetValue("active", 1, RegistryValueKind.DWord);
            rkNewDevice.SetValue("port_name", string.Format("BSP{0}:", index.ToString()), RegistryValueKind.String);
}

        rkNewDevice.Close();
        rkPortsDevice.Close();
        rkPortsDeviceUnimodem.Close();
        Marshal.FreeHGlobal(contextPtr);

// ClientFille.cpp
// Cria um arquivo sequencial.

#include <iostream>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::ios;

#include <fstream> // Fluxo de arquivos
using std::ofstream; // Gera a saída do fluxo do arquivo

#include <cstdlib>
using std::exit; // Sai do protótipo de funcão

int main()
{
    //  Construtor ofstream abre arquivo
    ofstream outClientFile( "Clients.dat", ios::out );
    
    // Fecha o programa se não conseguir criar o arquivo
    if ( !outClientFile ) // Operador ! sobrecarregado
    {
       cerr << "File could not be opened" << endl;
       exit( 1 );
    } // Fim do if
    
    cout << "Enter the account, name, and balance." << endl
       << "Enter end-of-file to end the input.\n? ";
       
    int account;
    char name[ 30 ];
    double balance;
    
    // Lê conta, nome e saldo a partir de cin, então coloca no arquivo
    while ( cin >> account >> name >> balance )
    {
       outClientFile << account << ' ' << name << ' ' << balance << endl;
       cout << "? ";
    } // Fim do while
    
    return 0; // Destruitor ofstream fecha o arquivo
} // Fim de main