├── Download.cs
├── LGPL-3.0.txt
└── README.md


/Download.cs:
--------------------------------------------------------------------------------
  1 | //Copyright 2013 MichaelTaylor3D
  2 | //www.michaeltaylor3d.com
  3 | 
  4 | using System;
  5 | using System.Collections;
  6 | using System.Collections.Generic;
  7 | using System.IO;
  8 | using UnityEngine;
  9 | 
 10 | public delegate void FailScript();
 11 | public delegate void DownloadCallback(WWW www);
 12 | 
 13 | public class Download : MonoBehaviour
 14 | {
 15 | 
 16 |     /////////////////////////////////////////////////
 17 |     //////-------------Public API--------------//////
 18 |     /////////////////////////////////////////////////
 19 | 
 20 |     /// <summary>
 21 |     /// Clears the download queue.
 22 |     /// </summary>
 23 |     public static void ClearQueue()
 24 |     {
 25 |         _downloadQueue.Clear();
 26 |     }
 27 | 
 28 |     /// <summary>
 29 |     ///  Downloads a file Async and sends it to the callback.
 30 |     /// </summary>
 31 |     public static void Async(string path, DownloadCallback callback)
 32 |     {
 33 |         Job job = new Job(path, callback, false, 0, null);
 34 |         _singleton.Enqueue(job);
 35 |     }
 36 | 
 37 |     /// <summary>
 38 |     ///  Downloads a file Async and sends it to the callback.
 39 |     ///  Invokes the failscript if the download failed
 40 |     /// </summary>
 41 |     public static void Async(string path, DownloadCallback callback, FailScript failscript)
 42 |     {
 43 |         Job job = new Job(path, callback, false, 0, failscript);
 44 |         _singleton.Enqueue(job);
 45 |     }
 46 | 
 47 |     /// <summary>
 48 |     ///  Downloads a file Async and sends it to the callback.
 49 |     ///  caches image files to local disk
 50 |     ///  retries the failed download a set number of times
 51 |     /// </summary>
 52 |     public static void Async(string path, DownloadCallback callback, bool saveToLocal, int downloadRetries)
 53 |     {
 54 |         Job job = new Job(path, callback, saveToLocal, downloadRetries, null);
 55 |         _singleton.Enqueue(job);
 56 |     }
 57 | 
 58 |     /// <summary>
 59 |     ///  Downloads a file Async and sends it to the callback.
 60 |     ///  retries the failed download a set number of times
 61 |     /// </summary>
 62 |     public static void Async(string path, DownloadCallback callback, int downloadRetries)
 63 |     {
 64 |         Async(path, callback, false, downloadRetries);
 65 |     }
 66 | 
 67 |     /// <summary>
 68 |     ///  Downloads a file Async and sends it to the callback.
 69 |     ///  caches image files to local disk
 70 |     /// </summary>
 71 |     public static void Async(string path, DownloadCallback callback, bool saveToLocal)
 72 |     {
 73 |         Async(path, callback, saveToLocal, 0);
 74 |     }
 75 | 
 76 |     /// <summary>
 77 |     /// Downloads a file in Sync and returns the result
 78 |     /// Useful for getting RESTful callbacks, NOT Images
 79 |     /// </summary>
 80 |     public static string Sync(string path)
 81 |     {
 82 |         string result;
 83 |         new Download.HTTP(path, out result);
 84 |         return result;
 85 |     }
 86 | 
 87 |     /// <summary>
 88 |     /// Gets a value indicating whether the download queue is active.
 89 |     /// </summary>
 90 |     /// <value>
 91 |     /// <c>true</c> if this download queue is active; otherwise, <c>false</c>.
 92 |     /// </value>	
 93 |     public static bool IsActive
 94 |     {
 95 |         get
 96 |         {
 97 |             return _IsActive;
 98 |         }
 99 |     }
100 |     private static bool _IsActive;
101 | 
102 |     /////////////////////////////////////////////////
103 |     //////-------------Queue Object--------------//////
104 |     /////////////////////////////////////////////////
105 |     public sealed class Job
106 |     {
107 |         public string path { get; set; }
108 |         public DownloadCallback callback { get; set; }
109 |         public bool saveToLocal { get; set; }
110 |         public int downloadRetries { get; set; }
111 |         public FailScript failscript;
112 | 
113 |         public Job(string path, DownloadCallback callback, bool saveToLocal, int downloadRetries, FailScript failscript)
114 |         {
115 |             this.path = path;
116 |             this.callback = callback;
117 |             this.saveToLocal = saveToLocal;
118 |             this.failscript = failscript;
119 | 
120 |             if (downloadRetries != default(int))
121 |             {
122 |                 this.downloadRetries = downloadRetries;
123 |             }
124 |             else
125 |             {
126 |                 this.downloadRetries = 0;
127 |             }
128 |         }
129 |     }
130 | 
131 |     /////////////////////////////////////////////////
132 |     //////---------Instance Members------------//////
133 |     /////////////////////////////////////////////////
134 | 
135 |     #region Singleton
136 |     private static Download _instance;
137 |     private static Download _singleton
138 |     {
139 |         get
140 |         {
141 |             if (_instance.Equals(null))
142 |             {
143 |                 GameObject runCode = GameObject.Find("RunCode");
144 | 
145 |                 if (runCode.Equals(null))
146 |                 {
147 |                     runCode = new GameObject("RunCode");
148 |                 }
149 | 
150 |                 _instance = runCode.AddComponent(typeof(Download)) as Download;
151 |             }
152 | 
153 |             return _instance;
154 |         }
155 |     }
156 |     #endregion
157 | 
158 |     private static Queue<Job> _downloadQueue;
159 |     private static string downloadDirectory;
160 | 
161 |     void Awake()
162 |     {
163 |         _IsActive = false;
164 |         _jobIsProcessing = false;
165 |         _downloadQueue = new Queue<Job>();
166 |         downloadDirectory = Application.persistentDataPath + "/downloads/";
167 |     }
168 | 
169 |     void FixedUpdate()
170 |     {
171 |         if (_downloadQueue.Count == 0)
172 |         {
173 |             _IsActive = false;
174 |             return;
175 |         }
176 | 
177 |         _IsActive = true;
178 | 
179 |         if (!_jobIsProcessing
180 |         && Internet.isConnected())
181 |         {
182 |             StartCoroutine(ProcessJob());
183 |         }
184 |     }
185 | 
186 |     private static bool _jobIsProcessing;
187 | 
188 |     private static IEnumerator ProcessJob()
189 |     {
190 |         _jobIsProcessing = true;
191 | 
192 |         Job job = _downloadQueue.Dequeue() as Job;
193 | 
194 |         yield return null;
195 | 
196 |         if (job != null)
197 |         {
198 |             for (int i = 0; i <= job.downloadRetries; i++)
199 |             {
200 |                 //initiate working variables
201 |                 WWW www = new WWW(job.path);
202 |                 yield return www;
203 | 
204 |                 if (www.error != null)
205 |                 {
206 |                     Debug.LogError("Download Error: " + www.url + " : " + www.error);
207 |                     if (job.failscript != null)
208 |                     {
209 |                         job.failscript();
210 |                     }
211 |                     continue;
212 |                 }
213 | 
214 |                 if (job.callback != null)
215 |                 {
216 |                     job.callback(www);
217 |                 }
218 | 
219 |                 if (job.saveToLocal)
220 |                 {
221 |                     Byte[] bytes = www.texture.EncodeToPNG();
222 | 
223 |                     if (!Directory.Exists(downloadDirectory))
224 |                     {
225 |                         Directory.CreateDirectory(downloadDirectory);
226 |                     }
227 | 
228 |                     string fileName = Path.GetFileNameWithoutExtension(www.url.Replace("%20", " "));
229 |                     string fileExtension = Path.GetExtension(www.url);
230 |                     string filePath = downloadDirectory + fileName + fileExtension;
231 |                     Debug.Log(filePath);
232 | #if !UNITY_WEBPLAYER
233 |                     File.WriteAllBytes(filePath.Replace("%20", " "), bytes);
234 | #endif
235 | 
236 | #if UNITY_IPHONE
237 | 					iPhone.SetNoBackupFlag(filePath); //Apple will reject the app if this is backed up
238 | #endif
239 |                 }
240 | 
241 |                 _jobIsProcessing = false;
242 | 
243 |                 break;
244 |             }
245 |             _jobIsProcessing = false;
246 |         }
247 |     }
248 | 
249 |     private void Enqueue(Job job)
250 |     {
251 |         _downloadQueue.Enqueue(job);
252 |     }
253 | 
254 |     ///////////////////////////////////////////////////////////////////
255 |     /////////////////////Sync Downloading//////////////////////////////
256 |     ////// Should Be used in editor only: Freezes IOS devices//////////
257 | 
258 |     private class HTTP
259 |     {
260 |         public HTTP(string request, out string result)
261 |         {
262 |             result = ServerRequest(request);
263 |         }
264 | 
265 |         private IEnumerator DownloadString(string url)
266 |         {
267 |             WWW www = new WWW(url);
268 |             float wwwStartTime = Time.realtimeSinceStartup;
269 |             float wwwTimeOutSec = 50f;
270 | 
271 |             while (!www.isDone)
272 |             {
273 |                 if (Time.realtimeSinceStartup - wwwStartTime > wwwTimeOutSec)
274 |                 {
275 |                     Debug.LogError("Download time Out");
276 |                     //yield return www.text;
277 |                 }
278 |             }
279 | 
280 |             yield return www.text;
281 |         }
282 | 
283 |         private string ServerRequest(string request)
284 |         {
285 |             string result = null;
286 |             IEnumerator e;
287 | 
288 |             //Send a RESTful server Request
289 |             e = DownloadString(request);
290 | 
291 |             //get the last result of the enumeration
292 |             while (e.MoveNext())
293 |             {
294 |                 result = e.Current.ToString();
295 |             }
296 | 
297 |             //check for server response errors
298 |             if (isServerResponseError(result))
299 |             {
300 |                 Debug.LogError(result);
301 |                 return null;
302 |             }
303 |             return result;
304 |         }
305 | 
306 |         private bool isServerResponseError(string www)
307 |         {
308 |             return www.Contains("Error:") ? true : false;
309 |         }
310 |     }
311 | }
312 | 
313 | public static class Internet
314 | {
315 | 
316 |     public static bool isConnected()
317 |     {
318 |         return (Network.player.ipAddress.ToString() == "127.0.0.1") ? false : true;
319 |     }
320 | }
321 | 


--------------------------------------------------------------------------------
/LGPL-3.0.txt:
--------------------------------------------------------------------------------
  1 |                    GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 | 
  9 |   This version of the GNU Lesser General Public License incorporates
 10 | the terms and conditions of version 3 of the GNU General Public
 11 | License, supplemented by the additional permissions listed below.
 12 | 
 13 |   0. Additional Definitions.
 14 | 
 15 |   As used herein, "this License" refers to version 3 of the GNU Lesser
 16 | General Public License, and the "GNU GPL" refers to version 3 of the GNU
 17 | General Public License.
 18 | 
 19 |   "The Library" refers to a covered work governed by this License,
 20 | other than an Application or a Combined Work as defined below.
 21 | 
 22 |   An "Application" is any work that makes use of an interface provided
 23 | by the Library, but which is not otherwise based on the Library.
 24 | Defining a subclass of a class defined by the Library is deemed a mode
 25 | of using an interface provided by the Library.
 26 | 
 27 |   A "Combined Work" is a work produced by combining or linking an
 28 | Application with the Library.  The particular version of the Library
 29 | with which the Combined Work was made is also called the "Linked
 30 | Version".
 31 | 
 32 |   The "Minimal Corresponding Source" for a Combined Work means the
 33 | Corresponding Source for the Combined Work, excluding any source code
 34 | for portions of the Combined Work that, considered in isolation, are
 35 | based on the Application, and not on the Linked Version.
 36 | 
 37 |   The "Corresponding Application Code" for a Combined Work means the
 38 | object code and/or source code for the Application, including any data
 39 | and utility programs needed for reproducing the Combined Work from the
 40 | Application, but excluding the System Libraries of the Combined Work.
 41 | 
 42 |   1. Exception to Section 3 of the GNU GPL.
 43 | 
 44 |   You may convey a covered work under sections 3 and 4 of this License
 45 | without being bound by section 3 of the GNU GPL.
 46 | 
 47 |   2. Conveying Modified Versions.
 48 | 
 49 |   If you modify a copy of the Library, and, in your modifications, a
 50 | facility refers to a function or data to be supplied by an Application
 51 | that uses the facility (other than as an argument passed when the
 52 | facility is invoked), then you may convey a copy of the modified
 53 | version:
 54 | 
 55 |    a) under this License, provided that you make a good faith effort to
 56 |    ensure that, in the event an Application does not supply the
 57 |    function or data, the facility still operates, and performs
 58 |    whatever part of its purpose remains meaningful, or
 59 | 
 60 |    b) under the GNU GPL, with none of the additional permissions of
 61 |    this License applicable to that copy.
 62 | 
 63 |   3. Object Code Incorporating Material from Library Header Files.
 64 | 
 65 |   The object code form of an Application may incorporate material from
 66 | a header file that is part of the Library.  You may convey such object
 67 | code under terms of your choice, provided that, if the incorporated
 68 | material is not limited to numerical parameters, data structure
 69 | layouts and accessors, or small macros, inline functions and templates
 70 | (ten or fewer lines in length), you do both of the following:
 71 | 
 72 |    a) Give prominent notice with each copy of the object code that the
 73 |    Library is used in it and that the Library and its use are
 74 |    covered by this License.
 75 | 
 76 |    b) Accompany the object code with a copy of the GNU GPL and this license
 77 |    document.
 78 | 
 79 |   4. Combined Works.
 80 | 
 81 |   You may convey a Combined Work under terms of your choice that,
 82 | taken together, effectively do not restrict modification of the
 83 | portions of the Library contained in the Combined Work and reverse
 84 | engineering for debugging such modifications, if you also do each of
 85 | the following:
 86 | 
 87 |    a) Give prominent notice with each copy of the Combined Work that
 88 |    the Library is used in it and that the Library and its use are
 89 |    covered by this License.
 90 | 
 91 |    b) Accompany the Combined Work with a copy of the GNU GPL and this license
 92 |    document.
 93 | 
 94 |    c) For a Combined Work that displays copyright notices during
 95 |    execution, include the copyright notice for the Library among
 96 |    these notices, as well as a reference directing the user to the
 97 |    copies of the GNU GPL and this license document.
 98 | 
 99 |    d) Do one of the following:
