/// <summary>
/// Method that handles syncing the offline and online maps
/// </summary>
private async Task SyncMap(Map map)
{
var syncTask = await OfflineMapSyncTask.CreateAsync(map);
// set parameters for sync
var taskParams = new OfflineMapSyncParameters()
{
SyncDirection = SyncDirection.Bidirectional,
RollbackOnFailure = true
};
try
{
// set the job to perform the sync
OfflineMapSyncJob = syncTask.SyncOfflineMap(taskParams);
// update the progress property when progress changes
OfflineMapSyncJob.ProgressChanged +=
(s, e) =>
{
Progress = OfflineMapSyncJob.Progress;
};
// listen for job changed events
OfflineMapSyncJob.JobChanged += (s, e) =>
{
// if sync succeeds, raise success message
if (OfflineMapSyncJob.Status == JobStatus.Succeeded)
{
BroadcastMessenger.Instance.RaiseBroadcastMessengerValueChanged(true, Models.BroadcastMessageKey.SyncSucceeded);
}
else if (OfflineMapSyncJob.Status == JobStatus.Failed)
{
// if the job failed display the error, unless the user has cancelled it on purpose
if (OfflineMapSyncJob.Error != null && OfflineMapSyncJob.Error.Message != "User canceled: Job canceled.")
{
UserPromptMessenger.Instance.RaiseMessageValueChanged(
null, OfflineMapSyncJob.Error.Message, true, OfflineMapSyncJob.Error.StackTrace);
}
BroadcastMessenger.Instance.RaiseBroadcastMessengerValueChanged(false, Models.BroadcastMessageKey.SyncSucceeded);
}
};
// begin sync job
OfflineMapSyncJob.Start();
}
catch (Exception ex)
{
UserPromptMessenger.Instance.RaiseMessageValueChanged(
null, ex.Message, true, ex.StackTrace);
BroadcastMessenger.Instance.RaiseBroadcastMessengerValueChanged(false, Models.BroadcastMessageKey.SyncSucceeded);
}
}
private async void SyncMapArea(string parameter)
{
try
{
_windowService.SetBusy(true);
SyncDirection synchronizationMode;
switch (parameter)
{
case "Download":
synchronizationMode = SyncDirection.Download;
_windowService.SetBusyMessage("Getting latest updates...");
break;
case "Upload":
synchronizationMode = SyncDirection.Upload;
_windowService.SetBusyMessage("Pushing local changes...");
break;
default:
synchronizationMode = SyncDirection.Bidirectional;
_windowService.SetBusyMessage("Synchronizing features...");
break;
}
// Create task that is used to synchronize the offline map
var task = await OfflineMapSyncTask.CreateAsync(Map);
// Create parameters
var parameters = new OfflineMapSyncParameters
{
SyncDirection = synchronizationMode
};
// Create job that does the work asynchronously
var job = task.SyncOfflineMap(parameters);
job.ProgressChanged += async(s, e) =>
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
var offlineMapSyncJob = s as OfflineMapSyncJob;
_windowService.SetBusyMessage($"Syncing map area...{offlineMapSyncJob.Progress}%");
});
};
// Run the job and wait the results
var results = await job.GetResultAsync();
if (results.HasErrors)
{
// handle nicely
}
foreach (string message in job.Messages.Select(x => x.Message))
{
Debug.WriteLine(message);
}
}
catch (Exception ex)
{
await _windowService.ShowAlertAsync(ex.Message, "Couldn't sync map area");
}
finally
{
RefreshCommands();
_windowService.SetBusy(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="map"></param>
/// <param name="jobHandler"></param>
/// <param name="progressHandler"></param>
///
/// <returns></returns>
public async Task <SynchronizeReplicaResult> SynchronizeReplicaAsync(Map map, EventHandler <JobChangedEventArgs> jobHandler,
EventHandler <ProgressChangedEventArgs> progressHandler)
{
var errors = new List <SyncReplicaErrorResult>();
var task = await OfflineMapSyncTask.CreateAsync(map);
var param = new OfflineMapSyncParameters()
{
RollbackOnFailure = true,
SyncDirection = SyncDirection.Bidirectional
};
var job = task.SyncOfflineMap(param);
if (jobHandler != null)
{
JobChangedEventHandler += jobHandler;
job.JobChanged += (o, e) =>
{
if (JobChangedEventHandler != null)
{
JobChangedEventHandler.Invoke(job, new JobChangedEventArgs()
{
Messages = job.Messages, Status = job.Status
});
}
};
}
if (progressHandler != null)
{
ProgressChangedEventHandler += progressHandler;
job.ProgressChanged += (o, e) =>
{
ProgressChangedEventHandler?.Invoke(job, new ProgressChangedEventArgs()
{
Progress = job.Progress
});
};
}
var result = await job.GetResultAsync();
if (result.HasErrors)
{
errors.AddRange(result.LayerResults
.Select(l => new SyncReplicaErrorResult()
{
Name = l.Key.Name, Error = l.Value.Error
}));
errors.AddRange(result.TableResults
.Select(t => new SyncReplicaErrorResult()
{
Name = t.Key.TableName, Error = t.Value.Error
}));
return(new SynchronizeReplicaResult {
Synchronized = false, ResultErrors = errors
});
}
else
{
return(new SynchronizeReplicaResult {
Synchronized = true
});
}
}
