private async void FetchFirebaseData(string accessToken, FirebaseAuthType authType)
{
try
{
// Convert the access token to firebase token
var auth = new FirebaseAuthProvider(new FirebaseConfig(FirebaseAppKey));
var data = await auth.SignInWithOAuthAsync(authType, accessToken);
// Setup FirebaseClient to use the firebase token for data requests
var db = new FirebaseClient(
FirebaseAppUri,
new FirebaseOptions
{
AuthTokenAsyncFactory = () => Task.FromResult(data.FirebaseToken)
});
// TODO: your path within your DB structure.
var dbData = await db
.Child("userGroups")
.Child(data.User.LocalId)
.OnceAsync <object>(); // TODO: custom class to represent your data instead of just object
// TODO: present your data
MessageBox.Show(string.Join("\n", dbData.Select(d => d.ToString())));
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public void AppleTest()
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
var auth = authProvider.SignInWithOAuthAsync(FirebaseAuthType.Apple, AppleIDToken).Result;
auth.FirebaseToken.Should().NotBeNullOrWhiteSpace();
}
private IObservable <Unit> SignInWithOAuth(FirebaseAuthType authType, string authToken)
{
return(_authProvider
.SignInWithOAuthAsync(authType, authToken)
.ToObservable()
.Do(authLink => AuthLink = authLink)
.SelectMany(authLink => SaveAccount(authLink)));
}
public void GoogleTest()
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
var auth = authProvider.SignInWithOAuthAsync(FirebaseAuthType.Google, GoogleAccessToken).Result;
auth.User.FirstName.Should().BeEquivalentTo(GoogleTestUserFirstName);
auth.FirebaseToken.Should().NotBeNullOrWhiteSpace();
}
public void FacebookTest()
{
FirebaseAuthProvider authProvider = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
FirebaseAuthLink auth = authProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook, FacebookAccessToken).Result;
auth.User.FirstName.Should().BeEquivalentTo(FacebookTestUserFirstName);
auth.OauthAccessToken.Should().NotBeNullOrWhiteSpace();
}
public async Task <AuthToken> SocialLogin(AuthConfig authConfig, SocialAuthProvider provider, string accessToken)
{
using (var client = new HttpClient())
{
try
{
var authType = FirebaseAuthType.Facebook;
switch (provider)
{
case SocialAuthProvider.Facebook: authType = FirebaseAuthType.Facebook; break;
case SocialAuthProvider.Google: authType = FirebaseAuthType.Google; break;
case SocialAuthProvider.Twitter: authType = FirebaseAuthType.Twitter; break;
}
var firebaseAuthProvider = new FirebaseAuthProvider(new FirebaseConfig(authConfig.ApiKey));
var authLink = await firebaseAuthProvider.SignInWithOAuthAsync(authType, accessToken);
var authToken = new AuthToken
{
Token = authLink.FirebaseToken,
ExpiresAt = DateTime.Now.AddSeconds(authLink.ExpiresIn)
};
var handler = new JwtSecurityTokenHandler();
var userInfo = handler.ReadJwtToken(authLink.FirebaseToken);
userInfo.Payload.TryGetValue("user_id", out object userId);
authToken.UserId = userId as string;
return(authToken);
}
catch (FirebaseAuthException e)
{
switch (e.Reason)
{
case AuthErrorReason.MissingEmail: throw new AuthException(SignUpError.MissingEmail.ToDescription());
case AuthErrorReason.WrongPassword: throw new AuthException(SignUpError.WrongPassowrd.ToDescription());
case AuthErrorReason.UserDisabled: throw new AuthException(SignUpError.DisabledUser.ToDescription());
case AuthErrorReason.InvalidEmailAddress: throw new AuthException(SignUpError.InvalidEmail.ToDescription());
case AuthErrorReason.Undefined: throw new AuthException(e.InnerException != null ? e.InnerException.Message : e.Message);
default: throw new AuthException(SignUpError.Other.ToDescription());
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
}
async Task <bool> LoginFirebase(string token, FirebaseAuthType firebaseAuthType)
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(AppConfigurations.FirebaseApiKey));
var auth = await authProvider.SignInWithOAuthAsync(firebaseAuthType, token);
if (auth != null)
{
Console.WriteLine($"Logged in as {auth.User.DisplayName ?? auth.User.FirstName ?? auth.User.LastName}");
}
return(auth != null);
}
private async void AuthOnCompleted(object sender, AuthenticatorCompletedEventArgs authenticatorCompletedEventArgs)
{
if (authenticatorCompletedEventArgs.IsAuthenticated)
{
AccountStore.Create(this).Save(authenticatorCompletedEventArgs.Account, "Facebook");
var facebookAccessToken = authenticatorCompletedEventArgs.Account.Properties ["access_token"];
var request = new OAuth2Request("GET",
new Uri("https://graph.facebook.com/me?fields=gender,age_range"),
null, authenticatorCompletedEventArgs.Account);
var response = await request.GetResponseAsync( );
var obj = JObject.Parse(response.GetResponseText( ));
var gender = obj ["gender"].ToString( ).Replace("\"", "");
var age = int.Parse(obj ["age_range"] ["min"].ToString( ).Replace("\"", "")) +
int.Parse(obj ["age_range"] ["max"].ToString( ).Replace("\"", ""));
age /= 2;
var auth = await _firebaseAuthProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook,
facebookAccessToken);
var user = new UserModel
{
LocalId = auth.User.LocalId,
DisplayName = auth.User.DisplayName,
Email = auth.User.Email,
LinkFb = auth.User.FederatedId,
FirstName = auth.User.FirstName,
LastName = auth.User.LastName,
PhotoUrl = auth.User.PhotoUrl,
Age = age,
State = StateEnum.Online,
Gender = gender == "male" ? GenderEnum.Male : GenderEnum.Female
};
await _firebaseClient.Child($"users/{user.LocalId}").PutAsync(user);
_eventAggregator.GetEvent <LoginSuccessEvent> ( ).Publish(user);
_currentUser = user;
_loginMedia.Start( );
_firebaseClient.Child("chatrooms").AsObservable <Chatroom>().Subscribe(OnRoomFound);
}
else
{
_eventAggregator.GetEvent <LoginFailEvent> ( ).Publish( );
}
}
public void RefreshAccessToken()
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
var auth = authProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook, FacebookAccessToken).Result;
var originalToken = auth.FirebaseToken;
// simulate the token already expired
auth.Created = DateTime.MinValue;
var freshAuth = auth.GetFreshAuthAsync().Result;
freshAuth.FirebaseToken.Should().NotBe(originalToken);
}
public FirebaseApiClient(Func <User> currentUserProvider, Func <Task> loginSequence)
{
_currentUserProvider = currentUserProvider;
_loginSequence = loginSequence;
_firebaseConfig = new FirebaseConfig("AIzaSyAqHIXOmzA0UgyaYYV7IGTjzzcxeNm9YZk");
_firebaseAuthProvider = new FirebaseAuthProvider(_firebaseConfig);
var databaseOptions = new FirebaseOptions();
databaseOptions.AuthTokenAsyncFactory = async delegate
{
if (currentUserProvider() == null)
{
await loginSequence();
}
FirebaseAuthLink authData = null;
User currentUser = currentUserProvider();
if (currentUser.authData == null)
{
// silent login
if (currentUser.email != null && currentUser.password != null)
{
authData = await _firebaseAuthProvider.SignInWithEmailAndPasswordAsync(currentUser.email, currentUser.password);
}
else if (currentUser.facebookToken != null)
{
authData = await _firebaseAuthProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook, currentUser.facebookToken);
}
currentUser.authData = authData;
}
else
{
authData = currentUser.authData;
}
return(authData?.FirebaseToken);
};
databaseOptions.SyncPeriod = TimeSpan.Zero;
_firebaseClient = new FirebaseClient("https://supernoteswifi3d.firebaseio.com/", databaseOptions);
var storageOptions = new FirebaseStorageOptions();
storageOptions.AuthTokenAsyncFactory = databaseOptions.AuthTokenAsyncFactory;
_firebaseStorage = new FirebaseStorage("supernoteswifi3d.appspot.com", storageOptions);
}
public async Task SignInWithFacebookTokenAsync(string token, Action <FirebaseAuthLink, Error> completionHandler)
{
FirebaseAuthLink authData = null;
Error error = null;
try
{
authData = await _firebaseAuthProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook, token);
}
catch (Exception e)
{
error = ErrorFromFibaseException(e);
}
completionHandler(authData, error);
}
public async Task <string> Google()
{
var initializer = new GoogleAuthorizationCodeFlow.Initializer
{
Scopes = new[] { "email", "profile" },
ClientSecrets = new ClientSecrets {
ClientId = "111234912313-l9aqmsrga183h3dnr90c4dad3ffotmlr.apps.googleusercontent.com", ClientSecret = "OOBmRORPQ1MgEr4Y3MSKPTeA"
},
};
var flow = new GoogleAuthorizationCodeFlow(initializer);
var result = await new AuthorizationCodeInstalledApp(flow, new LocalServerCodeReceiver()).AuthorizeAsync("user", CancellationToken.None);
if (result.Token.IsExpired(SystemClock.Default))
{
await result.RefreshTokenAsync(CancellationToken.None);
}
var auth = await authProvider.SignInWithOAuthAsync(FirebaseAuthType.Google, result.Token.AccessToken);
return(auth.User.Email);
}
public async Task <bool> SignInWithFirebaseAsync(string googleAccessToken)
{
try
{
var authProvider = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
FirebaseAuthLink = await authProvider.SignInWithOAuthAsync(FirebaseAuthType.Google, googleAccessToken);
accessToken = FirebaseAuthLink.FirebaseToken;
FirebaseAuthLink.FirebaseAuthRefreshed += FirebaseAuthLink_FirebaseAuthRefreshed;
return(true);
}
catch (Exception e)
{
// Log Exception.
LifecycleLog.Exception(e);
return(false);
}
}
async void OnLoginButtonClicked(object sender, EventArgs e)
{
var user = new LoginUser
{
UserEmail = UserEmailEntry.Text,
Password = passwordEntry.Text
};
//Calling Auth
// Email/Password Auth
var authProvider = new FirebaseAuthProvider(new FirebaseConfig("AIzaSyDhxe5x5aiiHdxlDC0XtIncM-Ja1upWrXY"));
var auth = await authProvider.CreateUserWithEmailAndPasswordAsync(user.UserEmail, user.Password);
// The auth Object will contain auth.User and the Authentication Token from the request
System.Diagnostics.Debug.WriteLine(auth.FirebaseToken);
var auth = await authProvider.SignInWithOAuthAsync(FirebaseAuthType.Facebook, facebookAccessToken);
var isValid = AreCredentialsCorrect(user);
if (isValid)
{
App.IsUserLoggedIn = true;
// MainPage = App.ManuPage;
// Navigation.InsertPageBefore(new ManuPage(), this);
await Navigation.PopAsync();
}
else
{
messageLabel.Text = "Login failed";
passwordEntry.Text = string.Empty;
}
}
private static async Task Initialize(FirebaseAuthType authType, string oauthAccessToken)
{
var _authProvider = new FirebaseAuthProvider(new FirebaseConfig(APIKEY));
AuthLink = await _authProvider.SignInWithOAuthAsync(authType, oauthAccessToken);
}
