Trabajo de unidad V

Google play licensing, LVL, Firmar una apk

[12/10/17]
Unidad V
Luis Fernando Gallegos González.
13550370
Plataforma II
Contenido
INTRODUCCION ............................................................................................................................................... 4
GOOGLE PLAY LICENSING................................................................................................................................. 5
QUE ES.................................................................................................................................................................. 5
SON SEGURAS ......................................................................................................................................................... 6
REQUERIMIENTOS Y LIMITACIONES .............................................................................................................................. 6
CONFIGURANDO EL LICENCIAMIENTO........................................................................................................................... 7
CONFIGURAR EL ENTORNO DE TIEMPO DE EJECUCIÓN...................................................................................................... 7
Corriendo en un dispositivo ............................................................................................................................ 7
Corriendo en un emulador de Android ........................................................................................................... 8
ACTUALIZANDO SU CONFIGURACIÓN DE PROYECTO ........................................................................................................ 9
LVL ................................................................................................................................................................. 10
QUE ES................................................................................................................................................................ 10
CONFIGURACIÓN DE LA BIBLIOTECA DE VERIFICACIÓN DE LICENCIAS ................................................................................. 11
MOVER LAS FUENTES DE LA BIBLIOTECA A UNA NUEVA UBICACIÓN ................................................................................... 11
TRABAJANDO CON PROYECTOS DE BIBLIOTECA ............................................................................................................. 11
CONFIGURACIÓN DEL ENTORNO DE PRUEBA ................................................................................................................ 12
CONFIGURANDO CUENTAS DE PRUEBA ....................................................................................................................... 13
REGISTRO DE CUENTAS DE PRUEBA EN LA CUENTA DEL EDITOR ........................................................................................ 14
DISTRIBUIR SU CLAVE PÚBLICA PARA PROBAR USUARIOS DE LA CUENTA............................................................................. 14
INICIAR SESIÓN EN UNA CUENTA DE GOOGLE EN UN EMULADOR...................................................................................... 14
AGREGAR LICENCIAS A SU APLICACIÓN ....................................................................................................................... 15
VERIFICACION DE LICENCIA. ..................................................................................................................................... 16
FIRMAR TÚ APLICACIÓN ................................................................................................................................ 18
CERTIFICADOS Y KEYSTORES ..................................................................................................................................... 18
Keystore ....................................................................................................................................................... 18
FIRMAR TU COMPILACIÓN DE DEPURACIÓN ................................................................................................................. 18
FECHA DE VENCIMIENTO DEL CERTIFICADO DE DEPURACIÓN ........................................................................................... 18
ADMINISTRAR TU CLAVE ......................................................................................................................................... 19
USAR LA FIRMA DE APLICACIONES DE GOOGLE PLAY ..................................................................................................... 19
FIRMAR UN APK ................................................................................................................................................... 19
GENERAR UNA CLAVE Y UN KEYSTORE ........................................................................................................................ 20
FIRMAR CADA CLASE DE PRODUCTO DE MANERA DIFERENTE ........................................................................................... 21
CONSIDERACIONES RESPECTO DE LAS FIRMAS .............................................................................................................. 23
PROTEGER TU CLAVE .............................................................................................................................................. 24
QUITAR INFORMACIÓN SOBRE FIRMAS DE TUS ARCHIVOS DE COMPILACIÓN ....................................................................... 25
DISTRIBUIR UNA APK A TRAVÉS DE GOOGLE PLAY ......................................................................................... 27
SUBE UNA APP ...................................................................................................................................................... 27
ADMINISTRA LOS ARCHIVOS APK.............................................................................................................................. 27
TAMAÑOS DE LOS ARCHIVOS APK............................................................................................................................. 27
FIRMA TU APP....................................................................................................................................................... 28
CONFIGURA TU FICHA DE PLAY STORE ....................................................................................................................... 28
Detalles del producto ................................................................................................................................... 28
Idiomas y traducciones ................................................................................................................................ 29
Imágenes y videos localizados ..................................................................................................................... 29
Traducciones automáticas ........................................................................................................................... 29
Categorización ............................................................................................................................................. 29
DISTRIBUIR UNA APP EN AMAZON ................................................................................................................ 30
DIRECTRICES DE POLÍTICA DE CONTENIDO ................................................................................................................... 30
REVISIÓN DE ALTO NIVEL DE REQUISITOS PREVIOS AL ENVÍO............................................................................................ 31
AÑADIR IMÁGENES ................................................................................................................................................ 32
CRITERIOS DE PRUEBA ............................................................................................................................................ 32
Política de contenido .................................................................................................................................... 32
Cualificaciones generales ............................................................................................................................. 32
PRESENTE SU APLICACIÓN Y COMPRUEBE EL ESTADO ..................................................................................................... 34
CONCLUSIÓN ................................................................................................................................................. 35
BIBLIOGRAFÍA ................................................................................................................................................ 36
Introduccion
El presente documento trata acerca de como subir una aplicación al mercado de aplicaciones de
android, y al principio podria parecer un proceso corto, pero es un proceso largo pero nada complejo
y con ello podremos tener nuestra aplicación en la tienda de google play.

Tambien viene un poco de informacion acerca de como subir una aplicación para la tienda de amazon
que es mas o menos lo mismo que Android.
Google Play licensing
Google Play ofrece un servicio de licencia que le permite aplicar políticas de licencia para las
aplicaciones que publica en Google Play. Con Google Play Licensing, su aplicación puede consultar
Google Play en tiempo de ejecución para obtener el estado de la licencia para el usuario actual, luego
permitir o no permitir el uso posterior según corresponda.

El servicio de licencias es un medio seguro para controlar el acceso a sus aplicaciones. Cuando una
aplicación verifica el estado de la licencia, el servidor de Google Play firma la respuesta de estado de
la licencia utilizando un par de claves asociado de forma única con la aplicación. Su aplicación
almacena la clave pública en su archivo compilado .apk y lo utiliza para verificar la respuesta del
estado de la licencia.

Cualquier aplicación que publique a través de Google Play puede usar el servicio de Licencias de
Google Play. No se necesita ninguna cuenta especial o registro. Además, como el servicio no utiliza
API de marco dedicadas, puede agregar licencias a cualquier aplicación que use un nivel mínimo de
API de 3 o superior.

Que es

Google Play Licensing es un servicio basado en red que permite a una aplicación consultar un servidor
de licencias de Google Play confiable para determinar si la aplicación tiene licencia para el usuario
actual del dispositivo. El servicio de licencias se basa en la capacidad del servidor de licencias de
Google Play para determinar si un usuario dado tiene licencia para usar una aplicación determinada.
Google Play considera que un usuario tiene licencia si el usuario es un comprador registrado de la
aplicación.

La solicitud comienza cuando su aplicación realiza una solicitud a un servicio alojado en la aplicación
cliente de Google Play. La aplicación Google Play luego envía una solicitud al servidor de licencias y
recibe el resultado. La aplicación Google Play envía el resultado a su aplicación, que puede permitir o
no permitir el uso posterior de la aplicación según sea necesario.

Para identificar correctamente al usuario y determinar el estado de la licencia, el servidor de licencias

requiere información sobre la aplicación y el usuario; su aplicación y el cliente de Google Play trabajan
juntos para reunir la información y el cliente de Google Play la pasa al servidor.

