Android desde cero

Anímate a realizar con el Android Studio tu primera aplicaión móvil

Abre el eclipse y escribe el mas simple "Hola Mundo!"con Spring MVC

Sigue 8 simples pasos para obtener al proyecto mas simple de Spring MVC con Eclipse y Maven.

Como subr una app al Google Play

Te mostramos en tres post, como subir una app en Android al Google Play

Mostrando entradas con la etiqueta GitHub. Mostrar todas las entradas
Mostrando entradas con la etiqueta GitHub. Mostrar todas las entradas

domingo, 10 de julio de 2016

CodeLabs de Google y Pruebas sobre proyectos de GitHub

Desde hace poco menos de un mes, estoy llevando una bitacora de las pruebas que realizo sobre algunos proyectos de GitHub que me interesa probar.

Se puede acceder a esa bitácora a una GitHub Page asociada a mi perfil de GitHub:


Además de proyectos de GitHub, hay registrados algunas experiencias con los CodeLabs de Google.

Los proyectos que estoy probando, y que están en la bitácora, giran alrededor de alguna de las siguientes temáticas:
  • Programación en Android o iOS
  • Proyectos vinculados al Ajedrez, como uso del motor Stockfish
  • Proyectos para aprender sobre las tecnologías Android, ejemplo:
    • Android Pay 
    • VR: Realidad Virtual
    • Tecnologia NDK y JNI dentro de Android
Y lo que vaya surgiendo y pueda resultar novedoso o interesante.

A su vez, la página fue armada con Jekyll, una plataforma muy cómoda para escribir blogs


https://pabloezequiel.github.io/

sábado, 2 de abril de 2016

Android, Heroku y Node.js para consumir webservices

Vamos a seguir un ejercicio que nos mostrará como consumir webservices REST.

Para seguir este ejercicio, vamos a ir desde atrás hacia adelante. O sea, desde el backend hacia el front end.

Comencemos:

¿Que webservice vamos a consumir?

En el curso que estoy haciendo nos publicaron la siguiente URL para hacer los ejercicios:

http://www.webkathon.com/pruebasit/products.php
http://www.webkathon.com/pruebasit/products.php?id=1

Que respeta el estándar de una API REST, y nos retorna tres productos.

En mi caso estoy haciendo el ejercicio adaptado con una juguetería, y así, antes de comenzar, creo que es válido plantearse las siguientes dos preguntas.

¿Podría tener mi propia API REST en vez de utilizar la API del curso?
¿Donde podría hostearla?





Para empezar, vamos a utilizar y probar una plataforma que nos recomendaron:


Con esta plataforma, según entiendo, se pueden hacer "mock" o backend de los servicios para poder concentrarse tan solo en el front.

En este punto, queda abierta una segunda pregunta: Si quisiéramos tener un backend propio, y a su vez con datos más reales... ¿Que plataforma deberíamos elegir.. ? ¿Podríamos hacerlo, por ejemplo, con la plataforma de Google Drive? O sea, exponiendo como json algunos datos de la hoja de cálculo. Según tengo entendido esto sería viable... y tendría un interesante nivel de escalamiento....

Quizá en una segunda parte del post, desarrollemos esta pregunta.

Paso 01: Probando Heroku - Crear cuenta

Vamos a crear una cuenta en https://www.heroku.com/ y lo primero que observamos es que nos solicita que definamos un lenguaje.... aunque programo en Java, voy a elegir Node.js así también aprovecho a "matar dos pájaros de un tiro" y aprender algo acerca de Node.js
Tenemos el siguiente escritorio:
Como dije al principio, la idea es desarrollar el backend con node.js (que entiendo que es algo así como javascript del lado del server, aunque no se mucho mas que eso...).

Mirando un Tutorial de "Getting Started" con heroku y node.js parece que necesitamos tener instalado el node.js en nuestro sisitema... Con lo cual, interrumpimos este post para instalarnos el node.js de https://nodejs.org/en/




Paso 02: Instalando node.js en la PC

Aparentemente... para poder empezar con heroku, tenemos que tener instalado node.js en nuestras PC, así que, hacia ahí vamos:
Voy a bajar la versión 4.4.2 de node.js, para ser un poco conservador... no quiero tener demasiadas sorpresas.


Finalizamos la instalación. ¿Como puedo saber si está bien instalado? Abro la terminal, y ejecuto el comando npm y lo encuentra.

