internal PlayAssetPackBatchRequest RetrieveAssetPackBatchAsyncInternal(IList <string> assetPackNames)
        {
            if (assetPackNames.Count != assetPackNames.Distinct().Count())
            {
                throw new ArgumentException("assetPackNames contains duplicate entries");
            }

            var activePackNames = assetPackNames.Where(name => _requestRepository.ContainsRequest(name)).ToArray();

            if (activePackNames.Length != 0)
            {
                throw new ArgumentException("There are already active requests for asset packs: {0}",
                                            string.Join(", ", activePackNames));
            }

            // A subset of assetPackNames of packs that are not available on disk.
            var unavailableAssetPackNames = new List <string>();
            var requests = new List <PlayAssetPackRequestImpl>();

            foreach (var assetPackName in assetPackNames)
            {
                var request = CreateAssetPackRequest(assetPackName);
                _requestRepository.AddRequest(request);
                request.Completed += req => _requestRepository.RemoveRequest(request.AssetPackName);
                requests.Add(request);

                if (IsDownloaded(assetPackName))
                {
                    request.OnPackAvailable();
                }
                else
                {
                    unavailableAssetPackNames.Add(assetPackName);
                }
            }

            var batchRequest = new PlayAssetPackBatchRequestImpl(requests);
            var fetchTask    = _assetPackManager.Fetch(unavailableAssetPackNames.ToArray());

            fetchTask.RegisterOnSuccessCallback(javaPackStates =>
            {
                batchRequest.OnInitializedInPlayCore();
                fetchTask.Dispose();
            });
            fetchTask.RegisterOnFailureCallback((reason, errorCode) =>
            {
                Debug.LogErrorFormat("Failed to retrieve asset pack batch: {0}", reason);
                batchRequest.OnInitializationErrorOccurred(PlayCoreTranslator.TranslatePlayCoreErrorCode(errorCode));
                fetchTask.Dispose();
            });

            return(batchRequest);
        }
        internal PlayAssetBundleRequest RetrieveAssetBundleAsyncInternal(string assetBundleName)
        {
            if (_requestRepository.ContainsRequest(assetBundleName))
            {
                throw new ArgumentException(string.Format("There is already an active request for AssetBundle: {0}",
                                                          assetBundleName));
            }

            var request = CreateAssetBundleRequest(assetBundleName);

            if (IsDownloaded(assetBundleName))
            {
                StartLoadingAssetBundle(request);
                request.OnLoadingStarted();
            }
            else
            {
                var fetchTask = _assetPackManager.Fetch(assetBundleName);
                fetchTask.RegisterOnSuccessCallback(javaPackStates =>
                {
                    request.OnInitializedInPlayCore();
                    fetchTask.Dispose();
                });
                fetchTask.RegisterOnFailureCallback((reason, errorCode) =>
                {
                    Debug.LogErrorFormat("Failed to retrieve AssetBundle {0}: ", reason);
                    request.OnErrorOccured(PlayCoreTranslator.TranslatePlayCoreErrorCode(errorCode));
                    fetchTask.Dispose();
                });
            }

            return(request);
        }