Para ayudarlo a agregar licencias a su aplicación, Android SDK proporciona un conjunto descargable
de fuentes de la biblioteca que puede incluir en su proyecto de aplicación: el paquete de licencias de
Google Market. La Biblioteca de verificación de licencias (LVL) es una biblioteca que puede agregar a
su aplicación que maneja toda la comunicación relacionada con las licencias con el servicio de
licencias de Google Play. Con el LVL agregado a su aplicación, su aplicación puede determinar el
estado de su licencia para el usuario actual simplemente llamando a un método e implementando
una devolución de llamada que recibe la respuesta de estado.

Son seguras

Para garantizar la integridad de cada consulta de licencia, el servidor firma los datos de respuesta de
licencia utilizando un par de claves RSA que se comparte exclusivamente entre usted y el servidor de
Google Play.

El servicio de licencias genera un único par de claves de licencia para cada aplicación y expone la clave
pública en la página de Servicios y API de su aplicación en Play Console. Debe copiar la clave pública
de Play Console e incrustarla en el código fuente de la aplicación. El servidor conserva la clave privada
internamente y la usa para firmar respuestas de licencia para las aplicaciones que publica con esa
cuenta.

Cuando su aplicación recibe una respuesta firmada, utiliza la clave pública incorporada para verificar
los datos. El uso de la criptografía de clave pública en el servicio de licencias hace posible que la
aplicación detecte respuestas manipuladas o falsificadas.

Requerimientos y limitaciones

Google Play Licensing está diseñado para permitirle aplicar controles de licencia a las aplicaciones que
publica a través de Google Play. El servicio no está diseñado para permitirle controlar el acceso a
aplicaciones que no se publican a través de Google Play o que se ejecutan en dispositivos que no
ofrecen el cliente de Google Play.

A continuación, le presentamos algunos puntos que debe tener en cuenta al implementar licencias en
su aplicación:

Una aplicación puede usar el servicio solo si el cliente de Google Play está instalado en su dispositivo
host y el dispositivo ejecuta Android 1.5 (API de nivel 3) o superior.

Para completar una verificación de licencia, el servidor de licencias debe ser accesible a través de la
red. Puede implementar comportamientos de almacenamiento en caché de licencias para administrar
el acceso a su aplicación cuando no hay conectividad de red.

La seguridad de los controles de licencia de su aplicación depende en última instancia del diseño de
su implementación. El servicio proporciona los bloques de construcción que le permiten verificar de
forma segura las licencias, pero la aplicación y el manejo reales de la licencia son factores que
depende de usted. Al seguir las mejores prácticas en los siguientes documentos, puede ayudar a
garantizar que su implementación sea segura.
Agregar licencias a una aplicación no afecta la forma en que funciona la aplicación cuando se ejecuta
en un dispositivo que no ofrece Google Play.

Puede implementar controles de licencia para una aplicación gratuita, pero solo si está utilizando el
servicio para proporcionar archivos de expansión APK

Configurando el licenciamiento

Si todavía no tiene una cuenta de editor para Google Play, debe registrarse para obtener una con su
cuenta de Google y aceptar los términos de servicio de Google Play.

Si ya tiene una cuenta de editor en Google Play, use su Play Console para configurar las licencias.

Con Google Play Console, puedes:

Obtener una clave pública específica de la aplicación para la licencia

Depurar y probar la implementación de licencia de una aplicación, antes de publicar la aplicación

Publique las aplicaciones a las que ha agregado soporte de licencia

Configurar el entorno de tiempo de ejecución

Como se describió anteriormente, las aplicaciones verifican el estado de la licencia no al contactar al

servidor de licencias directamente, sino al enlazar a un servicio provisto por la aplicación Google Play
e iniciar una solicitud de verificación de licencia. El servicio Google Play luego maneja la comunicación
directa con el servidor de licencias y finalmente envía la respuesta a su aplicación. Para depurar y
probar licencias en su aplicación, necesita configurar un entorno de tiempo de ejecución que incluya
el servicio necesario de Google Play, para que su aplicación pueda enviar solicitudes de verificación de
licencia al servidor de licencias.

Hay dos tipos de entorno de tiempo de ejecución que puede usar:

Un dispositivo con Android que incluye la aplicación Google Play, o un emulador de Android que
ejecuta el complemento API de Google, API nivel 8 (versión 2) o superior

Corriendo en un dispositivo

Para usar un dispositivo con Android para depurar y probar licencias, el dispositivo debe:

Ejecutar una versión compatible de Android 1.5 o posterior (API nivel 3 o superior) plataforma, y

Ejecute una imagen del sistema en la que esté preinstalada la aplicación cliente de Google Play.

Si Google Play no está preinstalado en la imagen del sistema, su aplicación no podrá comunicarse con
el servidor de licencias de Google Play.
Corriendo en un emulador de Android

Si no tiene un dispositivo disponible, puede usar un emulador de Android para depurar y probar las
licencias.

Debido a que las plataformas Android proporcionadas en el SDK de Android no incluyen Google Play,
debe descargar la plataforma de complementos API de Google, API nivel 8 (o superior), desde el
repositorio del SDK. Después de descargar el complemento, debe crear una configuración AVD que
use esa imagen del sistema.

El complemento API de Google no incluye el cliente completo de Google Play. Sin embargo,
proporciona:

Un servicio en segundo plano de Google Play que implementa la interfaz remota ILicensingService,
para que su aplicación pueda enviar comprobaciones de licencia a través de la red al servidor de
licencias.

Un conjunto de servicios de cuentas subyacentes que le permiten agregar una cuenta de Google en el
AVD e iniciar sesión usando su cuenta de editor o las credenciales de la cuenta de prueba.

Iniciar sesión con su editor o cuenta de prueba le permite depurar y probar su aplicación sin tener
que publicarla. Para obtener más información, consulte Iniciar sesión en una cuenta autorizada a
continuación.

Varias versiones del complemento API de Google están disponibles a través del Administrador de SDK,
pero solo la versión para Android 2.2 y superior incluye los servicios necesarios de Google Play.

Para configurar un emulador para agregar licencias a una aplicación, siga estos pasos:

Inicie el Administrador de Android SDK, disponible en el menú Herramientas de Studio de Android

(Herramientas> Android> Administrador de SDK) o ejecutando <sdk> / tools / android sdk.

Seleccione y descargue las API de Google para la versión de Android que desea orientar (debe ser
Android 2.2 o superior).

Cuando finalice la descarga, abra el Administrador de AVD, disponible en el menú Herramientas de

Studio de Android (Herramientas> Android> Administrador AVD) o ejecutando <sdk> / tools / android
avd.

En la ventana Administrador de dispositivos virtuales de Android, seleccione + Crear dispositivo virtual

para configurar los detalles del nuevo AVD.

En la ventana Configuración del dispositivo virtual, seleccione hardware del dispositivo, luego
seleccione Siguiente.

Seleccione una API de Google como la imagen del sistema para ejecutar en el nuevo AVD, luego
seleccione Siguiente.
Asigne un nombre descriptivo al AVD y luego configure los demás detalles de configuración según sea
necesario.

Seleccione Finalizar para crear la nueva configuración de AVD, que aparecerá en la lista de
dispositivos virtuales Android disponibles.

Actualizando su configuración de proyecto

Después de configurar un entorno de tiempo de ejecución que cumpla con los requisitos descritos
anteriormente, ya sea en un dispositivo real o en un emulador, asegúrese de actualizar su proyecto de
aplicación o compilar scripts según sea necesario, para que los archivos .apk compilados que usan
licencias se implementen en ese ambiente. En particular, si está desarrollando en Android Studio,
asegúrese de configurar una configuración de ejecución / depuración que se dirija al dispositivo
apropiado o AVD.

No es necesario que realice ningún cambio en la configuración de compilación de su aplicación,

