YooAsset

https://www.yooasset.com/docs
Admin
YooAsset is a resource management system for Unity3D that helps development teams quickly deploy and...
Tokens:48,327
Snippets:556
Trust Score:2.4
Update:3 months ago
Show doc for...
Tokens:
Raw
### WeChat Plugin Configuration Example

Source: https://www.yooasset.com/docs/minigame/Wechat

Example of setting the PackageRoot based on CDN configuration for WeChat Mini Games. The path should align with the WeChat plugin's settings.

```csharp
string packageRoot = $"{WeChatWASM.WX.env.USER_DATA_PATH}/__GAME_FILE_CACHE/yoo";
//string packageRoot = $"{WeChatWASM.WX.PluginCachePath}/yoo";


```

--------------------------------

### Custom Web File System Example

Source: https://www.yooasset.com/docs/solution/ExtendFileSystem

Extend WebNetworkFileSystem to add custom cache clearing logic for specific platforms like mini-game platforms.

```csharp
internal class CustomWebFileSystem : WebNetworkFileSystem  
{
    private string _cacheRoot;

    public override void OnCreate(string packageName, string packageRoot)
    {
        _cacheRoot = packageRoot;
        base.OnCreate(packageName, packageRoot);
    }

    public override FSClearCacheOperation ClearCacheAsync(FSClearCacheOptions options)
    {
        // 在这里接入平台专属缓存清理逻辑。
        return base.ClearCacheAsync(options);
    }
}
```

--------------------------------

### Initialize and Manage Resource Packages

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

Demonstrates initializing the resource system, creating, getting, and checking for the existence of resource packages. Note that default package static interfaces are removed in v3.0.

```csharp
// Initialize resource system  
YooAssets.Initialize();  

// Create default resource package  
var package = YooAssets.CreatePackage("DefaultPackage");  

// Get specified resource package, will throw error if not found  
var package = YooAssets.GetPackage("DefaultPackage");  

// Get specified resource package, will not throw error if not found  
if (YooAssets.TryGetPackage("DefaultPackage", out var package))  
{
    // Found resource package  
}

```

--------------------------------

### Google Play File System Example

Source: https://www.yooasset.com/docs/solution/ExtendFileSystem

Inherit from BuiltinFileSystem to override resource package loading logic for scenarios like Google Play Asset Delivery.

```csharp
internal class GooglePlayFileSystem : BuiltinFileSystem, IFileSystem  
{
    public new FSLoadPackageBundleOperation LoadPackageBundleAsync(FSLoadPackageBundleOptions options)
    {
        var operation = new GPFSLoadPackageBundleOperation(this, options);
        return operation;
    }
}
```

--------------------------------

### Wwise SoundBank Hot-Update Pseudocode Example

Source: https://www.yooasset.com/docs/solution/Wwise

This pseudocode demonstrates how to download updated audio files using tags and ensure their readiness for Wwise, including copying them to the specified hot-update directory.

```csharp
// 在资源收集界面，将SoundBank文件目录设置为原生文件（PackRawFile)，并增加一个Tag标记。  
public IEnumerator Start()  
{  
    ......  
          
    var package = YooAssets.GetPackage("DefaultPackage");  
    string soundbankTag = "soundbank";  
    string location = "Assets/GameRes/Wwise/Init.bnk";  
    string soundbankFileName = Path.GetFileName(location);  
      
    // 通过Tag标记下载更新的音频文件  
    var downloader = package.CreateResourceDownloader(new ResourceDownloaderOptions(soundbankTag, 10, 3));  
    downloader.StartDownload();  
    yield return downloader;  
      
    // 通过 EnsureBundleFileAsync 确保文件就绪并获取本地路径  
    var ensureOp = package.EnsureBundleFileAsync(new EnsureBundleFileOptions(location));  
    yield return ensureOp;  
      
    // 拷贝沙盒内音频文件到指定目录下（AddBasePath方法添加的目录）  
    var packageVersion = package.GetPackageVersion();  
    var basePath = $"{Application.persistentDataPath}/Audio/GeneratedSoundBanks/{packageVersion}";  
    var soundbankSourceFilePath = ensureOp.Detail.BundleFilePath;  
    var soundbankDestFilePath = $"{basePath}/{soundbankFileName}";  
    if (File.Exists(soundbankDestFilePath) == false)  
    {  
        Directory.CreateDirectory(basePath);  
        File.Copy(soundbankSourceFilePath, soundbankDestFilePath);  
    }  
}  

```

--------------------------------

### Ensure Bundle File and Get Path

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Ensure a bundle file is ready locally and get its file path. This is useful for passing real file paths to third-party systems. Not recommended for reading file content directly. Not supported on WebGL or mini-game platforms.

```csharp
IEnumerator Start()  
{  
    string location = "Assets/GameRes/wwise/init.bnk";  
    var ensureOp = package.EnsureBundleFileAsync(new EnsureBundleFileOptions(location));  
    yield return ensureOp;  
  
    string filePath = ensureOp.Detail.BundleFilePath;  
    AudioEngine.LoadBank(filePath);  
}  
```

--------------------------------

### Set Install Cleanup Mode

Source: https://www.yooasset.com/docs/guide-runtime/FileSystem

Defines the cleanup mode for cached files in the sandbox after an overwrite installation, applied on the first launch. Supports BuiltinFileSystem and SandboxFileSystem.

```csharp
fileSystemParameters.AddParameter(EFileSystemParameter.InstallCleanupMode, EInstallCleanupMode.ClearAllCacheFiles);

```

--------------------------------

### Get All Asset Information List

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Retrieve a list of all asset information objects within the package. This provides a comprehensive overview of all available assets.

```csharp
void GetAllAssetInfos()  
{  
    AssetInfo[] assetInfos = package.GetAllAssetInfos();  
    foreach (var assetInfo in assetInfos)  
    {  
        Debug.Log(assetInfo.AssetPath);  
    }  
}
```

--------------------------------

### Load Raw File Asynchronously

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Load a raw file asynchronously, such as a .bnk file for audio middleware. Requires the package to be built with a native pipeline. Provides methods to get file data as bytes or text.