Ok, además tengo que seguir instalando una Toolbar de Heroku:
Y luego:
Y probamos en la terminal:
  • npm que verifica que node.js esta instalado
  • heroku login, que pide las credenciales de nuestra cuenta
  • heroku local, lo cual baja la versión heroku de GitHub
 Ok.... y siguiendo los pasos del manual de inicio de Heroku:

https://devcenter.heroku.com/articles/getting-started-with-nodejs#prepare-the-app

Ejecutamos en la terminal los siguientes comandos que nos bajarán una aplicación de ejemplo de Heroku.

$ git clone https://github.com/heroku/node-js-getting-started.git
$ cd node-js-getting-started

Seguimos con los pasos del Tutorial ..... creamos la aplicación de ejemplo:

$ heroku create
Creating app... done, stack is cedar-14
https://infinite-lowlands-19433.herokuapp.com/ | https://git.heroku.com/infinite-lowlands-19433.git

Ejecutamos:

$ heroku ps:scale web=1
$ heroku open

Y vemos la aplicación tipo "Hola Mundo" levantada en la URL que heroku nos asignó:

Ejecutamos también

 $ heroku logs --tail

Para verificar que 

Va contra nuestra instancia local de heroku.



Observemos en la siguiente pantalla que también está la termial:


Donde Procfile contiene:

web: node index.js

Veamos los dynos (containerss) que están detras de nuestra app: 
Es uno solo.... para escalar a varios dynos tenemos que hacer un upgrade de la cuenta/plan gratuito que nos da heroku...

Se puede ejecutar la app localmente
Como se ve a continuación en el puerto 5000
Ejecutamos algunos comandos mas, asociado a promover cambios locales en repositorios remotos ...

npm install --save --save-exact cool-ascii-faces
... etc...
 heroku open cool

Y tenemos el nuevo directorio "cool" tanto en la app local como remota:

http://localhost:5000/cool


Un poco mas... para ver addons y otros servicios de terceros que podríamos incorporar:

heroku addons:create papertrail
Igualmente para los addons necesitamos ingresar la tarjeta de crédito... en este punto finalizamos el seguimiento del tutorial:





Como cosas positivas: después de varios pasos
Instalamos y configuramos localmente
  • Node.js
  • Heroku
  • Heroku nos dio un espacio gratuito para hostear una aplicación en internet.
  • Podemos versionar con Git
Como cosas negativas... aún no hemos podido hacer nuestro backend de productos...
Aunque tengo una idea de como se podría editar el proyecto

Paso 03: Publicar un servicio JSON de Productos

Con el ejercicio anterior, tenemos al menos, las aplicaciones:

http://localhost:5000/cool
https://infinite-lowlands-19433.herokuapp.com/cool


Vamos con un par de preguntas sencillas:

¿Podemos agregarle un par de servicios JSON?

Si, sería tan sencillo como agregar:
   
app.get('/helloJson', function (req, res) {              
  req.requestTime = Date.now();                          
  var responseText = 'Hello World! + Hola Mundo! Now:' +  req.requestTime + '';                                   
  // res.send(responseText);                             
  res.json({ user: 'tobi', msg : responseText });        
});   


Mi Resumen

Agrego un resumen de los nuevos recursos instalados y publicados, con utilidad, al menos para mi:
Heroku, ejemplo "Getting Started" en la PC:
  • /Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
Local:
   
$ cd /Users/pabloin/Desktop/_tmpAndroid/_heroku/node-js-getting-started
$ heroku local web
# 
# Abrir
#  --> http://localhost:5000/cool
#  --> http://localhost:5000/helloJson
#
$ npm install
$ heroku local
#
$ git add .
$ git commit -m "Demo"
$ git push heroku master
#
# Abre el Remoto en Internet
$ heroku open cool

Ampliando el contenido:


Los siguientes links me parecieron interesantes para ampliar el ejercicio:

http://webapplog.com/intro-to-express-js-simple-rest-api-app-with-monk-and-mongodb/
https://codeforgeek.com/2014/06/express-nodejs-tutorial/

Sobre Express, el framework que está por encima de Node.js comparto los links con la documentación oficial:

  • http://expressjs.com/es/starter/basic-routing.html
  • http://expressjs.com/es/4x/api.html#res.json

Con es finalizamos el ejemplo de como crear un entorno de backend con Heroku y Node.js que queda listo para ser consumido desde cualquier front, por ejemplo una aplicación Android como la que estamos armando en los post anteriores (Aplicación de Juguetería)

