Example #1
0
        public string LoadFromCache(Uri uri)
        {
            StorageSavedData storageSavedData = ServiceLocator.Resolve <IStorageService>().ResolveData <StorageSavedData>() ?? new StorageSavedData();

            if (!storageSavedData.Cache.ContainsKey(uri.ToString()))
            {
                throw new Exception("Item not cached");
            }
            return(storageSavedData.Cache[uri.ToString()]);
        }
Example #2
0
        public bool IsCached(Uri uri)
        {
            StorageSavedData storageSavedData = ServiceLocator.Resolve <IStorageService>().ResolveData <StorageSavedData>() ?? new StorageSavedData();

            return(storageSavedData.Cache.ContainsKey(uri.ToString()));
        }
Example #3
0
/*        private string GetServerStoragePath(string localPath)
 *      {
 *          return Base64Decode(Path.GetFileName(localPath));
 *      }*/
        public ComplitionPromise <string> LoadFromStorage(Uri uri, Action <DownloadProgress> progress)
        {
            ComplitionDeferred <string> deferred = new ComplitionDeferred <string>();
            IDispatcher      dispatcher          = GameDispatcher.Dispatcher;
            string           localFileName       = GetLocalStoragePath(uri.ToString());
            string           localPath           = Path.GetDirectoryName(localFileName);
            StorageSavedData savedData           = ServiceLocator.Resolve <IStorageService>().ResolveData <StorageSavedData>() ?? new StorageSavedData();

            if (savedData.Cache.ContainsKey(uri.ToString()))
            {
                savedData.Cache.Remove(uri.ToString());
            }
            ServiceLocator.Resolve <IStorageService>().UpdateData(savedData);
            ThreadPool.QueueUserWorkItem(state =>
            {
                try
                {
                    if (!Directory.Exists(localPath))
                    {
                        Directory.CreateDirectory(localPath);
                    }
                    using (FileStream file = File.Create(localFileName))
                    {
                        WebRequest request = WebRequest.Create(uri);
                        request.Method     = "GET";
                        using (WebResponse webResponse = request.GetResponse())
                        {
                            using (System.IO.Stream responseStream = webResponse.GetResponseStream())
                            {
                                int bytesRead;
                                byte[] buffer  = new byte[2048];
                                long wroteSize = 0;
                                while ((bytesRead = responseStream.Read(buffer, 0, buffer.Length)) != 0)
                                {
                                    file.Write(buffer, 0, bytesRead);
                                    wroteSize += bytesRead;
                                    long dispatchWroteSize     = wroteSize;
                                    long dispatchContentLength = webResponse.ContentLength;
                                    dispatcher.Dispach(() =>
                                    {
                                        progress(new DownloadProgress(dispatchContentLength, dispatchWroteSize));
                                    });
                                }
                            }
                        }
                    }

                    dispatcher.Dispach(() =>
                    {
                        StorageSavedData storageSavedData      = ServiceLocator.Resolve <IStorageService>().ResolveData <StorageSavedData>() ?? new StorageSavedData();
                        storageSavedData.Cache[uri.ToString()] = localFileName;
                        ServiceLocator.Resolve <IStorageService>().UpdateData(storageSavedData);
                        deferred.Resolve(localFileName);
                    });
                }
                catch (Exception e)
                {
                    try
                    {
                        File.Delete(localFileName);
                    }
                    catch (Exception)
                    {
                        // ignored
                    }
                    dispatcher.Dispach(() =>
                    {
                        Debug.LogException(e);
                        deferred.Reject();
                    });
                }
            });

            return(deferred.Promise());
        }