información al respecto. (https://google.com/racialequity?

hl=es-419)

Cómo con3gurar Android Studio

Android Studio proporciona asistentes y plantillas que veriBcan los requisitos de tu sistema,
como el Java Development Kit (JDK) y la memoria RAM disponible, y conBguran los ajustes
predeterminados, como una emulación optimizada predeterminada del dispositivo virtual de
Android (AVD) e imágenes del sistema actualizadas. En este documento, se describen
ajustes de conBguración adicionales que puedes usar para personalizar tu uso de
Android Studio.

Android Studio proporciona acceso a dos archivos de conBguración a través del menú Help:

studio.vmoptions (#customize_vm): Permite personalizar opciones para

Java Virtual Machine (JVM) de Studio, como el tamaño de montón y caché. Ten en
cuenta que, según tu versión de Android Studio, este archivo puede llevar el nombre
studio64.vmoptions en los equipos con Linux.

idea.properties (#customize_ide): Permite personalizar las funciones de

Android Studio, como la ruta de acceso de la carpeta de complementos o el tamaño
máximo de archivo admitido.

Para obtener documentación especíBca sobre la conBguración y el uso del emulador y el

dispositivo, consulta los siguientes temas:

Cómo administrar dispositivos virtuales

(https://developer.android.com/tools/devices?hl=es-419)

Cómo usar dispositivos de hardware (https://developer.android.com/tools/device?hl=es-419)

Controladores USB de OEM (https://developer.android.com/tools/extras/oem-usb?hl=es-419)

Cómo buscar tus archivos de con3guración

Los archivos de conBguración se almacenan en la carpeta de conBguración para

Android Studio. El nombre de la carpeta depende de tu versión de Studio. Por ejemplo, el
nombre de la carpeta para Android Studio 2.2 es AndroidStudio3.3. La ubicación de esta
:
 nombre de la carpeta para Android Studio 2.2 es AndroidStudio3.3. La ubicación de esta
carpeta depende de tu sistema operativo:

Windows: %USERPROFILE%\.CONFIGURATION_FOLDER

macOS: ~/Library/Preferences/CONFIGURATION_FOLDER

Linux: ~/.CONFIGURATION_FOLDER

También puedes usar las siguientes variables de entorno para señalar archivos de anulación
especíBcos en otro lugar:

STUDIO_VM_OPTIONS: Permite establecer el nombre y la ubicación del archivo

.vmoptions.

STUDIO_PROPERTIES: Permite establecer el nombre y la ubicación del archivo

.properties.

STUDIO_JDK: Permite establecer el JDK con el cual se ejecutará Studio.

Cómo personalizar las opciones de la VM

El archivo studio.vmoptions te permite personalizar las opciones para la JVM de

Android Studio. Para mejorar el rendimiento de Studio, la opción más común es ajustar el
tamaño máximo de montón. Sin embargo, también puedes usar el archivo
studio.vmoptions a Bn de anular otras conBguraciones predeterminadas, como los
cambios de tamaño inicial de montón, el tamaño de caché y la recolección de elementos no
utilizados de Java.

Para crear un archivo studio.vmoptions nuevo o abrir uno existente, realiza los siguientes
pasos:

1. Haz clic en Help > Edit Custom VM Options. Si nunca editaste las opciones de VM de
Android Studio, el IDE te solicitará crear un archivo studio.vmoptions nuevo. Haz clic
en Yes para hacerlo.

2. El archivo studio.vmoptions se abrirá en la ventana del editor de Android Studio.

Edítalo para agregar tus propias opciones personalizadas de VM. Para obtener una
lista completa de opciones de JVM personalizables, consulta la página de opciones
de VM de Java HotSpot
(http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html) de Oracle.
:
 El archivo studio.vmoptions que crees se agregará al archivo studio.vmoptions
predeterminado, ubicado en el directorio bin/ de tu carpeta de instalación de
Android Studio.

Ten en cuenta que nunca debes editar directamente el archivo studio.vmoptions situado
dentro de la carpeta de programa de Android Studio. Cuando puedas acceder al archivo
para ver las opciones predeterminadas de VM de Studio, editar solamente tu archivo
studio.vmoptions te garantizará que no anules conBguraciones predeterminadas
importantes para Android Studio. Por lo tanto, en tu archivo studio.vmoptions, anula
solamente los atributos que te importen y permite que Android Studio continúe usando los
valores predeterminados para cualquier atributo que no hayas cambiado.

Tamaño máximo del montón

De manera predeterminada, Android Studio tiene un tamaño máximo de montón de

1,280 MB. Si trabajas en un proyecto grande o tu sistema tiene mucha memoria RAM,
puedes mejorar el rendimiento aumentando el tamaño máximo de montón para los
procesos de Android Studio, como el IDE de núcleo, el daemon de Gradle o el daemon de
Kotlin.

Android Studio comprueba automáticamente si hay posibles optimizaciones de tamaño de

montón y te notiBca si detecta que se puede mejorar el rendimiento.

Figura 1: NotiBcación sobre la conBguración de memoria recomendada

Si usas un sistema de 64 bits con al menos 5 GB de RAM, también puedes ajustar los
tamaños de montón de tu proyecto manualmente. Para hacerlo, sigue estos pasos:

1. Haz clic en File > Settings en la barra de menú (o en Android Studio > Preferences en
macOS).

2. Haz clic en Appearance & Behavior > System Settings > Memory Settings.
:
 3. Ajusta los tamaños de montón con los valores que quieras.

4. Haz clic en Apply.

Si cambiaste el tamaño de montón de IDE, debes reiniciar Android Studio antes de que
se aplique la nueva conBguración de memoria.

Nota: Si asignas demasiada memoria, es posible que disminuya el rendimiento.

Cómo importar y exportar con3guraciones del IDE

Puedes exportar un archivo de conBguración JAR Settings.jar que contenga todas tus
conBguraciones del IDE o un subconjunto de estas que preBeras para un proyecto. Luego,
puedes importar el archivo JAR a los demás proyectos y hacer que esté disponible para que
tus colegas lo importen a sus proyectos.

Para obtener más información, consulta Cómo importar y exportar conBguraciones

(https://www.jetbrains.com/help/idea/2019.1/exporting-and-importing-settings.html) en IntelliJ IDEA.

Cómo personalizar tus propiedades del IDE

:
 El archivo idea.properties te permite personalizar las propiedades de IDE para
Android Studio, como la ruta de acceso a los complementos instalados por el usuario y el
tamaño máximo de archivo admitido por el IDE. El archivo idea.properties se fusiona con
las propiedades predeterminadas para el IDE de modo que puedas especiBcar solamente
las propiedades anuladas.

Para crear un nuevo archivo idea.properties o abrir uno existente, realiza los siguientes
pasos:

1. Haz clic en Help > Edit Custom Properties. Si nunca editaste las propiedades del IDE
antes, Android Studio te solicitará crear un archivo idea.properties nuevo. Haz clic
en Yes para hacerlo.

2. El archivo idea.properties se abrirá en la ventana del editor de Android Studio.

Edítalo para agregar tus propiedades personalizadas del IDE.

En el siguiente archivo idea.properties, se incluyen las propiedades de IDE comúnmente

personalizadas. Para obtener una lista completa de propiedades, lee información sobre el
archivo idea.properties para IntelliJ IDEA
(https://www.jetbrains.com/help/idea/2019.1/Ble-idea-properties.html).

#---------------------------------------------------------------------
# Uncomment this option if you want to customize path to user installed plugins
# you're using forward slashes.
#---------------------------------------------------------------------
# idea.plugins.path=${idea.config.path}/plugins
#---------------------------------------------------------------------
# Maximum file size (kilobytes) IDE should provide code assistance for.
# The larger file is the slower its editor works and higher overall system memor
# if code assistance is enabled. Remove this property or set to very large numbe
# code assistance for any files available regardless their size.
#---------------------------------------------------------------------
idea.max.intellisense.filesize=2500
#---------------------------------------------------------------------
# This option controls console cyclic buffer: keeps the console output size not
# specified buffer size (Kb). Older lines are deleted. In order to disable cycle
# idea.cycle.buffer.size=disabled
#---------------------------------------------------------------------
idea.cycle.buffer.size=1024
#---------------------------------------------------------------------
# Configure if a special launcher should be used when running processes from wit
:
 # Using Launcher enables "soft exit" and "thread dump" features
#---------------------------------------------------------------------
idea.no.launcher=false
#---------------------------------------------------------------------
# To avoid too long classpath
#---------------------------------------------------------------------
idea.dynamic.classpath=false
#---------------------------------------------------------------------
# There are two possible values of idea.popup.weight property: "heavy" and "medi
# If you have WM configured as "Focus follows mouse with Auto Raise" then you ha
# set this property to "medium". It prevents problems with popup menus on some
# configurations.
#---------------------------------------------------------------------
idea.popup.weight=heavy
#---------------------------------------------------------------------
# Use default anti-aliasing in system, i.e. override value of
# "Settings|Editor|Appearance|Use anti-aliased font" option. May be useful when
# Remote Desktop Connection for instance.
#---------------------------------------------------------------------
idea.use.default.antialiasing.in.editor=false
#---------------------------------------------------------------------
# Disabling this property may lead to visual glitches like blinking and fail to
# on certain display adapter cards.
#---------------------------------------------------------------------
sun.java2d.noddraw=true
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under Window
#---------------------------------------------------------------------
sun.java2d.d3d=false
#---------------------------------------------------------------------
# Workaround for slow scrolling in JDK6
#---------------------------------------------------------------------
swing.bufferPerWindow=false
#---------------------------------------------------------------------
# Removing this property may lead to editor performance degradation under X Wind
#---------------------------------------------------------------------
sun.java2d.pmoffscreen=false
#---------------------------------------------------------------------
# Workaround to avoid long hangs while accessing clipboard under Mac OS X.
#---------------------------------------------------------------------
# ide.mac.useNativeClipboard=True
#---------------------------------------------------------------------
# Maximum size (kilobytes) IDEA will load for showing past file contents -
# in Show Diff or when calculating Digest Diff
#---------------------------------------------------------------------
:
 # idea.max.vcs.loaded.size.kb=20480

Cómo con3gurar el IDE para equipos de memoria insu3ciente

Si ejecutas Android Studio en un equipo con menos especiBcaciones de las recomendadas

(consulta Requisitos del sistema (https://developer.android.com/studio?hl=es-419#Requirements)),
puedes personalizar el IDE para mejorar el rendimiento de tu equipo de la siguiente manera:

Reduce el tamaño máximo del montón disponible para Android Studio: reduce a
512 Mb el tamaño máximo del montón para Android Studio. Para obtener más
información sobre cómo cambiarlo, consulta Tamaño máximo de la pila
(#adjusting_heap_size).

Actualiza Gradle y el complemento de Android para Gradle: Actualiza ambos a las

versiones más recientes a Bn de asegurarte de aprovechar las nuevas mejoras de
rendimiento. Para obtener más información sobre la actualización de Gradle y el
complemento de Android para Gradle, consulta Notas de la versión del complemento
de Android para Gradle
(https://developer.android.com/studio/releases/gradle-plugin?hl=es-419).

Habilita el modo de ahorro de energía: la habilitación del modo de ahorro de energía

desactiva varias operaciones de segundo plano que consumen mucha memoria y
batería, incluidos el resalte de errores y las inspecciones en el momento, la Bnalización
de código emergente automático y la compilación incremental automática en segundo
plano. Para activar el modo de ahorro de energía, haz clic en File > Power Save Mode.

Inhabilita las comprobaciones de lint innecesarias: para cambiar las comprobaciones

de lint que Android Studio ejecuta en tu código, sigue estos pasos:

1. Haz clic en File > Settings (en macOS, Android Studio > Preferences) para abrir
el diálogo Settings.

2. En el panel izquierdo, expande la sección Editor y haz clic en Inspections.

3. Haz clic en las casillas de veriBcación para seleccionar o anular la selección de

las veriBcaciones de lint según corresponda para tu proyecto.

4. Haz clic en OK o Apply para guardar los cambios.

Realiza depuraciones en un dispositivo físico: La depuración requiere más memoria

:
 Realiza depuraciones en un dispositivo físico: La depuración requiere más memoria
en un emulador que en un dispositivo físico. Por ello, puedes mejorar el rendimiento
general de Android Studio realizando depuraciones en un dispositivo físico
(https://developer.android.com/studio/run/device?hl=es-419).

Incluye solo los servicios necesarios de Google Play como dependencias: incluir
servicios de Google Play como dependencias en tu proyecto aumenta el volumen de
memoria necesario. Incluye únicamente las dependencias necesarias para mejorar el
uso y el rendimiento de la memoria. Para obtener más información, consulta Cómo
agregar servicios de Google Play a tu proyecto
(https://developers.google.com/android/guides/setup?hl=es-
419#add_google_play_services_to_your_project)
.

Activa el modo sin conexión para Gradle: si tu ancho de banda es limitado, activa el
modo sin conexión para evitar que Gradle intente descargar dependencias faltantes
durante tu compilación. Si faltan dependencias, Gradle mostrará una falla y no
intentará descargarlas cuando esté activado el modo sin conexión. Para activar el
modo sin conexión, haz lo siguiente:

1. Haz clic en File > Settings (en macOS, Android Studio > Preferences) para abrir
el diálogo Settings.

2. En el panel izquierdo, expande Build, Execution, Deployment y, luego, haz clic en

Gradle.

3. En la conBguración global de Gradle, marca la casilla de veriBcación OUine

work.

4. Haz clic en Apply o en OK para que se apliquen los cambios.

Reduce el tamaño del montón máximo disponible para Gradle: el tamaño del montón
máximo predeterminado de Gradle es 1,536 MB. Para reducir este valor, anula la
propiedad org.gradle.jvmargs en el archivo gradle.properties, como se muestra a
continuación:

# Make sure to gradually decrease this value and note

# changes in performance. Allocating too lttle memory may
# also decrease performance.
org.gradle.jvmargs = -Xmx1536m
:
 No habilites la compilación paralela: Android Studio puede compilar módulos
independientes en paralelo, pero, si tu sistema tiene bajos recursos de memoria, no
debes activar esta función. Para veriBcar esta conBguración, haz lo siguiente:

1. Haz clic en File > Settings (en macOS, Android Studio > Preferences) para abrir
el diálogo Settings.

2. En el panel izquierdo, expande Build, Execution, Deployment y, luego, haz clic en

Compiler.

3. Asegúrate de que no esté marcada la opción Compile independent modules in

parallel.

4. Si has realizado un cambio, haz clic en Apply o en OK para que el cambio tenga
efecto.

Cómo establecer la versión de JDK

Se incluye una copia del último OpenJDK en conjunto con Android Studio 2.2 y versiones
posteriores, y esta es la versión de JDK que te recomendamos usar para tus proyectos de
Android. Para usar el JDK incluido, haz lo siguiente:

1. Abre tu proyecto en Android Studio y selecciona File > Project Structure en la barra de
menú.

2. En la página SDK Location y en JDK Location, marca la casilla de veriBcación Use

embedded JDK.

3. Haz clic en OK.

De forma predeterminada, la versión en lenguaje Java que se usa para compilar tu proyecto
se basa en la compileSdkVersion

(https://google.github.io/android-gradle-
dsl/current/com.android.build.gradle.BaseExtension.html#com.android.build.gradle.BaseExtension:comp
ileSdkVersion)
de tu proyecto (porque las versiones diferentes de Android admiten diferentes versiones de
Java). Si es necesario, puedes anular esta versión predeterminada de Java agregando el
siguiente bloque CompileOptions {}
:
 siguiente bloque CompileOptions {}
(https://google.github.io/android-gradle-
dsl/current/com.android.build.gradle.internal.CompileOptions.html)
a tu archivo build.gradle:

android {
compileOptions {
sourceCompatibility JavaVersion.VERSION\_1\_6
targetCompatibility JavaVersion.VERSION\_1\_6
}
}

Para obtener más información sobre el punto en el que se deBne la compileSdkVersion, lee
la documentación sobre el archivo de compilación de nivel de módulo
(https://developer.android.com/studio/build?hl=es-419#module-level).

Cómo establecer con3guraciones de proxy

Los proxy sirven como puntos de conexión intermedios entre los clientes HTTP y los
servidores web, y proporcionan seguridad y privacidad para las conexiones de Internet.

Para admitir la ejecución de Android Studio detrás de un Brewall, establece la conBguración

de proxy para el IDE de Android Studio. Usa la página de conBguración de proxy HTTP del
IDE de Android Studio para conBgurar estos ajustes.

Cuando se ejecuta el complemento de Android para Gradle desde la línea de comandos o en

equipos sin Android Studio, como los servidores de integración continua, debes establecer
las conBguraciones de proxy en el archivo de compilación de Gradle.

Nota: Después de la instalación inicial del paquete de Android Studio, puedes ejecutarlo con acceso a
Internet o sin conexión. No obstante, Android Studio requiere una conexión a Internet para la

sincronización del asistente de conBguración, el acceso a bibliotecas de terceros, el acceso a

repositorios remotos, la inicialización y sincronización de Gradle, y las actualizaciones de versión de
Android Studio.
:
 Cómo conBgurar el proxy de Android Studio

Android Studio admite ajustes de conBguración de proxy HTTP para que puedas ejecutarlo
detrás de un Brewall o una red segura. Para conBgurar el proxy HTTP en Android Studio:

1. En la barra de menú, haz clic en File > Settings (en macOS, haz clic en Android Studio
> Preferences).

2. En el panel izquierdo, haz clic en Appearance & Behavior > System Settings > HTTP
Proxy. Aparecerá la página del proxy HTTP.

3. Selecciona Auto-detect proxy settings para usar una URL de conBguración automática
de proxy o Manual proxy con]guration para ingresar cada una de las conBguraciones
tú mismo. Para acceder a una explicación detallada de estos ajustes, consulta Proxy
HTTP (https://www.jetbrains.com/help/idea/2019.1/http-proxy.html).

4. Haz clic en Apply o en OK para que se apliquen los cambios.

Complemento de Android para las conBguraciones de proxy HTTP de Gradle

Cuando se ejecuta el complemento para Android desde la línea de comandos o en equipos

sin Android Studio, establece la conBguración de proxy del complemento de Android para
Gradle en el archivo de compilación de Gradle.

Los ajustes del proxy HTTP especíBcos de la aplicación deben conBgurarse en el archivo
build.gradle, como se requiere para cada módulo de la aplicación.

apply plugin: 'com.android.application'

android {
...

defaultConfig {
...
systemProp.http.proxyHost=proxy.company.com
systemProp.http.proxyPort=443
systemProp.http.proxyUser=userid
systemProp.http.proxyPassword=password
systemProp.http.auth.ntlm.domain=domain
}
...
}
:
 }

Para conBguraciones de proxy HTTP en un proyecto, establece la conBguración de proxy en

el archivo gradle/gradle.properties.

# Project-wide Gradle settings.

...

systemProp.http.proxyHost=proxy.company.com
systemProp.http.proxyPort=443
systemProp.http.proxyUser=username
systemProp.http.proxyPassword=password
systemProp.http.auth.ntlm.domain=domain

systemProp.https.proxyHost=proxy.company.com
systemProp.https.proxyPort=443
systemProp.https.proxyUser=username
systemProp.https.proxyPassword=password
systemProp.https.auth.ntlm.domain=domain

...

Si deseas obtener información sobre el uso de propiedades de Gradle para la conBguración

del proxy, consulta la Guía del usuario de Gradle
(http://www.gradle.org/docs/current/userguide/build_environment.html).

Nota: Al usar Android Studio, los ajustes que se realicen en la página de conBguración del proxy HTTP del
IDE de Android Studio anularán la conBguración del proxy HTTP del archivo gradle.properties.

Cómo optimizar el rendimiento de Android Studio en Windows

El rendimiento de Android Studio en Windows puede verse afectado por una variedad de
factores. En esta sección, se describe cómo puedes optimizar la conBguración de
Android Studio para obtener el mejor rendimiento posible en Windows.
:
 Cómo minimizar el impacto del software antivirus en la velocidad de
compilación

Algunos programas antivirus pueden interferir con el proceso de compilación de

Android Studio, lo que hace que las compilaciones se ejecuten mucho más lentamente.
Cuando ejecutas una compilación en Android Studio, Gradle compila los recursos y el
código fuente de tu app y, luego, los empaqueta en un APK. Durante este proceso, se crean
muchos archivos en tu computadora. Si tu software antivirus tiene habilitado el escaneo en
tiempo real, puede hacer que el proceso de compilación se detenga cada vez que se crea un
archivo durante el escaneo de ese archivo.

Para evitar este problema, puedes excluir ciertos directorios del escaneo en tiempo real en
tu software antivirus.

Precaución: Para asegurarte de que tu computadora esté protegida contra software malicioso, no debes
inhabilitar completamente el escaneo en tiempo real ni el software antivirus.

En la siguiente lista, se muestra la ubicación predeterminada de cada directorio de

Android Studio que debes excluir del escaneo en tiempo real:

Caché de Gradle

%USERPROFILE%\.gradle

Proyectos de Android Studio

%USERPROFILE%\AndroidStudioProjects

SDK de Android

%USERPROFILE%\AppData\Local\Android\SDK

Archivos de sistema de Android Studio

%USERPROFILE%\.AndroidStudio<version>\system

Cómo personalizar ubicaciones de directorio para entornos controlados de política de grupo

Si hay una política de grupo que limita qué directorios puedes excluir del escaneo en tiempo
:
 real en tu computadora, puedes trasladar tus directorios de Android Studio a una de las
ubicaciones que la política de grupo centralizada ya excluye.

En la siguiente lista, se muestra cómo personalizar la ubicación de cada directorio de

Android Studio, donde C:\WorkFolder es el directorio que tu política de grupo ya excluye:

Caché de Gradle

DeBne la variable del entorno GRADLE_USER_HOME para que apunte a

C:\WorkFolder\.gradle.

Proyectos de Android Studio

Crea directorios de proyectos o transBérelos a un subdirectorio apropiado de

C:\WorkFolder. Por ejemplo, C:\WorkFolder\AndroidStudioProjects.

SDK de Android

Sigue estos pasos:

1. En Android Studio, abre el diálogo Settings (Preferences en macOS), luego

navega hasta Appearance & Behavior > System Settings > Android SDK.

2. Cambia el valor de Android SDK Location a C:\WorkFolder\AndroidSDK.

Para evitar descargar nuevamente el SDK, asegúrate de copiar el directorio del

SDK existente, ubicado en %USERPROFILE%\AppData\Local\Android\SDK de
forma predeterminada, y pegarlo en la nueva ubicación.

Archivos de sistema de Android Studio

Sigue estos pasos:

1. En Android Studio, haz clic en Help > Edit Custom Properties.

Android Studio te pedirá que crees un archivo idea.properties si aún no tienes

uno.

2. Agrega la siguiente línea a tu archivo idea.properties:

idea.system.path=c:/workfolder/studio/caches/trunk-system
:
 Cómo con3gurar dependencias de compilación sin conexión

Si deseas construir tu proyecto sin una conexión de red, sigue los pasos que se describen a
continuación para conBgurar el IDE a Bn de usar versiones sin conexión del complemento de
Gradle para Android y las dependencias de Google Maven.

Si aún no lo hiciste, descarga los componentes sin conexión

(https://developer.android.com/r/studio-omine/downloads?hl=es-419) desde la página de
descargas.

Cómo descargar y descomprimir componentes sin conexión

Después de descargar los componentes sin conexión, descomprime tu contenido en el

siguiente directorio, que deberás crear si aún no existe:

En Windows: %USER_HOME%/.android/manual-offline-m2/

En macOS y Linux: ~/.android/manual-offline-m2/

Para actualizar los componentes sin conexión, haz lo siguiente:

1. Borra el contenido dentro del directorio manual-offline-m2/.

2. Vuelve a descargar los componentes sin conexión

(https://developer.android.com/r/studio-omine/downloads?hl=es-419).

3. Descomprime el contenido de los archivos ZIP que descargaste en el directorio

manual-offline-m2/.

Cómo incluir componentes sin conexión en tu proyecto de Gradle

Para indicarle al sistema de compilación de Android que use los componentes sin conexión

que descargaste y descomprimiste, debes crear una secuencia de comandos, como se

describe a continuación. Ten en cuenta que debes crear y guardar esta secuencia de
comandos solo una vez, incluso después de actualizar tus componentes sin conexión.

1. Crea un archivo de texto vacío con la siguiente ruta y el siguiente nombre de archivo:
:
 En Windows: %USER_HOME%/.gradle/init.d/offline.gradle

En macOS y Linux: ~/.gradle/init.d/offline.gradle

2. Abre el archivo de texto e incluye la siguiente secuencia de comandos:

def reposDir = new File(System.properties['user.home'], ".android/manual-offlin

def repos = new ArrayList()
reposDir.eachDir {repos.add(it) }
repos.sort()

allprojects {
buildscript {
repositories {
for (repo in repos) {
maven {
name = "injected_offline_${repo.name}"
url = repo.toURI().toURL()
}
}
}
}
repositories {
for (repo in repos) {
maven {
name = "injected_offline_${repo.name}"
url = repo.toURI().toURL()
}
}
}
}

3. Guarda el archivo de texto.

4. (Opcional) Si deseas veriBcar que los componentes sin conexión funcionan según lo
previsto, borra los repositorios en línea de los archivos build.gradle de tu proyecto,
como se muestra a continuación. Después de conBrmar que tu proyecto se compila
correctamente sin estos repositorios, puedes volver a colocarlos en los archivos
build.gradle.

buildscript {
:
 buildscript {
repositories {
// Hide these repositories to test your build against
// the offline components. You can include them again after
// you've confirmed that your project builds ‘offline’.
// google()
// jcenter()
}
...
}
allprojects {
repositories {
// google()
// jcenter()
}
...
}

Nota: Esta secuencia de comandos se aplica a todos los proyectos de Gradle que abres en la estación de
trabajo.

Content and code samples on this page are subject to the licenses described in the Content License
(https://developer.android.com/license?hl=es-419). Java is a registered trademark of Oracle and/or its
aoliates.

Last updated 2020-05-11 UTC.

: