Add support for large video file uploads (tus.io)

Assets/Tests/Play/VimeoRecorderPlayTest.cs

@@ -92,7 +92,25 @@ public IEnumerator Can_Record_Video_From_MainCamera_With_Valid_Token()
 
         yield return new WaitUntil(()=> uploaded == true);
         Assert.IsTrue(uploaded);
-    }    
+    }
+
+    [UnityTest]
+    [Timeout(100000)]
+    public IEnumerator Can_Record_And_Upload_Multiple_Chunks()
+    {
+        UnityEngine.TestTools.LogAssert.NoUnexpectedReceived();
+
+        recorder.videoName = "MainCamera Test " + recorder.videoName;
+        recorder.defaultVideoInput = VideoInputType.Camera;
+        recorder.customByteChunkSize = 50000;
+        recorder.SignIn(VALID_RECORDING_TOKEN);
+        recorder.BeginRecording();
+
+        recorder.OnUploadComplete += UploadComplete;
+
+        yield return new WaitUntil(()=> uploaded == true);
+        Assert.IsTrue(uploaded);
+    }
 
     private void UploadComplete()
     {

Assets/Tests/Unit/VimeoUploaderTest.cs

@@ -70,23 +70,23 @@ public void CreateChunks_Makes_One_Chunk_For_Small_Files()
         uploader.Init("xtokenx", 100000000);
         uploader.CreateChunks(testFile, "xxx");
         Assert.AreEqual(uploader.chunks.Count, 1);
-        Assert.AreEqual(uploader.chunks.Peek().chunkSize, testFileSize);
+        Assert.AreEqual(uploader.chunks[0].chunkSize, testFileSize);
     }
 
     [Test]
     public void CreateChunks_Properly_Sets_Up_Chunk()
     {
         uploader.CreateChunks(testFile, "upload url");
-        Assert.AreEqual(uploader.chunks.Peek().url, "upload url");
-        Assert.AreEqual(uploader.chunks.Peek().filePath, new FileInfo(TEST_IMAGE_PATH).FullName);
+        Assert.AreEqual(uploader.chunks[0].url, "upload url");
+        Assert.AreEqual(uploader.chunks[0].filePath, new FileInfo(TEST_IMAGE_PATH).FullName);
     }
 
     [Test]
     public void CreateChunks_Sets_Size_Of_Each_Chunk()
     {
         uploader.Init("xtokenx", 1234);
         uploader.CreateChunks(testFile, "xxx");
-        Assert.AreEqual(uploader.chunks.Peek().chunkSize, 1234);
+        Assert.AreEqual(uploader.chunks[0].chunkSize, 1234);
     }
 
     [Test]
@@ -99,15 +99,15 @@ public void CreateChunks_Last_Chunk_Is_Remainder()
         );
     }
 
-    [Test]
-    public void UploadNextChunk_Dequeues()
-    {
-        uploader.CreateChunks(testFile, "xxx");
+    // [Test]
+    // public void UploadNextChunk_Dequeues()
+    // {
+    //     uploader.CreateChunks(testFile, "xxx");
 
-        int length = uploader.chunks.Count;
-        uploader.UploadNextChunk();
-        Assert.AreEqual(uploader.chunks.Count, length - 1);
-    }
+    //     int length = uploader.chunks.Count;
+    //     uploader.UploadNextChunk();
+    //     Assert.AreEqual(uploader.chunks.Count, length - 1);
+    // }
 
     // TODO setup way to load mock json file
     // [Test]

Assets/Vimeo/Scripts/Recorder/VimeoRecorder.cs

@@ -18,6 +18,12 @@ public class VimeoRecorder : RecorderSettings
         public bool isRecording = false;
         public bool isUploading = false;
         public float uploadProgress = 0;
