gsNotasNET para Android con Xamarin.Forms

Pues eso… que ayer (o anteayer) me puse a trastear con el Xamarin para crear aplicaciones para móviles (para Android, ya que no tengo conexión a un Mac y por tanto no puedo desarrollar para iPhone) y he creado una versión de gsNotasNET pero para dispositivos móviles de Android. Y ya lo tengo en funcionamiento en mi móvil 😉

El código está adaptado de un tutorial paso a paso que hay en la documentación de Microsoft, este es el enlace del primer ejemplo:

Create a single page Xamarin.Forms application – Xamarin | Microsoft Docs

He puesto el código fuente en GitHub: gsNotasNET.Android.

 

Un video de la aplicación funcionandoi en el emulador de Android

Nunca me acuerdo de apagar las bocinas (altavoces/speakers) cuando lo grabo y parece que estoy hablando desde el fondo de un cubo… en fin…

 

 

Cuando haga algunas capturas las pondré por aquí para que veas cómo queda.

Bueno, intentaré hacerle una para que no se quede muy soso este post 😉

 

Al final he hecho tres capturas.

Figura 1. La pantalla prinicpal

 

Figura 2. Editar una nota.

 

Figura 3. Escribir una nota nueva.

 

Espero que te sea de utilidad.

 

Nos vemos.
Guillermo

Tutorial Google APIs – Código para acceder a los contactos con People API

Ya estás en la segunda entrega de este Tutorial sobre el uso de las APIs de Google.
Aquí te mostraré el código de Visual Basic y C# para acceder a los contactos de Google usando People API. Como te comenté en la priumera entrega sobre cómo crear un proyecto en Google Cloud, el API que usaremos es People API, no te confundas con Contacts API (como a mí me ocurrió) ya que parece que será la más adecuada, pero además de que Google no recomienda que se use Contacts API, la he probado y no he conseguido sacar prácticamente nada de información, y al que he sacado es de unos pocos contactos (que ni recordaba que los tenía creados).

Nota:
Está uno acostumbrado a que te marquen los errores horrográficos que esto de que no te los marque es un Orror! 😛

Bueno vamos empezar con el código de C# que es lo que la gente suele ver en internet (de VB no he visto ni un ejemplo, así que… ya mismo lo verás en primicia).

Después de escribir el párrafo anterior he cambiado de opinión y te voy a enseñar conjuntamente el código de los dos lenguajes, para que vayas comparando.

Código de C# y VB para mostrar los contactos de una cuenta de Google usando People API

Nota:
Debo decir que parte de este código lo he visto en algunos ejemplosencontrados tanto en la documentación de Google como en foros de C#. Pero principalmente de la documentación (escasa) de Google y en agunos casos, los ejemplos eran de java, ni siquiera de C#.

Como te comenté en el preámbulo del tutorial, debes añadir las referencias a los paquetes de NuGet que instalarán las APIs en tu proyecto. Yo he añadido todas las que te indiqué en esa primera página del tutorial. Por supuesto si quieres acceder, por ejemplo al calendario o a GMail, tendrás que añadir referencias a esas APIs, además de añadirlas al proyecto creado en Google Cloud Platform.

Veamos el código inicial (con las importaciones de los espacios de nombres) que será básicamente el mismo en todas las apliocaciones que hagas para acceder a las APIs de Google.

// Genéricas
using Google.Apis.Auth.OAuth2;
using Google.Apis.Services;
using Google.Apis.Util.Store;
// People API
using Google.Apis.People.v1;
using Google.Apis.People.v1.Data;
// Docs API
using Google.Apis.Docs.v1;
using Google.Apis.Docs.v1.Data;
// Drive API
using Google.Apis.Drive.v3;
using Google.Apis.Drive.v3.Data; // Para el tipo File

using System;
using System.Collections.Generic;
//using System.IO;
using System.Threading;
using System.Text;
using System.Linq;
'// Genéricas
Imports Google.Apis.Auth.OAuth2
Imports Google.Apis.Services
Imports Google.Apis.Util.Store
'// People API
Imports Google.Apis.People.v1
Imports Google.Apis.People.v1.Data
'// Docs API
Imports Google.Apis.Docs.v1
Imports Google.Apis.Docs.v1.Data
'// Drive API
Imports Google.Apis.Drive.v3
Imports Google.Apis.Drive.v3.Data '// Para el tipo File

Imports System
Imports System.Collections.Generic
Imports System.Threading
Imports System.Text
Imports System.Linq

