Cenário RFCOMM: enviar arquivo como um cliente (HTML)

[ Este artigo destina-se aos desenvolvedores do Windows 8.x e do Windows Phone 8.x que escrevem aplicativos do Windows Runtime. Se você estiver desenvolvendo para o Windows 10, consulte documentação mais recente]

O cenário de Aplicativo básico é conectar a um dispositivo emparelhado com base em um serviço desejado. Nesse cenário, o desenvolvedor pode usar as funções RfcommDeviceService.GetDeviceSelector* para ajudar a gerar uma consulta AQS que pode ser usada para enumerar instâncias de dispositivo emparelhado do serviço desejado. De lá, o desenvolvedor do aplicativo seleciona um dispositivo enumerado, cria um RfcommDeviceService, e lê os atributos SDP conforme necessário (usando established data helpers para analisar os dados do atributo). O desenvolvedor do aplicativo, em seguida, pode criar um soquete e usar as propriedades ConnectionHostName e ConnectionServiceName do RfcommDeviceService para ConnectAsync para o serviço do dispositivo remoto com os parâmetros apropriados. Quando for o momento de enviar um arquivo, o desenvolvedor do aplicativo pode seguir os padrões de fluxo de dados estabelecidos para ler parte dos dados do arquivo e enviá-lo no OutputStream do soquete para o dispositivo.

var _service;    // Windows.Devices.Bluetooth.RfcommDeviceService
var _socket;     // Windows.Networking.Sockets.StreamSocket

function Initialize() {
    // Enumerate devices with the object push service
    Windows.Devices.Enumeration.DeviceInformation.findAllAsync(
        RfcommDeviceService.getDeviceSelector(
            RfcommServiceId.obexObjectPush))
    .done(function(services) {
        if (services.length > 0) {
            // Initialize the target Bluetooth BR device
            RfcommDeviceService.fromIdAsync(services[0].id)
            .done(function(service) {
                // Check that the service meets this App’s minimum
                // requirement
                if (SupportsProtection(service)
                    && IsCompatibleVersion(service))
                {
                    _service = service;

                    // Create a socket and connect to the target
                    _socket = new StreamSocket();
                    _socket.connectAsync(
                        _service.connectionHostName,
                        _service.connectionServiceName,
                        SocketProtectionLevel
                            .bluetoothEncryptionAllowNullAuthentication)
                    .done(function () {
                        // The socket is connected. At this point the App can
                        // wait for the user to take some action, e.g. click
                        // a button to send a file to the device, which could
                        // invoke the Picker and then send the picked file.
                        // The transfer itself would use the Sockets API and
                        // not the Rfcomm API, and so is omitted here for
                        // brevity.
                    });
                }
            });
        }
    });
}

// This App requires a connection that is encrypted but does not care about
// whether its authenticated.
function SupportsProtection(service)
{
    switch (service.protectionLevel)
    {
    case SocketProtectionLevel.plainSocket:
        if ((service.maximumProtectionLevel == SocketProtectionLevel
                .bluetoothEncryptionWithAuthentication)
            || (service.maximumProtectionLevel == SocketProtectionLevel
                .bluetoothEncryptionAllowNullAuthentication)
        {
            // The connection can be upgraded when opening the socket so the
            // App may offer UI here to notify the user that Windows may
            // prompt for a PIN exchange.
            return true;
        }
        else
        {
            // The connection cannot be upgraded so an App may offer UI here
            // to explain why a connection won’t be made.
            return false;
        }
    case SocketProtectionLevel.bluetoothEncryptionWithAuthentication:
        return true;
    case SocketProtectionLevel.bluetoothEncryptionAllowNullAuthentication:
        return true;
    }
    return false;
}

// This App relies on CRC32 checking available in version 2.0 of the service.
var SERVICE_VERSION_ATTRIBUTE_ID = 0x0300;
var byte SERVICE_VERSION_ATTRIBUTE_TYPE = 0x0A;   // UINT32
var MINIMUM_SERVICE_VERSION = 200;
function IsCompatibleVersion(service)
{
    service.getSdpRawAttributesAsync(BluetoothCacheMode.Uncached)
    .done(function(attributes) {
        var attribute = attributes[SERVICE_VERSION_ATTRIBUTE_ID];
        var reader = DataReader.fromBuffer(attribute);

        // The first byte contains the attribute's type
        var attributeType = reader.readByte();
        if (attributeType == SERVICE_VERSION_ATTRIBUTE_TYPE)
        {
            // The remainder is the data
            var version = reader.uint32();
            return version >= MINIMUM_SERVICE_VERSION;
        }
    });
}