Cómo configurar Android Studio

Android Studio proporciona asistentes y plantillas que verifican los requisitos de tu sistema, como el Java Development Kit (JDK) y la memoria RAM disponible, y configuran 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 configuración adicionales que puedes usar para personalizar tu uso de Android Studio.

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

  • studio.vmoptions: permite personalizar opciones para la máquina virtual Java (JVM) de Studio, como el tamaño del montón y el tamaño de la caché. Ten en cuenta que en máquinas Linux este archivo puede llamarse studio64.vmoptions, según la versión de Android Studio.
  • idea.properties: permite personalizar propiedades de Android Studio, como la ruta de la carpeta de complementos o el tamaño máximo de archivo admitido.

Para obtener documentación específica sobre la configuración y el uso del emulador y el dispositivo, consulta los siguientes temas:

Cómo buscar tus archivos de configuración

Los archivos de configuración se almacenan en la carpeta de configuración para Android Studio. El nombre de la carpeta depende de tu versión de Studio. Por ejemplo, en Android Studio 3.3, el nombre de la carpeta 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íficos 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 permite personalizar opciones para JVM de Android Studio. Para mejorar el rendimiento de Studio, la opción más común que se puede ajustar es el tamaño máximo del montón, pero también puedes usar el archivo studio.vmoptions para anular otras configuraciones predeterminadas, como el tamaño del montón inicial, el tamaño de la caché y los interruptores de recolección de elementos no utilizados de Java.

Para crear un nuevo archivo studio.vmoptions o abrir uno existente, sigue estos 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 de Oracle.

El archivo studio.vmoptions que crees se agregará al archivo studio.vmoptions predeterminado, que se ubica en el directorio bin/ dentro de tu carpeta de instalación de Android Studio.

Ten en cuenta que nunca debes editar directamente el archivo studio.vmoptions que se encuentra dentro de la carpeta del programa de Android Studio. Si bien puedes acceder a él para ver las opciones predeterminadas de la VM de Studio, editar solo tu archivo studio.vmoptions te garantizará que no anules las configuraciones predeterminadas importantes para Android Studio. Por lo tanto, en tu archivo studio.vmoptions, anula solo 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 1280 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 en las opciones de VM para Android Studio. Si tu sistema tiene restricciones de memoria, tal vez te convenga reducir el tamaño máximo del montón.

Para cambiar el tamaño máximo del montón, sigue estos pasos:

  1. Haz clic en Help > Edit Custom VM Options para abrir tu archivo studio.vmoptions.
  2. Agrega una línea al archivo studio.vmoptions para establecer el tamaño máximo del montón utilizando la sintaxis -XmxheapSize. El tamaño que elijas se debe basar en el tamaño de tu proyecto y la memoria RAM disponible en tu equipo. Como referencia, si tienes más de 4 GB de memoria RAM y un proyecto de tamaño medio, debes fijar el tamaño máximo del montón en 2 GB o más. Con la siguiente línea, se establece el tamaño máximo de montón en 2 GB:

    -Xmx2g
        
  3. Guarda tus cambios en el archivo studio.vmoptions y reinicia Android Studio para que se apliquen los cambios.

  4. Para confirmar el nuevo tamaño máximo del montón, abre la línea de comandos y escribe el siguiente:

        $ jps -lvm
        

    Verás una lista de JVM instrumentadas que se ejecutan en tu equipo; se incluirán el nombre completo del paquete de cada uno y los argumentos pasados. Ubica el elemento que corresponde a tu instancia de Android Studio. Debería terminar en -Didea.paths.selector=AndroidStudio[Version]. Verás dos argumentos que comienzan con -Xmx para esta JVM: uno con el valor predeterminado de 1280 MB y otro con tu valor nuevo, como se muestra en la figura 1.

    Figura 1: Salida terminal que muestra los argumentos actuales para la JVM de Android Studio

    1. El argumento -Xmx muestra el tamaño máximo del montón predeterminado; en este caso, 1280 m.
    2. El argumento -Didea.paths.selector muestra la versión de Android Studio que se está ejecutando actualmente.
    3. El argumento -Xmx muestra el nuevo tamaño máximo del montón personalizado. Ten en cuenta que a esto le sigue la ubicación del archivo studio.vmoptions personalizado que creaste anteriormente.

Cómo exportar e importar configuraciones del IDE

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

Para obtener más información, consulta Exportar e importar configuraciones en IntelliJ IDEA.

Cómo personalizar tus propiedades del IDE

El archivo idea.properties te permite personalizar las propiedades del 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 especificar solo las propiedades anuladas.

Para crear un nuevo archivo idea.properties o abrir uno existente, sigue estos 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 del IDE comúnmente personalizadas. Para obtener una lista completa de propiedades, lee información sobre el archivo idea.properties para IntelliJ IDEA.

