Expose SyncConfiguration.OnProgress (#1807)

* Expose SyncConfiguration.OnProgress

* Add docs and update PCL

* update PR number

* Fix the stylecop violation

Author: nirinchev

CHANGELOG.md

@@ -2,10 +2,10 @@ x.y.z (2018-mm-dd)
 ------------------
 
 ### Enhancements
-* None.
+* Exposed an `OnProgress` property on `SyncConfigurationBase`. It allows you to specify a progress callback that will be invoked when using `Realm.GetInstanceAsync` to report the download progress. ([#1807](https://github.com/realm/realm-dotnet/pull/1807))
 
 ### Fixed
-* <How to hit and notice issue? what was the impact?> ([#????](https://github.com/realm/realm-dotnet/issues/????), since v?.?.?)
+<!-- * <How to hit and notice issue? what was the impact?> ([#????](https://github.com/realm/realm-dotnet/issues/????), since v?.?.?) -->
 * Trying to call `Subscription.WaitForSynchronizationAsync` on a background thread (without a `SynchronizationContext`) would previously hang indefinitely. Now a meaningful exception will be thrown to indicate that this is not supported and this method should be called on a thread with a synchronization context. ([dotnet-private#130](https://github.com/realm/realm-dotnet-private/issues/130), since v3.0.0)
 
 ### Breaking changes

Platform.PCL/Realm.Sync.PCL/Configurations/SyncConfigurationBasePCL.cs

@@ -72,6 +72,14 @@ public abstract class SyncConfigurationBase : RealmConfigurationBase
         /// </seealso>
         public string TrustedCAPath { get; set; }
 
+        /// <summary>
+        /// Gets or sets a callback that is invoked when download progress is made when using <see cref="Realm.GetInstanceAsync"/>.
+        /// This will only be invoked for the initial download of the Realm and will not be invoked as futher download
+        /// progress is made during the lifetime of the Realm. It is ignored when using 
+        /// <see cref="Realm.GetInstance(RealmConfigurationBase)"/>.
+        /// </summary>
+        public Action<SyncProgress> OnProgress { get; set; }
+
         internal SyncConfigurationBase(Uri serverUri, User user = null, string optionalPath = null)
         {
             RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();

Realm/Realm.Sync/Configurations/SyncConfigurationBase.cs

@@ -79,6 +79,14 @@ public abstract class SyncConfigurationBase : RealmConfigurationBase
         /// </seealso>
         public string TrustedCAPath { get; set; }
 
+        /// <summary>
+        /// Gets or sets a callback that is invoked when download progress is made when using <see cref="Realm.GetInstanceAsync"/>.
+        /// This will only be invoked for the initial download of the Realm and will not be invoked as futher download
+        /// progress is made during the lifetime of the Realm. It is ignored when using 
+        /// <see cref="Realm.GetInstance(RealmConfigurationBase)"/>.
+        /// </summary>
+        public Action<SyncProgress> OnProgress { get; set; }
+
         internal SyncConfigurationBase(Uri serverUri, User user = null, string optionalPath = null)
         {
             Argument.Ensure(user != null || User.AllLoggedIn.Length == 1,
@@ -104,14 +112,8 @@ internal SyncConfigurationBase(Uri serverUri, User user = null, string optionalP
         /// </summary>
         public static LogLevel LogLevel
         {
-            get
-            {
-                return SharedRealmHandleExtensions.GetLogLevel();
-            }
-            set
-            {
-                SharedRealmHandleExtensions.SetLogLevel(value);
-            }
+            get => SharedRealmHandleExtensions.GetLogLevel();
+            set => SharedRealmHandleExtensions.SetLogLevel(value);
         }
 
         internal override Realm CreateRealm(RealmSchema schema)
@@ -135,12 +137,19 @@ internal override Realm CreateRealm(RealmSchema schema)
         internal override async Task<Realm> CreateRealmAsync(RealmSchema schema)
         {
             var session = new Session(SharedRealmHandleExtensions.GetSession(DatabasePath, ToNative(), EncryptionKey));
+            IDisposable subscription = null;
             try
             {
+                if (OnProgress != null)
+                {
+                    var observer = new Observer<SyncProgress>(OnProgress);
+                    subscription = session.GetProgressObservable(ProgressDirection.Download, ProgressMode.ForCurrentlyOutstandingWork).Subscribe(observer);
+                }
                 await session.WaitForDownloadAsync();
             }
             finally
             {
+                subscription?.Dispose();
                 session.CloseHandle();
             }
 

Tests/Tests.Sync.Shared/SessionTests.cs

@@ -206,7 +206,6 @@ public void Session_Error_WhenInvalidAccessToken()
         [TestCase(ProgressMode.ReportIndefinitely)]
         public void Session_ProgressObservable_IntegrationTests(ProgressMode mode)
         {
-            Console.WriteLine("Aaaaa");
             SyncTestHelpers.RequiresRos();
 
             const int ObjectSize = 1000000;

Tests/Tests.Sync.Shared/SynchronizedInstanceTests.cs

@@ -181,6 +181,52 @@ public void GetInstanceAsync_CreatesNonExistentRealm()
             });
         }
 
+        [Test]
+        public void GetInstanceAsync_ReportsProgress()
+        {
+            SyncTestHelpers.RequiresRos();
+
+            AsyncContext.Run(async () =>
+            {
+                var realmPath = Guid.NewGuid().ToString();
+                var user = await SyncTestHelpers.GetUserAsync();
+                var config = new FullSyncConfiguration(new Uri($"/~/{realmPath}", UriKind.Relative), user, Guid.NewGuid().ToString());
+                const int ObjectSize = 1000000;
+                const int ObjectsToRecord = 20;
+                using (var realm = GetRealm(config))
+                {
+                    for (var i = 0; i < ObjectsToRecord; i++)
+                    {
+                        realm.Write(() =>
+                        {
+                            realm.Add(new HugeSyncObject(ObjectSize));
+                        });
+                    }
+
+                    await WaitForSyncAsync(realm);
+                }
+
+                var callbacksInvoked = 0;
+
+                var lastProgress = default(SyncProgress);
+                config = new FullSyncConfiguration(new Uri($"/~/{realmPath}", UriKind.Relative), user, Guid.NewGuid().ToString())
+                {
+                    OnProgress = (progress) =>
+                    {
+                        callbacksInvoked++;
+                        lastProgress = progress; 
+                    }
+                };
+
+                using (var realm = await GetRealmAsync(config))
+                {
+                    Assert.That(realm.All<HugeSyncObject>().Count(), Is.EqualTo(ObjectsToRecord));
+                    Assert.That(callbacksInvoked, Is.GreaterThan(0));
+                    Assert.That(lastProgress.TransferableBytes, Is.EqualTo(lastProgress.TransferredBytes));
+                }
+            });
+        }
+
         [TestCase(true, true)]
         [TestCase(true, false)]
         [TestCase(false, true)]