Ahora vamos a crear una serie de campos estáticos/compartidos (static en C#, shared en VB) que usaremos también de forma genérica en todos los proyectos de acceso a Google APIs.

class Program
{
    // If modifying these scopes, delete your previously saved credentials
    // at ~/.credentials/docs.googleapis.com-dotnet-quickstart.json
    static string[] Scopes = { DocsService.Scope.Documents, 
                               DocsService.Scope.DriveFile, 
                               PeopleService.Scope.ContactsReadonly };

    static string ApplicationName = "Tutorial Google APIs VB";

    // Los datos del proyecto creado para VB
    static ClientSecrets secrets = new ClientSecrets()
    {
        ClientId = "430211665266-t68vl99t2q40v3lbctgbph23j2644bpj.apps.googleusercontent.com",
        ClientSecret = "Xqexl0FMPedNc1KYs0iJt22A"
    };

    static DocsService docService;
    static DriveService driveService;
    static PeopleService peopleService;

    static UserCredential Credential;
Class Program

    Shared Scopes As String() =
        {
            DocsService.Scope.Documents,
            DocsService.Scope.DriveFile,
            PeopleService.Scope.ContactsReadonly
        }

    Shared ApplicationName As String = "Tutorial Google APIs VB"

    Shared secrets As ClientSecrets = New ClientSecrets() With
        {
            .ClientId = "430211665266-t68vl99t2q40v3lbctgbph23j2644bpj.apps.googleusercontent.com",
            .ClientSecret = "Xqexl0FMPedNc1KYs0iJt22A"
        }

    Shared docService As DocsService
    Shared driveService As DriveService
    Shared peopleService As PeopleService

    Shared Credential As UserCredential

Lo que ese primer comentario indica (es de un quickstart de Google) es que si cambias los valores del array Scopes debes eliminar el directorio creado en Documentos\.credentials (ahora verás porqué).

El array Scopes contiene los ámbitos de la aplicación, es a qué estamos pidiendo permiso para acceder. Ahí he añadido los tres ámbitos que usaré en este tutorial, pero si solo quieres acceder a los contactos con People API, añadiendo PeopleService.Scope.ContactsReadonly sería suficiente. Si te fijas, estás pidiendo autorización (a OAuth) para acceder de forma de solo lectura a los contactos.
En realidad estás pidiendo permisos para acceder a los Documentos y al Drive sin restricciones, pero a los contactos solo para leerlos. Estos dos últimos necesitan más permisos porque queremos crear ficheros, eliminarlos, lo mismo con los documentos.

Lo importante (también) es la asignación de ClientSecrets, ahí tendás que poner los datos que te haya generado al configurar el OAuth de la aplicación. Eso que te muestro son los valores que en mi proyecto para este tutorial he pedido, el que se indique que la aplicación se llama Tutorial Google APis VB no significa que no se pueda usar para C#, ese título o nombre de aplicación no es restrictivo para nada.

Nota:
Normalmente esos valores se recomienda que no se hagan públicos… ¡vaya el caso que hago! jejejeje… pero para este caso, me fio de ti, y sé que no se lo dirás a nadie y así lo mantenemos en secreto… 😉

Las tres declaraciones después de asignar el valor a secrets son para acceder a los servicios de las tres APIs que usaré en estos tutoriales, las defino a nivel de clase para que se puedan usar en todos los métodos que sean necesarios y no tener que pasarlas como argumento de llamada al método que lo necesite.

La última declaración (Credential) es para crear las credenciales del usuario. La asignación la haré en el método Main, y como es un valor compartido, también se podrá usar en cualquier parte de la clase.

El siguiente código es el método Main, en el que llamaremos al método que accede a los contactos y los muestra.

Y como verás en las capturas el correo que he usado no tenía ningún contacto y he tenido que crear uno para comprobar que funciona… las cosas del Guille…

static void Main(string[] args)
{
    Console.WriteLine("Tutorial Google APIs con C#");

    string credPath = System.Environment.GetFolderPath(
        Environment.SpecialFolder.Personal);
    
    // Directorio donde se guardarán las credenciales
    credPath = System.IO.Path.Combine(credPath, ".credentials/Tutorial-Google-APIs-VB");

    Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
        secrets,
        Scopes,
        "user",
        CancellationToken.None,
        new FileDataStore(credPath, true)).Result;
    //Console.WriteLine("Credential file saved to: " + credPath);

    // Mostrar los contactos
    MostrarContactos();

    Console.WriteLine();
    Console.WriteLine("Pulsa una tecla.");
    Console.Read();
}
Public Shared Sub Main(ByVal args As String())

    Console.WriteLine("Tutorial Google APIs con Visual Basic")

    Dim credPath As String = System.Environment.GetFolderPath(
        Environment.SpecialFolder.Personal)

    '// Directorio donde se guardarán las credenciales
    credPath = System.IO.Path.Combine(credPath, ".credentials/Tutorial-Google-APIs-VB")

    Credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
        secrets,
        Scopes,
        "user",
        CancellationToken.None,
        New FileDataStore(credPath, True)).Result

    '// Mostrar los contactos
    MostrarContactos()

    Console.WriteLine()
    Console.WriteLine("Pulsa una tecla.")
    Console.Read()
End Sub

El valor de credPath es el direcorio donde se crearán las credenciales que vamos a usar en este programa. Se guardará en los documentos del usuario en una carpeta llamada Tutorial-Google-APIs-VB que estará incluida en .credentials.

Si haces cambios en los permisos o te han faltado permisos en la configuración de OAuth y los modificas, debes eliminar la carpeta del tutorial, a de .credentials la puedes dejar, por si la usas para almacenar las credenciales de otros programas que use el usuario.
También tendrás que borrarla si decides usar otra cuenta de Google (GMail) para acceder a esos contactos. Si solo tienes una cuenta de GMail, no hará falta que la borres salvo para los dos primeros casos.

Cuando ejecutemos la aplicación verás qué es lo que se guarda en esa carpeta.

A Credentials le asignamos las credenciales que queremos usar.

Aquí tengo que hacer una puntuialización.
El valor de secrets se asigna con los valores que hemos indicado (de foirma llana y clara) antes, pero también se puede hacer accediendo a un fichero que contiene esos valores, al menos así no se mostrarán directamente en el código los valores secretos. Aunque seguirán estando al alcance del usuario de la aplicación.

La forma de hacerlo lo pondré en otro ejemplo de este tutorial.

Ahora solo nos falta ver qué código contiene elmétodo MostrarContactos.

¡Vamos a ello!

private static void MostrarContactos()
{
    // Create Drive API service.
    peopleService = new PeopleService(new BaseClientService.Initializer()
    {
        HttpClientInitializer = Credential,
        ApplicationName = ApplicationName,
    });

    // Lista de los contactos (People)
    Console.WriteLine("Contactos:");

    // Este muestra todos los contactos
    GetPeople(peopleService, null);

    Console.WriteLine();
    Console.WriteLine($"Hay {total} contactos / People");
    Console.WriteLine();
}
Private Shared Sub MostrarContactos()
    peopleService = New PeopleService(New BaseClientService.Initializer() With
    {
        .HttpClientInitializer = Credential,
        .ApplicationName = ApplicationName
    })

    Console.WriteLine("Contactos:")

    GetPeople(peopleService, Nothing)

    Console.WriteLine()
    Console.WriteLine($"Hay {total} contactos / People")
    Console.WriteLine()