#---------------------------------------------------------------------
    # Uncomment this option if you want to customize path to user installed plugins folder. Make sure
    # 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 memory requirements are
    # if code assistance is enabled. Remove this property or set to very large number if you need
    # 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 higher than the
    # specified buffer size (Kb). Older lines are deleted. In order to disable cycle buffer use
    # idea.cycle.buffer.size=disabled
    #---------------------------------------------------------------------
    idea.cycle.buffer.size=1024
    #---------------------------------------------------------------------
    # Configure if a special launcher should be used when running processes from within IDE.
    # 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 "medium".
    # If you have WM configured as "Focus follows mouse with Auto Raise" then you have to
    # 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 using Windows
    # 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 repaint
    # on certain display adapter cards.
    #---------------------------------------------------------------------
    sun.java2d.noddraw=true
    #---------------------------------------------------------------------
    # Removing this property may lead to editor performance degradation under Windows.
    #---------------------------------------------------------------------
    sun.java2d.d3d=false
    #---------------------------------------------------------------------
    # Workaround for slow scrolling in JDK6
    #---------------------------------------------------------------------
    swing.bufferPerWindow=false
    #---------------------------------------------------------------------
    # Removing this property may lead to editor performance degradation under X Window.
    #---------------------------------------------------------------------
    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 configurar el IDE para equipos de memoria insuficiente

Si ejecutas Android Studio en un equipo con menos especificaciones de las recomendadas (consulta Requisitos del sistema), 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 del montón.
  • Actualiza Gradle y el complemento de Android para Gradle: actualiza Gradle y el complemento de Android para Gradle con las últimas versiones a fin de asegurarte de aprovechar las últimas 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.
  • 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 finalizació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 verificación para seleccionar o anular la selección de las verificaciones de lint según corresponda para tu proyecto.
    4. Haz clic en Apply o en OK para guardar los cambios.
  • 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 para Android Studio realizando depuraciones en un dispositivo físico.

  • 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 Agregar servicios de Google Play a tu proyecto.

  • 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 configuración global de Gradle, marca la casilla de verificación Offline 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 verificar esta configuració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 realizaste un cambio, haz clic en Apply o en OK para que se aplique.

Cómo configurar tu proyecto para Instant Run

Instant Run es un comportamiento para los comandos Run y Debug que reduce considerablemente el tiempo entre las actualizaciones de tu app. Si bien la primera compilación puede demorar más en completarse, Instant Run aplica actualizaciones posteriores en tu app sin compilar un APK nuevo, de modo que los cambios se visualizan mucho más rápido.

Android Studio habilita Instant Run de forma predeterminada para proyectos generados con un complemento de Android para Gradle 2.0.0 y versiones posteriores. Puedes mejorar el rendimiento de la compilación con Instant Run modificando algunas configuraciones para tu proyecto. Si deseas obtener más información sobre la configuración de tu proyecto para Instant Run, lee Configurar y optimizar tu proyecto para Instant Run.

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 verificació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 de tu proyecto (porque las versiones diferentes de Android son compatibles con diferentes versiones de Java). Si es necesario, puedes anular esta versión predeterminada de Java agregando el siguiente bloque CompileOptions {} 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 define la compileSdkVersion, lee la documentación sobre el archivo de compilación de nivel de módulo.

Cómo establecer configuraciones 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 firewall, establece la configuración de proxy para el IDE de Android Studio. Usa la página de configuración de proxy HTTP del IDE de Android Studio para configurar 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 configuraciones de proxy en el archivo de compilación de Gradle.

Cómo configurar el proxy de Android Studio

Android Studio admite ajustes de configuración de proxy HTTP para que puedas ejecutarlo detrás de un firewall o una red segura. Para configurar 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 configuración automática de proxy o Manual proxy configuration para ingresar cada una de las configuraciones tú mismo. Para acceder a una explicación detallada de estos ajustes, consulta Proxy HTTP.
  4. Haz clic en Apply o en OK para que se apliquen los cambios.

Complemento de Android para las configuraciones de proxy HTTP de Gradle

Cuando se ejecuta el complemento de Android desde la línea de comandos o en equipos sin Android Studio, establece la configuración de proxy del complemento de Android para Gradle en el archivo de compilación de Gradle.

Los ajustes del proxy HTTP específicos de la aplicación deben configurarse 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
        }
        ...
    }
    

Los ajustes del proxy HTTP para todo el proyecto deben configurarse 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 configuración del proxy, consulta la Guía del usuario de Gradle.

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 configuració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.

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
C:\Program Files\Android\Android Studio\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
Define la variable de entorno GRADLE_USER_HOME para que apunte a C:\WorkFolder\.gradle.
Proyectos de Android Studio
Crea directorios de proyectos o transfié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 por 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 solicita 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 configurar 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 configurar el IDE para usar versiones sin conexión del complemento Gradle para Android y las dependencias de Google Maven.

Si aún no lo hiciste, descarga los componentes sin conexión 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; 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-offline-m2")
        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 verificar 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 confirmar que tu proyecto se compila correctamente sin estos repositorios, puedes volver a colocarlos en los archivos build.gradle.

    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()
            }
            ...
        }