En un próximo post integraremos el Front Android de la Juguetería con el backend de Heroku y Node.js



viernes, 1 de abril de 2016

Android - Ejercicio Curso 2: Juguetería en Tablet

En el post anterior, realizamos el ejercicio del una juguetería en Celular.  Funcionando de la siguiente manera

En la primera pantalla seleccionamos "Metegol" y muestra el detalle de un metegol.
En la segunda pantalla seleccionamos "Monopatín" y muestra el detalle de un monopatín.

Repasamos los contenidos:
  • Fragments
  • ListView
  • Pantallas Master - Detail
Podemos descargar de GitHub el Tag v1.0.3 que representa esta versión:

https://github.com/PabloEzequiel/Android/releases/tag/v.1.0.3

En este post, vamos a extender el ejercicio para que se vea también correctamente en Tablets.





Paso 4: Objetivo: Soportar resoluciones de pantallas mas grandes (Tablet)

En este paso 4, seguramente el último de este post, vamos a agregar la posibilidad de soportar distintas resoluciones de pantallas: Tablet y Celular

Para esto debemos:

a) Elegir algún mecanismo para determinar si nos encontramos en una tablet o no.
b) Crear un nuevo Layout específico para tablet
c) Podemos agregar imágenes también (de distintos tamaños)

Como los componentes están en el repositorio de GitHub, y vamos a crear un nuevo Tag para identificar al paso 4, simplemente vamos a comentar que agregamos:

Agregamos:
- un nuevo layout especifico para tablet. Lo llamaremos también main_activity.xml pero en una nueva carpeta, con la palabra mágica layout-sw600dp  que es una indicación al motor de android que si estamos en una pantalla mas grande a los 600p tomará esta versión de main_activity.xml

¿Que diferencias incluiríamos específicas para Tablet?

Básicamente dos: cambiaremos el título y el linear layout que contiene los Fragments serían horizontales.

Agregamos un nuevo Android Virtual Device (AVD) que sea de tipo tablet:


y volvemos a ejecutar la aplicación, seleccionando el AVD de la tablet y queda:
Observemos las diferencias entre los dos layout:

Celulares: layout/main_activity.xml

Tablet: layout-sw600dp/main_activity.xml
Compartimos la versión en GitHub para cubrir este paso extra:


Cerrando el ejercicio:

Después de estos 4 pasos, vamos hacer el merge de este branch y cerramos el ejercicio.










domingo, 27 de marzo de 2016

Android - Ejercicio Curso 2: Juguetería en Celular

Veamos a comentar un segundo ejercicio de programación con Android que hace uso de los Fragments

Al final del post, este ejercicio nro 2 se encontrará publicado en nuestro repositorio público de GitHub:

Aclaro nuevamente que no se trata del material del curso descargado y subido a GitHub, sino que estoy siguiendo el enunciado planteado en el ejercicio y haciendo el proyecto de cero con el Android Studio, para fijar los conocimientos.

Comencemos:

Ejercicio nro 2: Tener un listado de productos, y cuando seleccionas un producto, se abre un nuevo fragment con el detalle. En el caso que se detecte que estamos en una tablet, el detalle estará integrado en la misma pantalla del listado....

Además de los conceptos de Fragments, tendremos que utilizar Table List con sus Adapters ....

Para poder comentar la evolución del ejercicio, vamos a estar haciendo varios push sobre el branch de GitHub, relatando los pasos intermedios.





Evolución:

Paso 1: "Creamos dos Fragments"-  Commit & Push al Branch de GitHub

Comenzamos con el proyecto vacío y creamos dos Fragments:


Este estado intermedio los publicamos en GitHub bajo el blanch del ejercicio 02 de Android:
Y lo pueden ver reflejado en la historia del Branch por si les interesa partir de un estado intermedio de los fuentes. O sea, se realizó Commit & Push: "Paso 1: Creamos dos Fragments"


Paso 2: Objetivo: Crear una ListView 

En el Fragmento uno, mostraremos un listado de 15 productos. Como el espacio es reducido, tendremos que armar un Tabla ListView, con su Adapter.

- Crearemos una clase Java Producto (id, nombre, descripción, precio)
- Creamos un ProductoAdapter que extiende de BaseAdapter para  poder paginar sobre los productos
- Creamos una clase ProductoFactory que genera los 15 productos que vamos a utilizar