100 | 
101 |        0) Convey the Minimal Corresponding Source under the terms of this
102 |        License, and the Corresponding Application Code in a form
103 |        suitable for, and under terms that permit, the user to
104 |        recombine or relink the Application with a modified version of
105 |        the Linked Version to produce a modified Combined Work, in the
106 |        manner specified by section 6 of the GNU GPL for conveying
107 |        Corresponding Source.
108 | 
109 |        1) Use a suitable shared library mechanism for linking with the
110 |        Library.  A suitable mechanism is one that (a) uses at run time
111 |        a copy of the Library already present on the user's computer
112 |        system, and (b) will operate properly with a modified version
113 |        of the Library that is interface-compatible with the Linked
114 |        Version.
115 | 
116 |    e) Provide Installation Information, but only if you would otherwise
117 |    be required to provide such information under section 6 of the
118 |    GNU GPL, and only to the extent that such information is
119 |    necessary to install and execute a modified version of the
120 |    Combined Work produced by recombining or relinking the
121 |    Application with a modified version of the Linked Version. (If
122 |    you use option 4d0, the Installation Information must accompany
123 |    the Minimal Corresponding Source and Corresponding Application
124 |    Code. If you use option 4d1, you must provide the Installation
125 |    Information in the manner specified by section 6 of the GNU GPL
126 |    for conveying Corresponding Source.)
127 | 
128 |   5. Combined Libraries.
129 | 
130 |   You may place library facilities that are a work based on the
131 | Library side by side in a single library together with other library
132 | facilities that are not Applications and are not covered by this
133 | License, and convey such a combined library under terms of your
134 | choice, if you do both of the following:
135 | 
136 |    a) Accompany the combined library with a copy of the same work based
137 |    on the Library, uncombined with any other library facilities,
138 |    conveyed under the terms of this License.
139 | 
140 |    b) Give prominent notice with the combined library that part of it
141 |    is a work based on the Library, and explaining where to find the
142 |    accompanying uncombined form of the same work.
143 | 
144 |   6. Revised Versions of the GNU Lesser General Public License.
145 | 
146 |   The Free Software Foundation may publish revised and/or new versions
147 | of the GNU Lesser General Public License from time to time. Such new
148 | versions will be similar in spirit to the present version, but may
149 | differ in detail to address new problems or concerns.
150 | 
151 |   Each version is given a distinguishing version number. If the
152 | Library as you received it specifies that a certain numbered version
153 | of the GNU Lesser General Public License "or any later version"
154 | applies to it, you have the option of following the terms and
155 | conditions either of that published version or of any later version
156 | published by the Free Software Foundation. If the Library as you
157 | received it does not specify a version number of the GNU Lesser
158 | General Public License, you may choose any version of the GNU Lesser
159 | General Public License ever published by the Free Software Foundation.
160 | 
161 |   If the Library as you received it specifies that a proxy can decide
162 | whether future versions of the GNU Lesser General Public License shall
163 | apply, that proxy's public statement of acceptance of any version is
164 | permanent authorization for you to choose that version for the
165 | Library.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Unity3D Download Manager
 2 | ====================
 3 | 
 4 | Author: Michael Taylor Contact: www.michaeltaylor3d.com/contact
 5 | 
 6 | Copyright (c) Michael Taylor
 7 | 
 8 | This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
 9 | 
