Language Packs

ovr-platform-util upload-rift-build -a 12345 -s 1234 -d path/to/mygame.zip  --language_packs_dir /path/to/myGame/language-packs -c ALPHA

ovr-platform-util upload-quest-build -a 12345 -s 1234 -d path/to/mygame.zip  --language_packs_dir /path/to/myGame/language-packs -c ALPHA

1. Navigate to the Meta Horizon Developer Dashboard⁠.
2. In the top-right corner of the Meta Horizon Dashboard, select your org.
3. Select your app.
4. In the left-side navigation, select Distribution > Builds. A list of all builds for your app appears.
5. In the Build column, click on a build.
6. Select the Expansion Files tab.
7. Find the Expansion Files column for the build you selected and then select View Expansion Files. The different kinds of assets will display.
8. Look for Language Packs.
   The following image shows an example of language packs.
   

1. Use the AssetFile.getList() function to get a list of all assets.
2. Check for an asset type via the AssetDetails.assetType property. A language pack has the asset type language_pack.
3. Read the language of the asset from the nullable AssetDetails.language property, whose tag field holds the BCP47 language code.

import horizon.platform.languagepack.LanguagePack

// Call from a coroutine.
val details = LanguagePack().getCurrent()
val tag = details.language?.tag
val path = details.filepath

import horizon.platform.assetfile.AssetFile
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch

// scope is the CoroutineScope your code owns. Start this before setCurrent().
val progressJob: Job = scope.launch {
    AssetFile().downloadUpdate().collect { update ->
        if (update.bytesTransferred < 0 || update.bytesTotal == 0uL) return@collect
        val progress = update.bytesTransferred.toFloat() / update.bytesTotal.toFloat()
    }
}

// Retain progressJob and cancel it after installation or when leaving the picker.

import horizon.platform.languagepack.LanguagePack
import horizon.platform.languagepack.LanguagePackException
import horizon.platform.languagepack.enums.LanguagePackStatusCode

// languagePackAssetId is a property on the object that owns scope.
scope.launch {
    try {
        val result = LanguagePack().setCurrent("de")
        languagePackAssetId = result.assetId
    } catch (e: LanguagePackException) {
        if (e.code == LanguagePackStatusCode.LanguagePackNotFound.value) {
            // No pack exists for that tag.
        }
    }
}

• A delay between requests, so the loop does not spin.
• A bound, either a maximum number of attempts or a timeout, so a pack that never reaches installed does not hold the loop open.
• A cancellation path, so leaving the picker ends the loop.
• Error handling on every response, so a failed request retries or ends the loop rather than reading as a status that is not installed.

// Call from a coroutine. installedPath is a property your code owns.
val details = AssetFile().statusById(languagePackAssetId)
if (details.downloadStatus == "installed") {
    installedPath = details.filepath
}

1. List every asset file, as described in Check for language packs in your app. Keep the entries whose asset type is the string language_pack. The list call takes no filter parameter, so filter the results in your app code. This gives you the entry list.
2. Label each entry from the names on its language info: the English name, for a list that stays readable to a user who selected the wrong language, and the native name, for the spelling used by that language. This gives you the display text.
3. Call get-current and pre-select the entry whose tag matches the tag it returns. This gives you the starting selection.
4. Start progress observation, then call set-current with the tag of the entry the user selects. Store the asset ID from the result in your picker state. This gives you the asset ID.
5. Request the asset status in your bounded loop until the download status is installed. Store the filepath from that response. This gives you the filepath.
6. Reload your localized content from the stored filepath, then end the progress observation.

import horizon.platform.assetfile.AssetFile

// Call from a coroutine.
val packs = AssetFile().getList().filter { it.assetType == "language_pack" }
packs.forEach { pack ->
    val info = pack.language ?: return@forEach
    val label = "${info.englishName} (${info.nativeName})"
}