Para preparar el listado:
- En nuestro MainLayout, en su primer fragment .... que al momento solo tiene un TextView que dice "Hello Fragmento Listado", le vamos a agregar un componente interno ListView con id lista_productos destinado a "inflarse" por medio de java con  "adapter_listado_productos.xml" que a continuación crearemos

- Creamos un nuevo LinearLayout "adapter_listado_productos.xml" que representa cada iteración dentro de la lista de productos.  Y vamos a agregarles los TextView para mostrar los datos de los productos: solamente (id, nombre, precio) la descripción lo mostraremos en el fragment de detalle. 

Repasando los ciclos de vida del post anterior:
- Utilizaremos el método onStart() del fragment para inflar el ListView del fragment, ya que en ese momento están tanto la vista como el fragmento creado.

Como veremos a continuación en la siguiente captura, hemos logrado alcanzar estos objetivos, y tenemos en el fragmento 1 un scroll de los 15 productos de la juguetería


Paso 2: "Crear una List View"-  Commit & Push al Branch de GitHub

Vamos a mostrar que bajo el tag "Paso 2 crear una List View" subimos al branch de GitHub este nuevo estado intermedio del ejercicio, por si alguien esta interesado en seguir el ejemplo a partir de este punto.





Tenemos dos fragmentos, y en el primer fragmento un listado de 15 productos, de una juguetería. Y como superan las dimensiones de la pantalla, tuvo que implementarse con una ListView que permite el scrolling.

Para mayor comodidad a la hora de recuperar la versión, hemos asignado un Tag de GitHub al punto intermedio que estamos haciendo commit & push:

Creamos el Tag v1.0.2



Que lo pueden recuperar de:

El contenido de los fuentes es el siguiente, donde el ejercicio 02 está en el punto descripto aquí:

Paso 3: Objetivo: Crear la sección de detalle

El objetivo de este paso, es que cuando hagamos click en cualquiera de los objetos del listado de productos de la Juguetería, en el segundo Fragment vemos la información de detalle.






Para lo cual, deberemos hacer los siguientes pasos:
a. Tomar el evento onClick sobre los ítem de la lista
b. Tener la posibilidad de referencia al MainActivity que tiene visibilidad a todos los Fragments.
c. Diseñar en el segundo Fragment una pantalla de detalle apropiada, para que además de los valores: id, nombre y precio, se muestre también la descripción del producto que forma parte de los datos.

¿Como hacemos para capturar el evento de click sobre un Item de la ListView? Utilizamos el método OnItemClickListener

¿Como hacemos para desde un Fragment poder llegar a modificar los datos del otro Fragment? Utilizamos una interface propia, llamada Callback para definir los métodos que queremos implementar para llegar al otro fragmento.

Estas cosas se pueden revisar en la clase frgmt_listado el código que vamos a subir a GitHub para esta etapa del ejercicio.

Y el punto de contacto, es que el context del Fragment es el Activity.

  • En el Fragment: al context (es MainActivity) se lo castea a un Callback
  • En el MainActivity: se lo hace extender de la interfaz Callback
Y de esta forma, en ambas clases, se tiene seguridad que el método de onProductoSelected estará disponible. Además, recordar que:

Activity: extends from Context


Paso 3: "Crear la sección de detalle" Commit & Push a GitHub

Hemos logrado enlazar el detalle al listado, compartimos una pantalla y el código fuente en GitHub con el tag v1.0.3 de este "Ejercicio 2"



Subimos a GitHub

 Y dentro de GitHub hacemos el Tag 03 por si alguien le interesa recuperar el ejercicio desde este punto intermedio:


Paso 03: Aplicación Juguetería funcionando.

Vamos a cerrar el post con esta versión de la aplicación juguetería funcionando compartiendo un par de pantallas de su funcionamiento:


En la primera pantalla seleccionamos "Metegol" y muestra el detalle de un metegol.
En la segunda pantalla seleccionamos "Monopatín" y muestra el detalle de un monopatín.

Los contenidos que repasamos en este post, son:
  • Fragments
  • ListView
  • Pantallas Master - Detail
En el próximo post, reutilizando los fragments y el código, ampliaremos el ejemplo para la versión tablet.

























sábado, 26 de marzo de 2016

Android - Ejercicios Cursos Android

Vamos a volcar al blog algunos ejercicios  de un curso de Android que estoy siguiendo.

Quiero aclarar, que no se trata del material perteneciente al curso (descargado de la página del curso, subido a GitHub y comentado en el blog)... sino son los ejercicios que voy escribiendo de nuevo el ejercicio para fijar los conceptos que estoy aprendiendo.

