//当需要一个依赖包，但是此依赖包还未加载成功，可能未加载，也可能正在加载之中时调用
//当一个依赖包正在加载之时，此时如果请求此依赖包，则进行依赖登记,加需要之后加载的资源名登记在list中
public static void AddWattingThisDependent(BundleData bundle, BundleRequest waitedRequest)
{
if (!CurrentLoadingDependent.ContainsKey(waitedRequest))
{
Log.E(ELogTag.ResourceSys, waitedRequest.Url + "Is not loading!");
return;
}
//直接将依赖的资源提取出来进行登记
List <string> regDependList = CurrentLoadingDependent[waitedRequest];
List <string> dependIncludeList = waitedRequest.bundleData.includs;
if (bundle == null || bundle.dependAssets == null)
{
Log.E(ELogTag.ResourceSys, "Bundle dependAssets is null");
}
List <string> bundleDependList = bundle.dependAssets;
int bundleDependCount = bundleDependList.Count;
for (int i = 0; i < bundleDependCount; i++)
{
string fileName = CommonTools.GetPathFileName(bundleDependList[i]);
if (!regDependList.Contains(fileName) &&
dependIncludeList.Contains(bundleDependList[i]))
{
regDependList.Add(fileName);
}
}
}
public IObservable <Level> LoadLevel(string name)
{
if (currentLevel)
{
UnloadLevel(currentLevel);
}
BundleRequest bundleNeeded = new BundleRequest(AssetCategoryRoot.Levels, name.ToLower(), name.ToLower());
return(Observable.Create <Level>(
(IObserver <Level> observer) =>
{
Action <Level> OnLevelLoaded = loadedLevel =>
{
Resources.UnloadUnusedAssets();
Debug.Log(("LevelLoaderService: Loaded level - " + loadedLevel.name).Colored(Colors.lightblue));
currentLevel = GameObject.Instantiate <Level>(loadedLevel);
currentLevel.name = loadedLevel.name;
if (loadingScreen)
{
loadingScreen.Close();
}
observer.OnNext(currentLevel);
observer.OnCompleted();
};
return assetService.GetAndLoadAsset <Level>(bundleNeeded)
.Subscribe(OnLevelLoaded);
}));
}
public async Task GivenATransactionBundleRequestWithNullUrl_WhenProcessing_ReturnsABadRequest()
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = BundleType.Transaction,
Entry = new List <EntryComponent>
{
new EntryComponent
{
Request = new RequestComponent
{
Method = HTTPVerb.PUT,
Url = null,
},
Resource = new Basic {
Id = "test"
},
},
},
};
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(RouteAsyncFunction);
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
await Assert.ThrowsAsync <RequestNotValidException>(async() => await _bundleHandler.Handle(bundleRequest, default));
}
internal override void Unload()
{
if (BundleRequest != null)
{
BundleRequest.Release();
}
if (children.Count > 0)
{
foreach (var item in children)
{
item.Release();
}
children.Clear();
}
if (loadSceneMode == LoadSceneMode.Additive)
{
if (SceneManager.GetSceneByName(sceneName).isLoaded)
{
SceneManager.UnloadSceneAsync(sceneName);
}
}
BundleRequest = null;
loadState = AssetLoadState.Unload;
}
internal override void Load()
{
bundle = Bundles.Load(assetBundleName);
var assetName = Path.GetFileName(url);
asset = bundle.assetBundle.LoadAsset(assetName, assetType);
}
//当一个依赖包加载完成，遍历所有正在等待他的包，将等待包中所需的资源load出来
public static void OnDenpendentLoadComplete(BundleRequest depRequest)
{
if (!CurrentLoadingDependent.ContainsKey(depRequest))
{
Log.E(ELogTag.ResourceSys, "Don't contains loading depend " + depRequest.Url);
return;
}
List <string> waittingAsset = CurrentLoadingDependent[depRequest];
int waittingCount = waittingAsset.Count;
for (int i = 0; i < waittingCount; ++i)
{
Object loadedAsset = depRequest.AssetBundle.LoadAsset(waittingAsset[i]);
Debug.Log(depRequest.bundleData.name + " load asset : " + loadedAsset.name);
}
//从正在loading的dependcy中移除
CurrentLoadingDependent.Remove(depRequest);
//加入到已经加载的request之中
if (LoadedAsset.ContainsKey(depRequest))
{
Log.F(ELogTag.ResourceSys, "Loaded request already loaded . " + depRequest.Url);
return;
}
LoadedAsset.Add(depRequest, new List <string>());
}
public async Task GivenABundleWithMultipleCalls_WhenProcessed_ThenANotificationWillBeEmitted(BundleType type, HTTPVerb method1, HTTPVerb method2, int code200s, int code404s)
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = type,
Entry = new List <EntryComponent>
{
new EntryComponent
{
Request = new RequestComponent
{
Method = method1,
Url = "unused1",
},
Resource = new Patient(),
},
new EntryComponent
{
Request = new RequestComponent
{
Method = method2,
Url = "unused2",
},
Resource = new Patient(),
},
},
};
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(RouteAsyncFunction);
BundleMetricsNotification notification = null;
await _mediator.Publish(Arg.Do <BundleMetricsNotification>(note => notification = note), Arg.Any <CancellationToken>());
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, default);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(type == BundleType.Batch ? BundleType.BatchResponse : BundleType.TransactionResponse, bundleResource.Type);
Assert.Equal(2, bundleResource.Entry.Count);
await _mediator.Received().Publish(Arg.Any <BundleMetricsNotification>(), Arg.Any <CancellationToken>());
Assert.Equal(type == BundleType.Batch ? AuditEventSubType.Batch : AuditEventSubType.Transaction, notification.FhirOperation);
var results = notification.ApiCallResults;
Assert.Equal(code200s, results["200"]);
if (code404s > 0)
{
Assert.Equal(code404s, results["404"]);
}
else
{
Assert.Equal(1, results.Keys.Count);
}
}
private static void UpdateBundles()
{
int max = MAX_BUNDLES_PERFRAME;
// 正在加载的bundle数量小于每帧可加载数量
if (_toloadBundles.Count > 0 && max > 0 && _loadingBundles.Count < max)
{
// 把能加载的bundle加进加载队列中
for (int i = 0; i < Math.Min(max - _loadingBundles.Count, _toloadBundles.Count); ++i)
{
BundleRequest item = _toloadBundles[i];
if (item.loadState == AssetLoadState.Init)
{
item.Load();
_loadingBundles.Add(item);
_toloadBundles.RemoveAt(i);
--i;
}
}
}
// 加载中bundleUpdate，加载完就移除
for (var i = 0; i < _loadingBundles.Count; i++)
{
var item = _loadingBundles[i];
if (item.Update())
{
continue;
}
_loadingBundles.RemoveAt(i);
--i;
}
// 加载完的bundle，并且没有引用，就加进无用bundle列表
foreach (var item in _bundles)
{
if (item.Value.isDone && item.Value.IsUnused())
{
_unusedBundles.Add(item.Value);
}
}
if (_unusedBundles.Count <= 0)
{
return;
}
// 清理无用bundle列表
for (int i = 0; i < _unusedBundles.Count; i++)
{
BundleRequest item = _unusedBundles[i];
if (item.isDone)
{
item.Unload();
_bundles.Remove(item.name);
GameLog.Log("UnloadBundle: " + item.name);
}
}
_unusedBundles.Clear();
}
//HunkRes = ManagerID.AssetManager+1,
//ReleaseSingleObj , //释放单个object
//ReleaseBundleObjes,//释放一个bundle 包里 所有的object
//ReleaseScenceObjes,// 释放 单个场景中所有的 object
//ReleaseSingleBundle,//释放单个 assetbundle
//ReleaseScenceBundle,//释放 一个场景中的所有的assetbundle
//ReleaseAll,// 释放 一个场景中所有的 bundle 和 objects
public override void ProcessEvent(MsgBase msg)
{
switch (msg.msgId)
{
case (ushort)AssetEvent.HunkMutiRes:
{
AssetRequesetMsg tmpMsg = (AssetRequesetMsg)msg;
tmpMsg.requesetInfo.Debug();
BundleRequest tmpRequeset = MutiResManager.AddRequeset(tmpMsg);
try
{
int tmpCount = tmpRequeset.bundleNode.Length;
for (int i = 0; i < tmpCount; i++)
{
BundleBackNode tmpNode = tmpRequeset.bundleNode[i];
string bundlFullName = ILoadManager.Instance.GetBundleRelateName(tmpNode.ScenceName, tmpNode.BundleName);
tmpNode.FullBundleName = bundlFullName;
MutiResManager.AddNodes(tmpNode);
RequesetBundle(tmpNode.ScenceName, tmpNode.BundleName, bundlFullName);
}
}
catch (System.Exception e)
{
Debug.LogError("e ==" + e);
}
}
break;
case (ushort)AssetEvent.HunkScences:
{
RequesetScenceMsg tmpMsg = (RequesetScenceMsg)msg;
ILoadManager.Instance.LoadAsset(tmpMsg.scenceName, tmpMsg.bundleName, tmpMsg.backDelegate);
}
break;
default:
break;
}
}
public async Task GivenABundle_WhenOneRequestProducesA429_429IsRetriedThenSucceeds()
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = BundleType.Batch,
Entry = new List <EntryComponent>
{
new EntryComponent {
Request = new RequestComponent {
Method = HTTPVerb.GET, Url = "/Patient"
}
},
new EntryComponent {
Request = new RequestComponent {
Method = HTTPVerb.GET, Url = "/Patient"
}
},
new EntryComponent {
Request = new RequestComponent {
Method = HTTPVerb.GET, Url = "/Patient"
}
},
},
};
int callCount = 0;
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(info =>
{
info.Arg <RouteContext>().Handler = context =>
{
callCount++;
if (callCount == 2)
{
context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
}
else
{
context.Response.StatusCode = StatusCodes.Status200OK;
}
return(Task.CompletedTask);
};
});
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, default);
Assert.Equal(4, callCount);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(3, bundleResource.Entry.Count);
foreach (var entry in bundleResource.Entry)
{
Assert.Equal("200", entry.Response.Status);
}
}
public static bool IsAssetLoaded(BundleRequest request, string assetName)
{
if (!LoadedAsset.ContainsKey(request))
{
return(false);
}
return(LoadedAsset[request].Contains(assetName));
}
public async Task GivenABundleWithAGet_WhenNotAuthorized_ReturnsABundleResponseWithCorrectEntry()
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = Hl7.Fhir.Model.Bundle.BundleType.Batch,
Entry = new List <Hl7.Fhir.Model.Bundle.EntryComponent>
{
new Hl7.Fhir.Model.Bundle.EntryComponent
{
Request = new Hl7.Fhir.Model.Bundle.RequestComponent
{
Method = Hl7.Fhir.Model.Bundle.HTTPVerb.GET,
Url = "/Patient",
},
},
},
};
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(RouteAsyncFunction);
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, CancellationToken.None);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(Hl7.Fhir.Model.Bundle.BundleType.BatchResponse, bundleResource.Type);
Assert.Single(bundleResource.Entry);
Hl7.Fhir.Model.Bundle.EntryComponent entryComponent = bundleResource.Entry.First();
Assert.Equal("403", entryComponent.Response.Status);
var operationOutcome = entryComponent.Response.Outcome as OperationOutcome;
Assert.NotNull(operationOutcome);
Assert.Single(operationOutcome.Issue);
var issueComponent = operationOutcome.Issue.First();
Assert.Equal(OperationOutcome.IssueSeverity.Error, issueComponent.Severity);
Assert.Equal(OperationOutcome.IssueType.Forbidden, issueComponent.Code);
Assert.Equal("Authorization failed.", issueComponent.Diagnostics);
void RouteAsyncFunction(CallInfo callInfo)
{
var routeContext = callInfo.Arg <RouteContext>();
routeContext.Handler = context =>
{
context.Response.StatusCode = 403;
return(Task.CompletedTask);
};
}
}
/// <summary>
/// bundle reuqeset 已经向上层发送object 完毕
/// </summary>
/// <param name="requeset"></param>
public void FinishRequeset(BundleRequest requeset)
{
for (int i = 0; i < requeset.bundleNode.Length; i++)
{
this.ReleaseNode(requeset.bundleNode[i].FullBundleName, requeset.bundleNode[i]);
}
requesetManager.Remove(requeset);
}
private static void UnloadDependencies(BundleRequest bundle)
{
for (var i = 0; i < bundle.dependencies.Count; i++)
{
var item = bundle.dependencies [i];
item.Release();
}
bundle.dependencies.Clear();
}
//将一个将要进行加载的依赖包加入等待加载队列之中
public static void AddLoadingDependent(BundleRequest bundleRequest)
{
if (CurrentLoadingDependent.ContainsKey(bundleRequest))
{
Log.E(ELogTag.ResourceSys, bundleRequest.Url + "Already in waitting");
return;
}
CurrentLoadingDependent.Add(bundleRequest, new List <string>());
}
internal override void Unload()
{
if (bundle != null)
{
bundle.Release();
bundle = null;
}
asset = null;
}
public void AddRequeset(BundleRequest requeset)
{
if (!bundleRequeset.ContainsKey(requeset.BackId))
{
bundleRequeset.Add(requeset.BackId, requeset);
}
else
{
Debuger.LogError("Bundle Requeset have contain key=== " + requeset.BackId);
}
}
/**
* Get WWW instance of the url.
* @return Return null if the WWW request haven't succeed.
*/
public WWW GetCreateRequest(string url)
{
BundleRequest request = GetRequest(url);
if (request != null)
{
return(request.CreateRequest);
}
return(null);
}
private bool OnError(BundleRequest bundleRequest)
{
error = bundleRequest.error;
if (!string.IsNullOrEmpty(error))
{
loadState = AssetLoadState.Loaded;
return(true);
}
return(false);
}
public async Task GivenABundle_WhenMultipleRequests_ReturnsABundleResponseWithCorrectOrder()
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = Hl7.Fhir.Model.Bundle.BundleType.Batch,
Entry = new List <Hl7.Fhir.Model.Bundle.EntryComponent>
{
new Hl7.Fhir.Model.Bundle.EntryComponent
{
Request = new RequestComponent
{
Method = HTTPVerb.GET,
Url = "/Patient",
},
},
new Hl7.Fhir.Model.Bundle.EntryComponent
{
Request = new RequestComponent
{
Method = HTTPVerb.POST,
Url = "/Patient",
},
Resource = new Hl7.Fhir.Model.Patient
{
},
},
new Hl7.Fhir.Model.Bundle.EntryComponent
{
Request = new RequestComponent
{
Method = HTTPVerb.PUT,
Url = "/Patient/789",
},
Resource = new Hl7.Fhir.Model.Patient
{
},
},
},
};
_router.When(r => r.RouteAsync(Arg.Any <RouteContext>()))
.Do(RouteAsyncFunction);
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, default);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(Hl7.Fhir.Model.Bundle.BundleType.BatchResponse, bundleResource.Type);
Assert.Equal(3, bundleResource.Entry.Count);
Assert.Equal("403", bundleResource.Entry[0].Response.Status);
Assert.Equal("404", bundleResource.Entry[1].Response.Status);
Assert.Equal("200", bundleResource.Entry[2].Response.Status);
}
void addRequestToWaitingList(BundleRequest request)
{
if (_succeedRequest.ContainsKey(request.Url) || isInWaitingList(request.Url))
{
return;
}
int insertPos = _waitingRequests.FindIndex(x => x.priority < request.priority);
insertPos = insertPos == -1 ? _waitingRequests.Count : insertPos;
_waitingRequests.Insert(insertPos, request);
}
public async Task GivenAConfigurationEntryLimit_WhenExceeded_ThenBundleEntryLimitExceededExceptionShouldBeThrown()
{
_bundleConfiguration.EntryLimit = 1;
var requestBundle = Samples.GetDefaultBatch();
var bundleRequest = new BundleRequest(requestBundle);
var expectedMessage = "The number of entries in the bundle exceeded the configured limit of 1.";
var exception = await Assert.ThrowsAsync <BundleEntryLimitExceededException>(async() => await _bundleHandler.Handle(bundleRequest, CancellationToken.None));
Assert.Equal(exception.Message, expectedMessage);
}
//当需要一个依赖包，并且此依赖包已经加载成功时调用
//将一个bundle中，自身所需的依赖资源加载出来，并且登记在LoadedAsset之中
public static void LoadDependent(BundleData bundleData, BundleRequest loadedDepRequest)
{
if (!LoadedAsset.ContainsKey(loadedDepRequest))
{
Log.F(ELogTag.ResourceSys, loadedDepRequest.Url + " dep request didn't loaded!!");
return;
}
List <string> loadedList = LoadedAsset[loadedDepRequest];
List <string> dependList = bundleData.dependAssets;
int dependCount = dependList.Count;
for (int i = 0; i < dependCount; i++)
{
//提取资源名称
string fileName = System.IO.Path.GetFileName(dependList[i]);
//確定在depend中是否有此資源
if (!loadedDepRequest.bundleData.includs.Contains(fileName))
{
continue;
}
//去除后缀
fileName = fileName.Substring(0, fileName.LastIndexOf('.'));
//如果已经加载，则直接跳过
if (loadedList.Contains(fileName))
{
continue;
}
//开始加载
Object loadedAsset = loadedDepRequest.AssetBundle.LoadAsset(fileName);
if (loadedAsset != null)
{
Debug.Log(loadedDepRequest.bundleData.name + " load asset : " + loadedAsset.name + ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
loadedList.Add(fileName);
}
else
{
//竟然无此依赖资源，或者出现同名资源
Log.F(ELogTag.ResourceSys, "Can't load dependcy asset , " + fileName);
continue;
}
}
}
private static void LoadDependencies(BundleRequest bundle, string assetBundleName, bool asyncRequest)
{
var dependencies = manifest.GetAllDependencies(assetBundleName);
if (dependencies.Length <= 0)
{
return;
}
for (var i = 0; i < dependencies.Length; i++)
{
var item = dependencies [i];
bundle.dependencies.Add(Load(item, false, asyncRequest));
}
}
internal override void Load()
{
assetName = Path.GetFileName(name);
if (LoadModule.runtimeMode)
{
var assetBundleName = assetName.Replace(".asset", ".unity3d").ToLower();
request = LoadModule.LoadBundleAsync(assetBundleName);
loadState = AssetLoadState.LoadAssetBundle;
}
else
{
loadState = AssetLoadState.Loaded;
}
}
internal override void Unload()
{
if (bundle != null)
{
bundle.Release();
}
if (SceneManager.GetSceneByName(sceneName).isLoaded)
{
SceneManager.UnloadSceneAsync(sceneName);
}
bundle = null;
}
//public string scenceName;
//public string[] bundles;
//public string[][] resNames;
//public ushort backId;
/// <summary>
/// 上层消息 转化为requeset 表
/// </summary>
/// <param name="tmpMsg"></param>
/// <returns></returns>
public BundleRequest AddRequeset(AssetRequesetMsg tmpMsg)
{
// BundleBackNode tmpNode = new BundleBackNode();
BundleRequest tmpRequeset = new BundleRequest(tmpMsg.requesetInfo, monoBase, FinishRequeset);
// Debug.Log("tmpRequeset back msgid ===="+tmpRequeset.BackId);
requesetManager.AddRequeset(tmpRequeset);
// ABReuqeset(tmpRequeset);
return(tmpRequeset);
}
internal override void Load()
{
if (!string.IsNullOrEmpty(assetBundleName))
{
bundle = Bundles.Load(assetBundleName);
if (bundle != null)
{
SceneManager.LoadScene(sceneName, loadSceneMode);
}
}
else
{
SceneManager.LoadScene(sceneName, loadSceneMode);
}
}
// ReSharper disable once MemberCanBePrivate.Global
public static void Unload(BundleRequest bundle)
{
bundle.Release();
for (var i = 0; i < _unusedBundles.Count; i++)
{
var item = _unusedBundles [i];
if (!item.url.Equals(bundle.url))
{
continue;
}
item.Unload();
_unusedBundles.RemoveAt(i);
return;
}
}
public async Task GivenAnEmptyBatchBundle_WhenProcessed_ReturnsABundleResponseWithNoEntries()
{
var bundle = new Hl7.Fhir.Model.Bundle
{
Type = BundleType.Batch,
};
var bundleRequest = new BundleRequest(bundle.ToResourceElement());
BundleResponse bundleResponse = await _bundleHandler.Handle(bundleRequest, CancellationToken.None);
var bundleResource = bundleResponse.Bundle.ToPoco <Hl7.Fhir.Model.Bundle>();
Assert.Equal(BundleType.BatchResponse, bundleResource.Type);
Assert.Empty(bundleResource.Entry);
}
IEnumerator DoLoadBundle (string bundleID)
{
if (!m_Bundles.ContainsKey (bundleID))
{
m_Bundles[bundleID] = new BundleRequest (
new WWW (BundleRootURL + bundleID + ".unity3d")
);
}
if (m_Bundles[bundleID].Bundle == null)
{
yield return StartCoroutine (m_Bundles[bundleID].Wait ());
if (m_Bundles[bundleID].Bundle == null)
{
Debug.LogError ("Bundle request failed: " + bundleID);
yield break;
}
}
}