siempre que el proyecto ya esté configurado para compilar contra una biblioteca estándar de Android
1.5 (API de nivel 3) o superior. Agregar licencias a una aplicación no debería tener ningún impacto en
la configuración de compilación de la aplicación
LVL
Que es

La Biblioteca de verificación de licencias (LVL) es una colección de clases de ayuda que simplifica en
gran medida el trabajo que debe hacer para agregar licencias a su aplicación. En todos los casos, le
recomendamos que descargue el LVL y lo utilice como base para la implementación de la licencia en
su aplicación.

El LVL está disponible como un paquete descargable del SDK de Android. El paquete incluye:

 Las fuentes LVL, almacenadas dentro de un proyecto de biblioteca de Android.

 Una aplicación de ejemplo llamada "muestra" que depende del proyecto de la biblioteca
LVL. El ejemplo ilustra cómo una aplicación usa las clases auxiliares de biblioteca para verificar
y aplicar licencias.

Para descargar el paquete LVL en su entorno de desarrollo, use el Administrador de Android

SDK. Inicie el Administrador de Android SDK y luego seleccione el paquete de licencias de Google
Market , como se muestra en la figura 2. Acepte los términos y haga clic en Instalar seleccionados para
comenzar la descarga.

Figura 2. El paquete de licencias contiene LVL y la aplicación de ejemplo LVL.

Cuando se completa la descarga, el Administrador de Android SDK instala tanto el proyecto de la

biblioteca LVL como la aplicación de ejemplo en estos directorios:

< sdk >/extras/google/market_licensing/library/ (el proyecto de la biblioteca LVL)

< sdk >/extras/google/market_licensing/sample/ (la aplicación de ejemplo)
Configuración de la biblioteca de verificación de licencias

Después de descargar el LVL a su computadora, debe configurarlo en su entorno de desarrollo, ya sea

como un proyecto de biblioteca Android o copiando (o importando) las fuentes de la biblioteca
directamente en su paquete de aplicación existente. En general, se recomienda utilizar LVL como
proyecto de biblioteca, ya que le permite reutilizar su código de licencia en múltiples aplicaciones y
mantenerlo más fácilmente con el tiempo. Tenga en cuenta que el LVL no está diseñado para
compilarse por separado y agregarse a una aplicación como un archivo .jar estático.

Mover las fuentes de la biblioteca a una nueva ubicación

Como va a personalizar las fuentes de LVL hasta cierto punto, debe asegurarse de mover o copiar las
fuentes de la biblioteca (todo el directorio en <sdk >/market_licensing/library/ ) a un directorio de
trabajo fuera del SDK. Luego debe usar las fuentes reubicadas como su conjunto de trabajo. Si está
utilizando un sistema de administración de código fuente, agregue y realice un seguimiento de las
fuentes que están en la ubicación de trabajo en lugar de aquellas en la ubicación predeterminada en el
SDK.

Mover las fuentes de la biblioteca es importante porque cuando más tarde actualiza el paquete de
licencias, el SDK instala los archivos nuevos en la misma ubicación que los archivos anteriores. Trasladar
los archivos de la biblioteca en funcionamiento a un lugar seguro garantiza que su trabajo no se
sobrescribirá inadvertidamente en caso de que descargue una nueva versión del LVL.

Creando el LVL como un proyecto de biblioteca

Trabajando con proyectos de biblioteca

El LVL se proporciona como un proyecto de biblioteca de Android, lo que significa que puede compartir
su código y recursos en múltiples aplicaciones. .

El LVL se proporciona como un proyecto de biblioteca configurado: una vez que lo haya descargado,
puede comenzar a usarlo de inmediato.

Si está trabajando en Android Studio, debe agregar el LVL a su proyecto como un nuevo módulo.

1. Use el Asistente de Nuevo Módulo para importar un módulo de biblioteca

seleccionando Archivo> Nuevo> Importar módulo .

2. En la ventana Nuevo módulo , en el directorio de origen , ingrese el directorio de library del LVL
(el directorio que contiene el archivo AndroidManifest.xml de la biblioteca) como raíz del
proyecto ( <sdk>/extras/google/play_licensing/library/AndroidManifest.xml ), luego
seleccione Siguiente

3. Seleccione Finalizar para importar el módulo de la biblioteca.

4. Copiando las fuentes LVL a su aplicación

Configuración del entorno de prueba

Google Play Console proporciona herramientas de configuración que le permiten a usted y a otros
probar licencias en su aplicación antes de que se publique.

Los principales componentes del entorno de prueba para la licencia incluyen:

 Una configuración de "Respuesta de prueba" en su cuenta de editor que le permite configurar

la respuesta de licencia estática devuelta, cuando el servidor procesa una verificación de
licencia para una aplicación cargada en la cuenta del editor, desde un usuario que haya iniciado
sesión en la cuenta del editor o en una cuenta de prueba.

 Un conjunto opcional de cuentas de prueba que recibirán la respuesta de prueba estática

cuando verifiquen la licencia de una aplicación que ha cargado (independientemente de si la
aplicación está publicada o no).

 Un entorno de tiempo de ejecución para la aplicación que incluye la aplicación Google Play o
el complemento de API de Google, en el que el usuario inicia sesión en la cuenta del editor o
en una de las cuentas de prueba.

La configuración adecuada del entorno de prueba implica:

1. Establecer respuestas de prueba estáticas devueltas por el servidor de licencias.

2. Configurando cuentas de prueba según sea necesario.

3. Inicio de sesión correctamente en un emulador o dispositivo, antes de iniciar una prueba de

verificación de licencia.

Las siguientes secciones proporcionan más información.

Establecer respuestas de prueba para verificaciones de licencia

Google Play proporciona una configuración en su cuenta de editor que le permite anular el
procesamiento normal de una verificación de licencia y devolver un código de respuesta estático
específico. La configuración es solo para pruebas y solo se aplica a las comprobaciones de licencias para
las aplicaciones que ha cargado, realizadas por cualquier usuario que haya iniciado sesión en un
emulador o dispositivo utilizando las credenciales de la cuenta del editor o una cuenta de prueba
registrada. Para otros usuarios, el servidor siempre procesa las verificaciones de licencia de acuerdo
con las reglas normales.

Para establecer una respuesta de prueba para su cuenta, inicie sesión en su cuenta de editor y haga clic
en "Editar perfil". En la página Editar perfil, ubique el menú Respuesta de prueba en el panel Licencias,
que se muestra a continuación. Puede seleccionar entre el conjunto completo de códigos de respuesta
del servidor válidos para controlar la respuesta o condición que desea probar en su aplicación.

En general, debe asegurarse de probar la implementación de licencia de su aplicación con cada código
de respuesta disponible en el menú Respuesta a prueba. Para obtener una descripción de los códigos,
consulte Códigos de respuesta del servidor en la Referencia de licencias .
Figura 4. El panel Prueba de licencia de la página de detalles de su cuenta le permite configurar cuentas
de prueba y administrar respuestas de prueba.

Configurando cuentas de prueba

Las cuentas de prueba son cuentas de Google estándar que usted registra en su cuenta de editor, de
modo que recibirán la respuesta de prueba para las aplicaciones que ha subido. Los desarrolladores
pueden iniciar sesión en sus dispositivos o emuladores utilizando las credenciales de la cuenta de
prueba e iniciar las comprobaciones de la licencia desde las aplicaciones instaladas. Cuando el servidor
de licencias recibe una verificación de licencia de un usuario de una cuenta de prueba, devuelve la
respuesta de prueba estática configurada para la cuenta del editor.

La siguiente tabla resume las diferencias de capacidades entre la cuenta del editor, una cuenta de
prueba y cualquier otra cuenta.

