public void GetDatasetMetadataAsync(string datasetName, AmazonCognitoSyncCallback <DatasetMetadata> callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
DescribeDatasetRequest request = new DescribeDatasetRequest();
request.IdentityPoolId = identityPoolId;
request.IdentityId = this.GetCurrentIdentityId();
request.DatasetName = datasetName;
client.DescribeDatasetAsync(request, (responseObj) =>
{
Exception dataStorageException = null;
DatasetMetadata metadata = null;
if (responseObj.Exception != null)
{
dataStorageException = new DataStorageException("Failed to get metadata of dataset: "
+ datasetName, responseObj.Exception);
}
else
{
metadata = ModelToDatasetMetadata(responseObj.Response.Dataset);
}
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetMetadata>(metadata, dataStorageException, responseObj.state)), options);
},
options);
}
private void SynchronizeHelperAsync(AsyncOptions options)
{
try
{
if (locked)
{
_logger.InfoFormat("Already in a Synchronize. Queueing new request.", DatasetName);
queuedSync = true;
return;
}
else
{
locked = true;
}
waitingForConnectivity = false;
InternalSDKUtils.AsyncExecutor(() =>
{
//make sure we have the updated credentials;
SynchornizeInternal(options);
}, new AsyncOptions()
{
ExecuteCallbackOnMainThread = false
});
}
catch (Exception e)
{
FireSyncFailureEvent(e, options);
_logger.Error(e, "");
}
}
private void PopulateListUpdatesAsync(string datasetName, long lastSyncCount, List <Record> records, string nextToken, AmazonCognitoSyncCallback <DatasetUpdates> callback, AsyncOptions options)
{
ListRecordsRequest request = new ListRecordsRequest();
request.IdentityPoolId = identityPoolId;
request.IdentityId = this.GetCurrentIdentityId();
request.DatasetName = datasetName;
request.LastSyncCount = lastSyncCount;
// mark it large enough to reduce # of requests
request.MaxResults = 1024;
request.NextToken = nextToken;
client.ListRecordsAsync(request, (responseObj) =>
{
ListRecordsResponse res = responseObj.Response;
Exception ex = responseObj.Exception;
object obj = responseObj.state;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetUpdates>(null, ex, obj)), options);;
}
else
{
ListRecordsResponse listRecordsResponse = res;
foreach (Amazon.CognitoSync.Model.Record remoteRecord in listRecordsResponse.Records)
{
//builder.addRecord(modelToRecord(remoteRecord));
records.Add(this.ModelToRecord(remoteRecord));
}
if (listRecordsResponse.NextToken == null)
{
DatasetUpdates updates = new DatasetUpdates(
datasetName,
records,
listRecordsResponse.DatasetSyncCount,
listRecordsResponse.SyncSessionToken,
listRecordsResponse.DatasetExists,
listRecordsResponse.DatasetDeletedAfterRequestedSyncCount,
listRecordsResponse.MergedDatasetNames
);
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <DatasetUpdates>(updates, ex, obj)), options);
return;
}
// update last evaluated key
nextToken = listRecordsResponse.NextToken;
// emulating the while loop
PopulateListUpdatesAsync(datasetName, lastSyncCount, records, nextToken, callback, new AsyncOptions()
{
ExecuteCallbackOnMainThread = false, State = obj
});
}
},
options);
}
/// <summary>
/// Refreshes dataset metadata. Dataset metadata is pulled from remote
/// storage and stored in local storage. Their record data isn't pulled down
/// until you sync each dataset.
/// </summary>
/// <param name="callback">Callback once the refresh is complete</param>
/// <param name="options">Options for asynchronous execution</param>
/// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
remote.GetDatasetMetadataAsync((cognitoResult) =>
{
Exception ex = cognitoResult.Exception;
List <DatasetMetadata> res = cognitoResult.Response;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
else
{
Local.UpdateDatasetMetadata(GetIdentityId(), res);
InternalSDKUtils.AsyncExecutor(() => callback(cognitoResult), options);
}
}, options);
}
public void PutRecordsAsync(string datasetName, List <Record> records, string syncSessionToken, AmazonCognitoSyncCallback <List <Record> > callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
UpdateRecordsRequest request = new UpdateRecordsRequest();
request.DatasetName = datasetName;
request.IdentityPoolId = identityPoolId;
request.IdentityId = this.GetCurrentIdentityId();
request.SyncSessionToken = syncSessionToken;
// create patches
List <RecordPatch> patches = new List <RecordPatch>();
foreach (Record record in records)
{
patches.Add(this.RecordToPatch(record));
}
request.RecordPatches = patches;
List <Record> updatedRecords = new List <Record>();
client.UpdateRecordsAsync(request, (responseObj) =>
{
Exception ex = responseObj.Exception;
UpdateRecordsResponse updateRecordsResponse = responseObj.Response;
Exception putRecordsException = null;
object obj = responseObj.state;
if (ex != null)
{
putRecordsException = HandleException(ex, "Failed to update records in dataset: " + datasetName);
}
else
{
foreach (Amazon.CognitoSync.Model.Record remoteRecord in updateRecordsResponse.Records)
{
updatedRecords.Add(ModelToRecord(remoteRecord));
}
}
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <Record> >(updatedRecords, putRecordsException, obj)), options);
},
options);
}
/// <summary>
/// Refreshes dataset metadata. Dataset metadata is pulled from remote
/// storage and stored in local storage. Their record data isn't pulled down
/// until you sync each dataset.
/// </summary>
/// <param name="callback">Callback once the refresh is complete</param>
/// <param name="options">Options for asynchronous execution</param>
/// <exception cref="Amazon.CognitoSync.SyncManager.DataStorageException">Thrown when fail to fresh dataset metadata</exception>
public void RefreshDatasetMetadataAsync(AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
AmazonCognitoSyncResult <List <DatasetMetadata> > cognitoResult = new AmazonCognitoSyncResult <List <DatasetMetadata> >(options.State);
InternalSDKUtils.AsyncExecutor(() =>
{
try
{
var response = Remote.ListDatasetMetadata();
Local.UpdateDatasetMetadata(IdentityId, response);
cognitoResult.Response = response;
}
catch (Exception e)
{
cognitoResult.Exception = e;
}
callback(cognitoResult);
}, options);
}
public void DeleteDatasetAsync(string datasetName, AmazonCognitoSyncCallback callback, AsyncOptions options = null)
{
options = options ?? new AsyncOptions();
DeleteDatasetRequest request = new DeleteDatasetRequest();
request.IdentityPoolId = identityPoolId;
request.IdentityId = this.GetCurrentIdentityId();
request.DatasetName = datasetName;
client.DeleteDatasetAsync(request, (responseObj) =>
{
if (responseObj.Exception != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(HandleException(responseObj.Exception, "Failed to delete dataset: " + datasetName), responseObj.state)), options);
}
else
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult(null, responseObj.state)), options);
}
},
options);
}
private void PopulateGetDatasetMetadataAsync(string nextToken, List <DatasetMetadata> datasets, AmazonCognitoSyncCallback <List <DatasetMetadata> > callback, AsyncOptions options)
{
ListDatasetsRequest request = new ListDatasetsRequest();
// a large enough number to reduce # of requests
request.MaxResults = 64;
request.NextToken = nextToken;
client.ListDatasetsAsync(request, (responseObj) =>
{
Exception ex = responseObj.Exception;
ListDatasetsResponse response = responseObj.Response;
object obj = responseObj.state;
if (ex != null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <DatasetMetadata> >(null, ex, obj)), options);
}
else
{
foreach (Amazon.CognitoSync.Model.Dataset dataset in response.Datasets)
{
datasets.Add(ModelToDatasetMetadata(dataset));
}
nextToken = response.NextToken;
if (nextToken == null)
{
InternalSDKUtils.AsyncExecutor(() => callback(new AmazonCognitoSyncResult <List <DatasetMetadata> >(datasets, null, obj)), options);
return;
}
PopulateGetDatasetMetadataAsync(nextToken, datasets, callback, options);
}
},
options);
}