End Sub

Le asignamos el valor a peopleService para que pida esos permisos a Google, como ves se usa el protocolo HTTP.
Eso lo que hará es abrir una página en el navegador pidiendo permiso para acceder a los datos de una cuenta de GMail (ver la figura 1)

Figura 1. Seleccionar la cunta que queremos usar para acceder a sus contactos.

Esa primera pantalla nos pide que indiquemos a qué contactos queremos acceder, es decir, solo accederá a los contactos de la cuenta que indiques, y para indicar esa cuenta debes tener el password, si no… no hay nada que hacer.
Por tanto, esto que vamos a hacer es seguro, en el sentido de que yo no voy a acceder (ni puedo) a tus contactos… otra cosa es que mi aplicación se comunicara conmigo o guardara esa información en algún sitio… pero no te preocupes, no lo hace, además lo puedes comprobar por ti mismo viendo el código.

Una vez elegida la cuenta, te mostrará un aviso de que la aplicación no es segura o, en realidad, que no se ha verificado (ver la figura 2).
Tendrás que autorizarla para que pueda seguir.

Figura 2. DEbes mostrar la información oculta para permitir ir a la aplicación

Una vez hechoi esto, Google te pedirá confirmación para dejar que la aplicación haga lo que se ha indicado en Scopes. Así que… otras tres pantallitas más de autorización (ver figuras 3 a 5).

Figura 3. Permiso para ver los contactos.
Figura 4. Acceder al Drive.
Figura 5. Acceder a los documentos.

Y una vez permitido estas cosas, debes terminar de aceptarlo (ver la figura 6 en la está el resumen de los permisos que le darás a la aplicación).

Figura 6. Confirmación final de los permisos.

Después de pulsar en Permitir, el navegador te mostrará un mensaje de que puedes cerrar la página.

Estos permisos no te los volverá a pedir para usar esta aplicación. Y por tanto, siempre accederá a la cuenta de GMail que has indicado.

Si quieres usar otra cuenta diferente, borra la carpeta esa que te comenté antes (o el fichero que contiene) y eso hará que te vuelva a mostrar todas estas pantallas.

Antes de seguir, espera un poco que me estoy meando de la risa… ¡ay!

Es que te dije que definí la variable peopleService (y las otras dos) a nivel de clase para no tener que usarla como argumento a un método y voy y pongo como argumento el valor de esa variable compartida… en fin… la cabeza del Guille…

Bueno, ya.

Sigamos con el código que accede a los contactos.

private static int total = 0;

static void GetPeople(PeopleService service, string pageToken)
{
    // Define parameters of request.
    PeopleResource.ConnectionsResource.ListRequest peopleRequest =
            service.People.Connections.List("people/me");

    //
    // Lista de campos a usar en RequestMaskIncludeField:
    // https://developers.google.com/people/api/rest/v1/people/get
    //

    peopleRequest.RequestMaskIncludeField = new List<string>()
            {"person.names", "person.phoneNumbers", "person.emailAddresses",
              "person.birthdays", "person.Addresses"
            };


    if (pageToken != null)
    {
        peopleRequest.PageToken = pageToken;
    }

    ListConnectionsResponse people = peopleRequest.Execute();

    if (people != null && people.Connections != null && people.Connections.Count > 0)
    {
        total += people.Connections.Count;
        foreach (var person in people.Connections)
        {
            Console.Write(person.Names != null ? ($"{person.Names.FirstOrDefault().DisplayName} - ") : "");
            Console.Write(person.PhoneNumbers != null ? ($"{person.PhoneNumbers.FirstOrDefault().Value} - ") : "");
            Console.Write(person.EmailAddresses != null ? ($"{person.EmailAddresses.FirstOrDefault().Value} - ") : "");
            Console.Write(person.Addresses != null ? ($"{person.Addresses.FirstOrDefault()?.City} - ") : "");
            if (person.Birthdays != null)
            {
                var fecha = "";
                var b = person.Birthdays.FirstOrDefault()?.Date;
                if (b != null)
                    fecha = $"{b.Day}/{b.Month}/{b.Year}";
                Console.Write($"{fecha}");
            }
            Console.WriteLine();
        }

        if (people.NextPageToken != null)
        {
            Console.WriteLine();
            Console.WriteLine($"{total} contactos mostrados hasta ahora. Pulsa una tecla para seguir mostrando contactos.");
            Console.WriteLine();
            Console.ReadKey();

            GetPeople(service, people.NextPageToken);
        }
    }
    else
    {
        Console.WriteLine("No se han encontrado contactos.");
        return;
    }
}
Private Shared total As Integer = 0

