/// <summary>
/// Returns true if all required privileges are granted, false otherwise.
/// </summary>
/// <returns>Task with check result.</returns>
public async Task <bool> CheckPrivileges()
{
CheckResult result = PrivacyPrivilegeManager.CheckPermission(HEALTHINFO_PRIVILEGE);
switch (result)
{
case CheckResult.Allow:
return(true);
case CheckResult.Deny:
return(false);
case CheckResult.Ask:
PrivacyPrivilegeManager.ResponseContext context = null;
PrivacyPrivilegeManager.GetResponseContext(HEALTHINFO_PRIVILEGE)
.TryGetTarget(out context);
if (context == null)
{
Log.Error("STT", "Unable to get privilege response context");
return(false);
}
_checkPrivilegesTask = new TaskCompletionSource <bool>();
context.ResponseFetched += PrivilegeManagerOnResponseFetched;
PrivacyPrivilegeManager.RequestPermission(HEALTHINFO_PRIVILEGE);
return(await _checkPrivilegesTask.Task);
default:
return(false);
}
}
private static void SetupPPMHandler(string privilege)
{
PrivacyPrivilegeManager.ResponseContext context = null;
if (PrivacyPrivilegeManager.GetResponseContext(privilege).TryGetTarget(out context))
{
context.ResponseFetched += PPMResponseHandler;
}
}
private void SetupPrivilegeHandler()
{
PrivacyPrivilegeManager.ResponseContext context = null;
if (PrivacyPrivilegeManager.GetResponseContext(hrmPrivilege).TryGetTarget(out context))
{
context.ResponseFetched += PrivilegeResponseHandler;
}
}
/// <summary>
/// Request user permission for privacy privileges
/// </summary>
/// <param name="service">privacy privilege</param>
/// <returns>true if user consent is gained</returns>
public async Task <bool> GetPermission(string service)
{
try
{
GrantedPermission = -1;
// Gets the status of a privacy privilege permission.
CheckResult result = PrivacyPrivilegeManager.CheckPermission(service);
switch (result)
{
case CheckResult.Allow:
// user consent for privacy privilege is already gained
Console.WriteLine("\n\n\nuser consent for privacy privilege is already gained\n\n");
return(true);
case CheckResult.Deny:
case CheckResult.Ask:
// User permission request should be required
tcs = new TaskCompletionSource <bool>();
// Gets the response context for a given privilege.
var reponseContext = PrivacyPrivilegeManager.GetResponseContext(service);
PrivacyPrivilegeManager.ResponseContext context = null;
if (reponseContext.TryGetTarget(out context))
{
if (context != null)
{
context.ResponseFetched += Context_ResponseFetched;
}
}
// Try to get the permission for service from a user.
PrivacyPrivilegeManager.RequestPermission(service);
// Check if permission is granted or not every second
Device.BeginInvokeOnMainThread(() =>
{
Device.StartTimer(new TimeSpan(0, 0, 0, 1, 0), CheckPermission);
});
return(await tcs.Task);
default:
return(false);
}
}
catch (Exception e)
{
Console.WriteLine("[UserPermission] (" + service + ") Error :" + e.Message + ", " + e.StackTrace + ", " + e.InnerException);
return(false);
}
}
static async Task <AccessState> RequestPermission(string priv)
{
var result = AccessState.Unknown;
var tcs = new TaskCompletionSource <AccessState>();
var handler = new EventHandler <RequestResponseEventArgs>((sender, args) =>
{
switch (args.result)
{
case RequestResult.AllowForever:
tcs.TrySetResult(AccessState.Available);
break;
default:
tcs.TrySetResult(AccessState.Denied);
break;
}
});
PrivacyPrivilegeManager.ResponseContext context = null;
try
{
PrivacyPrivilegeManager.GetResponseContext(priv).TryGetTarget(out context);
if (context == null)
{
tcs.SetResult(AccessState.NotSupported);
}
else
{
context.ResponseFetched += handler;
PrivacyPrivilegeManager.RequestPermission(priv);
}
result = await tcs.Task.ConfigureAwait(false);
}
finally
{
if (context != null)
{
context.ResponseFetched -= handler;
}
}
return(result);
}
private void initDataSourcesWithPrivileges()
{
PrivacyPrivilegeManager.ResponseContext context = null;
if (PrivacyPrivilegeManager.GetResponseContext(Tools.HEALTHINFO_PRIVILEGE).TryGetTarget(out context))
{
context.ResponseFetched += (s, e) =>
{
if (e.result != RequestResult.AllowForever)
{
Toast.DisplayText("Please provide the necessary privileges for the application to run!");
Environment.Exit(1);
}
else
{
initCampaignDataSources();
}
}
}
;
else
{
Toast.DisplayText("Please provide the necessary privileges for the application to run!");
Environment.Exit(1);
}
switch (PrivacyPrivilegeManager.CheckPermission(Tools.HEALTHINFO_PRIVILEGE))
{
case CheckResult.Allow:
initCampaignDataSources();
break;
case CheckResult.Deny:
Toast.DisplayText("Please provide the necessary privileges for the application to run!");
Environment.Exit(1);
break;
case CheckResult.Ask:
PrivacyPrivilegeManager.RequestPermission(Tools.HEALTHINFO_PRIVILEGE);
break;
default:
break;
}
}
/// <summary>
/// Request user permission for privacy privileges
/// </summary>
/// <param name="service">privacy privilege</param>
/// <returns>true if user consent is gained</returns>
public async Task <bool> GetPermission(string service)
{
try
{
// Gets the status of a privacy privilege permission.
CheckResult result = PrivacyPrivilegeManager.CheckPermission(service);
switch (result)
{
case CheckResult.Allow:
// user consent for privacy privilege is already gained
return(true);
case CheckResult.Deny:
case CheckResult.Ask:
// User permission request should be required
tcs = new TaskCompletionSource <bool>();
// Gets the response context for a given privilege.
var reponseContext = PrivacyPrivilegeManager.GetResponseContext(service);
PrivacyPrivilegeManager.ResponseContext context = null;
if (reponseContext.TryGetTarget(out context))
{
if (context != null)
{
context.ResponseFetched += Context_ResponseFetched;
}
}
// Try to get the permission for service from a user.
PrivacyPrivilegeManager.RequestPermission(service);
return(await tcs.Task);
default:
return(false);
}
}
catch (Exception e)
{
Console.WriteLine("[UserPermission] (" + service + ") Error :" + e.Message);
return(false);
}
}
internal static async Task <PermissionStatus> CheckPrivacyPermission(PermissionType permission, bool askUser)
{
EnsureDeclared(permission);
var tizenPrivileges = permission.ToTizenPrivileges(onlyRuntimePermissions: true);
foreach (var priv in tizenPrivileges)
{
if (PrivacyPrivilegeManager.CheckPermission(priv) == CheckResult.Ask)
{
if (askUser)
{
var tcs = new TaskCompletionSource <bool>();
PrivacyPrivilegeManager.ResponseContext context = null;
PrivacyPrivilegeManager.GetResponseContext(priv).TryGetTarget(out context);
void OnResponseFetched(object sender, RequestResponseEventArgs e)
{
tcs.TrySetResult(e.result == RequestResult.AllowForever);
}
context.ResponseFetched += OnResponseFetched;
PrivacyPrivilegeManager.RequestPermission(priv);
var result = await tcs.Task;
context.ResponseFetched -= OnResponseFetched;
if (result)
{
continue;
}
}
return(PermissionStatus.Denied);
}
else if (PrivacyPrivilegeManager.CheckPermission(priv) == CheckResult.Deny)
{
return(PermissionStatus.Denied);
}
}
return(PermissionStatus.Granted);
}
/// <summary>
/// Asks the user to grant the permission at runtime
/// </summary>
/// <param name="privilege">The privilege name to check for</param>
/// <returns>A status that indicates whether the permission has been granted or not</returns>
public static async Task <PrivacyPermissionStatus> RequestAsync(string privilege)
{
switch (PrivacyPrivilegeManager.CheckPermission(privilege))
{
case CheckResult.Allow:
return(PrivacyPermissionStatus.Granted);
case CheckResult.Deny:
case CheckResult.Ask:
var tcs = new TaskCompletionSource <PrivacyPermissionStatus>();
var response = PrivacyPrivilegeManager.GetResponseContext(privilege);
PrivacyPrivilegeManager.ResponseContext context = null;
if (response.TryGetTarget(out context))
{
context.ResponseFetched += (s, e) =>
{
PrivacyPermissionStatus result = PrivacyPermissionStatus.Denied;
if (e.result == RequestResult.AllowForever)
{
result = PrivacyPermissionStatus.Granted;
}
tcs.SetResult(result);
};
}
PrivacyPrivilegeManager.RequestPermission(privilege);
return(await tcs.Task);
default:
return(PrivacyPermissionStatus.Denied);
}
}