Tabla 1. Diferencias en los tipos de cuenta para probar licencias.

Tipo de cuenta Puede verificar la licencia antes de Puede recibir respuesta de prueba? Puede establecer la respuesta de prueba?
subirla?

Cuenta de editor Sí Sí Sí

Cuenta de prueba No Sí No

Otro No No No
Registro de cuentas de prueba en la cuenta del editor

Puede usar cualquier cuenta de Google como cuenta de prueba. Si desea poseer y controlar las cuentas
de prueba, puede crear las cuentas usted mismo y distribuir las credenciales a sus desarrolladores o
probadores.

Manejo de la carga y distribución de aplicaciones para usuarios de cuentas de prueba

Una vez que una aplicación se carga y se conoce por el servidor de licencias, los desarrolladores y
probadores pueden continuar modificando la aplicación en su entorno de desarrollo local, sin tener
que cargar nuevas versiones. Solo necesita cargar una nueva versión si la aplicación local incrementa el
atributo versionCode en el archivo de manifiesto.

Distribuir su clave pública para probar usuarios de la cuenta

El servidor de licencias maneja las respuestas de prueba estáticas de la manera normal, incluida la firma
de los datos de respuesta de la licencia, la adición de parámetros adicionales, etc. Para ayudar a los
desarrolladores que están implementando licencias usando cuentas de prueba en lugar de la cuenta
del editor, deberá distribuir la clave pública de la aplicación para que se les otorgue la licencia. Los
desarrolladores que no tienen acceso a Play Console no tienen acceso a la clave pública de la aplicación
y, sin ella, no podrán verificar las respuestas de la licencia.

Durante las pruebas, para asegurarse de que su aplicación pueda consultar con éxito el servidor de
licencias, debe asegurarse de iniciar sesión en una cuenta en el dispositivo o emulador utilizando:

 Las credenciales de una cuenta de editor, o

 Las credenciales de una cuenta de prueba que está registrada con una cuenta de editor

Iniciar sesión en una cuenta de Google en un emulador

Si está probando licencias en un emulador, debe iniciar sesión en una cuenta de Google en el
emulador. Si no ve una opción para crear una nueva cuenta de Google, el problema podría ser que su
AVD está ejecutando una imagen de sistema estándar de Android, en lugar de la API de Google Add-
On, API 8 (versión 2) o superior.

Iniciar sesión con una cuenta de editor ofrece la ventaja de permitir que sus aplicaciones reciban
respuestas de prueba estáticas incluso antes de que las aplicaciones se carguen en Play Console.

Para iniciar sesión en un dispositivo o emulador, siga los pasos a continuación. El enfoque preferido es
iniciar sesión como cuenta principal; sin embargo, si ya hay otras cuentas en uso en el dispositivo o
emulador, puede crear una cuenta adicional e iniciar sesión con las credenciales del editor o de la
cuenta de prueba.

1. Abre Configuración> Cuentas y sincronización

2. Seleccione Agregar cuenta y elija agregar una cuenta de Google.

3. Seleccione Siguiente y luego Iniciar sesión .

 4. Ingrese el nombre de usuario y la contraseña de la cuenta del editor o de la cuenta de prueba
registrada en la cuenta del editor.

5. Seleccione Iniciar sesión . El sistema inicia sesión en la nueva cuenta.

Agregar licencias a su aplicación

Agregar el permiso de licencia

Para usar la aplicación Google Play para enviar una verificación de licencia al servidor, su aplicación
debe solicitar el permiso correspondiente, com.android.vending.CHECK_LICENSE . Si su aplicación no
declara el permiso de licencia sino que intenta iniciar una verificación de licencia, el LVL arroja una
excepción de seguridad.

Para solicitar el permiso de licencia en su aplicación, declare un elemento <uses-permission> como

hijo de <manifest> , de la siguiente manera:

<uses-permission android:name="com.android.vending.CHECK_LICENSE" />

Implementando una política

ServerManagedPolicy

La política es una interfaz declarada por el LVL que está diseñada para mantener la lógica de su
aplicación para permitir o no permitir el acceso de los usuarios, en función del resultado de una
verificación de licencia. Para usar el LVL, su aplicación debe proporcionar una implementación de
la Policy .

La interfaz de Policy declara dos métodos, allowAccess() y processServerResponse() , que son

invocados por una instancia de LicenseChecker al procesar una respuesta del servidor de
licencias.También declara una enumeración llamada LicenseResponse , que especifica el valor de
respuesta de la licencia pasado en llamadas a processServerResponse() .

Implementando un Obfuscator

El LVL incluye una implementación completa de Obfuscator en el

archivo AESObfuscator.java . El Obfuscatorutiliza cifrado AES para ofuscar / desenfocar datos. Si está
utilizando una Policy (como ServerManagedPolicy) que almacena en caché los datos de respuesta de
licencia, se recomienda encarecidamente usar AESObfuscator como base para su implementación
de Obfuscator .

Una implementación de Policy típica necesita guardar los datos de respuesta de licencia para una
aplicación en una tienda persistente, de modo que esté accesible a través de invocaciones de
aplicaciones y ciclos de encendido del dispositivo. Por ejemplo, una Policy mantendría la marca de
tiempo de la última verificación de licencia exitosa, el recuento de reintentos, el período de validez de
la licencia e información similar en una tienda persistente, en lugar de restablecer los valores cada vez
que se inicia la aplicación. La Policy predeterminada incluida en el LVL, ServerManagedPolicy,
almacena datos de respuesta de licencia en una instancia de SharedPreferences , para garantizar que
los datos sean persistentes.

Debido a que la Policy utilizará los datos de respuesta de licencia almacenados para determinar si se
permite o no el acceso a la aplicación, se debe asegurar de que los datos almacenados sean seguros y
no puedan ser reutilizados o manipulados por un usuario raíz en un dispositivo. Específicamente,
la Policy siempre debe ofuscar los datos antes de almacenarlos, utilizando una clave que sea única
para la aplicación y el dispositivo. La ofuscación mediante el uso de una clave que sea específica de la
aplicación y específica del dispositivo es crítica, ya que evita que los datos ofuscados se compartan
entre aplicaciones y dispositivos

Verificacion de licencia.

Figura 6. Descripción general de una interacción de verificación de licencia típica.

El diagrama de arriba ilustra cómo se lleva a cabo una verificación de licencia típica:

1. El código en la Actividad principal de la aplicación LicenseCheckerCallback instancias de los

objetos LicenseCheckerCallback y LicenseChecker .Al construir LicenseChecker , el código
pasa en Context , una implementación de Policy a usar y la clave pública de la cuenta del
editor para la licencia como parámetros.

2. El código llama al método checkAccess() en el objeto LicenseChecker . La implementación del

método llama a la Policy para determinar si hay una respuesta de licencia válida en caché
localmente, en SharedPreferences .

o Si es así, las llamadas a la implementación de checkAccess() allow() .

o De lo contrario, LicenseChecker inicia una solicitud de verificación de licencia que se

envía al servidor de licencias.

Nota: El servidor de licencias siempre devuelve LICENSED cuando realiza una verificación de licencia
de un borrador de aplicación.
 3. Cuando se recibe una respuesta, LicenseChecker crea un LicenseValidator que verifica los
datos de la licencia firmada y extrae los campos de la respuesta, luego los pasa a
su Policy para su posterior evaluación.

o Si la licencia es válida, la Policy almacena en caché la respuesta

en SharedPreferences y notifica al validador, que luego llama al método allow() en el
objeto LicenseCheckerCallback .