El material de Android que vaya generando lo voy a compartir en GitHub



Ciclos de Vida en Android:

Los ciclos de vida de los Activities y los Fragments en android son los siguientes:







Comencemos:

Ejercicio 01: Hacer algunas pruebas con Fragments y compartiendo datos entre distintos fragments

Explicación de los pasos principales:
  1. Creamos dos XML de fragmentos, con sus clases Java que extienden de Fragments 
    • Cada Fragment tiene un TextView
  2. En el activity creamos un LinearLayout y agregamos los dos fragmentos
  3. Agregamos variables privadas dentro del Main Activity para referenciar a los dos Fragments
  4. En cada fragment agregamos un método "onSelected" que cambia el texto
  5. Implementamos el método onClickListener (asociado al callback onActivityCreated) para "escuchar" cuando se hace "click" en el fragmento.
    • Como el Fragment a su vez tiene una referencia a la View que lo contiene, cuando se hace click en el fragment se invoca a los método clickOnFirstFragment() y clickOnSecondFragment() del la View contenedora...
  6. Como la view (Main Activty) contenedora tiene visibilidad a los dos fragments, los métodos clickOnFirstFragment() y clickOnSecondFragment() simplemente cambian los textos de cada fragment

El ejercicio lo pueden descargar de GitHub en:
https://github.com/PabloEzequiel/Android/tree/master/Ejercicio01



Veamos el resultado:




Por ahora cerramos el post con el primer ejercicio realizado

















domingo, 20 de septiembre de 2015

Proyecto myApiRest en GitHub con Eclipse

Vamos a subir un proyecto simple a GitHub con una API Rest muy básica, que tenga un interceptor y Spring MVC

Utilizamos
La versión inicial del myApiRest.war para los que quieran seguir el post, se encuentra en la siguiente dirección de dropbox:


La evolución del myApiRest.war la realizaremos en GitHub

Comencemos:

Tomamos el war de myApiRest.war y lo importamos en el eclipse, como un nuevo proyecto maven:


Además ejecutamos, run > maven install que nos trae las dependencias y complica el proyecto.






Observemos el pom.xml que contiene el plugin de Tomcat, con lo cual, vamos a ejecutar el war y realizar algunas invocaciones:


  org.apache.tomcat.maven
  tomcat7-maven-plugin
  2.2



Para probar el proyecto, agregamos una nueva configuración al eclipse, equivalente a:

mvm tomcat7:run



Lo cual nos permitirá consumir algunas URL del WAR, después de ejecutar el tomcat7:run que configuramos






Podemos hacer lo mismo para utilizar Jetty en vez del Tomcat.


  org.eclipse.jetty
  jetty-maven-plugin
  9.3.7.v20160115

  
    10
    
      /myApiRest
    
    
      8080
    
  



Ok, con jetty levantado, también podemos invocar  a las url anteriores.

En esta primera versión, tenemos el ejemplo funcionando, con spring MVC, un interceptor, y además está swagger incorporado al proyecto.

Probando el WAR

Invocamos a uno de los controladores de spring

http://localhost:8080/myApiRest/javaBookManager/

Observamos en el log, que el controlador responde, además que el interceptor también lo captura.

El error que muestra es recién en la respuesta, porque intentamos retornar una respuesta JSON y nos falta incluir a jackson al proyecto



Las dependencias a agregar al pom.xml son las siguientes:
    
        com.fasterxml.jackson.core
        jackson-core
        2.2.3
    
    
        com.fasterxml.jackson.core
        jackson-databind
        2.2.3
    
    
        com.fasterxml.jackson.core
        jackson-annotations
        2.2.3
    

Y vemos el resultado, donde se recupera el JSON, a su vez, en el log podemos ver al interceptor trabajando:




Clases Java - Controller y @ResponseBody

Si bien el ejercicio completo está en GitHub en:


Vamos a mencionar un par de componentes Java: Observemos el  @ResponseBody para convertir las respuestas a JSON

   

package com.javaen.web;

import java.util.Collection;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

import com.javaen.business.BookManagerService;
import com.javaen.domain.JavaBook;


/**
 * @author [Pablo Ezequiel]
 *
 * REST API Book Manager
 * 
 *  - getAll
 *  - {id}
 *  - update (string, book)
 *  - add() 
 * 
 *   http://localhost:8080/myApiRest/javaBookManager/
 *   http://localhost:8080/myApiRest/javaBookManager/001
 *
 *   http://localhost:8080/myApiRest/swagger-ui/index.html
 */