```csharp
IEnumerator Start()  
{  
    // 注意：该Package必须是原生文件构建管线构建的资源包裹。  
    string location = "Assets/GameRes/wwise/init.bnk";  
    AssetHandle handle = package.LoadAssetAsync<RawFileObject>(location);  
    yield return handle;  
  
    RawFileObject rawFileObject = handle.GetAssetObject<RawFileObject>();  
    byte[] fileData = rawFileObject.GetBytes();  
    string fileText = rawFileObject.GetText();  
  
    handle.Release();  
}  
```

--------------------------------

### Runtime Asset Loading and Release

Source: https://www.yooasset.com/docs/solution/AssetReference

Load assets asynchronously using `LoadAssetAsync()` and instantiate them with `InstantiateSync()`. Always validate references with `RuntimeKeyIsValid()` before loading and release assets with `ReleaseAsset()` when done to prevent memory leaks. This example demonstrates loading a prefab and a texture.

```csharp
private IEnumerator Start()  
{
    // 加载并实例化预制体  
    if (_prefabReference.RuntimeKeyIsValid())
    {
        AssetHandle handle = _prefabReference.LoadAssetAsync();
        yield return handle;
        if (handle.Status == EOperationStatus.Succeeded)
        {
            handle.InstantiateSync(new InstantiateOptions(true, transform, false));
        }
    }

    // 加载纹理并赋值给材质  
    if (_textureReference.RuntimeKeyIsValid())
    {
        AssetHandle handle = _textureReference.LoadAssetAsync();
        yield return handle;
        if (handle.Status == EOperationStatus.Succeeded)
        {
            var renderer = GetComponent<Renderer>();
            if (renderer != null)
                renderer.material.mainTexture = handle.AssetObject as Texture2D;
        }
    }
}

private void OnDestroy()
{
    _prefabReference?.ReleaseAsset();
    _textureReference?.ReleaseAsset();
}
```

--------------------------------

### Configure Build for Variant Copying

Source: https://www.yooasset.com/docs/solution/VariantSinglePackage

Set build parameters to copy only assets tagged with a specific variant into the initial package. This reduces the initial installation size.

```csharp
buildParameters.BundledCopyOption = EBundledCopyOption.OnlyCopyByTags; // 或 ClearAndCopyByTags
buildParameters.BundledCopyParams = "2K";

```

--------------------------------

### Load Sprite Atlas Async Example

Source: https://www.yooasset.com/docs/solution/SpriteAtlasZeroRedundancy

Demonstrates how to asynchronously load a SpriteAtlas using YooAssets and retrieve a specific sprite from it. Ensure the SBP plugin is updated and the sprite asset collector is set to StaticAssetCollector.

```csharp
public IEnumerator Start()
{
    var package = YooAssets.GetPackage("DefaultPackage");
    var handle = package.LoadAssetAsync<SpriteAtlas>(location);
    yield return handle;
      
    var atlas = handle.AssetObject as SpriteAtlas;
    _image.sprite = atlas.GetSprite("icon_test");
}

```

--------------------------------

### Migrate Default Package API Calls

Source: https://www.yooasset.com/docs/MigrationGuide

In v3, static shortcut methods for default package operations are removed. Use YooAssets.GetPackage() to get the package instance and call methods on it.

```csharp
// v2.3 写法 -- 不再支持  
YooAssets.SetDefaultPackage(package);
YooAssets.LoadAssetAsync<GameObject>("Assets/Prefabs/Hero.prefab");  

// v3 写法 -- 必须通过 ResourcePackage 实例调用  
var package = YooAssets.GetPackage("DefaultPackage");  
package.LoadAssetAsync<GameObject>("Assets/Prefabs/Hero.prefab");  
```

--------------------------------

### Try Loading Local Package on Network Failure

Source: https://www.yooasset.com/docs/solution/WeakNetworkA

Attempts to load the last successfully updated local version of a package. If no local version exists (e.g., first install with no network), it falls back to the built-in version within the package. Requires careful handling of operation statuses and error callbacks.

```csharp
private IEnumerator TryLoadLocalPackage(ResourcePackage package, System.Action<bool, string> callback)
{
    string version = PlayerPrefs.GetString("GAME_VERSION", string.Empty);
    if (string.IsNullOrEmpty(version))
    {
        // 首次安装无网络时，尝试使用包体内置版本
        var builtinVersionOp = new GetBuildinPackageVersionOperation(package.PackageName);
        OperationHelper.StartOperation(package.PackageName, builtinVersionOp);
        yield return builtinVersionOp;
        if (builtinVersionOp.Status == EOperationStatus.Succeeded)
        {
            version = builtinVersionOp.PackageVersion;
        }
        else
        {
            callback.Invoke(false, builtinVersionOp.Error);
            yield break;
        }
    }

    // 加载本地缓存的资源清单文件
    // 注意：HostPlayMode下会优先使用沙盒里已有的Hash和Manifest文件。
    var manifestOp = package.LoadPackageManifestAsync(new LoadPackageManifestOptions(version, 60));
    yield return manifestOp;
    if (manifestOp.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false, manifestOp.Error);
        yield break;
    }

    // 在正常开始游戏之前，还需要验证本地资源内容的完整性
    var downloader = package.CreateResourceDownloader(new ResourceDownloaderOptions(1, 1));
    if (downloader.TotalDownloadCount > 0)
    {
        callback.Invoke(false, "本地资源内容不完整。");
        yield break;
    }

    callback.Invoke(true, string.Empty);
}
```

--------------------------------

### Initialize Package Async with Full Initialization Steps

Source: https://www.yooasset.com/docs/FAQ

This snippet demonstrates the complete asynchronous initialization process for a YooAsset package, including initializing the package, requesting version information, and loading the package manifest. Ensure all steps succeed before proceeding.

```csharp
private IEnumerator InitPackage()  
{
    //（本段为伪代码，以下代码参数已经全部省略！）  
    // 需要保证下面三步成功执行  
    // 1. 初始化包裹  
    var initOp = package.InitializePackageAsync(createParameters);
    yield return initOp;
    if (initOp.Status != EOperationStatus.Succeeded)
        yield break;
      
    // 2. 请求资源清单的版本信息  
    var versionOp = package.RequestPackageVersionAsync();
    yield return versionOp;
    if (versionOp.Status != EOperationStatus.Succeeded)
        yield break;
      
    // 3. 传入的版本信息更新资源清单  
    var manifestOp = package.LoadPackageManifestAsync(new LoadPackageManifestOptions(versionOp.PackageVersion, 60));
    yield return manifestOp;
    if (manifestOp.Status != EOperationStatus.Succeeded)
        yield break;
}
```

