c# - samsung - pedir varios permisos android studio

API de Google+: ¿Cómo puedo usar RefreshTokens para evitar solicitar acceso cada vez que mi aplicación se inicia?

Question

Estoy intentando usar la API de Google+ para acceder a la información del usuario autenticado. He copiado un código de una de las muestras, que funciona bien (a continuación), sin embargo, tengo problemas para que funcione de una manera que pueda reutilizar el token en los lanzamientos de aplicaciones.

Intenté capturar la propiedad "RefreshToken" y utilizar provider.RefreshToken() (entre otras cosas) y siempre obtengo una respuesta de 400 Bad Request .

¿Alguien sabe cómo hacer que esto funcione, o sabe dónde puedo encontrar algunas muestras? El sitio de Google Code no parece cubrir esto :-(

class Program
{
private const string Scope = "https://www.googleapis.com/auth/plus.me";
static void Main(string[] args)
{
var provider = new NativeApplicationClient(GoogleAuthenticationServer.Description);
provider.ClientIdentifier = "BLAH";
provider.ClientSecret = "BLAH";
var auth = new OAuth2Authenticator<NativeApplicationClient>(provider, GetAuthentication);
var plus = new PlusService(auth);
plus.Key = "BLAH";
var me = plus.People.Get("me").Fetch();
Console.WriteLine(me.DisplayName);
}
private static IAuthorizationState GetAuthentication(NativeApplicationClient arg)
{
// Get the auth URL:
IAuthorizationState state = new AuthorizationState(new[] { Scope });
state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl);
Uri authUri = arg.RequestUserAuthorization(state);
// Request authorization from the user (by opening a browser window):
Process.Start(authUri.ToString());
Console.Write(" Authorization Code: ");
string authCode = Console.ReadLine();
Console.WriteLine();
// Retrieve the access token by using the authorization code:
return arg.ProcessUserAuthorization(authCode, state);
}
}

Answer 1

Aquí hay un ejemplo. Asegúrese de agregar una configuración de cadena llamada RefreshToken y hacer referencia a System.Security o de encontrar otra forma de almacenar de forma segura el token de actualización.

 private static byte[] aditionalEntropy = { 1, 2, 3, 4, 5 };
private static IAuthorizationState GetAuthorization(NativeApplicationClient arg)
{
// Get the auth URL:
IAuthorizationState state = new AuthorizationState(new[] { PlusService.Scopes.PlusMe.GetStringValue() });
state.Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl);
string refreshToken = LoadRefreshToken();
if (!String.IsNullOrWhiteSpace(refreshToken))
{
state.RefreshToken = refreshToken;
if (arg.RefreshToken(state))
return state;
}
Uri authUri = arg.RequestUserAuthorization(state);
// Request authorization from the user (by opening a browser window):
Process.Start(authUri.ToString());
Console.Write(" Authorization Code: ");
string authCode = Console.ReadLine();
Console.WriteLine();
// Retrieve the access token by using the authorization code:
var result = arg.ProcessUserAuthorization(authCode, state);
StoreRefreshToken(state);
return result;
}
private static string LoadRefreshToken()
{
return Encoding.Unicode.GetString(ProtectedData.Unprotect(Convert.FromBase64String(Properties.Settings.Default.RefreshToken), aditionalEntropy, DataProtectionScope.CurrentUser));
}
private static void StoreRefreshToken(IAuthorizationState state)
{
Properties.Settings.Default.RefreshToken = Convert.ToBase64String(ProtectedData.Protect(Encoding.Unicode.GetBytes(state.RefreshToken), aditionalEntropy, DataProtectionScope.CurrentUser));
Properties.Settings.Default.Save();
}

Answer 2

La especificación de OAuth 2.0 aún no está terminada, y hay un puñado de implementaciones de especificaciones en los distintos clientes y servicios que hacen que aparezcan estos errores. Lo más probable es que esté haciendo todo bien, pero la versión de DotNetOpenAuth que está usando implementa un borrador diferente de OAuth 2.0 del que Google está implementando actualmente. Ninguna de las partes es "correcta", ya que la especificación aún no está finalizada, pero hace que la compatibilidad sea una pesadilla.

Puede verificar que la versión de DotNetOpenAuth que está usando es la más reciente (en caso de que eso ayude, lo que podría ser ), pero en última instancia, es posible que tenga que sentarse hasta que las especificaciones estén finalizadas y todos los implementen correctamente, o leer la documentación de Google. usted mismo (que presumiblemente describe su versión de OAuth 2.0) e implemente una que apunte específicamente a su versión de borrador.