@Controller
@RequestMapping("/javaBookManager")
public class BookManagerController {
 
 static final Logger LOG = LoggerFactory.getLogger(BookManagerController.class);

 @Autowired BookManagerService bookManagerService;
 
 @RequestMapping(value="/{id}",method=RequestMethod.GET)
 public  @ResponseBody JavaBook get(@PathVariable String id) {
  
  LOG.debug("BookManagerController::get("+id+")");
  
  JavaBook book = bookManagerService.get(id);
  
  LOG.debug("Book("+id+"): " + book);
  
  return book;
 }
 

 @RequestMapping(method=RequestMethod.GET)
 public  @ResponseBody  Collection select() {
  LOG.debug("BookManagerController::getAll()");
  
  Collection books =  bookManagerService.getAll();
  
  LOG.debug("BookManagerController select(): " + books);
  
  return books;
 }

 @RequestMapping(value="/{id}",method=RequestMethod.PUT)
 @ResponseStatus(HttpStatus.NO_CONTENT)
 public void update(@PathVariable String id, @RequestBody JavaBook book) {
  
  LOG.debug("BookManagerController::update("+id+","+book+")");
  
  book.setId(id);
  bookManagerService.update(id, book);
 }

 
 @RequestMapping(method=RequestMethod.POST)
 @ResponseStatus(HttpStatus.CREATED)
 public void add(@RequestBody JavaBook book, HttpServletResponse response) {
  
  LOG.debug("BookManagerController::add("+book+")");
  
  bookManagerService.add(book);
 } 
 
}



Con esto damos finalizado el ejercicio de un proyecto con Spring MVC para una hacer una API REST

Se deja el siguiente TAG en GitHub para el que le interese recuperar el estado de esta versión:

https://github.com/PabloEzequiel/Java/releases/tag/v1.0.1


En un próximo post, el objetivo será que swagger levante la info de la API Rest para documentarla.


Un poco de Feedback


  • ¿Pudieron hacer funcionar el ejemplo?



miércoles, 16 de septiembre de 2015

GitHub con GitHub Desktop

GitHub Desktop es una aplicación oficial de GitHub. La podemos descargar de https://desktop.github.com/

¿Cuál es la motivación para utilizar el Cliente Desktop de GitHub cuando el Android Studio y otros IDE tienen incluido su integración con GitHub?

Seguramente esto que voy a comentar se solucione de una forma muy sencilla, la cual aún no conozco, y es lo que me llevó a instalar y utilizar la versión de GitHub Desktop. En mi repositorio de GitHub me gustaría subir varios proyectos de distintas tecnologías que estoy explorando... Android, Java, iOS, etc. Y me gustaría que los distintos ejercicios no estén en la raíz de GitHub sino dentro de sus carpetas "Android", "Java", "iOS"... etc. Lamento si suena obvio para muchos, pero no encontré la forma desde distintos IDE´s "pegarle" adentro del árbol que arma git, en vez de solamente la raiz... Estoy seguro que la solución es muy obvia, pero aún no la encontré, asi que por esta razón recurro a la versión Desktop de GitHub, que seguramente también tendrá muchos otros beneficios que gracias a este problema, vamos a poder aprender.

Sigamos:

Veamos como la configuramos con nuestra cuenta de GitHub:

Después de descargar la aplicación:
 Cargamos los datos de la cuenta:



 Y en este caso, como no elegimos ninguno de nuestros repositorios locales aparece vacío:
Ahora, creamos con GitHub Desktop un nuevo repositorio para poner a los proyectos de Android que queremos compartir en GitHub:


Inicialmente esa carpeta está vacía, por lo cual, desde el Android Studio crearemos un nuevo proyecto que esté alojado en esa carpeta:






Luego, creamos un nuevo proyecto de Android con todo "Default" excepto que elegimos en "Proyject Location" el nuevo repositorio que creamos para compartir con GitHub: 

Observamos que ese directorio no está vacío:



Y, lo mejor, y lo que estábamos esperando lograr, que el GitHub 


Y a continuación procedemos a realizar el commit, o el publish:





Y de esta manera nos queda claro que podemos seguir sumando proyectos dentro de "Android" y que no quedarán en la Raiz

El repositorio de GitHub es:

https://github.com/PabloEzequiel/Android

Hasta la próxima