Resumable Synchronization API

Syntax

SMP101DB.ResumePendingSynchronization();

SMP101DB.CancelPendingSynchronization();

1. When the system is in a pending synchronization state, waiting for either a resume pending synchronization request by calling ResumePendingSynchronization API or a cancellation request by calling CancelPendingSynchronization, the synchronization queue is locked. Any other new blocking or non-blocking synchronization requests are not permitted.
2. If partial data has not downloaded to the device when the interruption occurs, for example, the device is uploading data to the server, or the server is still fetching data from the EIS, the synchronization request terminates immediately and the client reverts to standard behavior. If the interruption is due to:
   • Environmental changes – instead of receiving a SynchronizationStatus.INTERRUPTED_WITH_PARTIAL_DATA status, the exception in the sync context is returned.
   • Application code disables or cancels the synchronization for any reason – SyncStatusListener's objectSyncStatus method returns true.

Examples

• Sample code for setting the resumable option then synchronize –

  ...
  ...
  ...
  //turn on the resume synchronization option
  SMP101DB.GetSynchronizationProfile().ResumeSynchronization = true;
  MyCallbackHandlerForResumeSync callback = new MyCallbackHandlerForResumeSync();
  SMP101DBRegisterCallbackHandler(callback);
  MyResumeSyncStatusListener listener = new MyResumeSyncStatusListener();
  GenericList<ISynchronizationGroup> groups = new GenericList<ISynchronizationGroup>();
  groups.Add(SynchronizationGroup.GetInstance("default"));
      
  //submit a non-blocking sync request
  SMP101DB.BeginSynchronize(groups, null, false, listener); 

• CallbackHandler sample code in receiving SynchronizationStatus.INTERRUPTED_WITH_PARTIAL_DATA status –

   //in the implementation of SUPDefaultCallbackHandler class
      ...
      ...
      ...
      SynchronizationAction OnSynchronize(GenericList<ISynchronizationGroup> groups, SynchronizationContext context)
      {    
          switch (context.Status)
          {
          ...
          case SynchronizationStatus.INTERRUPTED_WITH_PARTIAL_DATA:
  	        _isInterruptedWithPartialData = true;
  
              // By returning continue, the system waits for a request to resume or cancel the pending synchronization and the synchronization queue is locked.
              // If returning SynchronizationAction.CANCEL instead, the system automatically cancels the pending synchronization.  
              // Application cannot resume the synchronization and the synchronization queue is not locked.
  
  	        return SynchronizationAction.CONTINUE;
          ...
          }
      } 

• Sample code for resuming or canceling synchronization on sync callback status changed notification –

   void HandleInterruptedWithPartialData()
      {
          if (MAX_INTERRUPTED_STATUS == _interruptedStatusCount)
          {
              CancelPendingSync();
              Console.WriteLine("Resume sync is canceled.");
              Console.WriteLine("Interrupted status count reached the max: {0}.", MAX_INTERRUPTED_STATUS);
          }
          else
          {
              _isInterruptedWithPartialData = true;
              _interruptedStatusCount++;
              
              int waitCount = 0;
              while(!_isDeviceConnectedToInternet)
              {
                  System.Threading.Thread.Sleep(1000);
                  waitCount++;
                  
                  if (waitCount > MAX_WAIT)
                  {
                      Console.WriteLine("There is no network connection {0} seconds.", MAX_WAIT);
                      break;
                  }
              }
              
              if (_isDeviceConnectedToInternet)
              {
                  ResumeSync();
              }
              else
              {
                  CancelPendingSync();
                  
                  Console.WriteLine("Resume sync is canceled.");
                  Console.WriteLine("there's no network connectivity for too long.");
              }
          }
      }
  
      void CancelPendingSync()
      {
          Console.WriteLine("going to cancel pending sync...");
          
          if (SMP101DB.CancelPendingSynchronization())
          {
              Console.WriteLine("failed to cancel pending sync.");
          }
          else
          {
              Console.WriteLine("pending sync has been cancelled.");
          }
      }
  
      void ResumeSync()
      {
          if (!_isInterruptedWithPartialData)
          {
              Console.WriteLine("no resume as there is no interrupted with partiald data.");
              return;
          }
          
          Console.WriteLine("going to resume sync...");
          bool resumed = SMP101DB.ResumePendingSynchronization();
          _isInterruptedWithPartialData = false;
          if (!resumed)
          {
              Console.WriteLine("failed to resume pending syn.");
          }
          else
          {
             _resumeSyncCount++;
             Console.WriteLine("resume sync count: {0}.", _resumeSyncCount);
          }
      }