Private Shared Sub GetPeople(service As PeopleService, pageToken As String)

    Dim peopleRequest As PeopleResource.ConnectionsResource.ListRequest =
        service.People.Connections.List("people/me")

    peopleRequest.RequestMaskIncludeField = New List(Of String)() From {
            "person.names",
            "person.phoneNumbers",
            "person.emailAddresses",
            "person.birthdays",
            "person.Addresses"
        }

    If pageToken IsNot Nothing Then
        peopleRequest.PageToken = pageToken
    End If

    Dim people As ListConnectionsResponse = peopleRequest.Execute()

    If people IsNot Nothing AndAlso
            people.Connections IsNot Nothing AndAlso
            people.Connections.Count > 0 Then
        total += people.Connections.Count

        For Each person In people.Connections
            Console.Write(If(person.Names IsNot Nothing,
                          ($"{person.Names.FirstOrDefault().DisplayName} - "), ""))
            Console.Write(If(person.PhoneNumbers IsNot Nothing,
                          ($"{person.PhoneNumbers.FirstOrDefault().Value} - "), ""))
            Console.Write(If(person.EmailAddresses IsNot Nothing,
                          ($"{person.EmailAddresses.FirstOrDefault().Value} - "), ""))
            Console.Write(If(person.Addresses IsNot Nothing,
                          ($"{person.Addresses.FirstOrDefault()?.City} - "), ""))

            If person.Birthdays IsNot Nothing Then
                Dim fecha = ""
                Dim b = person.Birthdays.FirstOrDefault()?.Date
                If b IsNot Nothing Then fecha = $"{b.Day}/{b.Month}/{b.Year}"
                Console.Write($"{fecha}")
            End If

            Console.WriteLine()
        Next

        If people.NextPageToken IsNot Nothing Then
            Console.WriteLine()
            Console.WriteLine($"{total} contactos mostrados hasta ahora. " &
                              "Pulsa una tecla para seguir mostrando contactos.")
            Console.WriteLine()
            Console.ReadKey()
            GetPeople(service, people.NextPageToken)
        End If
    Else
        Console.WriteLine("No se han encontrado contactos.")
        Return
    End If
End Sub

El valor de peopleRequest debe ser siempre people/me o bien si te sabes el ID de otro usuario lo podrías indicar en lugar de «me«. Ese me significa que accedes a tus contactos.
He buscado por todas partes, y no he averiguado como saber ese famoso ID, ni siquiera de una de mis cuentas para poder saber si se puede acceder a la cuenta de alguien que no seas tú.
Cuando lo averigüe te lo cuento.

Los valores asigndos a la lista RequestMaskIncludeField serán a los datos que queremos acceder y siempre deben empezar con person. seguido del campo al que queremos acceder. En este ejemplo estamos indicando que queremos acceder a: los nombres, teléfonos, emails, cumpleaños y domicilios.

Y como esos valores pueden ser nulos (y normalmente son una colección de valores), comprobamos si es nulo y en el caso de las colecciones accedemos al primero o al predeterminado, si hay algo lo mostramos y si no, se usa una cadena vacía.

Con el valor de Birtdays debemos hacer una comprobación más elaborada e incluso te recomendaría que usaras un try/catch si quieres acceder a los valores de la fecha, porque de las pruebas que he heco, en un caso me dio error al querer acceder al año… se ve que el contacto ese no quería dar su año de nacimiento y dio error al querer convertirlo a entero… en fin…

El NextPageToken nos indica que hay más págins de datos, así que… si las hay volvemos a llamar a este método y seguimos mostrando los contactos que falten por acceder.

Y esto es todo lo que hay que hacer para mostrar los contactos usando People API. Otra cosa es que quieras crear contactos o modificarlos, en esos casos tendrás que modificar el valor del Scope de los contatos.
Si hago pruebas de crear o modificar te los pondré por aquí.

Para terminar, la captura del programa en funcionamiento. Ver la figura 7.

Figura 7. La cuenta que he usado para acceder a los contactos, ¡no tiene contactos!

Pues la sorpresa que me llevé… pensé que lo mismo fallaba algo, así que… me fui a google, creé un contacto y volvía a probar… ¡Esta vez sí que sí! (ver la figira 8).

Figura 8. Un contacto tengo en la cuenta que he usado para esta prueba.

Y esto es todo por ahora.

Ahora a esperar a la siguiente entrega.

Este código está publicado en GitHub: Tutorial-APIs-Google.

Nos vemos.
Guillermo

P.S.
Versión en inglés / English version.

Tutorial Google APIs – Crear Proyecto en Google Cloud

Aquí tienes la primera entrega del tutorial sobre el uso de las APIs de Google para acceder a Drive, Contactos y Documentos.

Si quieres crer una cuenta y un proyecto para poder acceder a esos APIs de Google, lo primero es acceder a Google Cloud Platform y crear una cuenta, o mejor dicho, activarla con Google Cloud.

Una vez que tengas la cuenta, tendrás que crear un proyecto y configurarlo para que pueda acceder a esas APIs.

En este tutorial te explico paso a paso cómo hacerlo, y con un montón de capturas para que no te líes y yo no me olvide de contarte los paso, que todo hay que decirlo. 🙂

Nota:
Por ahora te voy dejar las capturas y en otra ocasión, si hace falta, te explico lo que cada captura significa.
Es que quiero pasar a mostrarte el código para acceder al API de People (contactos) que ya lo tengo hecho tanto con C# como con Visual Basic.

Figura 1. Crear un nuevo proyecto

 

Figura 2.

 

Figura 3.

 

Figura 4.

 

Figura 5.

 

Figura 6. En la ficha G Suite están las de Docs API y drive API

 

Figura 7. Tienes que elegir y habilitar una por una.

 

Figura 8.

 

Figura 9. Añadir más librerías (bibliotecas)

 

Figura 10. Elige People API. No elijas Contacts API, que aparte de estar obsoleta, no vale para nada…

 

Figura 11. Esta es la parte más importnte, sin la autorización OAuth no podrás acceder a nada.

 

Figura 12. Siempre debe ser External

 

Figura 13.

 

Figura 14.

 

Figura 15. Añadir las características que tu aplicación usará de cada API que has añadido.

 

Figura 16.

 

Figura 17.

Nota:
Los permisos debes ir probándolos a ver qué error te da, según lo que quieras hacer.
Pero básicamente necesitas acceso de lectura, salvo que quieras modificar un contacto, un documento o algún fichero del Drive.