--------------------------------

### Initialize Douyin File System

Source: https://www.yooasset.com/docs/minigame/Tiktok

Initializes the ResourcePackage for Douyin Mini Game, setting up the remote service and file system parameters. Ensure no caching is enabled for the resource manifest version file.

```csharp
IEnumerator InitPackage()  
{  
    // 创建远程服务类  
    string defaultHostServer = GetHostServerURL();  
    string fallbackHostServer = GetHostServerURL();  
    IRemoteService remoteService = new RemoteService(defaultHostServer, fallbackHostServer);  
      
    // 创建解密服务类  
    IBundleDecryptor decryptor = null; //如需资源加密，请传入自定义解密器实例。  
      
    // 创建初始化参数  
    var createParameters = new WebPlayModeOptions();  
    createParameters.WebNetworkFileSystemParameters = TiktokFileSystemCreater.CreateFileSystemParameters(remoteService, decryptor);  
      
    // 初始化ResourcePackage  
    yield return package.InitializePackageAsync(createParameters);  
}  

```

--------------------------------

### GetAssetInfo

Source: https://www.yooasset.com/docs/api/YooAsset/ResourcePackage

Retrieves asset information using its location or GUID.

```APIDOC
## GetAssetInfo(string)

### Description
Gets the asset information using its location address.

### Method Signature
```csharp
public AssetInfo GetAssetInfo(string location)
```

### Parameters
#### Parameters
- **location** (System.String) - Required - The location address of the asset.

### Returns
`YooAsset.AssetInfo` - The asset information object.
```

```APIDOC
## GetAssetInfo(string, Type)

### Description
Gets the asset information using its location address and type.

### Method Signature
```csharp
public AssetInfo GetAssetInfo(string location, Type type)
```

### Parameters
#### Parameters
- **location** (System.String) - Required - The location address of the asset.
- **type** (System.Type) - Required - The type of the asset.

### Returns
`YooAsset.AssetInfo` - The asset information object.
```

```APIDOC
## GetAssetInfoByGuid(string)

### Description
Gets the asset information using its asset GUID.

### Method Signature
```csharp
public AssetInfo GetAssetInfoByGuid(string assetGuid)
```

### Parameters
#### Parameters
- **assetGuid** (System.String) - Required - The asset GUID.

### Returns
`YooAsset.AssetInfo` - The asset information object.
```

```APIDOC
## GetAssetInfoByGuid(string, Type)

### Description
Gets the asset information using its asset GUID and type.

### Method Signature
```csharp
public AssetInfo GetAssetInfoByGuid(string assetGuid, Type type)
```

### Parameters
#### Parameters
- **assetGuid** (System.String) - Required - The asset GUID.
- **type** (System.Type) - Required - The type of the asset.

### Returns
`YooAsset.AssetInfo` - The asset information object.
```

--------------------------------

### Initialize File System for Video Playback

Source: https://www.yooasset.com/docs/solution/VideoPackAndLoad

Initializes the file system with default parameters for built-in and sandbox file systems. Ensure this is called before package initialization.

```csharp
// Initialize file system considerations
// Note: APPEND_FILE_EXTENSION parameter has been removed
public IEnumerator Start()
{
    var builtinFileSystemParams = FileSystemParameters.CreateDefaultBuiltinFileSystemParameters();    
    var cacheFileSystemParams = FileSystemParameters.CreateDefaultSandboxFileSystemParameters(remoteServices);
  
    var createParameters = new HostPlayModeOptions();
    createParameters.BuiltinFileSystemParameters = builtinFileSystemParams;
    createParameters.CacheFileSystemParameters = cacheFileSystemParams;
    var initializationOperation = package.InitializePackageAsync(createParameters);
    yield return initializationOperation;
}

```

--------------------------------

### Get Default Yoo Folder Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Retrieves the root folder name for asset packages. Returns 'yoo' if not configured.

```csharp
public static string GetYooFolderName()

```

--------------------------------

### Instantiate Prefab with Options

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Instantiate a loaded prefab synchronously using InstantiateOptions to specify parent, position, rotation, and activation state.

```csharp
var options = new InstantiateOptions(true, parent, false);  
GameObject go = handle.InstantiateSync(options);  
```

--------------------------------

### BeginCollect() Method

Source: https://www.yooasset.com/docs/api/YooAsset.Editor/BundleCollectorSetting

Initiates the asset collection process for a specified package. Allows for simulation and use of the asset dependency database.

```csharp
public CollectResult BeginCollect(string packageName, bool simulateBuild, bool useAssetDependencyDB)  
```

--------------------------------

### Get UOS CDN Host Server URL

Source: https://www.yooasset.com/docs/minigame/Minihost

Retrieves the CDN root directory configured through the official interface. This is used for setting up remote services.

```csharp
private string GetHostServerURL()  
{  
    // 可以通过官方接口直接获取配置的CDN根目录  
    string cdn = minihost.TJ.GetDataCDN();  
    return cdn;  
}  

```

--------------------------------

### Get Build Report File Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Generates the file name for a build report, including the .report extension. Requires package name and version.

```csharp
public static string GetBuildReportFileName(string packageName, string packageVersion)

```

--------------------------------

### Initialize WebPlayMode Package

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

Initializes a resource package for WebPlayMode, suitable for platforms like WeChat Mini Games and Douyin Mini Games. Requires building resource packages and configuring remote services for CDN downloads.

