> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# XtfGetAvailableSpaceForAppInstallation

> XtfGetAvailableSpaceForAppInstallation

# XtfGetAvailableSpaceForAppInstallation

Obtiene el número total de bytes disponibles en el dispositivo de almacenamiento especificado de una consola de desarrollo.

<a id="syntaxSection" />

## Sintaxis

```cpp theme={null}
HRESULT XtfGetAvailableSpaceForAppInstallation(
         LPCWSTR address,
         LPCWSTR storageName,
         UINT64 *bytes
)  
```

<a id="parametersSection" />

### Parámetros

*address*\
Tipo: LPCWSTR

\[in] Dirección de la consola de desarrollo que se va a comprobar.

*storageName*\
Tipo: LPCWSTR

\[in] Nombre del dispositivo de almacenamiento que se va a comprobar. Se permiten los valores siguientes:

| Valor     | Descripción                                      |
| --------- | ------------------------------------------------ |
| `nullptr` | El dispositivo de almacenamiento predeterminado. |
| internal  | El dispositivo de almacenamiento interno.        |

*bytes*\
Tipo: UINT64\*

\[out] Número total de bytes disponibles en el dispositivo de almacenamiento especificado en *storageName* para la consola de desarrollo especificada en *address*.

<a id="retvalSection" />

### Valor devuelto

Tipo: HRESULT

Devuelve `S_OK` si se ejecuta correctamente; de lo contrario, devuelve un código de error HRESULT.

<a id="remarksSection" />

## Comentarios

Esta función obtiene el número total de bytes disponibles en el dispositivo de almacenamiento especificado de una consola de desarrollo, lo que permite a un desarrollador de herramientas que escribe una herramienta de implementación personalizada para la consola comprobar que hay suficiente espacio para instalar un paquete de aplicación antes de iniciar el proceso de instalación. Para obtener más información sobre las herramientas de XBOX Tools Framework (XTF), consulte [Herramientas de línea de comandos (tema con NDA)](/tools/tools-console/commandlinetools/commandlinetools).

En el ejemplo de código siguiente se muestra cómo calcular el espacio necesario para un paquete de aplicación.