Figura 18. No te olvides de darle a UPDATE ya que al estar tan abajo en la pantalla emergente ni se ve, y so no le das a Update, no se guardan los cambios.

 

Figura 19.

 

Figura 20.

 

Figura 21. Aquí tienes que añadir los usuarios autorizados para que usen la aplicación. El máximo es 100 y una vez que aades uno, ya no lo puedes eliminar.

 

Figura 22.

 

Figura 23. Los tipos de credenciales que crearemos

 

Figura 24.

 

Figura 25. Estas so las APIs que usaremos con este proyecto.

 

Figura 26. El tipo de aplicación que vamos a crear.

 

Figura 27.

 

Figura 28. Estas son las dos claves que necesitarás en tu código

 

Figura 29.

 

Figura 30.

 

Figura 31. Si no hs copiado las credenciales de acceso, descarga el fichero .json y ahí las tienes.

 

 

Pues esto es todo lo que debes saber para crear un proyecto.
En la siguiente entrega voy a mostrarte el código de una aplicación de consola para acceder a los contactos (People API). Sí, en C# y en VB.

 

 

Nos vemos.
Guillermo

Tutorial para usar las APIs de Google con C# y Visual Basic

Pues eso… que como yo me he encontrado con problemas a la hora de implementar las APIs de Google y de encontrar ejemplos (que de haberlos solo eran para C#), me he decido a escribir esta especie de tutorial para poder acceder a las siguientes APIs de Google: Drive, Docs y People. Es decir, poder manipular el contenido de Google Drive, los documentos y los contactos de Google que están asociados tu cuenta (o la cuenta que decidas usar) de GMail.

Lo primero que necesitas (salvo que uses las que yo voy a crear para este tutorial) es crearte una cuenta en Google Cloud Platform, es gratuito al menos sino usas recursos que son de pago.
La cuenta a usar será la que tengas ya de GMail o bien puedes crear una nueva cuenta y asociarla con Google Cloud.

Cuandoi asocias una cuenta por primera vez, te darán una oferta de 300$ (US $) para que pruebes de forma gratuita los recursos de pago (siempre que no te pases de esos 300 dólares). Pero como te digo, para las cosas que te voy a explicar no te hace falta.

Por ahora me voy a saltar el paso de crear tus propios poyectos en Google Cloud, eso lo dejaré para el final (salvo que cambie de opinión), lo que sí te digo es que si quieres utilizar los ejemplos que te voy a mostrar usando mis claves o las que yo indique en el código) antes debes decírmelo para poder añadir tu correo de GMail a los usuarios que pueden usar esas claves.

Esto ultimo lo puedes hacer dejando un comentario en este mismo post y yo te agregaré, esto puede que no lo haga pasado unos meses, ya que solo quiero que la gente lo pruebe en este tiempo reciente, mientras publico los tutoriales. Y dejando, como mucho, unos tres meses de desde la publicación original, así que… si estás leyendo este tutorial después del 15 de marzo de 2021, es posible que o bien no admita más usuarios o simplemente que no lo siga «soportando», además de que hay un límite de 100 usuarios por proyecto, y si ya están esos usuarios registrados con la aplciación, es posible que, incluso antes del 15 de marzo del 2021 no pueda admitir más usuarios.

Dicho esto, empecemos.

Nota:
Los ejemplos los voy a hacer con .NET 5.0.1 pero son válidos para .NET Framework v4.5 y superiores, .NET Standard y .NET Core.

Crear un proyecto en C# o Visual Basic

Crea un proyecto de consola para C# o VB y ve a Tools>NuGet Package Manager>Manage NuGet Packages for Solution… (en español es: Herramientas>Administrador de paquetes NuGet>Administrar paquetes NuGet para la solución…)

Busca y añade los siguientes paquetes de NuGet (entre paréntesis te indico las versiones que estoy usando al escribir este tutorial):

Nota:
Los enlaces son por si quieres ir a la página de NuGet y descargarlas desde allí o ver cómo instalarlas según estés usando Visual Studio 2019 o Visual Studio Code o simplemente creando los proyectos desde la consola con dotnet.
Eso sí, necesitarás tener instlado el SDK de dotnet 5 para poder compilar el código.

Esto añadirá las referencias necesarias para usar el código que te mostraré.

Nota:
Si te interesa ver el código fuente de las APIs de google puedes verlas en el siguiente enlace: google-api-dotnet-client.

Las entregas

  1. Entrega 1: Crear Proyecto en Google Cloud
  2. Entrega 2: Código para acceder a los contactos con People API
  3. Entrega 3: Código para acceder a los documentos con Drive API y Docs API
  4. Entrega 4: Código para crear un documento con Docs API

Nota:
Voy a publicar ahora este post mientras creo el protyecto de prueba, escribo el código, lo convierto de C# a VB (ya tengo código escrito en C#) y lo publico, así podrás solicitar tu «permiso» para usar estos ejemplos con mi ID y clave secreta (que después de publicarla no será tan secreta 😉 )

Nos vemos.
Guillermo

¿Te gustaría obtener más prestaciones de gsNotasNET?

Pues eso… estoy pensando darle al programa más opciones para indicar dónde se guardarán las notas, actualmente se guardan en un fichero de texto en la carpeta documentos del usuario activo. Con lo cual no estarían esas notas disponibles en otro equipo distinto del que se usó para crearlas. Salvo que copies ese fichero y te lo lleves contigo… pero eso, creo que está demostrado que no es muy fiable, sobre todo para gente como yo que, en mi caso, soy más despistado que… en fin… que seguro que me cargaría alguna nota por olvidarme de actualizar el fichero en alguno de los ordenadores a los que me lo llevara… y según la ley de San Murphy, seguro que la nota que perdería sería la que más me interesaría mantener… ¿A ti también te ha pasado? pues ya sabes… sigue leyendo 😉

