Transferindo conteúdo do dispositivo para um computador

Uma operação comum realizada por um aplicativo WPD é a transferência de conteúdo de um dispositivo conectado para o computador.

As transferências de conteúdo são realizadas usando as interfaces descritas na tabela a seguir.

Interface	Descrição
IPortableDeviceContent Interface	Fornece acesso à interface IPortableDeviceProperties .
IPortableDeviceProperties Interface	Fornece acesso a métodos específicos da propriedade.
IPortableDeviceResources Interface	Usado para armazenar as chaves de propriedade para o perfil especificado.
IStream Interface	Usado para ler e gravar os dados.

 

A TransferContentFromDevice função no módulo ContentTransfer.cpp do aplicativo de exemplo demonstra como um aplicativo pode transferir informações de contato de um dispositivo conectado para um computador.

A primeira tarefa realizada pela TransferContentFromDevice função é solicitar que o usuário insira um identificador de objeto para o objeto pai no dispositivo (sob o qual o conteúdo será transferido).

HRESULT                            hr                   = S_OK;
WCHAR                              szSelection[81]      = {0};
CComPtr<IPortableDeviceContent>    pContent;
CComPtr<IPortableDeviceResources>  pResources;
CComPtr<IPortableDeviceProperties> pProperties;
CComPtr<IStream>                   pObjectDataStream;
CComPtr<IStream>                   pFinalFileStream;
DWORD                              cbOptimalTransferSize = 0;
CAtlStringW                        strOriginalFileName;

if (pDevice == NULL)
{
    printf("! A NULL IPortableDevice interface pointer was received\n");
    return;
}


// Prompt user to enter an object identifier on the device to transfer.
printf("Enter the identifer of the object you wish to transfer.\n>");
hr = StringCbGetsW(szSelection,sizeof(szSelection));
if (FAILED(hr))
{
    printf("An invalid object identifier was specified, aborting content transfer\n");
}

A próxima etapa é a recuperação de um objeto IPortableDeviceContent que o exemplo usa para acessar os métodos específicos do conteúdo.

if (SUCCEEDED(hr))
{
    hr = pDevice->Content(&pContent);
    if (FAILED(hr))
    {
        printf("! Failed to get IPortableDeviceContent from IPortableDevice, hr = 0x%lx\n",hr);
    }
}

A próxima etapa é a recuperação de um objeto IPortableDeviceResources que o exemplo usa para acessar os métodos específicos do recurso.

if (SUCCEEDED(hr))
{
    hr = pContent->Transfer(&pResources);
    if (FAILED(hr))
    {
        printf("! Failed to get IPortableDeviceResources from IPortableDeviceContent, hr = 0x%lx\n",hr);
    }
}

A próxima etapa é a recuperação de um objeto IStream que o exemplo usa para ler os dados que está transferindo do dispositivo.

if (SUCCEEDED(hr))
{
    hr = pResources->GetStream(szSelection,             // Identifier of the object we want to transfer
                               WPD_RESOURCE_DEFAULT,    // We are transferring the default resource (which is the entire object's data)
                               STGM_READ,               // Opening a stream in READ mode, because we are reading data from the device.
                               &cbOptimalTransferSize,  // Driver supplied optimal transfer size
                               &pObjectDataStream);
    if (FAILED(hr))
    {
        printf("! Failed to get IStream (representing object data on the device) from IPortableDeviceResources, hr = 0x%lx\n",hr);
    }
}

A próxima etapa é a recuperação do nome do arquivo do objeto no dispositivo. Essa cadeia de caracteres é usada para criar o nome de arquivo correspondente no computador. Se o objeto não tiver um nome de arquivo no dispositivo, o identificador do objeto será convertido em uma cadeia de caracteres e usado para criar o nome do arquivo de destino.

if (SUCCEEDED(hr))
{
    hr = pContent->Properties(&pProperties);
    if (SUCCEEDED(hr))
    {
        hr = GetStringValue(pProperties,
                            szSelection,
                            WPD_OBJECT_ORIGINAL_FILE_NAME,
                            strOriginalFileName);
        if (FAILED(hr))
        {
            printf("! Failed to read WPD_OBJECT_ORIGINAL_FILE_NAME on object '%ws', hr = 0x%lx\n", szSelection, hr);
            strOriginalFileName.Format(L"%ws.data", szSelection);
            printf("* Creating a filename '%ws' as a default.\n", (PWSTR)strOriginalFileName.GetString());
            // Set the HRESULT to S_OK, so we can continue with our newly generated
            // temporary file name.
            hr = S_OK;
        }
    }
    else
    {
        printf("! Failed to get IPortableDeviceProperties from IPortableDeviceContent, hr = 0x%lx\n", hr);
    }
}

Depois disso, o exemplo cria um objeto IStream de destino.

if (SUCCEEDED(hr))
{
    hr = SHCreateStreamOnFile(strOriginalFileName, STGM_CREATE|STGM_WRITE, &pFinalFileStream);
    if (FAILED(hr))
    {
        printf("! Failed to create a temporary file named (%ws) to transfer object (%ws), hr = 0x%lx\n",(PWSTR)strOriginalFileName.GetString(), szSelection, hr);
    }
}

Por fim, o objeto IStream de origem é copiado para o destino no computador.

if (SUCCEEDED(hr))
{
    DWORD cbTotalBytesWritten = 0;

    // Since we have IStream-compatible interfaces, call our helper function
    // that copies the contents of a source stream into a destination stream.
    hr = StreamCopy(pFinalFileStream,       // Destination (The Final File to transfer to)
                    pObjectDataStream,      // Source (The Object's data to transfer from)
                    cbOptimalTransferSize,  // The driver specified optimal transfer buffer size
                    &cbTotalBytesWritten);  // The total number of bytes transferred from device to the finished file
    if (FAILED(hr))
    {
        printf("! Failed to transfer object from device, hr = 0x%lx\n",hr);
    }
    else
    {
        printf("* Transferred object '%ws' to '%ws'.\n", szSelection, (PWSTR)strOriginalFileName.GetString());
    }
}

Tópicos relacionados

IPortableDevice Interface

IPortableDeviceContent Interface

IPortableDeviceValues Interface

Guia de programação