Nella scheda Metodo di accesso, attiva il provider GitHub.
Aggiungi l'ID cliente e il client secret della console per sviluppatori del provider alla configurazione del provider:
Registra la tua app come applicazione per sviluppatori su GitHub e ottieni l'ID client e il client secret OAuth 2.0 della tua app.
Assicurati che l'URI di reindirizzamento OAuth di Firebase (ad es. my-app-12345.firebaseapp.com/__/auth/handler)
sia impostato come URL di callback di autorizzazione nella pagina delle impostazioni dell'app sul tuo
Configurazione dell'app GitHub.
Fai clic su Salva.
Accedi al corso firebase::auth::Auth
La classe Auth è il gateway per tutte le chiamate API.
Aggiungi i file di intestazione Auth e App:
#include"firebase/app.h"#include"firebase/auth.h"
Nel codice di inizializzazione, crea un'istanza
firebase::App.
Se il tuo programma ha un ciclo di aggiornamento che viene eseguito regolarmente (ad esempio 30 o 60 volte al secondo), puoi controllare i risultati una volta per aggiornamento con Auth::SignInAndRetrieveDataWithCredentialLastResult:
firebase::Future<firebase::auth::AuthResult>result=auth->SignInAndRetrieveDataWithCredentialLastResult();if(result.status()==firebase::kFutureStatusComplete){if(result.error()==firebase::auth::kAuthErrorNone){firebase::auth::AuthResultauth_result=*result.result();printf("Sign in succeeded for `%s`\n",auth_result.user.display_name().c_str());}else{printf("Sign in failed with error '%s'\n",result.error_message());}}
Alcuni programmi hanno funzioni Update che vengono chiamate 30 o 60 volte al secondo.
Ad esempio, molti giochi seguono questo modello. Questi programmi possono chiamare le funzioni LastResult
per eseguire il polling delle chiamate asincrone.
Tuttavia, se il tuo programma è basato su eventi, ti consigliamo di registrare le funzioni di callback.
Una funzione di callback viene chiamata al termine del Future.
voidOnCreateCallback(constfirebase::Future<firebase::auth::User*>&result,void*user_data){// The callback is called when the Future enters the `complete` state.assert(result.status()==firebase::kFutureStatusComplete);// Use `user_data` to pass-in program context, if you like.MyProgramContext*program_context=static_cast<MyProgramContext*>(user_data);// Important to handle both success and failure situations.if(result.error()==firebase::auth::kAuthErrorNone){firebase::auth::User*user=*result.result();printf("Create user succeeded for email %s\n",user->email().c_str());// Perform other actions on User, if you like.firebase::auth::User::UserProfileprofile;profile.display_name=program_context->display_name;user->UpdateUserProfile(profile);}else{printf("Created user failed with error '%s'\n",result.error_message());}}voidCreateUser(firebase::auth::Auth*auth){// Callbacks work the same for any firebase::Future.firebase::Future<firebase::auth::AuthResult>result=auth->CreateUserWithEmailAndPasswordLastResult();// `&my_program_context` is passed verbatim to OnCreateCallback().result.OnCompletion(OnCreateCallback,&my_program_context);}
La funzione di callback può essere utilizzata anche come lambda, se preferisci.
voidCreateUserUsingLambda(firebase::auth::Auth*auth){// Callbacks work the same for any firebase::Future.firebase::Future<firebase::auth::AuthResult>result=auth->CreateUserWithEmailAndPasswordLastResult();// The lambda has the same signature as the callback function.result.OnCompletion([](constfirebase::Future<firebase::auth::User*>&result,void*user_data){// `user_data` is the same as &my_program_context, below.// Note that we can't capture this value in the [] because std::function// is not supported by our minimum compiler spec (which is pre C++11).MyProgramContext*program_context=static_cast<MyProgramContext*>(user_data);// Process create user result...(void)program_context;},&my_program_context);}
Passaggi successivi
Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente e collegato alle credenziali, ovvero nome utente e password, numero di telefono o informazioni del fornitore di autenticazione, con cui l'utente ha eseguito l'accesso. Questo nuovo account viene archiviato nel tuo progetto Firebase e può essere utilizzato per identificare un utente in tutte le app del progetto, indipendentemente da come accede.
firebase::auth::Useruser=auth->current_user();if(user.is_valid()){std::stringname=user.display_name();std::stringemail=user.email();std::stringphoto_url=user.photo_url();// The user's ID, unique to the Firebase project.// Do NOT use this value to authenticate with your backend server,// if you have one. Use firebase::auth::User::Token() instead.std::stringuid=user.uid();}
Nelle Regole di sicurezzaFirebase Realtime Database e Cloud Storage, puoi recuperare l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Mancano le informazioni di cui ho bisogno","missingTheInformationINeed","thumb-down"],["Troppo complicato/troppi passaggi","tooComplicatedTooManySteps","thumb-down"],["Obsoleti","outOfDate","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Problema relativo a esempi/codice","samplesCodeIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-09-04 UTC."],[],[],null,["You can let your users authenticate with Firebase using their GitHub accounts\nby integrating GitHub authentication into your app.\n\nBefore you begin\n\n1. [Add Firebase to your C++ project](/docs/cpp/setup#note_select_platform).\n2. In the [Firebase console](//console.firebase.google.com/), open the **Auth** section.\n3. On the **Sign in method** tab, enable the **GitHub** provider.\n4. Add the **Client ID** and **Client Secret** from that provider's developer console to the provider configuration:\n 1. [Register your app](https://github.com/settings/applications/new) as a developer application on GitHub and get your app's OAuth 2.0 **Client ID** and **Client Secret**.\n 2. Make sure your Firebase **OAuth redirect URI** (e.g. `my-app-12345.firebaseapp.com/__/auth/handler`) is set as your **Authorization callback URL** in your app's settings page on your [GitHub app's config](https://github.com/settings/developers).\n5. Click **Save**.\n\nAccess the `firebase::auth::Auth` class The `Auth` class is the gateway for all API calls.\n\n1. Add the Auth and App header files: \n\n ```c++\n #include \"firebase/app.h\"\n #include \"firebase/auth.h\"\n ```\n2. In your initialization code, create a [`firebase::App`](/docs/reference/cpp/class/firebase/app) class. \n\n ```c++\n #if defined(__ANDROID__)\n firebase::App* app =\n firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);\n #else\n firebase::App* app = firebase::App::Create(firebase::AppOptions());\n #endif // defined(__ANDROID__)\n ```\n3. Acquire the `firebase::auth::Auth` class for your `firebase::App`. There is a one-to-one mapping between `App` and `Auth`. \n\n ```c++\n firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);\n ```\n\nAuthenticate with Firebase\n\n1. Follow instructions for [Android](/docs/auth/android/github-auth#authenticate_with_firebase) and [iOS+](/docs/auth/ios/github-auth#authenticate_with_firebase) to get a token for the signed-in GitHub user.\n2. After a user successfully signs in, exchange the token for a Firebase credential, and authenticate with Firebase using the Firebase credential: \n\n ```c++\n firebase::auth::Credential credential =\n firebase::auth::GitHubAuthProvider::GetCredential(token);\n firebase::Future\u003cfirebase::auth::AuthResult\u003e result =\n auth-\u003eSignInAndRetrieveDataWithCredential(credential);\n ```\n3. If your program has an update loop that runs regularly (say at 30 or 60 times per second), you can check the results once per update with `Auth::SignInAndRetrieveDataWithCredentialLastResult`: \n\n ```c++\n firebase::Future\u003cfirebase::auth::AuthResult\u003e result =\n auth-\u003eSignInAndRetrieveDataWithCredentialLastResult();\n if (result.status() == firebase::kFutureStatusComplete) {\n if (result.error() == firebase::auth::kAuthErrorNone) {\n firebase::auth::AuthResult auth_result = *result.result();\n printf(\"Sign in succeeded for `%s`\\n\",\n auth_result.user.display_name().c_str());\n } else {\n printf(\"Sign in failed with error '%s'\\n\", result.error_message());\n }\n }\n ```\n Or, if your program is event driven, you may prefer to [register a callback on the\n Future](#register_callback_on_future).\n\nRegister a callback on a Future Some programs have `Update` functions that are called 30 or 60 times per second. For example, many games follow this model. These programs can call the `LastResult` functions to poll asynchronous calls. However, if your program is event driven, you may prefer to register callback functions. A callback function is called upon completion of the Future. \n\n```c++\nvoid OnCreateCallback(const firebase::Future\u003cfirebase::auth::User*\u003e& result,\n void* user_data) {\n // The callback is called when the Future enters the `complete` state.\n assert(result.status() == firebase::kFutureStatusComplete);\n\n // Use `user_data` to pass-in program context, if you like.\n MyProgramContext* program_context = static_cast\u003cMyProgramContext*\u003e(user_data);\n\n // Important to handle both success and failure situations.\n if (result.error() == firebase::auth::kAuthErrorNone) {\n firebase::auth::User* user = *result.result();\n printf(\"Create user succeeded for email %s\\n\", user-\u003eemail().c_str());\n\n // Perform other actions on User, if you like.\n firebase::auth::User::UserProfile profile;\n profile.display_name = program_context-\u003edisplay_name;\n user-\u003eUpdateUserProfile(profile);\n\n } else {\n printf(\"Created user failed with error '%s'\\n\", result.error_message());\n }\n}\n\nvoid CreateUser(firebase::auth::Auth* auth) {\n // Callbacks work the same for any firebase::Future.\n firebase::Future\u003cfirebase::auth::AuthResult\u003e result =\n auth-\u003eCreateUserWithEmailAndPasswordLastResult();\n\n // `&my_program_context` is passed verbatim to OnCreateCallback().\n result.OnCompletion(OnCreateCallback, &my_program_context);\n}\n```\nThe callback function can also be a lambda, if you prefer. \n\n```c++\nvoid CreateUserUsingLambda(firebase::auth::Auth* auth) {\n // Callbacks work the same for any firebase::Future.\n firebase::Future\u003cfirebase::auth::AuthResult\u003e result =\n auth-\u003eCreateUserWithEmailAndPasswordLastResult();\n\n // The lambda has the same signature as the callback function.\n result.OnCompletion(\n [](const firebase::Future\u003cfirebase::auth::User*\u003e& result,\n void* user_data) {\n // `user_data` is the same as &my_program_context, below.\n // Note that we can't capture this value in the [] because std::function\n // is not supported by our minimum compiler spec (which is pre C++11).\n MyProgramContext* program_context =\n static_cast\u003cMyProgramContext*\u003e(user_data);\n\n // Process create user result...\n (void)program_context;\n },\n &my_program_context);\n}\n```\n\nNext steps\n\nAfter a user signs in for the first time, a new user account is created and\nlinked to the credentials---that is, the user name and password, phone\nnumber, or auth provider information---the user signed in with. This new\naccount is stored as part of your Firebase project, and can be used to identify\na user across every app in your project, regardless of how the user signs in.\n\n- In your apps, you can get the user's basic profile information from the\n [`firebase::auth::User`](/docs/reference/cpp/class/firebase/auth/user) object:\n\n ```c++\n firebase::auth::User user = auth-\u003ecurrent_user();\n if (user.is_valid()) {\n std::string name = user.display_name();\n std::string email = user.email();\n std::string photo_url = user.photo_url();\n // The user's ID, unique to the Firebase project.\n // Do NOT use this value to authenticate with your backend server,\n // if you have one. Use firebase::auth::User::Token() instead.\n std::string uid = user.uid();\n }\n ```\n- In your Firebase Realtime Database and Cloud Storage\n [Security Rules](/docs/database/security/user-security), you can\n get the signed-in user's unique user ID from the `auth` variable,\n and use it to control what data a user can access.\n\nYou can allow users to sign in to your app using multiple authentication\nproviders by [linking auth provider credentials to an\nexisting user account.](/docs/auth/cpp/account-linking)\n\nTo sign out a user, call [`SignOut()`](/docs/reference/cpp/class/firebase/auth/auth#signout): \n\n```c++\nauth-\u003eSignOut();\n```"]]