+        private int m_customByteChunkSize = 1024 * 1024 * 128;
+        public int customByteChunkSize {
+            set {
+                m_customByteChunkSize = value;
+            }
+        }
 
         public void Start()
         {
@@ -74,7 +80,7 @@ public void PublishVideo()
 
             if (publisher == null) {
                 publisher = gameObject.AddComponent<VimeoPublisher>();
-                publisher.Init(this);
+                publisher.Init(this, m_customByteChunkSize);
 
                 publisher.OnUploadProgress += UploadProgress;
                 publisher.OnNetworkError += NetworkError;

Assets/Vimeo/Scripts/Services/VimeoUploader.cs

@@ -18,8 +18,8 @@ public class VimeoUploader : VimeoApi
         public event UploadAction OnUploadProgress;
         public event RequestAction OnUploadComplete;
 
-        private Queue<VideoChunk> m_chunks;
-        public Queue<VideoChunk> chunks {
+        private List<VideoChunk> m_chunks;
+        public List<VideoChunk> chunks {
             get {
                 return m_chunks;
             }
@@ -61,10 +61,13 @@ public float uploadProgress {
                 return m_uploadProgress;
             }
         }
+        private int currentChunkIndex = 0;
+        private VideoChunk lastChunk;
 
         public void Init(string _token, int _maxChunkByteSize = 1024 * 1024 * 128)
         {
-            m_chunks = new Queue<VideoChunk>();
+            currentChunkIndex = 0;
+            m_chunks = new List<VideoChunk>();
             token = _token;
             m_maxChunkSize = _maxChunkByteSize;
         }
@@ -79,8 +82,19 @@ private void RequestComplete(string response)
             m_vimeoUrl = rawJSON["link"].Value;
             CreateChunks(m_fileInfo, tusUploadLink);
 
-            VideoChunk firstChunk = m_chunks.Dequeue();
-            firstChunk.Upload();
+            VideoChunk currentChunk = GetNextChunk();
+            currentChunk.Upload();
+        }
+
+        private VideoChunk GetNextChunk()
+        {
+            if (HasChunksLeftToUpload()) {
+                VideoChunk currentChunk = m_chunks[currentChunkIndex];
+                RegisterChunkEvents(currentChunk);
+                return currentChunk;    
+            }
+
+            return null;
         }
 
         public void Upload(string _file)
@@ -92,30 +106,44 @@ public void Upload(string _file)
             StartCoroutine(RequestTusResource("me/videos", m_fileInfo.Length));
         }
 
-        private void OnCompleteChunk(VideoChunk chunk, string msg)
+        private void OnCompleteChunk(VideoChunk chunk, string latestUploadedByte)
         {
-            //Emit the event
             if (OnChunckUploadComplete != null) {
-                OnChunckUploadComplete(chunk, msg);
+                // OnUploadProgress("Uploading", 1f);
+                OnChunckUploadComplete(chunk, latestUploadedByte);
             }
 
             Destroy(chunk);
 
-            UploadNextChunk();
+            currentChunkIndex++;
+            UploadNextChunk(GetNextChunk());
         }
 
         private void OnUploadChunkProgress(VideoChunk chunk, float progress)
         {
-            //Calculate the addition of each chunk to the total file length (in bytes)
             m_uploadProgress = (chunks.Count + 1) * ((progress * (float)chunk.chunkSize) / (float)m_fileInfo.Length);
             if (OnUploadProgress != null) {
                 OnUploadProgress("Uploading", m_uploadProgress);
             }
         }
 
+        private void RegisterChunkEvents(VideoChunk chunk)
+        {
+            chunk.OnChunkUploadComplete += OnCompleteChunk;
+            chunk.OnChunkUploadError += OnChunkError;
+            chunk.OnChunkUploadProgress += OnUploadChunkProgress;
+        }
+
+        private void DisposeChunkEvents(VideoChunk chunk)
+        {
+            chunk.OnChunkUploadComplete -= OnCompleteChunk;
+            chunk.OnChunkUploadError -= OnChunkError;
+            chunk.OnChunkUploadProgress -= OnUploadChunkProgress;
+        }
+
         private void OnChunkError(VideoChunk chunk, string err)
         {
-            if (OnChunckUploadError != null) {
+            if (OnChunckUploadError != null && chunk != null) {
                 OnChunckUploadError(chunk, err);
             }
         }
@@ -127,7 +155,7 @@ public void CreateChunks(FileInfo fileInfo, string tusUploadLink)
 
             for (int i = 0; i < m_numChunks; i++) {
                 int indexByte = m_maxChunkSize * i;
-                VideoChunk chunk = this.gameObject.AddComponent<VideoChunk>();
+                VideoChunk chunk = gameObject.AddComponent<VideoChunk>();
                 chunk.hideFlags = HideFlags.HideInInspector;
 
                 //If we are at the last chunk set the max chunk size to the fractional remainder
@@ -137,21 +165,22 @@ public void CreateChunks(FileInfo fileInfo, string tusUploadLink)
                 } else {
                     chunk.Init(indexByte, tusUploadLink, fileInfo.FullName, m_maxChunkSize);
                 }
-
-                chunk.OnChunkUploadComplete += OnCompleteChunk;
-                chunk.OnChunkUploadError += OnChunkError;
-                chunk.OnChunkUploadProgress += OnUploadChunkProgress;
-                m_chunks.Enqueue(chunk);
+                m_chunks.Add(chunk);
             }
         }
 
-        public void UploadNextChunk()
+        public void UploadNextChunk(VideoChunk currentChunk)
         {
-            //Make sure the queue is not empty
-            if (m_chunks.Count != 0) {
-                VideoChunk currentChunk = m_chunks.Dequeue();
-
+            if (lastChunk != null) {
+                DisposeChunkEvents(lastChunk);
+            }
+
+            //Make sure there are still chunks to upload
+            if (currentChunk != null) {
                 currentChunk.Upload();
+
+                //Store the reference to latest uploaded chunk to de-register events
+                lastChunk = currentChunk;
             } else {
                 if (OnUploadProgress != null) {
                     OnUploadProgress("UploadComplete", 1f);
@@ -161,5 +190,13 @@ public void UploadNextChunk()
                 }
             }
         }
+
+        private bool HasChunksLeftToUpload()
+        {
+            if (currentChunkIndex < m_chunks.Count) {
+                return true;
+            }
+            return false;
+        }
     }
 }

Assets/Vimeo/Scripts/Utils/VideoChunk.cs

@@ -99,21 +99,6 @@ private IEnumerator SendTusRequest()
             DisposeBytes();
         }
 
-        private void Update() {
-
-            //Make sure that we are uploading this chunk and the request is not null
-            if (m_isUploadingChunk && chunkUploadRequest != null) {
-
-                //We only emit events if the upload started (i.e > 0) or it hasn't finished yet (i.e < 1)
-                if (chunkUploadRequest.uploadProgress > 0.0f &&
-                    chunkUploadRequest.uploadProgress < 1.0f) {
-                        OnChunkUploadProgress(this, chunkUploadRequest.uploadProgress);
-                }
-
-            }
-
-        }
-
         public void Upload()
         {
             StartCoroutine(SendTusRequest());