private async void SyncEditsButton_Click(object sender, RoutedEventArgs e)
{
var gdb = await Geodatabase.OpenAsync(this.LocalDataPathTextBlock.Text);
// create a new GeodatabaseSyncTask with the uri of the feature server to pull from
var serverUrl = this.featureLayerServiceUrl.Substring(0, this.featureLayerServiceUrl.LastIndexOf('/'));
var uri = new Uri(serverUrl);
var geodatabaseSyncTask = new GeodatabaseSyncTask(uri);
var geodatabaseSyncParams = new SyncGeodatabaseParameters();
geodatabaseSyncParams.SyncDirection = SyncDirection.Bidirectional;
var checkStatusInterval = new TimeSpan(0, 0, 3);
// Create a System.Progress<T> object to report status as the task executes
var progress = new Progress <GeodatabaseStatusInfo>();
progress.ProgressChanged += (s, info) =>
{
this.SyncStatusTextBlock.Text = "Sync edits: " + info.Status;
};
this.SyncStatusTextBlock.Text = "Starting sync ...";
this.SyncProgressBar.Visibility = System.Windows.Visibility.Visible;
this.SyncStatusPanel.Visibility = System.Windows.Visibility.Visible;
var result = await geodatabaseSyncTask.SyncGeodatabaseAsync(geodatabaseSyncParams, gdb, syncCompleteCallback, uploadCompleteCallback, checkStatusInterval, progress, new CancellationToken());
}
private async Task SyncGeodatabase()
{
// Return if not ready.
if (_readyForEdits != EditState.Ready)
{
return;
}
// Disable the sync button.
SyncButton.IsEnabled = false;
// Create parameters for the sync task.
SyncGeodatabaseParameters parameters = new SyncGeodatabaseParameters()
{
GeodatabaseSyncDirection = SyncDirection.Bidirectional,
RollbackOnFailure = false
};
// Get the layer ID for each feature table in the geodatabase, then add to the sync job.
foreach (GeodatabaseFeatureTable table in _resultGdb.GeodatabaseFeatureTables)
{
// Get the ID for the layer.
long id = table.ServiceLayerId;
// Create the SyncLayerOption.
SyncLayerOption option = new SyncLayerOption(id);
// Add the option.
parameters.LayerOptions.Add(option);
}
// Create job.
SyncGeodatabaseJob job = _gdbSyncTask.SyncGeodatabase(parameters, _resultGdb);
// Subscribe to progress updates.
job.ProgressChanged += (o, e) =>
{
// Update the progress bar.
UpdateProgressBar(job.Progress);
};
// Show the progress bar.
GenerateSyncProgressBar.Visibility = Visibility.Visible;
// Start the sync.
job.Start();
// Wait for the result.
await job.GetResultAsync();
// Hide the progress bar.
GenerateSyncProgressBar.Visibility = Visibility.Collapsed;
// Do the remainder of the work.
HandleSyncCompleted(job);
// Re-enable the sync button.
SyncButton.IsEnabled = true;
}
// Synchronize edits in the local geodatabase with the service.
private async void SynchronizeEdits(object sender, EventArgs e)
{
// Show the progress bar while the sync is working.
_progressBar.Hidden = false;
try
{
// Create a sync task with the URL of the feature service to sync.
GeodatabaseSyncTask syncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(SyncServiceUrl));
// Create sync parameters.
SyncGeodatabaseParameters taskParameters = await syncTask.CreateDefaultSyncGeodatabaseParametersAsync(_localGeodatabase);
// Create a synchronize geodatabase job, pass in the parameters and the geodatabase.
SyncGeodatabaseJob job = syncTask.SyncGeodatabase(taskParameters, _localGeodatabase);
// Handle the JobChanged event for the job.
job.JobChanged += (s, arg) =>
{
InvokeOnMainThread(() =>
{
// Update the progress bar.
UpdateProgressBar(job.Progress);
switch (job.Status)
{
// Report changes in the job status.
case JobStatus.Succeeded:
_statusLabel.Text = "Synchronization is complete!";
_progressBar.Hidden = true;
break;
case JobStatus.Failed:
// Report failure.
_statusLabel.Text = job.Error.Message;
_progressBar.Hidden = true;
break;
default:
_statusLabel.Text = "Sync in progress ...";
break;
}
});
};
// Await the completion of the job.
await job.GetResultAsync();
}
catch (Exception ex)
{
// Show the message if an exception occurred.
_statusLabel.Text = "Error when synchronizing: " + ex.Message;
}
}
// Synchronize edits in the local geodatabase with the service
public async void SynchronizeEdits(object sender, EventArgs e)
{
// Show the progress bar while the sync is working
_progressBar.Visibility = Android.Views.ViewStates.Visible;
try
{
// Create a sync task with the URL of the feature service to sync
GeodatabaseSyncTask syncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(SyncServiceUrl));
// Create sync parameters
SyncGeodatabaseParameters taskParameters = await syncTask.CreateDefaultSyncGeodatabaseParametersAsync(_localGeodatabase);
// Create a synchronize geodatabase job, pass in the parameters and the geodatabase
SyncGeodatabaseJob job = syncTask.SyncGeodatabase(taskParameters, _localGeodatabase);
// Handle the JobChanged event for the job
job.JobChanged += (s, arg) =>
{
RunOnUiThread(() =>
{
// Update the progress bar
UpdateProgressBar(job.Progress);
// Report changes in the job status
if (job.Status == JobStatus.Succeeded)
{
_messageTextBlock.Text = "Synchronization is complete!";
_progressBar.Visibility = Android.Views.ViewStates.Gone;
}
else if (job.Status == JobStatus.Failed)
{
// Report failure ...
_messageTextBlock.Text = job.Error.Message;
_progressBar.Visibility = Android.Views.ViewStates.Gone;
}
else
{
// Report that the job is in progress ...
_messageTextBlock.Text = "Sync in progress ...";
}
});
};
// Await the completion of the job
await job.GetResultAsync();
}
catch (Exception ex)
{
// Show the message if an exception occurred
_messageTextBlock.Text = "Error when synchronizing: " + ex.Message;
}
}
private async Task SyncGeodatabase()
{
// Return if not ready.
if (_readyForEdits != EditState.Ready)
{
return;
}
// Disable the sync button.
_syncButton.Enabled = false;
// Disable editing.
_myMapView.GeoViewTapped -= GeoViewTapped;
// Show the progress bar.
_progressBar.Hidden = false;
// Create parameters for the sync task.
SyncGeodatabaseParameters parameters = new SyncGeodatabaseParameters
{
GeodatabaseSyncDirection = SyncDirection.Bidirectional,
RollbackOnFailure = false
};
// Get the layer Id for each feature table in the geodatabase, then add to the sync job.
foreach (GeodatabaseFeatureTable table in _resultGdb.GeodatabaseFeatureTables)
{
// Get the ID for the layer.
long id = table.ServiceLayerId;
// Create the SyncLayerOption.
SyncLayerOption option = new SyncLayerOption(id);
// Add the option.
parameters.LayerOptions.Add(option);
}
// Create job.
_gdbSyncJob = _gdbSyncTask.SyncGeodatabase(parameters, _resultGdb);
// Subscribe to progress updates.
_gdbSyncJob.ProgressChanged += Job_ProgressChanged;
// Start the sync.
_gdbSyncJob.Start();
// Get the result.
await _gdbSyncJob.GetResultAsync();
// Do the rest of the work.
HandleSyncCompleted(_gdbSyncJob);
}
////////////////////////////////////////////////////////////////
// 同期
////////////////////////////////////////////////////////////////
/**
* サーバー(AGOL)と同期する
* ① 同期タスクを作成する
* ② 同期パラメータを取得する
**/
private async void OnSyncClick(object sender, RoutedEventArgs e)
{
// 同期したいレイヤーでタスクオブジェクトを作成する
geodatabaseSyncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(FEATURELAYER_SERVICE_URL));
readGeoDatabase();
// タスクオブジェクトから同期するためのパラメータを作成する
syncParams = await geodatabaseSyncTask.CreateDefaultSyncGeodatabaseParametersAsync(geodatabase);
// パラーメータを使用してgeodatabaseを同期する
syncGeodatabase();
}
// Synchronize edits in the local geodatabase with the service
public async void SynchronizeEdits(object sender, EventArgs e)
{
// Show the progress bar while the sync is working
LoadingProgressBar.IsVisible = true;
try
{
// Create a sync task with the URL of the feature service to sync
GeodatabaseSyncTask syncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(SyncServiceUrl));
// Create sync parameters
SyncGeodatabaseParameters taskParameters = await syncTask.CreateDefaultSyncGeodatabaseParametersAsync(_localGeodatabase);
// Create a synchronize geodatabase job, pass in the parameters and the geodatabase
SyncGeodatabaseJob job = syncTask.SyncGeodatabase(taskParameters, _localGeodatabase);
// Handle the JobChanged event for the job
job.JobChanged += (s, arg) =>
{
// Report changes in the job status
if (job.Status == JobStatus.Succeeded)
{
// Report success ...
Device.BeginInvokeOnMainThread(() => MessageTextBlock.Text = "Synchronization is complete!");
}
else if (job.Status == JobStatus.Failed)
{
// Report failure ...
Device.BeginInvokeOnMainThread(() => MessageTextBlock.Text = job.Error.Message);
}
else
{
// Report that the job is in progress ...
Device.BeginInvokeOnMainThread(() => MessageTextBlock.Text = "Sync in progress ...");
}
};
// Await the completion of the job
await job.GetResultAsync();
}
catch (Exception ex)
{
// Show the message if an exception occurred
MessageTextBlock.Text = "Error when synchronizing: " + ex.Message;
}
finally
{
// Hide the progress bar when the sync job is complete
LoadingProgressBar.IsVisible = false;
}
}
private async Task SyncDataAsync(IEnumerable <Geodatabase> syncGeodatabases, SyncDirection syncDirection)
{
foreach (var geodatabase in syncGeodatabases)
{
IReadOnlyList <SyncLayerResult> results = null;
try
{
Log.Debug($"{geodatabase.Path} about to start {syncDirection} sync");
if (!geodatabase.HasLocalEdits() && syncDirection == SyncDirection.Upload)
{
Log.Debug("No edits skipping sync");
continue;
}
Log.Debug($"ServiceUrl: {geodatabase.Source}");
GeodatabaseSyncTask syncTask = await GeodatabaseSyncTask.CreateAsync(geodatabase.Source);
SyncGeodatabaseParameters syncParameters = await syncTask.CreateDefaultSyncGeodatabaseParametersAsync(geodatabase);
syncParameters.GeodatabaseSyncDirection = syncDirection;
SyncGeodatabaseJob job = syncTask.SyncGeodatabase(syncParameters, geodatabase);
results = await job.GetResultAsync();
LogResults(results);
}
catch (Exception e)
{
Log.Error(e.Message);
Log.Error($"{geodatabase.Path} did not sync");
if (results != null)
{
LogResults(results);
}
}
}
if (syncDirection == SyncDirection.Bidirectional || syncDirection == SyncDirection.Download)
{
EventAggregator.GetEvent <SyncCompleteEvent>().Publish(SyncCompleteEventArgs.Empty);
}
}
private void SyncGeodatabase()
{
// Return if not ready
if (_readyForEdits != EditState.Ready)
{
return;
}
// Create parameters for the sync task
SyncGeodatabaseParameters parameters = new SyncGeodatabaseParameters()
{
GeodatabaseSyncDirection = SyncDirection.Bidirectional,
RollbackOnFailure = false
};
// Get the layer Id for each feature table in the geodatabase, then add to the sync job
foreach (GeodatabaseFeatureTable table in _resultGdb.GeodatabaseFeatureTables)
{
// Get the ID for the layer
long id = table.ServiceLayerId;
// Create the SyncLayerOption
SyncLayerOption option = new SyncLayerOption(id);
// Add the option
parameters.LayerOptions.Add(option);
}
// Create job
SyncGeodatabaseJob job = _gdbSyncTask.SyncGeodatabase(parameters, _resultGdb);
// Subscribe to status updates
job.JobChanged += Job_JobChanged;
// Subscribe to progress updates
job.ProgressChanged += Job_ProgressChanged;
// Start the sync
job.Start();
}
private async Task SyncGeodatabaes(SyncDirection syncDirection)
{
foreach (var gdbPath in BidirectionalGdbs)
{
Geodatabase geodatabase = null;
IReadOnlyList <SyncLayerResult> results = null;
try
{
geodatabase = await Geodatabase.OpenAsync(gdbPath);
Log.Debug($"{geodatabase.Path} about to start {syncDirection} sync");
if (!geodatabase.HasLocalEdits() && syncDirection == SyncDirection.Upload)
{
Log.Debug("No edits skipping sync");
continue;
}
Log.Debug($"ServiceUrl: {geodatabase.Source}");
GeodatabaseSyncTask syncTask = await GeodatabaseSyncTask.CreateAsync(geodatabase.Source);
SyncGeodatabaseParameters syncParameters = await syncTask.CreateDefaultSyncGeodatabaseParametersAsync(geodatabase);
syncParameters.GeodatabaseSyncDirection = syncDirection;
SyncGeodatabaseJob job = syncTask.SyncGeodatabase(syncParameters, geodatabase);
results = await job.GetResultAsync();
LogResults(results);
}
catch (Exception e)
{
Log.Error(e.Message);
Log.Error($"{geodatabase?.Path} did not sync");
LogResults(results);
}
}
}
private void SyncGeodatabase()
{
// Return if not ready
if (_readyForEdits != EditState.Ready)
{
return;
}
// 同期タスクのパラメータを作成する
SyncGeodatabaseParameters parameters = new SyncGeodatabaseParameters()
{
GeodatabaseSyncDirection = SyncDirection.Bidirectional,
RollbackOnFailure = false
};
// ジオデータベース内の各フィーチャテーブルのレイヤー ID を取得してから、同期ジョブに追加する
foreach (GeodatabaseFeatureTable table in _resultGdb.GeodatabaseFeatureTables)
{
// レイヤーのIDを取得する
long id = table.ServiceLayerId;
// CSyncLayerOption を作成する
SyncLayerOption option = new SyncLayerOption(id);
// オプションを追加する
parameters.LayerOptions.Add(option);
}
// ジョブを作成する
SyncGeodatabaseJob job = _gdbSyncTask.SyncGeodatabase(parameters, _resultGdb);
// ステータス更新
job.JobChanged += Job_JobChanged;
// プログレスバーの更新
job.ProgressChanged += Job_ProgressChanged;
// 同期を開始する
job.Start();
}
public static async Task <Geodatabase> DownloadOrUpdateFeatureService(String serviceUrl, Extent extent, Action <double, double> ProgressUpdate)
{
var task = new TaskCompletionSource <Geodatabase>();
var syncTask = await GeodatabaseSyncTask.CreateAsync(new Uri(serviceUrl));
var serviceName = PullArcgisServiceName(serviceUrl);
var geodatabaseFilePath = Path.Combine(CachePath, serviceName + ".gdb");
Geodatabase ret;
if (File.Exists(geodatabaseFilePath))
{
//add service to existing mobile geodatabase
ret = await Geodatabase.OpenAsync(geodatabaseFilePath);
// create sync parameters
var taskParameters = new SyncGeodatabaseParameters()
{
RollbackOnFailure = true,
GeodatabaseSyncDirection = SyncDirection.Download
};
// create a synchronize geodatabase job, pass in the parameters and the geodatabase
SyncGeodatabaseJob syncGdbJob = syncTask.SyncGeodatabase(taskParameters, ret);
syncGdbJob.JobChanged += (async(object sender, EventArgs e) =>
{
var job = sender as SyncGeodatabaseJob;
switch (job?.Status)
{
case JobStatus.Succeeded:
await syncTask.UnregisterGeodatabaseAsync(ret);
task.SetResult(ret);
break;
case JobStatus.Failed:
if (job.Error != null)
{
task.SetException(job.Error);
}
else
{
String message = string.Empty;
var m = from msg in job.Messages select msg.Message;
message += ": " + string.Join <string>("\n", m);
task.SetException(new Exception(message));
}
task.SetResult(null);
break;
}
});
syncGdbJob.ProgressChanged += ((object sender, EventArgs e) =>
{
ProgressUpdate?.Invoke(syncGdbJob.Progress, 1.0);
});
// Start the job
var result = await syncGdbJob.GetResultAsync();
}
else
{
var envelope = new Envelope(extent.MinX, extent.MinY, extent.MaxX, extent.MaxY, SpatialReference.Create(extent.WKID));
// Get the default parameters for the generate geodatabase task
GenerateGeodatabaseParameters generateParams = await syncTask.CreateDefaultGenerateGeodatabaseParametersAsync(envelope);
// Create a generate geodatabase job
var generateGdbJob = syncTask.GenerateGeodatabase(generateParams, geodatabaseFilePath);
// Handle the job changed event
generateGdbJob.JobChanged += (async(object sender, EventArgs e) =>
{
var job = sender as GenerateGeodatabaseJob;
switch (job?.Status)
{
case JobStatus.Succeeded:
ret = await job.GetResultAsync();
await syncTask.UnregisterGeodatabaseAsync(ret);
task.SetResult(ret);
break;
case JobStatus.Failed:
if (job.Error != null)
{
task.SetException(job.Error);
}
else
{
String message = string.Empty;
var m = from msg in job.Messages select msg.Message;
message += ": " + string.Join <string>("\n", m);
task.SetException(new Exception(message));
}
task.SetResult(null);
break;
}
});
// Handle the progress changed event (to show progress bar)
generateGdbJob.ProgressChanged += ((object sender, EventArgs e) =>
{
ProgressUpdate?.Invoke(generateGdbJob.Progress, 1.0);
});
// Start the job
generateGdbJob.Start();
}
return(await task.Task);
}
public async Task<GeodatabaseStatusInfo> SyncGeodatabase(string url, Geodatabase gdb, bool unregister, bool syncing)
{
Console.WriteLine("Starting Sync " + DateTime.Now + " --> " + syncing);
var syncTask = new GeodatabaseSyncTask(new Uri(url));
var layerIdsAndName = new Dictionary<int, string>();
FeatureServiceInfo serviceInfo = await syncTask.GetServiceInfoAsync();
foreach (LayerServiceInfo layerServiceInfo in serviceInfo.Layers)
{
if (!layerIdsAndName.ContainsKey(layerServiceInfo.ID))
{
layerIdsAndName.Add(layerServiceInfo.ID, layerServiceInfo.Name);
}
}
var tcs = new TaskCompletionSource<GeodatabaseStatusInfo>();
Action<GeodatabaseStatusInfo, Exception> completionAction = (info, ex) =>
{
if (ex != null)
{
tcs.SetException(ex);
return;
}
tcs.SetResult(info);
};
var syncProgress = new Progress<GeodatabaseStatusInfo>();
syncProgress.ProgressChanged += (sndr, sts) => Console.WriteLine("Status:" + sts.Status.ToString() + "," +" --> " + syncing + "," + sts.SubmissionTime + "," + sts.ResultUri);
IDictionary<int, LayerSyncInfo> layerSync = null;
layerSync = new Dictionary<int, LayerSyncInfo>();
foreach (var id_name in layerIdsAndName)
{
var layerQuery = new LayerSyncInfo { SyncDirection = SyncDirection.Bidirectional };
layerSync.Add(id_name.Key, layerQuery);
}
Action<UploadResult> uploadAction = result => { Console.Write(""); };
//should we remove sync direction since it should be defined in layers?
var syncParams = new SyncGeodatabaseParameters(gdb) { RollbackOnFailure = false, UnregisterGeodatabase = unregister, LayerSyncInfos = layerSync, SyncDirection = SyncDirection.Bidirectional };
Console.WriteLine("Calling sync " + DateTime.Now);
await syncTask.SyncGeodatabaseAsync(syncParams, gdb,
completionAction,
uploadAction,
TimeSpan.FromSeconds(3),
syncProgress,
CancellationToken.None);
return await tcs.Task;
}
// function to submit a sync task
// -the url for the feature service and the path to the local geodatabase are passed in
public async Task SyncronizeEditsAsync(FeatureLayerInfo featureLayerInfo, Uri uri)
{
// create sync parameters
var taskParameters = new SyncGeodatabaseParameters
{
RollbackOnFailure = true,
SyncDirection = SyncDirection.Bidirectional
};
// cancel if an earlier call was made and hasn't completed
if (_syncCancellationTokenSource != null)
{
_syncCancellationTokenSource.Cancel();
}
// create a new cancellation token
_syncCancellationTokenSource = new CancellationTokenSource();
var cancelToken = _syncCancellationTokenSource.Token;
// create a sync task with the url of the feature service to sync
var syncTask = new GeodatabaseSyncTask(uri);
// create a new Progress object to report updates to the sync status
var progress = new Progress<GeodatabaseStatusInfo>();
progress.ProgressChanged += (sender, s) => { _model.SetMessageInfo("Progress: " + s.Status.ToString()); };
// call SyncGeodatabaseAsync and pass in: sync params, local geodatabase, completion callback, update interval, progress, and cancellation token
var geodatabaseFeatureTable = featureLayerInfo.FeatureLayer.FeatureTable as GeodatabaseFeatureTable;
var gdbResult = await syncTask.SyncGeodatabaseAsync(
taskParameters,
geodatabaseFeatureTable.Geodatabase,
(p, q) =>
{
// reset the cancellation token source
_syncCancellationTokenSource = null;
// if unsuccessful, report the exception and return
if (q != null)
{
_model.SetMessageInfo("An exception occured: " + q.Message);
return;
}
// if successful, notify the user
_model.SetMessageInfo("--- Sync completed ---");
//// optionally, do something with the result
//var resultUri = p.ResultUri;
// ...
UpdateToc(featureLayerInfo);
_model.SetSyncState(CheckSyncState(false));
},
null,
new TimeSpan(0, 0, 10),
progress,
cancelToken);
}
private async void Sync_Click(object sender, RoutedEventArgs e)
{
var tcs = new TaskCompletionSource <GeodatabaseStatusInfo>();
Action <GeodatabaseStatusInfo, Exception> completionAction = (info, ex) =>
{
if (ex != null)
{
tcs.SetException(ex);
}
tcs.SetResult(info);
};
Geodatabase gdb = null;
var syncTask = new GeodatabaseSyncTask(new Uri(uristring));
try
{
gdb = await Esri.ArcGISRuntime.Data.Geodatabase.OpenAsync(@"C:\Temp\10_2_7Demo\WildlifeLocal.geodatabase");
var table = gdb.FeatureTables.FirstOrDefault();
var lyr = new FeatureLayer
{
ID = table.Name,
DisplayName = table.Name,
FeatureTable = table
};
MyMapView.Map.Layers.Add(lyr);
Console.WriteLine(table.Name);
}
catch (Exception et)
{
Console.WriteLine(et.Message);
}
var taskParameters = new SyncGeodatabaseParameters()
{
RollbackOnFailure = false,
SyncDirection = Esri.ArcGISRuntime.Tasks.Offline.SyncDirection.Bidirectional
};
// cancel if an earlier call was made and hasn't completed
if (_syncCancellationTokenSource != null)
{
_syncCancellationTokenSource.Cancel();
}
// create a new cancellation token
_syncCancellationTokenSource = new CancellationTokenSource();
var cancelToken = _syncCancellationTokenSource.Token;
// create a new Progress object to report updates to the sync status
var progress = new Progress <GeodatabaseStatusInfo>();
progress.ProgressChanged += (sender2, s) =>
{
Console.WriteLine(s.Status);
};
try
{
// call SyncGeodatabaseAsync and pass in: sync params, local geodatabase, completion callback, update interval, progress, and cancellation token
var gdbResult = await syncTask.SyncGeodatabaseAsync(
taskParameters,
gdb,
this.syncCompleteCallback,
null,
new TimeSpan(0, 0, 2),
progress,
cancelToken);
}
catch (ArcGISWebException a)
{
Console.WriteLine(a.Code);
Console.WriteLine(a.StackTrace);
}
}