```csharp
private IEnumerator InitPackage()
{
    var package = YooAssets.GetPackage("DefaultPackage");
    string defaultHostServer = "http://127.0.0.1/CDN/Android/v1.0";
    string fallbackHostServer = "http://127.0.0.1/CDN/Android/v1.0";

    //说明：RemoteServices类定义请参考联机运行模式！
    IRemoteService remoteServices = new RemoteServices(defaultHostServer, fallbackHostServer);
    var webServerFileSystemParams = FileSystemParameters.CreateDefaultWebServerFileSystemParameters();
    var webNetworkFileSystemParams = FileSystemParameters.CreateDefaultWebNetworkFileSystemParameters(remoteServices); //支持跨域下载
      
    var createParameters = new WebPlayModeOptions();
    createParameters.WebServerFileSystemParameters = webServerFileSystemParams;
    createParameters.WebNetworkFileSystemParameters = webNetworkFileSystemParams;
      
    var initOperation = package.InitializePackageAsync(createParameters);
    yield return initOperation;
      
    if(initOperation.Status == EOperationStatus.Succeeded)
        Debug.Log("资源包初始化成功！");
    else   
        Debug.LogError($"资源包初始化失败：{initOperation.Error}");
      
    //获取资源版本  
    ...(代码省略，见下文)  
      
    //更新资源清单  
    ...(代码省略，见下文)      
}
```

--------------------------------

### Editor: Manual Sprite Atlas Dependency

Source: https://www.yooasset.com/docs/solution/SpriteAtlasWhiteBlock

Manually add SpriteAtlas dependencies in the editor. This requires configuring GUIDs for relevant folders in their meta files.

```csharp
/// <summary>  
/// 面板文件夹GUID  
/// </summary>  
private const string UIPanelDirectoryGUID = "12d33f33f3a55224c9c747d7bffa1c68";  

/// <summary>  
/// 精灵文件夹GUID  
/// </summary>  
private const string UISpriteDirectoryGUID = "935d7f20c085cc141a3daf9cacfabfae";  

/// <summary>  
/// 图集文件夹GUID  
/// </summary>  
private const string UIAtlasDirectoryGUID = "c355c783476322b4cacac98c5e1b46d8";  
```

```csharp
public class PanelManifest : MonoBehaviour  
{
	/// <summary>  
	/// 面板自动引用的图集  
	/// </summary>
	public List<SpriteAtlas> ReferencesAtlas = new List<SpriteAtlas>();  
}
public class UIPanelMonitor : UnityEditor.Editor  
{
    [InitializeOnLoadMethod]  
    static void StartInitializeOnLoadMethod()  
    {
        PrefabStage.prefabSaving += OnPrefabSaving;  
    }
    static void OnPrefabSaving(GameObject go)  
    {
        // 扫描预制体所有Image组件，找到对应的图集对象并建立引用关系  
        ......  
    }
}
```

--------------------------------

### Initialize Package Async with Null Builtin File System

Source: https://www.yooasset.com/docs/FAQ

If you encounter 'Can not found package version file' errors in HostPlayMode and have no initial built-in assets, set BuiltinFileSystemParameters to null during initialization.

```csharp
private IEnumerator InitPackage()  
{
    var createParameters = new HostPlayModeOptions();
    createParameters.BuiltinFileSystemParameters = null; //设置为NULL解决报错！  
    createParameters.CacheFileSystemParameters = FileSystemParameters.CreateDefaultSandboxFileSystemParameters(remoteServices);
    var initializationOperation = package.InitializePackageAsync(createParameters);
    yield return initializationOperation;
}
```

--------------------------------

### Initialize Host Play Mode

Source: https://www.yooasset.com/docs/solution/WeakNetworkB

Initializes the package in host play mode, attempting to connect to remote services, request package version, load manifest, and download necessary resources. Any failure in these steps results in the host mode being considered unavailable.

```csharp
private IEnumerator InitHostPlayMode(System.Action<bool> callback)
{
    var package = YooAssets.CreatePackage(PackageName);

    var remoteServices = new RemoteService(defaultHostServer, fallbackHostServer);
    var initParameters = new HostPlayModeOptions();
    initParameters.BuiltinFileSystemParameters = FileSystemParameters.CreateDefaultBuiltinFileSystemParameters();
    initParameters.CacheFileSystemParameters = FileSystemParameters.CreateDefaultSandboxFileSystemParameters(remoteServices);
    var initOperation = package.InitializePackageAsync(initParameters);
    yield return initOperation;
    if (initOperation.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    // 获取远端版本失败，判定为无网络  
    var versionOp = package.RequestPackageVersionAsync(new RequestPackageVersionOptions(true, 30));
    yield return versionOp;
    if (versionOp.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    // 加载远端资源清单  
    var manifestOp = package.LoadPackageManifestAsync(new LoadPackageManifestOptions(versionOp.PackageVersion, 60));
    yield return manifestOp;
    if (manifestOp.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    // 下载更新资源  
    var downloader = package.CreateResourceDownloader(new ResourceDownloaderOptions(10, 3));
    if (downloader.TotalDownloadCount > 0)
    {
        downloader.StartDownload();
        yield return downloader;
        if (downloader.Status != EOperationStatus.Succeeded)
        {
            callback.Invoke(false);
            yield break;
        }
    }

    callback.Invoke(true);
}
```

--------------------------------

### Get Asset Information by Variant Tag

Source: https://www.yooasset.com/docs/solution/VariantSinglePackage

Retrieve information about assets belonging to a specific variant tag. This can be used to query available assets for a given variant.

```csharp
AssetInfo[] infos = package.GetAssetInfos(VariantLoader.Variant); // -> GetAssetInfosByTags

```

--------------------------------

### Initialize Package Async with EditorSimulateModeOptions

Source: https://www.yooasset.com/docs/FAQ

Use this when initializing YooAsset in EditorSimulateMode. Ensure the EditorFileSystemParameters are correctly configured with the package root directory.

```csharp
if (playMode == EPlayMode.EditorSimulateMode)  
{
    var buildResult = EditorSimulateBuildInvoker.Build(packageName, (int)EBundleType.VirtualAssetBundle);
    var packageRoot = buildResult.PackageRootDirectory;
    var createParameters = new EditorSimulateModeOptions();
    createParameters.EditorFileSystemParameters = FileSystemParameters.CreateDefaultEditorFileSystemParameters(packageRoot);
    yield return package.InitializePackageAsync(createParameters);
}
```

--------------------------------

### Get Package Version File Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Generates the file name for a package version record file, including the .version extension. Requires package name.