Answer 3

La idea general es la siguiente:

1. Redirecciona al usuario al punto final de autorización de Google.

2. Obtienes un Código de Autorización de corta duración.

3. Inmediatamente, intercambia el Código de autorización por un token de acceso de larga duración utilizando el punto final de token de Google. El token de acceso viene con una fecha de caducidad y un token de actualización.

4. Usted realiza solicitudes a la API de Google utilizando el token de acceso.

Puede reutilizar el token de acceso para todas las solicitudes que desee hasta que caduque. Luego, puede usar el token de actualización para solicitar un nuevo token de acceso (que viene con una nueva fecha de caducidad y un nuevo token de actualización).

Ver también:

• El Protocolo de Autorización OAuth 2.0
• Documentación de Google OAuth 2.0

Answer 4

Recomendaría ver el proyecto "SampleHelper" en la solución de muestras de la API del cliente de Google .NET:

• Samples/SampleHelper/AuthorizationMgr.cs

Este archivo muestra cómo usar los datos protegidos de Windows para almacenar un token de actualización, y también cómo usar un servidor de bucle de retorno local y diferentes técnicas para capturar el código de acceso en lugar de que el usuario lo ingrese manualmente.

Una de las muestras en la biblioteca que utiliza este método de autorización se puede encontrar a continuación:

• Samples/Tasks.CreateTasks/Program.cs

Answer 5

También tuve problemas para hacer que la autenticación "fuera de línea" funcionara (es decir, adquirir la autenticación con un token de actualización), y obtuve una 400 Bad request errónea de respuesta HTTP 400 Bad request con un código similar al código del OP. Sin embargo, tengo que trabajar con la línea client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(this.clientSecret); en el método de Authenticate . Esto es esencial para obtener un código de trabajo. Creo que esta línea obliga al clienteSecret a enviarse como un parámetro POST al servidor (en lugar de como un parámetro de Autenticación Básica HTTP).

Esta solución supone que ya tiene un ID de cliente, un secreto de cliente y un token de actualización. Tenga en cuenta que no necesita ingresar un token de acceso en el código. (Un código de acceso de corta duración se adquiere "debajo del capó" del servidor de Google al enviar el token de actualización de larga duración con el client.RefreshAuthorization(state); de client.RefreshAuthorization(state); Este token de acceso se almacena como parte de la auth -variable, desde donde se usa para autorizar las llamadas a API "bajo el capó".

Un ejemplo de código que me funciona con Google API v3 para acceder a mi calendario de Google:

class SomeClass
{
private string clientID = "XXXXXXXXX.apps.googleusercontent.com";
private string clientSecret = "MY_CLIENT_SECRET";
private string refreshToken = "MY_REFRESH_TOKEN";
private string primaryCal = "MY_GMAIL_ADDRESS";
private void button2_Click_1(object sender, EventArgs e)
{
try
{
NativeApplicationClient client = new NativeApplicationClient(GoogleAuthenticationServer.Description, this.clientID, this.clientSecret);
OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(client, Authenticate);
// Authenticated and ready for API calls...
// EITHER Calendar API calls (tested):
CalendarService cal = new CalendarService(auth);
EventsResource.ListRequest listrequest = cal.Events.List(this.primaryCal);
Google.Apis.Calendar.v3.Data.Events events = listrequest.Fetch();
// iterate the events and show them here.
// OR Plus API calls (not tested) - copied from OP''s code:
var plus = new PlusService(auth);
plus.Key = "BLAH"; // don''t know what this line does.
var me = plus.People.Get("me").Fetch();
Console.WriteLine(me.DisplayName);
// OR some other API calls...
}
catch (Exception ex)
{
Console.WriteLine("Error while communicating with Google servers. Try again(?). The error was:/r/n" + ex.Message + "/r/n/r/nInner exception:/r/n" + ex.InnerException.Message);
}
}
private IAuthorizationState Authenticate(NativeApplicationClient client)
{
IAuthorizationState state = new AuthorizationState(new string[] { }) { RefreshToken = this.refreshToken };
// IMPORTANT - does not work without:
client.ClientCredentialApplicator = ClientCredentialApplicator.PostParameter(this.clientSecret);
client.RefreshAuthorization(state);
return state;
}
}