private void loadCachedCredentials()
{
String AK = _persistentStore.Get(AK_KEY);
String SK = _persistentStore.Get(SK_KEY);
String ST = _persistentStore.Get(ST_KEY);
String EXP = _persistentStore.Get(EXP_KEY);
string IP = _persistentStore.Get(IP_KEY);
long ticks = EXP != null?long.Parse(EXP) : 0;
// make sure we have valid data in prefs
if (AK == null || SK == null ||
ST == null || IP == null)
{
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "No valid credentials found in LocalStorage");
_currentState = null;
return;
}
_currentState = new CredentialsRefreshState
{
Credentials = new ImmutableCredentials(AK, SK, ST),
Expiration = new DateTime(ticks)
};
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Loaded credentials from LocalStorage");
}
/// <summary>
/// Constructs a new CognitoAWSCredentials instance, which will use the
/// specified Amazon Cognito identity pool to make a requests to the
/// AWS Security Token Service (STS) to request short lived session credentials.
/// </summary>
/// <param name="accountId">The AWS accountId for the account with Amazon Cognito</param>
/// <param name="identityPoolId">The Amazon Cogntio identity pool to use</param>
/// <param name="unAuthRoleArn">The ARN of the IAM Role that will be assumed when unauthenticated</param>
/// <param name="authRoleArn">The ARN of the IAM Role that will be assumed when authenticated</param>
/// <param name="region">Region to use when accessing Amazon Cognito and AWS Security Token Service.</param>
public CachingCognitoAWSCredentials(
string accountId, string identityPoolId,
string unAuthRoleArn, string authRoleArn,
RegionEndpoint region)
: this(
unAuthRoleArn, authRoleArn,
new AmazonCognitoIdentityProvider(accountId, identityPoolId, new AnonymousAWSCredentials(), region),
new AmazonSecurityTokenServiceClient(new AnonymousAWSCredentials(), region))
{
if (string.IsNullOrEmpty(accountId))
{
throw new ArgumentNullException("accountId cannot be null");
}
if (string.IsNullOrEmpty(identityPoolId))
{
throw new ArgumentNullException("identityPoolId cannot be null");
}
if (string.IsNullOrEmpty(unAuthRoleArn) && string.IsNullOrEmpty(authRoleArn))
{
throw new ArgumentNullException("Both unAuthRoleArn and authRoleArn cannot be null");
}
#if UNITY_WEBPLAYER
_persistentStore = new InMemoryKVStore();
#else
_persistentStore = new SQLiteKVStore();
#endif
string IP = _persistentStore.Get(IP_KEY);
if (!string.IsNullOrEmpty(IP) && 0 == IP.CompareTo(identityPoolId))
{
IdentityProvider.UpdateIdentity(_persistentStore.Get(ID_KEY));
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Loaded Cached IdentityID from LocalStorage");
loadCachedCredentials();
}
else if (!string.IsNullOrEmpty(IP))
{
// identity pool id is different from whats caching
Clear();
}
IdentityProvider.IdentityChangedEvent += delegate(object sender, IdentityChangedArgs e)
{
if (!string.IsNullOrEmpty(e.OldIdentityId))
{
this.Clear();
}
if (string.IsNullOrEmpty(_persistentStore.Get(IP_KEY)))
{
// identity pool id is not cached
_persistentStore.Put(IP_KEY, this.IdentityProvider.IdentityPoolId);
}
// caching identity whenever new identity is found
_persistentStore.Put(ID_KEY, e.NewIdentityId);
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CachingCognitoAWSCredentials", "Saved identityID to LocalStorage");
};
}
/// <summary>
/// Constructs a new CognitoAWSCredentials instance, which will use the
/// specified Amazon Cognito identity pool to make a requests to the
/// AWS Security Token Service (STS) to request short lived session credentials.
/// </summary>
/// <param name="accountId">The AWS accountId for the account with Amazon Cognito</param>
/// <param name="identityPoolId">The Amazon Cogntio identity pool to use</param>
/// <param name="unAuthRoleArn">The ARN of the IAM Role that will be assumed when unauthenticated</param>
/// <param name="authRoleArn">The ARN of the IAM Role that will be assumed when authenticated</param>
/// <param name="cibClient">Preconfigured Cognito Identity client to make requests with</param>
/// <param name="stsClient">Preconfigured STS client to make requests with</param>
public CognitoAWSCredentials(string unAuthRoleArn, string authRoleArn,
AbstractCognitoIdentityProvider idClient, IAmazonSecurityTokenService stsClient)
{
if (idClient == null)
{
throw new ArgumentNullException("idClient");
}
UnAuthRoleArn = unAuthRoleArn;
AuthRoleArn = authRoleArn;
IdentityProvider = idClient;
sts = stsClient;
#if UNITY_WEBPLAYER
_persistentStore = new InMemoryKVStore();
#else
_persistentStore = new SQLiteKVStore();
#endif
//Load cached credentials
string cachedIdentity = _persistentStore.Get(namespacedKey(ID_KEY));
if (string.IsNullOrEmpty(cachedIdentity))
{
//Try to recover unamespaced identities stored by old versions of the SDK
cachedIdentity = _persistentStore.Get(ID_KEY);
}
if (!string.IsNullOrEmpty(cachedIdentity))
{
IdentityProvider.UpdateIdentity(cachedIdentity);
loadCachedCredentials();
}
//Register Identity Changed Listener to update the cache
IdentityProvider.IdentityChangedEvent += delegate(object sender, IdentityChangedArgs e)
{
saveCredentials();
AmazonLogging.Log(AmazonLogging.AmazonLoggingLevel.Verbose, "CognitoAWSCredentials", "Saved identityID to LocalStorage");
};
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="Amazon.MobileAnalytics.MobileAnalyticsManager.Internal.SubmissionTimePolicy"/> class.
/// </summary>
/// <param name="WaitInterval">Wait interval.</param>
public SubmissionTimePolicy(long WaitInterval)
{
this.WaitInterval = WaitInterval;
//retrieve the last submitted timestamp from the cache
_persistStore = new PlayerPreferenceKVStore();
String TimeStamp = _persistStore.Get(LAST_SUCCESSFUL_DELIVERY_TIME_STAMP_KEY);
if (TimeStamp != null && TimeStamp.Length > 0)
{
this.LastSubmittedTime = long.Parse(TimeStamp);
}
else
{
this.LastSubmittedTime = 0;
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="Amazon.MobileAnalytics.MobileAnalyticsManager.ClientContextConfig"/> class.
/// </summary>
/// <param name="appTitle">App title - The title of your app. For example, My App.</param>
/// <param name="appVersionName">App version name - The version of your app. For example, V2.0.</param>
/// <param name="appVersionCode">App version code - The version code for your app. For example, 3.</param>
/// <param name="appPackageName">App package name - The name of your package. For example, com.example.my_app.</param>
/// <param name="appId">App identifier - AWS Mobile Analytics App ID corresponding to your App</param>
public ClientContextConfig(string appTitle, string appVersionName, string appVersionCode, string appPackageName, string appId)
{
if (string.IsNullOrEmpty(appTitle))
{
throw new ArgumentNullException("appTitle");
}
if (string.IsNullOrEmpty(appVersionName))
{
throw new ArgumentNullException("appVersionName");
}
if (string.IsNullOrEmpty(appId))
{
throw new ArgumentNullException("appId");
}
if (string.IsNullOrEmpty(appPackageName))
{
throw new ArgumentNullException("appPackageName");
}
if (string.IsNullOrEmpty(appVersionCode))
{
throw new ArgumentNullException("appVersionCode");
}
this._appTitle = appTitle;
this._appVersionName = appVersionName;
this._appVersionCode = appVersionCode;
this._appPackageName = appPackageName;
this._appId = appId;
_kvStore = new PlayerPreferenceKVStore();
_clientId = _kvStore.Get(APP_CLIENT_ID_KEY);
if (string.IsNullOrEmpty(_clientId))
{
_clientId = Guid.NewGuid().ToString();
_kvStore.Put(APP_CLIENT_ID_KEY, _clientId);
}
}
public string GetValue(string key, ApplicationSettingsMode mode)
{
return(kvStore.Get(key));
}