```csharp
public static string GetPackageVersionFileName(string packageName)

```

--------------------------------

### Configure Custom Download Backend

Source: https://www.yooasset.com/docs/guide-runtime/FileSystem

Replaces the default download implementation with a custom one by providing an instance of IDownloadBackend. Supported only by SandboxFileSystem.

```csharp
IDownloadBackend backend = new MyDownloadBackend();
fileSystemParameters.AddParameter(EFileSystemParameter.DownloadBackend, backend);

```

--------------------------------

### Get Package Hash File Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Generates the file name for a package hash file, including the .hash extension. Requires package name and version.

```csharp
public static string GetPackageHashFileName(string packageName, string packageVersion)

```

--------------------------------

### Initialize ResourcePackage Asynchronously

Source: https://www.yooasset.com/docs/minigame/Website

Initializes the ResourcePackage asynchronously for web mini-games. Requires setting up remote services and creating initialization parameters. Does not support synchronous loading or downloaders.

```csharp
IEnumerator InitPackage()  
{  
    // 创建远程服务类  
    string defaultHostServer = GetHostServerURL();  
    string fallbackHostServer = GetHostServerURL();  
    IRemoteService remoteService = new RemoteService(defaultHostServer, fallbackHostServer);  
      
    // 创建初始化参数  
    var createParameters = new WebPlayModeOptions();  
    createParameters.WebNetworkFileSystemParameters = FileSystemParameters.CreateDefaultWebNetworkFileSystemParameters(remoteService);  
    createParameters.WebServerFileSystemParameters = FileSystemParameters.CreateDefaultWebServerFileSystemParameters();  
      
    // 初始化ResourcePackage  
    yield return package.InitializePackageAsync(createParameters);  
}  

```

--------------------------------

### Get Manifest JSON File Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Generates the file name for a manifest JSON file, including the .json extension. Requires package name and version.

```csharp
public static string GetManifestJsonFileName(string packageName, string packageVersion)

```

--------------------------------

### Creating Default Built-in File System Parameters

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

This snippet shows how to set up the root directory for the built-in file system, which is a sandbox directory. Be cautious when using the persistentDataPath as the root for the built-in file system due to potential risks.

```csharp
string packageRoot = Application.persistentDataPath + "/builtin"; //沙盒目录  
FileSystemParameters.CreateDefaultBuiltinFileSystemParameters(packageRoot);

```

--------------------------------

### Get Manifest Binary File Name

Source: https://www.yooasset.com/docs/api/YooAsset/YooAssetConfiguration

Generates the file name for a manifest binary file, including the .bytes extension. Requires package name and version.

```csharp
public static string GetManifestBinaryFileName(string packageName, string packageVersion)

```

--------------------------------

### Migrate Bundle File Path Acquisition

Source: https://www.yooasset.com/docs/MigrationGuide

The GetRawFilePath() method on handles is removed in v3. Use EnsureBundleFileAsync with EnsureBundleFileOptions to get the bundle file path asynchronously.

```csharp
// v2.3 写法  
var handle = package.LoadRawFileSync("location");  
string path = handle.GetRawFilePath();  

// v3 写法  
var options = new EnsureBundleFileOptions("location");  
var op = package.EnsureBundleFileAsync(options);  
await op;  
string path = op.Detail.BundleFilePath;  
```

--------------------------------

### Initialize CustomPlayMode Package

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

Initializes a resource package using CustomPlayMode, which supports multiple file systems. The last element in the FileSystemParameterList is designated as the primary file system.

```csharp
private IEnumerator InitPackage()
{
    var package = YooAssets.GetPackage("DefaultPackage");
    // 配置各个文件系统参数  
    ......  
      
    var createParameters = new CustomPlayModeOptions();
    createParameters.FileSystemParameterList.Add(FileSystemParamsA);
    createParameters.FileSystemParameterList.Add(FileSystemParamsB);
    createParameters.FileSystemParameterList.Add(FileSystemParamsC);
      
    var initOperation = package.InitializePackageAsync(createParameters);
    yield return initOperation;
      
    if(initOperation.Status == EOperationStatus.Succeeded)
        Debug.Log("资源包初始化成功！");
    else   
        Debug.LogError($"资源包初始化失败：{initOperation.Error}");
}
```

--------------------------------

### Get Asset Information List by Tag

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Retrieve a list of asset information objects by specifying a tag. This is useful for filtering and managing assets based on their assigned tags.

```csharp
void GetAssetInfosByTag(string tag)  
{  
    AssetInfo[] assetInfos = package.GetAssetInfos(tag);  
    foreach (var assetInfo in assetInfos)  
    {  
        Debug.Log(assetInfo.AssetPath);  
    }  
}
```

--------------------------------

### Initialize File System

Source: https://www.yooasset.com/docs/minigame/Minihost

Initializes the ResourcePackage for the file system. Ensure remote services are correctly configured before calling.

```csharp
IEnumerator InitPackage()  
{  
    // 创建远程服务类  
    string defaultHostServer = GetHostServerURL();  
    string fallbackHostServer = GetHostServerURL();  
    IRemoteService remoteService = new RemoteService(defaultHostServer, fallbackHostServer);  
      
    // 创建初始化参数  
    var createParameters = new WebPlayModeOptions();  
    createParameters.WebNetworkFileSystemParameters = FileSystemParameters.CreateDefaultWebNetworkFileSystemParameters(remoteService);  
      
    // 初始化ResourcePackage  
    yield return package.InitializePackageAsync(createParameters);  
}  

```

--------------------------------

### Initialize Package in Host Play Mode

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

Initializes a resource package for host play mode, designed for games that require hot updates. This mode requires building resource bundles and uses remote services for updates.