o Si la licencia no es válida, la Policy notifica al validador, que llama al

método dontAllow() en LicenseCheckerCallback .

4. En caso de un error local o de servidor recuperable, como cuando la red no está disponible
para enviar la solicitud, LicenseChecker pasa una
respuesta processServerResponse() método processServerResponse() su objeto
de processServerResponse() .

Además, los métodos de devolución de llamada allow() y dontAllow() reciben un argumento

de reason . El motivo del método allow() suele ser Policy.LICENSED o Policy.RETRY y
el dontAllow() suele ser Policy.NOT_LICENSED o Policy.RETRY . Estos valores de respuesta son útiles
para que pueda mostrar una respuesta adecuada para el usuario, como al proporcionar un botón
"Reintentar" cuando dontAllow() responde con Policy.RETRY , lo que podría haber sido porque el
servicio no estaba disponible.

5. En caso de error de la aplicación, como cuando la aplicación intenta verificar la licencia de un

nombre de paquete inválido, LicenseChecker pasa una respuesta de error al
método applicationError() LicenseCheckerCallback.
Firmar tú aplicación
Android exige que todos los APK se firmen digitalmente con un certificado para poder
instalarse. En este documento se describe la manera de firmar tus APK usando Android Studio,
incluidos los procesos de creación y almacenamiento de tu certificado, la firma de diferentes
configuraciones de compilación con distintos certificados y la configuración del proceso de
compilación para firmar tus APK automáticamente.

Certificados y keystores

Un certificado de clave pública, también conocido como certificado digital o un certificado de identidad,
contiene la clave pública de un par de claves públicas y privadas, y otros metadatos que identifican al
propietario de la clave (por ejemplo, el nombre y la ubicación). El propietario del certificado conserva la
clave privada correspondiente.

Keystore

Un keystore es un campo binario que contiene una o más claves privadas.

Todas las aplicaciones deben usar el mismo certificado durante su vida útil para que los usuarios puedan
instalar versiones nuevas como actualizaciones de las aplicaciones.

Firmar tu compilación de depuración

Cuando ejecutas o depuras tu proyecto desde el IDE, Android Studio automáticamente firma tu APK con un
certificado de depuración generado por las herramientas de Android SDK. La primera vez que ejecutas o
depuras tu proyecto en Android Studio, el IDE automáticamente crea el keystore y el certificado de
depuración en $HOME/.android/debug.keystore, y configura el keystore y las contraseñas de claves.

Debido a que el certificado de depuración se crea con las herramientas de compilación y no es seguro por
diseño, en la mayoría de las tiendas de aplicaciones (incluida Google Play Store) no se aceptará un APK
firmado con un certificado de depuración para la publicación.

Fecha de vencimiento del certificado de depuración

El certificado autofirmado que se usa para firmar tu APK en el modo de depuración tiene un plazo de
vencimiento de 365 días a partir de su fecha de creación. Cuando el certificado caduque, verás aparecer un
error de compilación.

Para solucionar este problema, simplemente borra el archivo debug.keystore. El archivo se almacena en las
siguientes ubicaciones:

 ~/.android/ en SO X y Linux;

 C:\Documents and Settings\<user>\.android\ en Windows XP;

 C:\Users\<user>\.android\ en Windows Vista y Windows 7, 8 y 10.

La próxima vez que compiles y ejecutes el tipo de compilación de depuración, las herramientas de
compilación generarán un keystore y una clave de depuración nuevos. Ten en cuenta que debes ejecutar tu
aplicación; la compilación por si sola no regenera el keystore ni la clave de depuración.

Administrar tu clave

Ya que tu clave de firma de aplicaciones se usa para verificar tu identidad como desarrollador, y garantizar
que las actualizaciones se realicen de forma seguras y sin inconvenientes para tus usuarios, es muy
importante administrar tu clave y mantenerla protegida, tanto para ti como para tus usuarios. Puedes optar
por usar la firma de aplicaciones de Google Play para administrar y guardar tu clave de firma de aplicaciones
de manera segura a través de la infraestructura de Google, o puedes administrar y proteger tu clave de firma
de aplicaciones y tu keystore propios.

Usar la firma de aplicaciones de Google Play

Cuando uses la firma de aplicaciones de Google Play, emplearás dos claves: la de firma de aplicaciones y
la de subida. Google se encarga de administrar y proteger la clave de firma de aplicaciones, y tú debes
guardar la clave de subida y usarla para firmar tus aplicaciones a fin de que puedan subirse a Google Play
Store.

Al aceptar usar la firma de aplicaciones de Google Play, exportarás y encriptarás tu clave de firma de
aplicaciones usando la herramienta Play Encrypt Private Key que provee Google Play, y luego la subirás a la
infraestructura de Google. Después de esto, crearás una clave de subida aparte y la registrarás con Google.
Cuando estés listo para la publicación, firmarás tu aplicación usando la clave de subida y la subirás a Google
Play. Luego, Google usará el certificado de subida para verificar tu identidad y volverá a firma tu APK con tu
clave de firma de aplicaciones para su distribución, como se muestra en la figura 1. (Si todavía no posees
una clave de firma de aplicaciones, puedes generar una durante el proceso de registro.)

Figura 1: Firma de una aplicación con el procedimiento de firma de aplicaciones de Google Play.

Firmar un APK

Independientemente de cómo elijas administrar tu clave y keystore, puedes usar Android Studio para firmar
tus APK (con la clave de subida o la clave de firma de aplicaciones), ya sea manualmente o configurando tu
proceso de compilación para que firme los APK de manera automática.

Si optas por administrar y proteger tu clave de firma de aplicaciones y tu keystore propios, firmarás tus APK
con tu clave de firma de aplicaciones. Si eliges la firma de aplicaciones de Google Play para administrar y
proteger tu clave de firma de aplicaciones y tu keystore, firmarás tus APK con tu clave de subida.
Generar una clave y un keystore

Puedes generar una clave de firma de aplicaciones o una clave de subida usando Android Studio siguiendo
estos pasos:

1. En la barra de menú, haz clic en Build > Generate Signed APK.

2. Selecciona un módulo del menú desplegable y haz clic en Next.

3. Haz clic en Create new para crear una nueva clave y keystore.
4. En la ventana New Key Store, proporciona la siguiente información para tu keystore y clave, como se
muestra en la figura 3.

Figura 3: Creación de un keystore nuevo en Android Studio.

Keystore
o Key store path: selecciona la ubicación en la que se debe crear tu keystore.

o Password: genera y confirma una contraseña segura para tu keystore.

Key
o Alias: ingresa un nombre de identificación para tu clave.
 o Password: genera y confirma una contraseña segura para tu clave. Esta debe ser diferente de la
contraseña que elegiste para tu keystore.

o Validity (years): fija el período de validez de tu clave en años. Tu clave debe ser válida durante al
menos 25 años. Por ello, puedes firmar actualizaciones para tu aplicación con la misma clave durante
toda su vida útil.

o Certificate: ingresa información sobre ti para tu certificado. Esta información no se muestra en tu

aplicación, pero se incluye en tu certificado como parte del APK.

Una vez que completes el formulario, haz clic en OK.

5. Continúa hacia Manually sign an APK si deseas generar un APK firmado con tu nueva clave, o haz clic
en Cancel si solo deseas generar una clave y un keystore, sin firmar un APK.

6. Si deseas usar la firma de aplicaciones de Google Play, dirígete a Manage your app signing keys y sigue
las instrucciones para configurar la firma de aplicaciones de Google Play.

Firmar cada clase de producto de manera diferente