Guardar las notas en la nube (un sitio de Internet)

Te decía que estoy barajando la posibilidad de almacenar las notas «en la nube», concretamente en el Drive de Google, pero en tu Drive, no en el mío… bueno, mis notas estarían en el Drive de mi cuenta de gmail, las tuyas en el Drive de tu cuenta de gmail y las de Pepito, en el Drive de la cuenta de gmail de Pepito, y así sucesivamente.

El problema de esta opción es que solo tengo disponibles uns 90 cuentas que asignar, es decir, 90 usuarios podrían beneficiarse de esa opción de guardar las notas en Google Drive.

Seguramente nio habrá tantas peticiones, pero… nunca se sabe…jajaja.

¿Por qué 90 usuarios?

Porque para cada aplicación (o proyecto) que se crea en la nube de Google (Google Cloud Platform) te da la opción de permitir hasta 100 usuarios, y de esos 100 yo me reservo al menos 10, por si se lo ofrezco a algunos de los currantes de la empresa de los kayak en la que trabajo actualmente (Maro – Kayak Nerja).

¿Por qué hay que configurar una cuenta?

Porque si un usuario (cuenta de gmail) no está registrado en el proyecto, no podrá usar su cuenta de correo para acceder al Drive.

El mensaje de error es el mostrado en la figura 1.

Figura 1. Error al intentar acceder con una cuenta de gmail no configurada.

Nota:
Repito lo de «cuenta de GMAIL» porque solo se pueden usar cuentas de gmail, al menos a mi no me ha dejado definir otra cuenta de otro servidor, por ejemplo Outlook.com.

Otras opciones para tener las notas en la nube

Otra opción sería crear una base de datos en el hosting donde tengo mis sitios alojados y sería menos problemático, ya que ahí no habría límite de usuarios, pero… no me mola esa opción.

¿Por qué en documentos de Google Drive?

La idea era hacerlo con las notas de Google, (Keep) pero para esa aplicación no existen APIs con las que se puedan acceder, así que… me decidí por usar los documentos, ya que, al menos para mi, es más cómo de leer, imprimir, etc.

¿Y de la privacidad qué?

Si no te animas porque yo vaya a fisgonear en tus documentos o en tu Drive, no te preocupes que aunque tenga acceso para muchas cosas (tengo que poder crear y eliminar ficheros y carpetas en Drive), no haré nada que no sea solo para gestionar las notas, además de que todo lo que se guarde o se elimine, si esa opción la marcas cuando esté listo todo esto, solo lo hará en la carpeta gsNotas que se creará en Drive, y dentro de esa carpeta habrá una carpeta por cada grupo de notas que vayas creando.

Lo de poner como opcional el que se borren las notas sustituidas es porque cada vez que se crea un documento en Drive, aunque ya exista el mismo nombre del documento, se mantienen copias independientes, de esa forma puedes tener una especie de copia de seguridad de cada nota. Así que… si no quieres que haya muchos ficheros repetidos, podrás marcarla opción de borrar la nota antes de guardar o no… pero, como siempre, eso será cosa tuya 😉

Volviendo a la petición de guardar las notas en la nube…

Así que… si quieres que te incluya en la lista, escribe por aquí (en los comentarios) que estás interesado en que ta añada a los que pueden guardar las notas en Google Drive.

En el comentario no es necesario que indiques tu cuenta de correo, ya que para poder escribir un comentario tienes que indicar tu cuenta de correo (aunque no se muestra), así que… m´s fácil imposible… eso sí, en la cuenta de correo que uses para escribir el comentario/petición debes usar una cuenta de gmail que sea tuya (que tú tengas acceso).

Si, de casualidad, hubiese más de las 90 peticiones, ya me las ingeniaré para poder tener otras 100 más… aunque creo que sin pagar (yo a Google) no se podrá hacer. 😉

Ah, y esto no te va a costar nada… ni siquiera te voy a pedir que hagas un donativo con PayPal… ¡anda! ya l,lo he dicho… jajajaja pero no es obligatoriuom, aunque no estaría mal, que hasta el mes de junio o julio no tengo trabajo con lo de los kayak/piraguas 😉

Y esto es todo… si no sabes de qué va esto de gsNotasNET, sigue estos enlaces:
La página de gsNotas en elguillemola.com, el código fuente de gsNotasNET en GitHub.

Gracias.

Nos vemos.
Guillermo

Simular discard de C# en Visual Basic

Pues eso… haciendo pruebas con el conversor de C# a VB de Paul1956 comprobé que los discard de C# (asignación digamos que nula de una función o descartes según la traducción al español ) los generaba usando dos guiones bajo (undercore) y el «asistente» de VS indicó que creara una función para usar ese descarte. Y al ver que es válido usar el nombre __ (dos guiones bajos) como nombre de una función, pensé que también sería válido para una propiedad… de forma que se pudiese haccer ese tipo de asignación.

Por ejemplo, si tenemos este código de C# en el que se «descarta» el valor devuelto por la función MostrarAyuda:

class Program
{
    static void Main(string[] args)
    {
        _ = MostrarAyuda(true, false);

        //Console.WriteLine(_);

        Console.WriteLine();
        Console.WriteLine("Pulsa una tecla para finalizar.");
        Console.ReadKey();
    }

    private static string MostrarAyuda(bool value1, bool value2)
    {
        var s = $"Valores: value1: {value1}, value2: {value2}";
        Console.WriteLine(s);
        return s;
    }
}

La conversión podría quedar de esta forma:

Public Shared Sub Main(args As String())
    '__ = MostrarAyuda(True, False)

    __ = MostrarAyuda(True, False)

    Console.WriteLine(__)

    Console.WriteLine()
    Console.WriteLine("Pulsa una tecla para finalizar.")
    Console.ReadKey()