```csharp
private IEnumerator InitPackage()  
{
    var package = YooAssets.GetPackage("DefaultPackage");  
    string defaultHostServer = "http://127.0.0.1/CDN/Android/v1.0";  
    string fallbackHostServer = "http://127.0.0.1/CDN/Android/v1.0";  
    IRemoteService remoteServices = new RemoteServices(defaultHostServer, fallbackHostServer);
    var cacheFileSystemParams = FileSystemParameters.CreateDefaultSandboxFileSystemParameters(remoteServices);
    var builtinFileSystemParams = FileSystemParameters.CreateDefaultBuiltinFileSystemParameters();  
      
    var createParameters = new HostPlayModeOptions();  
    createParameters.BuiltinFileSystemParameters = builtinFileSystemParams;
    createParameters.CacheFileSystemParameters = cacheFileSystemParams;
      
    var initOperation = package.InitializePackageAsync(createParameters);
    yield return initOperation;
      
    if(initOperation.Status == EOperationStatus.Succeeded)
        Debug.Log("Resource package initialized successfully!");
    else  
        Debug.LogError($"Resource package initialization failed: {initOperation.Error}");
      
    // Get resource version  
    ...(code omitted, see below)  
      
    // Update resource manifest  
    ...(code omitted, see below)      
}

```

--------------------------------

### Merge Downloaders

Source: https://www.yooasset.com/docs/guide-runtime/ResourceUpdate

Combines multiple resource downloaders from the same package into a single downloader. This is useful for downloading tagged resources and specific asset files concurrently. The combined downloader is then started.

```csharp
// 例如：把关卡资源下载器和某个指定资源下载器进行合并。  
var downloader1 = package.CreateResourceDownloader(new ResourceDownloaderOptions("level_tag", downloadingMaxNum, failedTryAgain));  
var assetInfo = package.GetAssetInfo("asset_location");  
var downloader2 = package.CreateResourceDownloader(new BundleDownloaderOptions(assetInfo, false, downloadingMaxNum, failedTryAgain));  
downloader1.Combine(downloader2);  

//开启下载  
downloader1.StartDownload();  
```

--------------------------------

### Load Asset Async with Fuzzy and Exact Path Matching

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Demonstrates fuzzy matching without an extension and exact matching with an extension for asynchronous asset loading.

```csharp
// 不带扩展名的模糊匹配  
package.LoadAssetAsync<AudioClip>("Assets/GameRes/Audio/bgMusic");  
  
// 带扩展名的精准匹配  
package.LoadAssetAsync<AudioClip>("Assets/GameRes/Audio/bgMusic.mp3");  
```

--------------------------------

### Initialize Package in Editor Simulate Mode

Source: https://www.yooasset.com/docs/guide-runtime/ResourceInit

Initializes a resource package for editor simulation. This mode does not require building resource bundles and is only effective in the editor. It uses virtual asset bundle types.

```csharp
private IEnumerator InitPackage()  
{
    var package = YooAssets.GetPackage("DefaultPackage");  
    var buildResult = EditorSimulateBuildInvoker.Build("DefaultPackage", (int)EBundleType.VirtualAssetBundle);
    var packageRoot = buildResult.PackageRootDirectory;
    var fileSystemParams = FileSystemParameters.CreateDefaultEditorFileSystemParameters(packageRoot);
      
    var createParameters = new EditorSimulateModeOptions();  
    createParameters.EditorFileSystemParameters = fileSystemParams;
      
    var initOperation = package.InitializePackageAsync(createParameters);
    yield return initOperation;
      
    if(initOperation.Status == EOperationStatus.Succeeded)
        Debug.Log("Resource package initialized successfully!");
    else  
        Debug.LogError($"Resource package initialization failed: {initOperation.Error}");
      
    // Get resource version  
    ...(code omitted, see below)  
      
    // Update resource manifest  
    ...(code omitted, see below)
}

```

--------------------------------

### Instantiate Prefab Asynchronously

Source: https://www.yooasset.com/docs/guide-runtime/ResourceLoad

Load a prefab asynchronously and then instantiate it synchronously. The instantiated GameObject is returned.

```csharp
IEnumerator Start()  
{  
    AssetHandle handle = package.LoadAssetAsync<GameObject>("Assets/GameRes/Panel/login.prefab");  
    yield return handle;  
    GameObject go = handle.InstantiateSync();  
    Debug.Log($
```

--------------------------------

### Initialize Game Logic and Art Packages in Editor

Source: https://www.yooasset.com/docs/solution/DistributedBuild

Initializes the 'GameLogic' package using editor simulation mode and the 'GameArt' package using host play mode for development and art asset updates respectively. This approach is suitable for the project development phase.

```csharp
private IEnumerator Start()
{
    // 游戏工程使用编辑器模拟运行方式，可以方便快捷的验证游戏修改效果。
    {
        var package = YooAssets.CreatePackage("GameLogic");
        var initParameters = new EditorSimulateModeOptions();
        ...（省略初始化参数）
        var initializationOperation = package.InitializePackageAsync(initParameters);
        yield return initializationOperation;
    }

    // 美术工程使用HostPlayMode运行方式，通过公司本地的资源服务器来更新。
    {
        var package = YooAssets.CreatePackage("GameArt");
        var initParameters = new HostPlayModeOptions();
        ...（省略初始化参数）
        var initializationOperation = package.InitializePackageAsync(initParameters);
        yield return initializationOperation;
          
        //美术资源更新流程
        ......
    }
}
```

--------------------------------

### Initialize WeChat File System

Source: https://www.yooasset.com/docs/minigame/Wechat

Initializes the ResourcePackage for WeChat Mini Games. Ensure the WeChat plugin configuration matches the packageRoot path. Does not support synchronous loading.

```csharp
IEnumerator InitPackage()
{
    // 创建远程服务类
    string defaultHostServer = GetHostServerURL();
    string fallbackHostServer = GetHostServerURL();
    IRemoteService remoteService = new RemoteService(defaultHostServer, fallbackHostServer);

    // 小游戏缓存根目录
    // 注意：此处代码根据微信插件配置来填写！
    string packageRoot = $"{WeChatWASM.WX.env.USER_DATA_PATH}/__GAME_FILE_CACHE/yoo";
    //string packageRoot = $"{WeChatWASM.WX.PluginCachePath}/yoo";

    // 创建初始化参数
    var createParameters = new WebPlayModeOptions();
    createParameters.WebNetworkFileSystemParameters = WechatFileSystemCreater.CreateFileSystemParameters(packageRoot, remoteService, null);

    // 初始化ResourcePackage
    yield return package.InitializePackageAsync(createParameters);
}

```

--------------------------------

### Scene Unload Example