Si en tu aplicación se usan las clases de productos y deseas firmar cada clase de manera diferente, puedes
crear configuraciones de firmas adicionales y asignarlas por clase:

1. En la ventana Project, haz clic con el botón secundario en tu aplicación y luego con el primario en Open
Module Settings.

2. En la ventana Project Structure, sección Modules del panel izquierdo, haz clic en el módulo que desees
firmar.

3. Haz clic en la pestaña Signing y luego en Add. .

4. Selecciona el archivo de tu keystore, ingresa un nombre para esta configuración de firma (ya que puedes
crear más de una) y la información requerida.
 Figura 8: Ventana para crear una configuración nueva de firma.

5. Repite los pasos 3 y 4 cuando sea necesario hasta crear todas tus configuraciones de firmas.

6. Haz clic en la pestaña Flavors.

7. Haz clic en la clase que desees configurar y luego selecciona la configuración correspondiente de firmas
en el menú desplegable Signing Config.

Figura 9: Configuración de ajustes de firmas según la clase de producto.

Repite el procedimiento para configurar cualquier clase de producto adicional.

8. Haz clic en OK.

También puedes especificar tus ajustes de firma en los archivos de configuración de Gradle. Para obtener
más información, consulta Configurar ajustes de firmas.

Consideraciones respecto de las firmas

Debes firmar todos tus APK con el mismo certificado durante toda la vida útil prevista de tus aplicaciones.
Existen varias razones por las cuales deberías hacer esto:

 Actualización de las aplicaciones: al instalar una actualización en una aplicación, el sistema compara el o
los certificados de la nueva versión con los de la versión existente. El sistema permite la actualización si
los certificados concuerdan. Si firmas la nueva versión con un certificado diferente, debes asignar un
nombre de paquete diferente a la aplicación. En este caso, el usuario instala la nueva versión como una
aplicación completamente nueva.

 Modularidad de las aplicaciones: Android permite que los APK firmados por el mismo certificado se
ejecuten en el mismo proceso, si las aplicaciones lo solicitan, para que el sistema las trate como una
 misma aplicación. De este modo puedes implementar tu aplicación en módulos, y los usuarios pueden
actualizar cada uno de estos de manera independiente.

 Compartir código o datos mediante permisos: Android ofrece ejecución de permisos basados en firmas,
para que una aplicación pueda exponer la funcionalidad ante otra aplicación firmada con un certificado
determinado. Al firmar varios APK con el mismo certificado y aplicar control de permisos basados en
firmas, tus aplicaciones pueden compartir código y datos de manera segura.

Si planeas admitir actualizaciones para una aplicación, asegúrate de que tu clave de firma de aplicaciones
tenga un período de validez que exceda la vida útil prevista de la aplicación. Se recomienda un período de
validez de 25 o más años. Cuando expire el período de validez de tu clave, los usuarios ya no podrán realizar
actualizaciones a versiones nuevas de tu aplicación de manera fluida.

Si planeas publicar tus aplicaciones en Google Play, la clave que uses para firmar los APK en cuestión debe
tener un período de validez que termine después del 22 de octubre de 2033. Google Play exige este requisito
para garantizar que los usuarios puedan actualizar aplicaciones sin inconvenientes cuando haya nuevas
versiones disponibles. Si usas la firma de aplicaciones de Google Play, Google confirma que tus aplicaciones
se firmen correctamente y puedan recibir actualizaciones durante su vida útil.

Proteger tu clave

Si eliges administrar y proteger tu clave de firma de aplicaciones y tu keystore por cuenta propia (en vez de
usar la firma de aplicaciones de Google Play), es imprescindible que protejas tu clave de firma de
aplicaciones, tanto para ti como para el usuario. Si permites que alguien use tu clave, o dejas tu keystore y
tus contraseñas en un lugar desprotegido como para que un tercero pueda encontrarlos y usarlos, tu
identidad de autoría y la confianza del usuario se verán comprometidas.

Nota: Si usas la firma de aplicaciones de Google Play, tu clave de firma de aplicaciones permanecerá
protegida a través de la infraestructura de Google. No obstante, también deberás proteger tu clave de
subida como se describe a continuación. Si tu clave de subida se ve comprometida, puedes contactar a
Google para que la revoque y recibas una clave de subida nueva.

Si un tercero lograra obtener tu clave sin tu conocimiento o permiso, podría firmar y distribuir aplicaciones
que reemplacen maliciosamente tus aplicaciones verdaderas, o alterarlas. También podría firmar y distribuir
con tu identidad aplicaciones que ataquen a otras aplicaciones o al propio sistema, o bien que dañen o
sustraigan información del usuario.

Tu clave privada se necesita para firmar versiones futuras de tu aplicación. Si pierdes tu clave o no la guardas
correctamente, no podrás publicar actualizaciones para tu aplicación. No puedes regenerar una clave ya
generada.

Tu reputación como entidad desarrolladora depende de que protejas correctamente tu clave de firma de
aplicaciones en todo momento, hasta que esta expire. A continuación, te proporcionamos algunas
sugerencias para mantener protegida tu clave:

 Escoge contraseñas fuertes para el keystore y la clave.

 No des ni prestes tu clave privada a nadie, y no dejes que personas no autorizadas conozcan tu keystore
y contraseñas de claves.

 Guarda el archivo de keystore que contiene tu clave privada en un lugar seguro y protegido.
En general, si tomas precauciones basadas en el sentido común al generar, usar y guardar tu clave, esta
estará protegida.

Quitar información sobre firmas de tus archivos de compilación

Cuando creas una configuración de firma, Android Studio agrega tu información de firma en el texto sin
formato a los archivos build.gradle del módulo. Si trabajas en equipo o con código abierto, debes retirar esta
información confidencial de los archivos de compilación de modo que otros no puedan acceder fácilmente
a ella. Para hacerlo, debes crear un archivo de propiedades por separado a fin de almacenar información
segura y hacer referencia a él en tus archivos de compilación de la siguiente manera:

1. Genera una configuración de firma y asígnala a uno o más tipos de compilación. En estas instrucciones
se da por sentado que tienes preparada una configuración de firma única para tu tipo de compilación de
lanzamiento, como se describe en Configurar el proceso de compilación para que firme
automáticamente tu APK, previamente.

2. Crea un archivo llamado keystore.properties en el directorio raíz de tu proyecto. Este archivo debe
contener tu información de firmas, con el siguiente aspecto:

storePassword=myStorePassword
keyPassword=mykeyPassword
keyAlias=myKeyAlias
storeFile=myStoreFileLocation

3. En el archivo build.gradle de tu módulo, agrega código para cargar tu archivo keystore.properties antes
del bloque android {}.

...

// Create a variable called keystorePropertiesFile, and initialize it to your

// keystore.properties file, in the rootProject folder.
def keystorePropertiesFile = rootProject.file("keystore.properties")

// Initialize a new Properties() object called keystoreProperties.

def keystoreProperties = new Properties()

// Load your keystore.properties file into the keystoreProperties object.

keystoreProperties.load(new FileInputStream(keystorePropertiesFile))

android {
...
}

Nota: Puedes optar por almacenar tu archivo keystore.properties en otra ubicación (por ejemplo, en la
carpeta del módulo en lugar de la carpeta raíz para el proyecto, o en tu servidor de compilación si usas
una herramienta de integración continua). En ese caso, debes modificar el código anterior para inicializar
de manera correcta keystorePropertiesFile usando la ubicación real de tu archivo keystore.properties.
4. Puedes hacer referencia a las propiedades almacenadas en keystoreProperties usando la
sintaxis keystoreProperties['propertyName']. Modifica el bloque signingConfigs del archivo build.gradle de
tu módulo para hacer referencia a la información de firma almacenada en keystoreProperties usando esta
sintaxis.