10 | This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
11 | 
12 | You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.
13 | 
14 | 
15 | 
16 | 
17 | 
18 | A download queue system for Unity3D. Automatically caches image files to disk. 
19 | 
20 | Supports Downloading Async (with callback) or Sync
21 | 
22 | Warning: Do not use sync on iOS devices, this will cause the device to freeze. Use Async instead.
23 | 
24 | API
25 | ====
26 | 
27 | KEY:
28 | 
29 | path: your download path
30 | 
31 | callback: Callback function to send downloaded data to
32 | 
33 | failscript: invokes the failScript function if the download fails
34 | 
35 | saveToLocal: saves and caches the download to the local disk (image downloads only)
36 | 
37 | downloadRetries: how many times to retry a failed download
38 | 
39 | 
40 | 
41 | API MEMBERS:
42 | 
43 | 
44 | public static string Sync(string path)
45 | 
46 | Async Overloads:
47 | 
48 | public static void Async(string path, DownloadCallback callback)
49 | 
50 | public static void Async(string path, DownloadCallback callback,  FailScript failscript)
51 | 
52 | public static void Async(string path, DownloadCallback callback, bool saveToLocal, int downloadRetries)
53 | 
54 | public static void Async(string path, DownloadCallback callback, int downloadRetries)
55 | 
56 | public static void Async(string path, DownloadCallback callback, bool saveToLocal)
57 | 


--------------------------------------------------------------------------------