End Sub

Private Shared Property __ As Object

Private Shared Function MostrarAyuda(value1 As Boolean, value2 As Boolean) As String
    Dim s = $"Valores: value1: {value1}, value2: {value2}"
    Console.WriteLine(s)
    Return s
End Function

Es un apaño, pero puede valer para equiparar los dos lenguajes.

Nota:
Fíjate que en VB al ser una propiedad válida la podemos usar como cualquier otra variable para mostrar el contenido.

Y esto es todo… a ver si lo implementa y así no dará error cuando se convierta código de C# que tenga ese tipo de asignación (que la implementaron en C# 7.0)

Nos vemos.
Guillermo

Érase una vez hace… cuando la Expo 92

Pues eso… hoy Alejandro Herrero me ha mandado unas fotos de cuando yo estaba en la radio (en calle Carabeo), fotos que hice / nos hicimos para algo así como una presentación de los trabajadores de la radio que mi amigo Freddy llevaba (a su manera). No te voy a hablar de este amigo, porque si no, me enfadaré/entristeceré por lo mal que se portó conmigo y dejando de darme lo que me correspondía de mi sueldo y otros préstamos, así que… mejor no pensar qué podría hacer con esos más de sesenta mil euros del año dos mil y pocos… en fin…

Lo que te decía, y razón por la que he puesto esta foto (no para hacerte saber del bisho malo ese de Alfredito), si no porque al ver la foto y ver el ordenador, seguramente un Amstrad PC de 512 KB de memoria y con dos disqueteras de 5 1/4, eso sí, doble cara doble densidad ;-), y si no era un Amstrad sería uno clónico, pero creo que los clónicos que empecé a vender cuando tenía la tienda de IBM, (por esas fechas ya la tenía a punto de cerrar), eran con disqueteras de 3,5 de 720 KB o de 1.44 MB con disco duro y en colores). Para que supieras que he trabajo con casi toda clase de ordenadores… y se trabajba casi igual que ahora con nosecuantos gigas en el disco y en la memoria… eso sí, el Windows 1.0 cabía en 2 discos de 5 y cuarto… ¡qué tiempos!

Aquí está la foto:

Nos vemos.
Guillermo

Probando con el tema Theme Freesia Extension

Pues eso… que haciendo pruebas con el WordPress me he topado en el tema Extension de Theme Freesia, y me ha gustado… la foto de la chica queda bien (¡mola!) y le da un aspecto más profesional, aunque no tengo ni idea de quién puede ser… viene con el tema y la he dejado… 😉

¡Pues ya está!

Sólo quería comentarte porqué está esa foto ahí 😀

Aunque se ve que solamente se muestra al entrar en el enlace del inicio del sitio, pero bueno… ¡es lo que hay! que si no, se iba a poner muy vista… 😉

 

Pues ya lo he quitado, que al bajarse la parte superior, el Google Kit siempre metía un anuncio y es un rollo… en fin…

 

Y como lo he quitado, te dejo una captura de cómo era.

captura del tema Theme Fressia Extension
Captura del tema Theme Fressia Extension

 

Nos vemos.
Guillermo

gsNotasNETF – Utilidad para tomar notas hecha con C# y un control de usuario

 

Nota del 10-dic-2020 01:04 GMT+1:
La utilidad ha cambiado, para ver los cambios, te recomiendo que o bien los veas en GitHub o en la página de gsNotasNETF.

 

Nota:
Esta es la entrada de esta utilidad, también existe una página con (casi) el mismo nombre para que aparezca en el menú de Utilidades NET>Utilidades con .NET Framework
Pulsa aquí para ir a la página gsNotasNETF.

 

Esta utilidad sirve para escribir y guardar notas, agrupadas en grupos (o si lo prefieres, etiquetas).
Cada grupo contendrá un número de notas (por ahora no hay un máximo de notas por grupo, pero si veo que el rendimiento es malo, tendré que limitarlo).
Tampoco hay límite de grupos a crear, pero como dije antes, comprobaré el rendimiento y veré si es necesario hacer alguna limitación de número de grupos.

Esta utilidad está definida por un formulario que simplemente sierve de contenedor del control de usuario NotasUC que a su vez utiliza el control de usuario CabeceraNotasUC que es el que se encarga de mantener, guardar y leer la colección con los grupos y notas.
El aspecto del control (en tiempo de diseño es el mostrado en la figura 1):

Figura 1. El control NotasUC en tiempo de diseño. Arriba está el control CabeceraNotaUC.
Figura 1. El control NotasUC en tiempo de diseño. Arriba está el control CabeceraNotaUC.

 

Figura 2. La aplicación de prueba, arriba las notas del grupo seleccionado, abajo el control NotasUC con las notas.
Figura 2. La aplicación de prueba, arriba las notas del grupo seleccionado, abajo el control NotasUC con las notas.

 

El formato que utiliza el fichero con las notas es lo que yo he llamado formato NotasUC que tiene el siguiente formato:

#Formato NotasUC - v1.0.0.0 - 05-dic-2020
#
# Fichero de Notas con formato NotasUC
#
# Contenido de gsNotasNETF.notasUC.txt
#
# Formato:
#    G:Nombre del grupo 1
#       Lista de notas del grupo 1, una en cada línea
#       GFin: Fin de las notas del grupo 1
#    G:Nombre del grupo 2
#       Lista de notas del grupo 2, una en cada línea
#       GFin: Fin de las notas del grupo 2
#
# Notas:
#     No se guardan los grupos o notas que estén en blanco.
#     Si la nota tiene estos caracteres, se hará un cambio al guardar el texto:
#         Las comillas dobles se guardan como |quot|.
#         El signo mayor > se guarda como |gt|.
#         El signo mayor < se guarda como |lt|.
#         El ampersand & se guarda como |A|.
#         Si la cadena empieza con un espacio, se sustituye por |sp|.
#         Los cambios de línea  '\n\r' (CrLf) se guardan como |NL|.
#         Los cambios de línea  '\n'   (Cr)   se guardan como |CR|.
#         Los retornos de carro '\r'   (Lf)   se guardan como |LF|.
#             La comprobación se hace en este orden: CrLf, Cr, Lf
#             Es para los casos que haya distintos cambios de línea (según el formato del fichero)
#