android {
signingConfigs {
config {
keyAlias keystoreProperties['keyAlias']
keyPassword keystoreProperties['keyPassword']
storeFile file(keystoreProperties['storeFile'])
storePassword keystoreProperties['storePassword']
}
}
...
}

5. Abre la ventana de herramientas Build Variants y asegúrate de que esté seleccionado el tipo de
compilación de lanzamiento.

6. Haz clic en Build > Build APK para crear tu compilación de lanzamiento y confirma que Android Studio
haya creado un APK firmado en el directorio build/outputs/apk/ para tu módulo.

Debido a que tus archivos de compilación ya no contendrán información confidencial, ahora podrás incluirlos
en el control de orígenes o cargarlos en una base de códigos compartida. Asegúrate de mantener protegido
el archivo keystore.properties. Esto puede incluir eliminarlo del sistema de control de orígenes.
Distribuir una apk a través de Google Play
Sube una app

1. Accede a tu cuenta de Play console.

2. Selecciona Todas las aplicaciones > Crea una aplicación.

3. En el menú desplegable, selecciona el idioma predeterminado y agrega un título para tu app.

Escribe el nombre de la app como quieres que aparezca en Google Play.

4. Crea la Ficha de Play Store de tu app, responde el cuestionario de clasificación del

contenido y configura el precio y la distribución.

Administra los archivos APK

Los nombres de los paquetes de los archivos de apps son únicos y permanentes, por lo que debes
elegirlos con cuidado. Los nombres de los paquetes no se podrán borrar ni volver a usar en el futuro.

Para ver los APK de tus apps, haz lo siguiente:

1. Accede a tu cuenta de Play Console.

2. Selecciona una app.

3. Selecciona Administración de lanzamientos > Biblioteca de artefactos. Verás una lista de los
APK activos, en borrador y archivados de tu app.

 En borrador: Incluye los archivos APK que todavía no están disponibles para los
usuarios.

 Activos: Incluye los archivos APK disponibles para los usuarios.

 Archivados: Incluye los archivos APK que estuvieron activos, pero ya no están
disponibles para los usuarios.

Tamaños de los archivos APK

Los archivos APK tienen un tamaño máximo, que varía en función de la versión de Android compatible
con tu APK. Si un único archivo APK no es compatible con todos los dispositivos, puedes subir varios
archivos APK con la misma ficha de la app, que admitan dispositivos con diferente configuración.

 100 MB: archivos APK diseñados para Android 2.3 o versiones posteriores (API nivel 9-10 y 14
o posterior).

 50 MB: archivos APK diseñados para Android 2.2 y versiones anteriores (API nivel 8 o anterior).
Sugerencia: Los usuarios deben ejecutar la versión 5.2 de Play Store o una posterior para instalar
archivos APK de 100 MB.

Firma tu app

Android requiere que todas las apps estén firmadas digitalmente con un certificado antes de que
puedan instalarse.

Requisitos de la versión del APK para Play Console

Cada archivo APK tiene un versionCode en el archivo de manifiesto que aumenta con cada
actualización de tu app.

Para subir tu app a Play Console, el valor máximo posible del versionCode es 200000000. Si
el versionCode de tu APK supera este valor, Play Console no te permitirá enviar un nuevo APK.

Cuando selecciones el versionCode para tu APK, ten en cuenta que deberás aumentar
el versionCode para cada actualización y, a la vez, mantenerlo por debajo del máximo.

Configura tu Ficha de Play Store

Detalles del producto

1. Accede a tu cuenta de Play Console.

2. Selecciona Todas las aplicaciones .

3. Selecciona una app y llena los campos en "Detalles de producto".

Límite de
Campo Descripción caracteres Notas

Título Es el nombre de tu app en Límite de 50 Puedes agregar un título

Google Play. caracteres localizado por idioma.

Descripción Es el primer texto que los Límite de 80 Los usuarios pueden

breve usuarios ven cuando visitan la caracteres ampliar este texto para ver
página de detalles de tu app la descripción completa de
en Play Store. tu app.

Descripción Es la descripción de tu app en Límite de

completa Google Play. 4000
caracteres
Idiomas y traducciones

Agrega y administra traducciones

Cuando subes una app, el idioma predeterminado es inglés (Estados Unidos, en-US). Puedes agregar
traducciones de la información de tu app, capturas de pantalla en el idioma y otros recursos gráficos.

1. Accede a tu cuenta de Play Console.

2. Selecciona Todas las aplicaciones .

3. Selecciona una app y revisa los idiomas que aparecen en "Detalles del producto".

4. Para agregar idiomas nuevos, selecciona Administrar traducciones > Comprar

traducciones o Agregar tu propio texto traducido.

Imágenes y videos localizados

Para comercializar tu app en diferentes idiomas con mayor eficacia, puedes agregar recursos gráficos a
la ficha de Play Store de la app.

Los usuarios verán los recursos gráficos localizados en Google Play si sus preferencias de idioma
coinciden con los idiomas que agregaste.

Traducciones automáticas

Si no agregas traducciones, los usuarios verán la ficha de Play Store de tu app en el idioma
predeterminado de la app o una traducción automática de Google Traductor.

Cuando se muestren traducciones automáticas, habrá una nota que explicará que la traducción se
realizó de forma automática, junto con una opción para ver el idioma predeterminado de la app. Ten
en cuenta que las traducciones automáticas no son compatibles con los siguientes idiomas: armenio,
retorromance, tagalo y zulú.

Categorización

Para seleccionar el tipo de app y la categoría, realiza lo siguiente:

1. Accede a tu cuenta de Play Console.

2. Selecciona Todas las aplicaciones .

3. Selecciona una app.

4. En "Categorización", selecciona un tipo de app y una categoría

5. Detalles de contacto

Si quieres agregar recursos de asistencia para los usuarios de Google Play, realiza lo siguiente:

1. Accede a tu cuenta de Play Console.

2. Selecciona Todas las aplicaciones .

 3. Selecciona una app.

4. En "Información de contacto", agrega tu información de contacto. Puedes ofrecer varios

canales de asistencia (sitio web, correo electrónico, teléfono), pero se requiere un correo
electrónico de contacto para publicar apps en Google Play.

Distribuir una app en Amazon

Directrices de política de contenido

Todas las aplicaciones enviadas a Amazon Appstore deben cumplir con las Pautas de contenido que
se describen en esta sección. Si Amazon determina que una aplicación contiene, facilita o promueve
contenido que está prohibido por estas pautas, Amazon rechazará el envío de la aplicación o
suspenderá la distribución de su aplicación y le notificará a la dirección de correo electrónico asociada
con su cuenta de desarrollador.

 Contenido Ofensivo : lo que consideramos ofensivo es probablemente lo que esperarías. Nos

reservamos el derecho de determinar la idoneidad de todas las aplicaciones y aceptar o rechazar
cualquier aplicación a nuestro criterio. También tenemos la discreción de publicar clasificaciones
de contenido para las aplicaciones.

 Pornografía : prohibimos las aplicaciones que contienen pornografía o que representan actos
sexuales gráficos o material sexualmente explícito. Esto incluye desnudez completa contenida en
su aplicación o materiales de marketing. Tampoco permitimos contenido que dirija el tráfico a
sitios pornográficos.

 Actividad ilegal : cada aplicación debe cumplir con todas las leyes aplicables. Prohibimos las
