public ContentSystemResponse(ContentManifest manifest, ScenePrereqContentBundlesManifest scenePrereq, bool requiresUpgrade, bool appUpgradeAvailable)
{
Manifest = manifest;
ScenePrereq = scenePrereq;
RequiresUpgrade = requiresUpgrade;
AppUpgradeAvailable = appUpgradeAvailable;
}
private void scenePrereqBundlesManifest_cacheDownloadedToDisk(ScenePrereqContentBundlesManifest scenePrereqBundlesManifestToCache)
{
string path = Path.Combine(Application.persistentDataPath, "ScenesPrereqBundlesManifest.json");
string contents = Service.Get <JsonService>().Serialize(scenePrereqBundlesManifestToCache);
File.WriteAllText(path, contents);
}
private void onCommandComplete(ContentManifest manifest, ScenePrereqContentBundlesManifest scenePrereqBundlesManifest, bool requiresUpgrade, bool appUpgradeAvailable)
{
appService.RequiresUpdate = requiresUpgrade;
appService.UpdateAvailable = appUpgradeAvailable;
string languageString = Service.Get <Localizer>().LanguageString;
if (!Service.IsSet <Content>())
{
contentSystem = new Content(manifest, languageString);
Service.Set(contentSystem);
Service.Set(new BundlePrecacheManager(manifest));
Service.Set(new ScenePrereqContentManager(Service.Get <BundlePrecacheManager>(), scenePrereqBundlesManifest));
currentContentVersion = manifest.ContentVersion;
currentContentManifestHash = manifest.ContentManifestHash;
}
else if (Service.Get <INetworkServicesManager>().IsGameServerConnected())
{
cachedContentSystemResponse = new ContentSystemResponse(manifest, scenePrereqBundlesManifest, requiresUpgrade, appUpgradeAvailable);
}
else if (!requiresUpgrade && (!currentContentVersion.Equals(manifest.ContentVersion) || !currentContentManifestHash.Equals(manifest.ContentManifestHash)))
{
if (!currentContentVersion.Equals(manifest.ContentVersion))
{
currentContentVersion = manifest.ContentVersion;
}
if (!currentContentManifestHash.Equals(manifest.ContentManifestHash))
{
currentContentManifestHash = manifest.ContentManifestHash;
}
contentSystem.UpdateContentManifest(manifest);
Service.Get <BundlePrecacheManager>().SetManifest(manifest);
Service.Get <ScenePrereqContentManager>().SetPrereqs(Service.Get <BundlePrecacheManager>(), scenePrereqBundlesManifest);
}
lastUpdate = DateTime.Now;
}
private IEnumerator contentManifest_download(ContentManifestDirectoryEntry directoryEntry)
{
if (directoryEntry == null)
{
handleFailure();
yield break;
}
if (string.IsNullOrEmpty(directoryEntry.url))
{
handleFailure();
yield break;
}
string contentManifestUrl = directoryEntry.url;
ICPipeManifestService cpipeManifestService = Service.Get <ICPipeManifestService>();
CPipeManifestResponse cpipeManifestResponse = new CPipeManifestResponse();
yield return(cpipeManifestService.LookupAssetUrl(cpipeManifestResponse, contentManifestUrl));
UnityWebRequest www = UnityWebRequest.GetAssetBundle(cpipeManifestResponse.FullAssetUrl, 1u, 0u);
Service.Get <LoadingController>().RegisterDownload(www);
yield return(www.SendWebRequest());
Service.Get <LoadingController>().UnRegisterDownload(www);
AssetBundle contentBundle = ((DownloadHandlerAssetBundle)www.downloadHandler).assetBundle;
if (www.isNetworkError || contentBundle == null)
{
Log.LogErrorFormatted(this, "Failed to download content bundle from CDN: {0}", www.error);
handleFailure();
yield break;
}
downloadedManifest = ContentHelper.GetContentManifestFromAssetBundle(contentBundle);
if (downloadedManifest != null)
{
checkContentVersionAndManifestHashInManifest(downloadedManifest, directoryEntry);
contentManifest_cacheDownloadedToDisk(downloadedManifest);
}
string[] assetNames = contentBundle.GetAllAssetNames();
for (int i = 0; i < assetNames.Length; i++)
{
string fileName = Path.GetFileName(assetNames[i]);
if (string.Equals(fileName, "ScenesPrereqBundlesManifest.json", StringComparison.OrdinalIgnoreCase))
{
TextAsset textAsset = contentBundle.LoadAsset <TextAsset>(assetNames[i]);
scenePrereqBundlesManifest = Service.Get <JsonService>().Deserialize <ScenePrereqContentBundlesManifest>(textAsset.text);
scenePrereqBundlesManifest_cacheDownloadedToDisk(scenePrereqBundlesManifest);
}
}
contentBundle.Unload(unloadAllLoadedObjects: false);
if (downloadedManifest == null)
{
Log.LogError(this, "Content manifest not found in downloaded bundle! Reverting to the embedded manifest");
handleFailure();
}
}
public void SetPrereqs(BundlePrecacheManager bundlePrecacheManager, ScenePrereqContentBundlesManifest scenePrereqBundlesManifest)
{
if (bundlePrecacheManager == null)
{
throw new ArgumentNullException("bundlePrecacheManager");
}
this.bundlePrecacheManager = bundlePrecacheManager;
if (scenePrereqBundlesManifest == null)
{
return;
}
ContentManifest manifest = bundlePrecacheManager.GetManifest();
if (manifest == null)
{
throw new ContentManifestException("No Contentmanifest set in BundlePreCacheManager to reference for scene prerequisites.");
}
foreach (KeyValuePair <string, string[]> item in scenePrereqBundlesManifest)
{
string key = item.Key;
string[] value = item.Value;
if (value == null)
{
continue;
}
List <ContentManifest.BundleEntry> list = new List <ContentManifest.BundleEntry>();
string[] array = value;
foreach (string text in array)
{
if (!manifest.BundleEntryMap.ContainsKey(text))
{
throw new ContentManifestException("Expected bundle key not found in BundleEntryMap for bundleKey=" + text);
}
list.Add(manifest.BundleEntryMap[text]);
}
if (list.Count > 0)
{
scenePrereqBundles.Add(item.Key, list.ToArray());
}
}
}
public ScenePrereqContentManager(BundlePrecacheManager bundlePrecacheManager, ScenePrereqContentBundlesManifest prereqs)
{
scenePrereqBundles = new Dictionary <string, ContentManifest.BundleEntry[]>();
SetPrereqs(bundlePrecacheManager, prereqs);
}
private void onInitializeManifestCommandComplete(ContentManifest mergedManifest, ScenePrereqContentBundlesManifest scenePrereqBundlesManifest, bool requiresAppUgrade, bool appUpgradeAvailable)
{
IntegrationTest.Assert(manifestsAreIdentical(mergedManifest));
doneWaiting();
}
private void onInitializeManifestCommandComplete(ContentManifest mergedManifest, ScenePrereqContentBundlesManifest scenePrereqBundlesManifest, bool requiresAppUgrade, bool appUpgradeAvailable)
{
string text = ExpectedResult.Validate(mergedManifest, requiresAppUgrade);
if (!string.IsNullOrEmpty(text))
{
Log.LogError(this, text);
IntegrationTest.Fail(text);
}
else
{
IntegrationTest.Pass();
Log.LogErrorFormatted(this, "ReadManifestDirectoryTest: TEST '{0}' SUCCEEDED.", ExpectedResult.TestName);
}
doneWaiting();
}