En GitHub he puesto el código fuente de esta utilidad que se puede usar como biblioteca dinámica para acceder a los dos controles definidos, aunque usando solo NotasUC es suficiente, ya que ahí se hace prácticamente todo el trabajo.

El código fuente en GitHug de gsNotasNETF.

 

Nos vemos.
Guillermo

Un reloj para Windows escrito en C# por un VBer que quiere evolucionar (#evolveVB #evolucionarVB)

Pues eso… Este es un programa muy simple, bueno no tanto, lo que hace principalmente es mostrarte la fecha y la hora, actualizándose para que muestre los segundos, ¡es un reloj! ¡Pero aparte de la hora te muestro también la fecha hombre! 🙂

Nota del 4-dic-2020:
Ya está publicado el código de Visual Basic del Reloj Windows.
convertido del código de C# usando la utilidad CSharpToVB de paul1956.
Aquí tienes el enlace a Form1.vb en github.

 

Nota:
Esto no está repetido.
Es que lo he creado primero como página y ahora como entrada.
La página, a la que cambiaré el nombre, es para enlazarla en los proyectos de github, etc.

 

 

Versión en inglés / English version
En documentos de Google / In Google’s Documents.

 

En el código que después te pondré, puedes ver qué es y cómo se puede utilizar como una especie de salvapantalla. Otra de las cosas que le he añadido es que puedas acoplar la pantalla tanto a la izquierda como a la derecha, pero en la parte superior. Cuando se acopla se puede hacer al tamaño que tiene la pantalla actualmente o bien hacerlo a un tamaño mucho más pequeño, todo eso es configurable por medio del menú de opciones. También puede que te interese en el código es que puedes mover la pantalla pulsando sobre la fecha o sobre la hora, además de, por supuesto, pulsando en la barra de título como en cualquier aplicación. Y, aunque no tiene mucho misterio, el que a la ventana se pueda cambiar el nivel de opacidad o transparencia.
Te voy a pegar el texto que tengo en el menú de ayuda, acerca de, y así no me tengo que acordar de las cosas que le he ido añadiendo a esta aplicación.

 

El contenido de Acerca de:

Esta aplicación es un ‘simple’ reloj que te muestra la fecha y la hora en una ventana.

Te permite controlar dónde verla, si a tamaño normal, a tamaño pequeño, incluso puedes cambiar el tamaño a tu gusto.

Puedes hacer que esté encima del resto de ventanas.

Además puedes hacerla menos opaca (más transparente) para que pueda verse lo que hay debajo de la ventana.

El nivel de transparencia lo puedes controlar a tu gusto, desde casi totalmente transparente a totalmente opaca.

Puedes usarla también como una especie de salvapantallas (se va desplazando por la pantalla), pero con transparencia con idea de que veas lo que hay debajo sin tener que detener la aplicación.

Si quieres dejar de ver cómo se mueve por la pantalla, simplemente haz doble-clic en la fecha o en la hora.

El salvapantallas lo puedes usar a tamaño normal o en tamaño pequeño.

Cuando funciona como salvapantalla siempre está encima del resto de las ventanas y no muestra la barra de título.

La ventana la puedes mover desde la barra de título o bien manteniendo el ratón pulsado en la fecha o en la hora.

También puedes acoplarla en la parte superior izquierda o derecha, en esos casos, se cambia a tamaño mínimo y se hace transparente.

Y esto es casi todo… creo… en el menú de opciones (en el botón que hay abajo a la derecha) están todas las opciones de uso disponibles.

¡Disfrútala! 🙂

Capturas de la aplicación en funcionamiento

Aquí te muestro un par de capturas de la aplicación en modo normal y acoplada (que se muestra con transparencia).

Figura 1. Las opciones y cambiar la opacidad.

 

Figura 2. Acoplada en la parte superior izquierda (con transparencia)

 

Figura 3. Lista de las opciones del programa

 

El código no te lo voy a mostrar aquí, ya que son 680 líneas y no es plan… pero si podrás verlo en Github (ahora te pongo el enlace).

Este código por ahora está solo para C#, pero intentaré convertirlo para Visual Basic; cuando esté te avisaré o mejor aún, pásate por repositorio de Github y así podrás ver el código completo, de los dos lenguajes (recuerda que ahora mismo solo está el de C#).

Este es el repositorio de github: elGuille-info/Reloj-Windows: Reloj Windows es una aplicación que muestra la fecha y hora y se puede usar casi como un salvapantalla. Permite acoplarlo a la parte superior derecha o izquierda. (github.com)

El Documentos de Google pega el enlace con la descripción y todo… ¡mola! (cool!)

Este ha sido el segundo intento de usar la herramienta Dictado por voz, pero nada, a pesar de que en las sugerencias te dice que puedes decir punto y nueva línea, por ahora, de los signos de puntuación solo me ha reconocido el punto… en fin.

Y esto es todo… espero que te guste o al menos te sea de utilidad alguna parte del código.

Nos vemos.
Guillermo

P.S.
Sigo probando con C# y con Documentos de Google para ver si de una vez acaba entendiendo lo que digo 😉 (con el reconocimiento de voz o dictado por voz).

#evolveVB #evolucionarVB