Source: https://www.yooasset.com/docs/guide-runtime/ResourceUnload

Asynchronously load a scene and then unload it. Scene unloading automatically releases the handle's reference count. You must retain at least one scene; the last scene cannot be unloaded.

```csharp
IEnumerator Start()
{
    // Asynchronously load scene
    var sceneHandle = package.LoadSceneAsync("Assets/GameRes/Scene/scene_home");
    yield return sceneHandle;
      
    ...
      
    // After the scene is unloaded successfully, the handle's reference count will be automatically released!
    // You must keep at least one scene, and the last scene cannot be unloaded!
    var operation = sceneHandle.UnloadSceneAsync();
    yield return operation;
}

```

--------------------------------

### Initialize Package with Weak Network Fallback

Source: https://www.yooasset.com/docs/solution/WeakNetworkA

Initializes the YooAssets package, copying the built-in manifest and setting up cleanup modes. It then attempts a remote update and falls back to the local package if the remote update fails.

```csharp
private IEnumerator Start()
{
    var package = YooAssets.CreatePackage("DefaultPackage");

    // 注意：设置参数CopyBuiltinPackageManifest，可以初始化的时候拷贝内置清单到沙盒目录
    var builtinFileSystemParams = FileSystemParameters.CreateDefaultBuiltinFileSystemParameters();
    builtinFileSystemParams.AddParameter(EFileSystemParameter.CopyBuiltinPackageManifest, true);

    // 注意：设置参数InstallCleanupMode，可以解决覆盖安装的时候将拷贝的内置清单文件清理的问题
    var cacheFileSystemParams = FileSystemParameters.CreateDefaultSandboxFileSystemParameters(remoteServices);
    cacheFileSystemParams.AddParameter(EFileSystemParameter.InstallCleanupMode, EInstallCleanupMode.None);

    var playModeParameters = new HostPlayModeOptions();
    playModeParameters.BuiltinFileSystemParameters = builtinFileSystemParams;
    playModeParameters.CacheFileSystemParameters = cacheFileSystemParams;
    var initOperation = package.InitializePackageAsync(playModeParameters);
    yield return initOperation;

    if (initOperation.Status != EOperationStatus.Succeeded)
    {
        ShowMessageBox($"资源系统初始化失败：{initOperation.Error}");
        yield break;
    }

    // 优先尝试远端更新流程
    bool remoteSucceed = false;
    string remoteError = string.Empty;
    yield return TryUpdateRemotePackage(package, (succeed, error) =>
    {
        remoteSucceed = succeed;
        remoteError = error;
    });
    if (remoteSucceed)
    {
        StartGame();
        yield break;
    }

    // 远端流程失败时，回退到本地可用版本
    bool localSucceed = false;
    string localError = string.Empty;
    yield return TryLoadLocalPackage(package, (succeed, error) =>
    {
        localSucceed = succeed;
        localError = error;
    });
    if (localSucceed)
    {
        StartGame();
        yield break;
    }

    ShowMessageBox($"资源更新失败：{remoteError}\n本地资源不可用：{localError}");
}
```

--------------------------------

### Download All Resources

Source: https://www.yooasset.com/docs/guide-runtime/ResourceUpdate

Initiates the download of all resource package files for the current resource version. It allows configuration of maximum concurrent downloads and retry attempts for failed downloads. Callbacks are registered for download progress and completion events.

```csharp
IEnumerator Download()  
{  
    int downloadingMaxNum = 10;  
    int failedTryAgain = 3;  
    var package = YooAssets.GetPackage("DefaultPackage");  
    var downloader = package.CreateResourceDownloader(new ResourceDownloaderOptions(downloadingMaxNum, failedTryAgain));  
      
    //没有需要下载的资源  
    if (downloader.TotalDownloadCount == 0)  
    {          
        yield break;  
    }  
  
    //需要下载的文件总数和总大小  
    int totalDownloadCount = downloader.TotalDownloadCount;  
    long totalDownloadBytes = downloader.TotalDownloadBytes;      
  
    //注册回调方法  
    downloader.DownloadCompleted += OnDownloadCompletedFunction; //当下载器结束（无论成功或失败）  
    downloader.DownloadError += OnDownloadErrorFunction; //当下载器发生错误  
    downloader.DownloadProgressChanged += OnDownloadProgressChangedFunction; //当下载进度发生变化  
    downloader.DownloadFileStarted += OnDownloadFileStartedFunction; //当开始下载某个文件  
  
    //开启下载  
    downloader.StartDownload();  
    yield return downloader;  
  
    //检测下载结果  
    if (downloader.Status == EOperationStatus.Succeeded)  
    {  
        //下载成功  
    }  
    else  
    {  
        //下载失败  
    }  
}
```

--------------------------------

### Build Custom Initial Package Resources

Source: https://www.yooasset.com/docs/solution/BuiltinBundleCustom

This code snippet demonstrates how to identify and copy AssetBundle files that should be included in the initial package. It loads a package manifest, finds assets based on a provided list, identifies their dependent bundles, and copies these bundles to the StreamingAssets directory.

```csharp
using UnityEngine;
using UnityEditor;
using YooAsset;
using YooAsset.Editor;

void BuildBundle()
{
    // 等待资源构建流程完成
    ......
      
    // 加载构建成功的资源清单对象
    byte[] manifestBytes = FileUtility.ReadAllBytes(manifestPath);
    PackageManifest manifest = PackageManifestHelper.DeserializeManifestFromBinary(manifestBytes, null);
      
    // 查找所有需要打进首包资源的依赖AB
    HashSet<PackageBundle> bundles = new HashSet<PackageBundle>();
    foreach(var assetPath in builtinAssetPathList)
    {
        if(manifest.TryGetPackageAsset(assetPath, out PackageAsset packageAsset))
        {
            var packageBundle = manifest.BundleList[packageAsset.BundleID];
            if(bundles.Contains(packageBundle) == false)
                bundles.Add(packageBundle);
        }
    }
      
    // 拷贝所有首包文件
    string root = $"{BundleBuilderHelper.GetStreamingAssetsRoot()}/{packageName}";
    foreach(var packageBundle in bundles)
    {
        string destPath = $"{root}/{packageBundle.GetFileName()}";
        ...... //拷贝文件
    }
}

```

