/// <summary>
/// 同步加载AB包，安卓下可能会有问题（路径问题）
/// </summary>
/// <param name="bundleName">包名</param>
/// <returns></returns>
public AssetBundleItem LoadBundleSync(string bundleName)
{
if (_AssetBundlePool.BundleIsLoaded(bundleName))
{
return(_AssetBundlePool.GetBundleItem(bundleName));
}
// 检查主Manifest清单文件是否加载完成
if (!ABManifestLoader.Instance.IsLoadFinish)
{
Debug.LogError("加载" + bundleName + "的时候，主清单尚未加载完毕");
return(null);
}
// 检查目标包及其依赖包是否在异步加载中
if (CheckBundleCanLoadSync(bundleName) == false)
{
Debug.LogError(bundleName + "或其依赖包在异步加载中，不能进行同步加载");
return(null);
}
AssetBundleItem bundleItem = _AssetBundlePool.GetBundleItem(bundleName);
if (bundleItem == null)
{
bundleItem = _AssetBundlePool.AddBundleItem(bundleName);
}
bundleItem.BundleLoadStatus = BundleLoadStatus.LOADING;
LoadBundleDependeceSync(bundleItem);
return(bundleItem);
}
/// <summary>
/// 加载ab包并添加依赖项
/// </summary>
/// <param name="bundleItem">加载目标包</param>
private void LoadBundleDependeceSync(AssetBundleItem bundleItem)
{
string[] strDependeceArray = ABManifestLoader.Instance.GetAssetBundleDependce(bundleItem.BundleName);
foreach (var depend in strDependeceArray)
{
// 添加依赖项
bundleItem.abRelation.AddDependence(depend);
AssetBundleItem dependBundleItem = _AssetBundlePool.GetBundleItem(depend);
if (dependBundleItem != null && _AssetBundlePool.BundleIsLoaded(depend))
{
// 添加被依赖项
dependBundleItem.abRelation.AddReference(bundleItem.BundleName);
continue;
}
if (dependBundleItem == null)
{
dependBundleItem = _AssetBundlePool.AddBundleItem(depend);
}
dependBundleItem.BundleLoadStatus = BundleLoadStatus.LOADING;
// 添加被依赖项
dependBundleItem.abRelation.AddReference(bundleItem.BundleName);
LoadBundleDependeceSync(dependBundleItem);
}
bundleItem.LoadAssetBundleSync();
}
public void LoadBundleAsset(string bundleName, string assetName, Action <UnityEngine.Object> loadcallback, bool isCache = false)
{
// 判断AB包是否已加载
if (_AssetBundlePool.BundleIsLoaded(bundleName))
{
AssetBundleItem bundleItem = _AssetBundlePool.GetBundleItem(bundleName);
UnityEngine.Object obj = bundleItem.LoadAsset(assetName, isCache);
loadcallback(obj);
}
else
{
// 创建AB包加载完毕回调
Action <bool, string> bundleLoadCallback = delegate(bool succeed, string assetbundleName)
{
// 如果加载成功
if (succeed)
{
AssetBundleItem abItem = _AssetBundlePool.GetBundleItem(assetbundleName);
UnityEngine.Object obj = abItem.LoadAsset(assetName, isCache);
loadcallback(obj);
}
else
{
loadcallback(null);
}
};
// 先加载AB包
LoadBundle(bundleName, bundleLoadCallback);
}
}
/// <summary>
/// 加载依赖的AB包并设置被依赖关系
/// </summary>
/// <param name="dependBundleName">当前包依赖的AB包名称</param>
/// <param name="bundleItem">当前包Item</param>
/// <returns></returns>
private IEnumerator LoadReference(string dependBundleName, AssetBundleItem bundleItem)
{
Action <bool, string> loadCompleteCallback = delegate(bool succeed, string assetBundleName) //协程加载完成的回调
{
if (succeed)
{
//添加AB包被依赖关系（引用）
_AssetBundlePool.GetBundleItem(assetBundleName).abRelation.AddReference(bundleItem.BundleName);
}
};
AssetBundleItem dependBundleItem = _AssetBundlePool.GetBundleItem(dependBundleName);
//如果AB包已经加载
if (dependBundleItem != null)
{
//添加AB包被依赖关系（引用）
dependBundleItem.abRelation.AddReference(bundleItem.BundleName);
}
else
{
//开始加载依赖的包(这是一个递归调用)
yield return(LoadBundleIEn(dependBundleName, loadCompleteCallback));
}
}
/// <summary>
/// 释放ab包的接口，所以AB包释放都调用这个方法
/// </summary>
/// <param name="abName"></param>
public void DisposeAssetBundle(string abName)
{
AssetBundleItem bundleItem = null;
_AssetBundleDic.TryGetValue(abName, out bundleItem);
// 加载完的AB包才能卸载
if (bundleItem != null && bundleItem.BundleLoadStatus == BundleLoadStatus.LOADED)
{
//不在常驻内存列表的AB包才能卸载
if (abPermanentAsset == null || !abPermanentAsset.BundleNameHS.Contains(abName))
{
ABRelation abRelation = bundleItem.abRelation;
// 没有被别的包依赖才可以进行卸载
if (abRelation.GetAllReference().Count == 0)
{
bundleItem.Dispose(); // 卸载目标ab包
_AssetBundleDic.Remove(abName);
List <string> dependenceList = abRelation.GetAllDependence(); // 获取目标包所有依赖的包列表
foreach (string DependAbName in dependenceList)
{
bool isClear = _AssetBundleDic[DependAbName].abRelation.RemoveReference(abName); // 去掉目标包所依赖的包的被依赖关系
// 如果目标包所依赖的包已经没有被其他包依赖了，则把目标包所依赖的包也卸载掉（递归）
if (isClear)
{
DisposeAssetBundle(DependAbName);
}
}
}
}
}
}// function_end
public AssetBundleItem AddBundleItem(string bundleName, Action <bool, string> loadCallbcak = null)
{
AssetBundleItem assetBundleItem = new AssetBundleItem(bundleName, loadCallbcak);
_AssetBundleDic.Add(bundleName, assetBundleItem);
return(assetBundleItem);
}
private IEnumerator LoadBundleIEn(string bundleName, Action <bool, string> loadCallback)
{
//等待主Manifest清单文件加载完成
while (!ABManifestLoader.Instance.IsLoadFinish)
{
yield return(null);
}
AssetBundleItem bundleItem = _AssetBundlePool.GetBundleItem(bundleName);
// 检查是否已加载
if (_AssetBundlePool.BundleIsLoaded(bundleName))
{
loadCallback(true, bundleName);
}
// 检查是否加载中
else if (bundleItem != null && bundleItem.BundleLoadStatus == BundleLoadStatus.LOADING)
{
bundleItem.LoadCallback += loadCallback;
}
else
{
if (bundleItem == null)
{
bundleItem = _AssetBundlePool.AddBundleItem(bundleName, loadCallback);
}
else
{
bundleItem.LoadCallback += loadCallback;
}
bundleItem.BundleLoadStatus = BundleLoadStatus.LOADING;
string[] strDependeceArray = ABManifestLoader.Instance.GetAssetBundleDependce(bundleItem.BundleName);
foreach (var depend in strDependeceArray)
{
// 添加依赖项
bundleItem.abRelation.AddDependence(depend);
// 先加载所有依赖的AB包并设置被依赖关系
yield return(LoadReference(depend, bundleItem));
}
// 真正加载AB包
yield return(bundleItem.LoadAssetBundle());
}
}
/// <summary>
/// 同步加载ab包资源
/// </summary>
/// <param name="bundleName">包名</param>
/// <param name="assetName">资源名</param>
/// <returns></returns>
public UnityEngine.Object LoadBundleAssetSync(string bundleName, string assetName, bool cache = false)
{
if (_AssetBundlePool.BundleIsLoaded(bundleName))
{
return(_AssetBundlePool.GetBundleItem(bundleName).LoadAsset(assetName, cache));
}
else
{
AssetBundleItem bundleItem = LoadBundleSync(bundleName);
if (bundleItem != null)
{
return(bundleItem.LoadAsset(assetName, cache));
}
else
{
return(null);
}
}
}
/// <summary>
/// 检查ab包能否在进行异步加载，如果处于异步加载中，则不允许进行同步加载
/// </summary>
/// <returns></returns>
public bool CheckBundleCanLoadSync(string bundleName)
{
AssetBundleItem bundleItem = _AssetBundlePool.GetBundleItem(bundleName);
if (bundleItem != null && bundleItem.BundleLoadStatus == BundleLoadStatus.LOADING)
{
return(false);
}
string[] strDependeceArray = ABManifestLoader.Instance.GetAssetBundleDependce(bundleName);
foreach (var depend in strDependeceArray)
{
if (CheckBundleCanLoadSync(depend) == false)
{
return(false);
}
}
return(true);
}