```cpp theme={null}
#include <stdio.h>
#include <conio.h>
#include <Windows.h>
#include <xtfapi.h>

//Round up file sizes to the nearest 4K boundary to get a better estimate of the actual size of disk
#define ESTIMATED_FILE_SIZE_ON_DISK(fileSize) ((fileSize + ((4UI64 * 1024UI64) - 1)) & ~((4UI64 * 1024UI64) - 1))

//Size of the buffer (string) that we use to contain file/directory names - MAX_PATH + 1 for the terminating null
#define DIR_BUFFER_LENGTH (MAX_PATH + 1)

//Forward declaration of the function that figures out the game size on disk
UINT64 EstimateRequiredSpace(LPWSTR targetDir) ;

//Calculates whether there is enough disk space to deploy the game
//Returns an ERRORLEVEL:
//   0 - OK - Enough space
//   1 - ERROR - Not enough space
//   2 - ERROR - Other error
int wmain(int argc, wchar_t **argv)
{
    HRESULT hr              = S_OK;
    UINT64  availableBytes  = 0;
    UINT64  requiredBytes   = 0;
    LPWSTR  consoleAddress  = nullptr;
    LPWSTR  targetDir       = nullptr;

    if (argc != 3)
    {
        wprintf(L"\nUsage: %s <consoleAddress> <directory name>\n", argv[0]);
        return 2;
    }

    consoleAddress = argv[1];
    targetDir = argv[2];

    wprintf(L"\nTarget console is %s\n", consoleAddress);
    wprintf(L"\nTarget directory is %s\n\n",targetDir);

    hr = XtfGetAvailableSpaceForAppInstallation(consoleAddress, L"Internal", &availableBytes);
    if (hr != S_OK)
    {
        wprintf(L"\n\n*** Error %d", hr);
        return 2;
    }

    requiredBytes = EstimateRequiredSpace(targetDir);
    if (hr != S_OK)
    {
        wprintf(L"\n\n*** Error calculating size");
        return 2;
    }

    wprintf(L"*** Space available on console is %I64u \n", availableBytes);
    wprintf(L"*** Space required is %I64u \n", requiredBytes);

    if (requiredBytes > availableBytes)
    {
        wprintf(L"*** DO NOT DEPLOY \n");
        return 1;
    }

    wprintf(L"*** OK TO DEPLOY \n");
    return 0;

}

//Function that figures out the game size on disk
UINT64 EstimateRequiredSpace(LPWSTR targetDir)
{
    WIN32_FIND_DATA  ffd;
    LARGE_INTEGER    filesize;
    TCHAR            szDir[DIR_BUFFER_LENGTH];
    size_t           targetDirLength    = 0;
    HANDLE           hFind              = INVALID_HANDLE_VALUE;
    DWORD            dwError            = 0;
    UINT64           requiredBytes      = 0;

    // Check that the input path plus 3 is not longer than the size of szDir.
    // Three characters are for the "\*" plus NULL appended below.
    targetDirLength = wcsnlen_s(targetDir, DIR_BUFFER_LENGTH);

    if (targetDirLength + 3 > DIR_BUFFER_LENGTH)
    {
        wprintf(L"\nDirectory path is too long.\n");
        return -1;
    }

    // Create the search string for FindFile functions.
    wcscpy_s(szDir, DIR_BUFFER_LENGTH, targetDir);
    wcscat_s(szDir, DIR_BUFFER_LENGTH, L"\\*");

    // Find the first file in the directory.
    hFind = FindFirstFile(szDir, &ffd);
    if (INVALID_HANDLE_VALUE == hFind)
    {
        dwError = GetLastError();
        wprintf(L"\nError: FindFirstFile failed %d.\n", dwError);
        return -1;
    }

    // Iterate over all the files in the game collecting file size information
    do
    {
        //If is a directory drill into it
        if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            if (wcscmp(ffd.cFileName, L".") != 0 && wcscmp(ffd.cFileName, L"..") != 0) //There is probably a better way to do this...
            {
                size_t newDirLength = wcsnlen_s(ffd.cFileName, DIR_BUFFER_LENGTH);
                if (targetDirLength + 1 + newDirLength + 1 > DIR_BUFFER_LENGTH)
                {
                    wprintf(L"\nDirectory path is too long.\n");
                    return -1;
                }

                wcscpy_s(szDir, DIR_BUFFER_LENGTH, targetDir);
                wcscat_s(szDir, DIR_BUFFER_LENGTH, L"\\");
                wcscat_s(szDir, DIR_BUFFER_LENGTH, ffd.cFileName);
                UINT64 result = EstimateRequiredSpace(szDir);
                if (result == -1)
                {
                    return -1;
                }
                requiredBytes += result;
            }
        }
        else
        {
            filesize.LowPart = ffd.nFileSizeLow;
            filesize.HighPart = ffd.nFileSizeHigh;

            //Round up file sizes to the nearest 4K boundary to get a better estimate of the actual size of disk
            requiredBytes += ESTIMATED_FILE_SIZE_ON_DISK(filesize.QuadPart);
        }
    }
    while (FindNextFile(hFind, &ffd) != 0);

    dwError = GetLastError();
    if (dwError != ERROR_NO_MORE_FILES)
    {
        wprintf(L"\nError: FindNextFile failed %d.\n", dwError);
        return -1;
    }

    FindClose(hFind);
    return requiredBytes;
}  
```

<a id="requirementsSection" />

## Requisitos

**Encabezado:** xtfapi.h

**Biblioteca:** XtfApi.lib

**Plataformas compatibles:** Windows (para las herramientas de consola XBOX)

<a id="seealsoSection" />

## Consulte también

[XtfConsoleControl](/reference/tools/xtf/xtfconsolecontrol/xtfconsolecontrol_members)\
[Referencia de la API nativa de XBOX Tools Framework](/reference/tools/xtf/atoc-xtf-native)


## Related topics

- [XtfGetCountofAppUserModelIds](/es/reference/tools/xtf/xtfapi/functions/xtfgetcountofappusermodelids-xtfapi-xbox-windows-m.md)
- [XPersistentLocalStorageSpaceInfo](/es/reference/system/xpersistentlocalstorage/structs/xpersistentlocalstoragespaceinfo.md)
- [IXtfApplicationClient::GetInstalled](/es/reference/tools/xtf/xtfapplication/classes/IXtfApplicationClient/methods/getinstalled-ixtfapplicationclient-xtfapplication-xbox-microsoft-m.md)
- [IXtfApplicationClient::GetDlc](/es/reference/tools/xtf/xtfapplication/classes/IXtfApplicationClient/methods/getdlc-ixtfapplicationclient-xtfapplication-xbox-microsoft-m.md)
- [XtfGetAumid](/es/reference/tools/xtf/xtfapi/functions/xtfgetaumid-xtfapi-xbox-windows-m.md)