--------------------------------

### Include Specific Variant in Initial Package

Source: https://www.yooasset.com/docs/solution/VariantMultiPackage

Configure the build parameters to only copy assets tagged with a specific variant (e.g., '2K') into the initial package. This is useful for optimizing the size of the first download.

```csharp
p.BundledCopyOption = EBundledCopyOption.OnlyCopyByTags;
p.BundledCopyParams = "2K"; //仅内置 2K
```

--------------------------------

### Load and Play Video File

Source: https://www.yooasset.com/docs/solution/VideoPackAndLoad

Loads a video file using EnsureBundleFileAsync, copies it to the sandbox directory, and plays it using a VideoPlayer. Ensure the video file is correctly packaged and accessible.

```csharp
// Video loading example
// Note: Use EnsureBundleFileAsync to get the local file path, copy it to the sandbox directory, and then play
public IEnumerator Start()
{
    var package = YooAssets.GetPackage("DefaultPackage");
    string location = "Assets/GameRes/Video/login.mp4";
    var ensureOp = package.EnsureBundleFileAsync(new EnsureBundleFileOptions(location));
    yield return ensureOp;
  
    // Copy to sandbox directory and name it as .mp4 format
    string bundleFilePath = ensureOp.Detail.BundleFilePath;
    string videoFileName = Path.GetFileNameWithoutExtension(location) + ".mp4";
    string destFilePath = Path.Combine(Application.persistentDataPath, videoFileName);
    if (File.Exists(destFilePath) == false)
    {
        File.Copy(bundleFilePath, destFilePath);
    }
  
    _videoPlayer.url = destFilePath;
    _videoPlayer.Play();
}

```

--------------------------------

### Automated Asset Bundle Build with Legacy Pipeline

Source: https://www.yooasset.com/docs/guide-editor/AssetBundleBuilder

This C# code demonstrates how to perform an automated asset bundle build using the LegacyBuildPipeline. It configures build parameters such as output paths, pipeline type, compression, and caching options. Ensure to set the correct build target and package name.

```csharp
private static void BuildInternal(BuildTarget buildTarget)  
{
    Debug.Log($"开始构建 : {buildTarget}");  

    var buildoutputRoot = BundleBuilderHelper.GetDefaultBuildOutputRoot();  
    var streamingAssetsRoot = BundleBuilderHelper.GetStreamingAssetsRoot();  
      
    // 构建参数  
    LegacyBuildParameters buildParameters = new LegacyBuildParameters();  
    buildParameters.BuildOutputRoot = buildoutputRoot;  
    buildParameters.BundledFileRoot = streamingAssetsRoot;  
    buildParameters.BuildPipeline = EBuildPipeline.LegacyBuildPipeline.ToString();  
    buildParameters.BuildBundleType = (int)EBundleType.AssetBundle; //必须指定资源包类型  
    buildParameters.BuildTarget = buildTarget;  
    buildParameters.PackageName = "DefaultPackage";  
    buildParameters.PackageVersion = "1.0";  
    buildParameters.VerifyBuildingResult = true;  
    buildParameters.EnableSharePackRule = true; //启用共享资源构建模式，兼容1.5x版本  
    buildParameters.FileNameStyle = EFileNameStyle.HashName;  
    buildParameters.BundledCopyOption = EBundledCopyOption.None;  
    buildParameters.BundledCopyParams = string.Empty;  
    buildParameters.BundleEncryptor = CreateEncryptionInstance();  
    buildParameters.CompressOption = ECompressOption.LZ4;  
    buildParameters.ClearBuildCacheFiles = false; //不清理构建缓存，启用增量构建，可以提高打包速度！  
    buildParameters.UseAssetDependencyDB = true; //使用资源依赖关系数据库，可以提高打包速度！  
      
    // 执行构建  
    LegacyBuildPipeline pipeline = new LegacyBuildPipeline();  
    var buildResult = pipeline.Run(buildParameters, true);  
    if (buildResult.Success)  
    {
         Debug.Log($"构建成功 : {buildResult.OutputPackageDirectory}");  
    }
    else  
    {
        Debug.LogError($"构建失败 : {buildResult.ErrorInfo}");  
    }
}
  
// 从构建命令里获取参数示例  
private static string GetBuildPackageName()
{
    foreach (string arg in System.Environment.GetCommandLineArgs())
    {
        if (arg.StartsWith("buildPackage"))
            return arg.Split("="[0])[1];
    }
    return string.Empty;
}

```

--------------------------------

### Initialize Offline Play Mode

Source: https://www.yooasset.com/docs/solution/WeakNetworkB

Initializes the package in offline play mode. This involves destroying and removing any existing package with the same name, then creating a new package and initializing it with offline parameters, loading built-in resources and manifest.

```csharp
private IEnumerator InitOfflinePlayMode(System.Action<bool> callback)
{
    // 销毁并移除联机模式创建的包裹  
    if (YooAssets.ContainsPackage(PackageName))
    {
        var oldPackage = YooAssets.GetPackage(PackageName);
        var destroyOp = oldPackage.DestroyPackageAsync();
        yield return destroyOp;

        // 注意：必须等待包裹销毁完成后才能移除  
        YooAssets.RemovePackage(PackageName);
    }

    // 重新创建包裹，使用离线模式初始化  
    var package = YooAssets.CreatePackage(PackageName);
    var initParameters = new OfflinePlayModeOptions();
    initParameters.BuiltinFileSystemParameters = FileSystemParameters.CreateDefaultBuiltinFileSystemParameters();
    var initOperation = package.InitializePackageAsync(initParameters);
    yield return initOperation;
    if (initOperation.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    // 离线模式下获取的是包体内置版本  
    var versionOp = package.RequestPackageVersionAsync();
    yield return versionOp;
    if (versionOp.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    // 加载包体内置资源清单  
    var manifestOp = package.LoadPackageManifestAsync(new LoadPackageManifestOptions(versionOp.PackageVersion, 60));
    yield return manifestOp;
    if (manifestOp.Status != EOperationStatus.Succeeded)
    {
        callback.Invoke(false);
        yield break;
    }

    callback.Invoke(true);
}
```
Tokens:
Raw