aplicaciones que promueven o pueden conducir a la producción de un artículo ilegal o actividad
ilegal. Los desarrolladores son responsables de investigar para garantizar que cada aplicación
cumpla con todas las leyes locales, estatales, nacionales e internacionales.

 Apostar con moneda real : prohibimos las aplicaciones que permiten a los clientes participar en
actividades de juegos de apuestas con moneda real (moneda con valor monetario real). Esto no
incluye las actividades simuladas de juegos de apuestas que usan moneda sin un valor monetario
real.

 Infracción de Propiedad Intelectual (IP) : las aplicaciones que infringen los derechos de propiedad
intelectual de un tercero no pueden distribuirse en nuestro Programa. Consulte las Preguntas
frecuentessobre publicación de Appstore para obtener más información sobre la propiedad
intelectual. Si su aplicación incluye desde un tercero, se le pedirá que envíe documentación que
indique que posee la licencia o permiso apropiado para usar esa IP en su aplicación.

 Infracción de privacidad / publicidad : tenemos la privacidad personal en el más alto respeto. Por
lo tanto, prohibimos las aplicaciones que infringen o pueden infringir la privacidad de una persona,
el derecho de publicidad o retratar a una persona bajo una luz falsa. Las imágenes de celebridades
y / o los nombres de celebridades no se pueden utilizar con fines comerciales sin el permiso de la
celebridad o su dirección. Esto incluye colecciones de imágenes de celebridades no autorizadas.
 Restricciones específicas de país : algunos países en los que vendemos nuestras aplicaciones
pueden tener estándares más restrictivos que otros países para lo que califica como "Contenido
ofensivo", "Pornografía" o "Actividad ilegal". Podemos restringir la venta de cualquier aplicación
o elemento IAP. en cualquier país donde la venta o distribución del contenido de esa aplicación
violaría las leyes, normas culturales o sensibilidades de ese país.

Revisión de alto nivel de requisitos previos al envío

La publicación en Amazon Appstore requiere lo siguiente:

 Cuenta de cliente de Amazon: si no tiene una cuenta de cliente de Amazon, cree una en
Amazon.com.

 Cuenta de desarrollador de Amazon: si no tiene una cuenta de desarrollador de Amazon, vaya al

Portal de desarrollador de aplicaciones y juegos de Amazon e inicie sesión con la misma dirección
de correo electrónico que su cuenta de cliente de Amazon. El portal lo guiará a través del proceso
de creación de cuenta.

 Una aplicación de Android que desee publicar en la tienda de aplicaciones de Amazon: cada
aplicación que envíe debe cumplir con la política de contenido de Amazon. Si Amazon determina
que una aplicación contiene, facilita o promueve contenido prohibido por estas pautas, Amazon
rechazará la presentación. Consulte los requisitos de la política de contenido de Amazon Appstore.

 Imagen de los activos para la promoción del producto. Debe proporcionar capturas de pantalla e
iconos grandes y pequeños para promocionar su aplicación en la Tienda Apps de Amazon.
Opcionalmente puede proporcionar una imagen promocional y videos. Consulte las Pautas de
activos de imágenes para la presentación de Appstore.

 Documentación de Propiedad Intelectual (IP) (si es necesario): si su aplicación utiliza propiedad

intelectual (IP) de un tercero, prepárese para presentar la documentación de que ha obtenido la
licencia o el permiso adecuados para usar esa IP en su aplicación
Añadir imágenes

Use la pestaña Imágenes y multimedia para enviar una colección de imágenes que Amazon utilizará
para representar su aplicación en su lista de Appstore y con fines promocionales. Cada activo de
imagen tiene especificaciones y pautas únicas detalladas en las secciones de documentación con
pestañas a continuación. Además, todas las imágenes deben cumplir con los Requisitos de la Política
de Contenido de Amazon Appstore, que incluye la obtención de cualquier derecho o licencia para los
medios con protección de propiedad intelectual.

Criterios de prueba

Política de contenido

Cada aplicación que nos envíe también debe cumplir con los requisitos de la política de contenido de
Amazon Appstore. Si Amazon determina que una aplicación contiene, facilita o promueve contenido
que está prohibido por estas pautas, Amazon rechazará el envío de la aplicación y le notificará
mediante la dirección de correo electrónico asociada a su cuenta de desarrollador.

Cualificaciones generales

En un nivel alto, su aplicación debe cumplir con los siguientes requisitos:

• Tener una experiencia de usuario simple y bien pensada que no cause confusión al usuario.

• Ser probado exhaustivamente y libre de errores, fallas y defectos obvios.

• Proporcionar una indicación visual de que la acción de un usuario ha tenido éxito o ha fallado.

• Falla correctamente si el usuario intenta acceder a la funcionalidad no compatible. Por ejemplo, la

aplicación podría mostrar un mensaje de error que dice "Esta función no está disponible actualmente".

• Utilice completamente el área de la pantalla de la tableta Fire o la pantalla Fire TV.

• Estar libre de defectos visuales, como imágenes faltantes / distorsionadas / pixeladas, elementos de
UI mal alineados o texto ilegible.

• Tener texto de interfaz de usuario libre de errores gramaticales o de ortografía

Localizacion de la instalacion

La configuración en su archivo de Manifiesto de Android determina dónde está instalada su aplicación

en los dispositivos Fire. Dos ubicaciones de almacenamiento son posibles:

Almacenamiento externo (como una tarjeta SD)

Almacenamiento interno (usando la memoria del dispositivo)Fire TV Stick no tiene almacenamiento

externo, pero Fire TV (Gen 1 y Gen 2, pero no Gen 3) proporciona opciones de almacenamiento
externo a través de una ranura para tarjeta de memoria.
En general, su aplicación debe especificar el almacenamiento externo como la ubicación de instalación
predeterminada.

Descripción general de publicación

La Consola de desarrollador proporciona varias pestañas por las que puede ingresar para ingresar
información sobre su aplicación:

Portal de envío de aplicaciones

El siguiente mapa de flujo de trabajo lo guía a través de este proceso:

PASO 1:

Inicie sesión y agregue una aplicación →

PASO 2:

Agregue información general →

PASO 3:

Agregar disponibilidad y precios →

PASO 4:

Añadir descripciones

PASO 5:

Agregar imágenes y multimedia →

PASO 6:

Agregar clasificación de contenido →

PASO 7:

Agregue archivos Binary o Webapp →

PASO 8:
Presente su aplicación y compruebe el estado

Después de completar toda la información requerida para una pestaña, el Portal del Desarrollador
muestra una marca de verificación verde. Ícono de marca verde para esa pestaña. No podrá enviar su
aplicación hasta que las seis pestañas muestren marcas verdes.
Conclusión
Como conclusión podemos obtener que firmar una aplicación es todo un proceso bastante largo de
realizar pero a su vez necesario ya que nosotros como clientes tenemos que tener productos de cierta
calidad y que cumplan ciertos lineamientos para así lograr que no cualquier aplicación subida este
disponible en una tienda ya sea la de google o la de Amazon y que se pierda calidad con ello y que solo
aquellas aplicaciones que tengan todos los requisitos realizados puedan pertenecer a estos mercados
de aplicaciones.
Bibliografía
Amazon. (Diciembre de 2017). Amazon developer. Obtenido de https://developer.amazon.com/app-
submission

Google. (Diciembre de 2017). Android Developers. Obtenido de

https://developer.android.com/studio/publish/app-signing.html

Google. (Diciembre de 2017). App Licensing. Obtenido de

https://developer.android.com/google/play/licensing/index.html

Shana. (Diciembre de 2017). Support Google. Obtenido de

https://support.google.com/googleplay/android-developer/answer/113469?hl=es-419