public async Task <(string IdToken, string AccessToken)> GetCredentialAsync()
{
if (_tcs != null && !_tcs.Task.IsCompleted)
{
_tcs.TrySetCanceled();
}
_tcs = new TaskCompletionSource <string>();
var account = GoogleSignIn.GetLastSignedInAccount(_activity);
if (account != null && !account.IsExpired)
{
return(account.IdToken, null);
}
try
{
account = await _client.SilentSignInAsync().ConfigureAwait(false);
return(account.IdToken, null);
}
catch
{
_activity.StartActivityForResult(_client.SignInIntent, SignInRequestCode);
var idToken = await _tcs.Task.ConfigureAwait(false);
return(idToken, null);
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
DependencyService.Register <ILocalize, Localize>();
DependencyService.Register <IAuthRepository, AuthRepository>();
base.OnCreate(savedInstanceState);
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
Forms.Init(this, savedInstanceState);
LocalNotificationsImplementation.NotificationIconId = Resource.Drawable.ic_stat_futurelife;
ImageCircleRenderer.Init();
Rg.Plugins.Popup.Popup.Init(this, savedInstanceState);
GoogleSignInAccount account = GoogleSignIn.GetLastSignedInAccount(this);
if (account == null)
{
ConfigureGoogleSignIn();
GoogleSignInLaunch();
}
LoadApplication(new App());
}
public void Logout()
{
if (currentActivity == null || googleSignInClient == null)
{
throw new GoogleClientNotInitializedErrorException(GoogleClientBaseException.ClientNotInitializedErrorMessage);
}
if (GoogleSignIn.GetLastSignedInAccount(currentActivity) != null)
{
idToken = null;
googleSignInClient.SignOut();
}
}
public ApplicationUser GetUser()
{
GoogleSignInAccount account = GoogleSignIn.GetLastSignedInAccount(Context);
if (account != null)
{
return(new ApplicationUser
{
DisplayName = account.DisplayName,
Email = account.Email,
PhotoUrl = account.PhotoUrl.ToString()
});
}
return(null);
}
private async void SigninButton_Click(object sender, System.EventArgs e)
{
//await Auth.GoogleSignInApi.SignOut(mGoogleApiClient);
GoogleSignInAccount account = GoogleSignIn.GetLastSignedInAccount(this);
if (account == null)
{
var signInIntent = Auth.GoogleSignInApi.GetSignInIntent(mGoogleApiClient);
StartActivityForResult(signInIntent, SIGN_IN_CODE);
}
else
{
FirebaseLogin(account);
}
}
public override Task <bool> RequestPermissionAsync(params HealthDataType[] dataTypes)
{
var fitnessOptions = GetFitnessOptions(dataTypes);
_tcsAuth = new TaskCompletionSource <bool>();
if (HasOAuthPermission(fitnessOptions))
{
_tcsAuth.SetResult(true);
}
else
{
GoogleSignIn.RequestPermissions(CurrentActivity, REQUEST_CODE,
GoogleSignIn.GetLastSignedInAccount(_currentContext), fitnessOptions);
}
return(_tcsAuth.Task);
}
// utility function that gets the basal metabolic rate averaged over a week
private async Task <double> GetBasalAvg(DateTime endDate)
{
float basalAvg = 0;
long startDate = endDate.AddDays(-7).ToJavaTimeStamp();
var readRequest = new DataReadRequest.Builder()
.Aggregate(DataType.TypeBasalMetabolicRate, DataType.AggregateBasalMetabolicRateSummary)
.BucketByTime(1, TimeUnit.Days)
.SetTimeRange(startDate, endDate.ToJavaTimeStamp(), TimeUnit.Milliseconds).Build();
var response = await FitnessClass.GetHistoryClient(_currentActivity, GoogleSignIn.GetLastSignedInAccount(_currentActivity))
.ReadDataAsync(readRequest);
if (response.Status.IsSuccess)
{
var avgsN = 0;
foreach (var bucket in response.Buckets)
{
// in the com.google.bmr.summary data type, each data point represents
// the average, maximum and minimum basal metabolic rate, in kcal per day, over the time interval of the data point.
var dataSet = bucket.GetDataSet(DataType.AggregateBasalMetabolicRateSummary);
foreach (var dataPoint in dataSet.DataPoints)
{
var avg = dataPoint.GetValue(Field.FieldAverage).AsFloat();
if (avg > 0)
{
basalAvg += avg;
avgsN++;
}
}
}
// do the average of the averages
if (avgsN != 0)
{
basalAvg /= avgsN; // this a daily average
}
return(basalAvg);
}
throw new Exception(response.Status.StatusMessage);
}
public void RequestFitnessPermissions()
{
//we have to do all this hullaballoo because Xamarin.PlayServices.Fitness does not contain a constructor for FitnessOptions
//IntPtr classRef = JNIEnv.FindClass("com/google/android/gms/fitness/FitnessOptions$Builder");
//IntPtr constructorId = JNIEnv.GetMethodID(classRef, "<init>", "I(V)");
//IntPtr referenceInstance = JNIEnv.NewObject(classRef, constructorId);
//var fitnessApiOptions = new FitnessOptions.Builder()
var fitnessApiOptions = FitnessOptions.InvokeBuilder()
.AddDataType(Android.Gms.Fitness.Data.DataType.AggregateActivitySummary, FitnessOptions.AccessWrite)
.AddDataType(Android.Gms.Fitness.Data.DataType.AggregateSpeedSummary, FitnessOptions.AccessWrite)
.Build();
account = GoogleSignIn.GetLastSignedInAccount(this);
if (account == null && !googleLoginInProgress)
{
GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DefaultSignIn)
.RequestEmail()
.Build();
var signInClient = GoogleSignIn.GetClient(this, gso);
googleLoginInProgress = true;
StartActivityForResult(signInClient.SignInIntent, REQUEST_GOOGLE_SIGN_IN);
return;
}
if (!GoogleSignIn.HasPermissions(account, fitnessApiOptions))
{
GoogleSignIn.RequestPermissions(
this,
REQUEST_FITNESS_PERMISSIONS,
account,
fitnessApiOptions);
}
else
{
HasGoogleFitnessPermissions = true;
GoogleFitnessPermissionsUpdated?.Invoke(HasGoogleFitnessPermissions);
}
}
public async Task <GoogleResponse> LoginAsync()
{
if (currentActivity == null || googleSignInClient == null)
{
throw new GoogleClientNotInitializedErrorException(GoogleClientBaseException.ClientNotInitializedErrorMessage);
}
loginTcs = new TaskCompletionSource <GoogleResponse>();
GoogleSignInAccount account = GoogleSignIn.GetLastSignedInAccount(currentActivity);
if (account != null)
{
OnSignInSuccessful(account);
}
else
{
Intent intent = googleSignInClient.SignInIntent;
currentActivity?.StartActivityForResult(intent, authActivityID);
}
return(await loginTcs.Task);
}
public async Task <GoogleResponse> SilentLoginAsync()
{
if (currentActivity == null || googleSignInClient == null)
{
throw new GoogleClientNotInitializedErrorException(GoogleClientBaseException.ClientNotInitializedErrorMessage);
}
loginTcs = new TaskCompletionSource <GoogleResponse>();
GoogleSignInAccount account = GoogleSignIn.GetLastSignedInAccount(currentActivity);
if (account != null)
{
OnSignInSuccessful(account);
}
else
{
GoogleSignInAccount userAccount = await googleSignInClient.SilentSignInAsync();
OnSignInSuccessful(userAccount);
}
return(await loginTcs.Task);
}
internal bool HasOAuthPermission(FitnessOptions fitnessOptions)
{
return(GoogleSignIn.HasPermissions(GoogleSignIn.GetLastSignedInAccount(_currentContext), fitnessOptions));
}
protected override async Task <IEnumerable <T> > Query <T>(HealthDataType healthDataType,
AggregateTime aggregateTime,
DateTime startDate, DateTime endDate)
{
var authorized = _healthService.HasOAuthPermission(_healthService.FitnessReadOptions(new HealthDataType[] { healthDataType }));
if (!authorized)
{
throw new UnauthorizedAccessException($"Not enough permissions to request {healthDataType}");
}
var fitData = healthDataType.ToGoogleFit();
long startTime = startDate.ToJavaTimeStamp();
long endTime = endDate.ToJavaTimeStamp();
var readBuilder = new DataReadRequest.Builder()
.SetTimeRange(startTime, endTime, TimeUnit.Milliseconds)
.EnableServerQueries();
if (aggregateTime != AggregateTime.None)
{
readBuilder.Aggregate(fitData.TypeIdentifier, fitData.AggregateType);
switch (aggregateTime)
{
case AggregateTime.Year:
readBuilder.BucketByTime(365, TimeUnit.Days);
break;
case AggregateTime.Month:
readBuilder.BucketByTime(31, TimeUnit.Days);
break;
case AggregateTime.Week:
readBuilder.BucketByTime(7, TimeUnit.Days);
break;
case AggregateTime.Day:
readBuilder.BucketByTime(1, TimeUnit.Days);
break;
case AggregateTime.Hour:
readBuilder.BucketByTime(1, TimeUnit.Hours);
break;
}
}
else
{
readBuilder.Read(fitData.TypeIdentifier);
}
var readRequest = readBuilder.Build();
var response = await FitnessClass.GetHistoryClient(_currentActivity, GoogleSignIn.GetLastSignedInAccount(_currentActivity))
.ReadDataAsync(readRequest).ConfigureAwait(false);
double valueToSubstract = 0;
if (healthDataType == HealthDataType.CaloriesActive)
{
valueToSubstract = await GetBasalAvg(endDate);
}
if (response == null)
{
return(new List <T>());
}
if (response.Buckets.Any())
{
var output = new List <T>();
foreach (var bucket in response.Buckets)
{
var dataSet = bucket.GetDataSet(fitData.AggregateType);
output.AddRange((IEnumerable <T>)dataSet.DataPoints.Select(result =>
CreateAggregatedData(result, fitData, valueToSubstract)));
if (!dataSet.DataPoints.Any() && healthDataType == HealthDataType.Droid_BasalMetabolicRate)
{
output.Add(
new AggregatedHealthData()
{
StartDate = bucket.GetStartTime(TimeUnit.Milliseconds).ToDateTime(),
EndDate = bucket.GetEndTime(TimeUnit.Milliseconds).ToDateTime(),
Sum = valueToSubstract
} as T);
}
}
return(output);
}
return((IEnumerable <T>)response.GetDataSet(fitData.TypeIdentifier)?.DataPoints?
.Select(dataPoint => new HealthData
{
StartDate = dataPoint.GetStartTime(TimeUnit.Milliseconds).ToDateTime(),
EndDate = dataPoint.GetEndTime(TimeUnit.Milliseconds).ToDateTime(),
Value = ReadValue(dataPoint, fitData.Unit, valueToSubstract) ?? 0,
UserEntered = dataPoint.OriginalDataSource?.StreamName == "user_input"
}).ToList());
}
public bool HasPreviousSignIn()
{
return(GoogleSignIn.GetLastSignedInAccount(Activity) != null);
}
public void CreateGoogleFitClient()
{
if (_activity == null || isWaitingForConnectivity)
{
return;
}
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.Q)
{
if (!_activity.HasActivityRecognition)
{
_activity.ActivityRecognitionPermissionUpdated += OnActivityRecognitionPermissionUpdated;
isWaitingForConnectivity = true;
_activity.RequestActivityRecognition();
return;
}
}
if (!_activity.HasAccessFineLocation)
{
_activity.AccessFineLocationPermissionUpdated += OnAccessFineLocationPermissionUpdated;
isWaitingForConnectivity = true;
_activity.RequestAccessFineLocation();
return;
}
if (!_activity.HasGoogleFitnessPermissions)
{
_activity.GoogleFitnessPermissionsUpdated += OnFitnessPermissionsUpdated;
isWaitingForConnectivity = true;
_activity.RequestFitnessPermissions();
return;
}
GoogleSignInAccount googleAccount = GoogleSignIn.GetLastSignedInAccount(_activity);
fitnessHistoryClient = FitnessClass.GetHistoryClient(_activity, googleAccount);
fitnessRecordingClient = FitnessClass.GetRecordingClient(_activity, googleAccount);
if (checkSubscriptionsTask == null)
{
checkSubscriptionsTask = Task.Run(
async() =>
{
bool hasSubscribedToSpeedData = await SubscribeToSpeedData();
if (hasSubscribedToSpeedData)
{
_isConnected = true;
}
});
}
//create FitnessApi client, needs an activity
//_client = new GoogleApiClient.Builder(_activity)
// .AddApi(FitnessClass.RECORDING_API)
// .AddApi(FitnessClass.HISTORY_API)
// .AddScope(FitnessClass.ScopeLocationReadWrite)
// .AddScope(FitnessClass.ScopeActivityReadWrite)
// .AddConnectionCallbacks(
// async bundle =>
// {
// if (Mvx.IoCProvider != null)
// {
// Mvx.IoCProvider.Resolve<IMissingPermissionService>().ResolvedMissingPermission(MissingPermission.AndroidFitnessAccountLink);
// }
// var isSubscribed = await SubscribeToSpeedData();
// if (!isSubscribed)
// {
// Analytics.TrackEvent(TrackingEvents.Error, new TrackingEvents.ErrorArgs(TrackingEvents.ErrorData.SpeedDataSubscriptionFailed));
// }
// _isConnected = true;
// CrossLocalNotifications.Current.Cancel(Config.NotificationIdConnectivity);
// OnConnected();
// await RequestUpdate();
// },
// suspensionReason =>
// {
// if (suspensionReason == GoogleApiClient.ConnectionCallbacks.CauseNetworkLost)
// {
// Crashes.TrackError(new Exception("Connection to Google Fitness lost due to Network Lost"));
// }
// else if (suspensionReason == GoogleApiClient.ConnectionCallbacks.CauseServiceDisconnected)
// {
// Crashes.TrackError(new Exception("Connection to Google Fitness lost due to Service Disconnected"));
// }
// else
// {
// Crashes.TrackError(new Exception("Connection to Google Fitness lost: " + suspensionReason));
// }
// })
// .AddOnConnectionFailedListener(
// async result =>
// {
// _isConnected = false;
// if (UpdateService.Current.GetUpdateMode() == UpdateMode.Foreground && !isWaitingForConnectivity)
// {
// lastConnectionResult = result;
// bool canReachGoogle = await CrossConnectivity.Current.IsRemoteReachable("http://www.google.com", 80, 1000);
// if (!canReachGoogle)
// {
// bool hasCellular = CrossConnectivity.Current.ConnectionTypes.Contains(ConnectionType.Cellular);
// bool hasWifi = CrossConnectivity.Current.ConnectionTypes.Contains(ConnectionType.WiFi);
// CrossConnectivity.Current.ConnectivityTypeChanged += ConnectivityTypeChanged;
// isWaitingForConnectivity = true;
// await UserDialogs.Instance.AlertAsync(
// "Du må ha en internett-forbindelse for å kunne hente ut dine gangdata fra Google Fit",
// "Trenger nettforbindelse");
// if (!hasWifi)
// {
// var intent = new Intent(Android.Provider.Settings.ActionWifiSettings);
// intent.SetFlags(ActivityFlags.NewTask);
// _activity.StartActivity(intent);
// }
// else if (!hasCellular)
// {
// var intent = new Intent(Android.Provider.Settings.ActionDataUsageSettings);
// intent.SetFlags(ActivityFlags.NewTask);
// _activity.StartActivity(intent);
// }
// }
// else
// {
// _activity.GoogleFitnessAuthenticationUpdated -= OnGoogleFitnessAuthenticationUpdated;
// _activity.GoogleFitnessAuthenticationUpdated += OnGoogleFitnessAuthenticationUpdated;
// _activity.RequestGoogleFitnessAuthentication(lastConnectionResult);
// }
// }
// else
// {
// CrossLocalNotifications.Current.Show(AppText.notification_title, AppText.notification_google_fit_auth_failed, Config.NotificationIdConnectivity);
// }
// })
// .Build();
//ConnectGoogleFitClient();
}
