Tengo un proyecto múltiple (~ 10 módulos) de los cuales el edificio toma alrededor de 20-30 segundos cada vez. Cuando presiono Ejecutar en Android Studio, tengo que esperar cada vez para reconstruir la aplicación, que es extremadamente lenta.

¿Es posible automatizar el proceso de construcción en Android Studio? ¿O tienes algún consejo sobre cómo acelerar este proceso?

En Eclipse, gracias a la construcción automática, ejecutar el mismo proyecto en un emulador tarda entre 3 y 5 segundos.

Este es mi archivo build.gradle (módulo de aplicación):

buildscript {
    repositories {
        maven { url 'http://repo1.maven.org/maven2' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.4'
    }
}
apply plugin: 'android'

dependencies {
    compile fileTree(dir: 'libs', include: '*.jar')
    compile project(':libraries:SharedLibs')
    compile project(':libraries:actionbarsherlock')
    compile project(':libraries:FacebookSDK')
    compile project(':libraries:GooglePlayServices')
    compile project(':libraries:HorizontalGridView')
    compile project(':libraries:ImageViewTouch')
    compile project(':libraries:SlidingMenu')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 16
    }
}

Hardware

Lo siento, pero actualizar la estación de desarrollo a SSD y toneladas de ram probablemente tenga una influencia mayor que los puntos combinados a continuación.

Versiones de herramientas

Aumentar el rendimiento de la compilación tiene una prioridad importante para los equipos de desarrollo, así que asegúrese de estar utilizando el último Gradle y Android Gradle Plugin .

Archivo de configuración

Cree un archivo nombrado gradle.propertiesen el directorio que corresponda:

• /home/<username>/.gradle/ (Linux)
• /Users/<username>/.gradle/ (Mac)
• C:\Users\<username>\.gradle (Windows)

Adjuntar:

# IDE (e.g. Android Studio) users:
# Settings specified in this file will override any Gradle settings
# configured through the IDE.

# For more details on how to configure your build environment visit
# http://www.gradle.org/docs/current/userguide/build_environment.html

# The Gradle daemon aims to improve the startup and execution time of Gradle.
# When set to true the Gradle daemon is to run the build.
# TODO: disable daemon on CI, since builds should be clean and reliable on servers
org.gradle.daemon=true

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.krd1mm27v
org.gradle.jvmargs=-Xmx5120m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
org.gradle.parallel=true

# Enables new incubating mode that makes Gradle selective when configuring projects. 
# Only relevant projects are configured which results in faster builds for large multi-projects.
# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:configuration_on_demand
org.gradle.configureondemand=true

# Set to true or false to enable or disable the build cache. 
# If this parameter is not set, the build cache is disabled by default.
# http://tools.android.com/tech-docs/build-cache
android.enableBuildCache=true

Las propiedades de Gradle funcionan localmente si las coloca projectRoot\gradle.propertiesy globalmente si las coloca user_home\.gradle\gradle.properties. Propiedades aplicadas si ejecuta tareas de gradle desde la consola o directamente desde la idea:

Configuraciones IDE

Es posible ajustar la integración de Gradle-IntelliJ desde la GUI de configuración IDE. Habilitar el "trabajo sin conexión" (verifique la respuesta de yava a continuación) deshabilitará las solicitudes de red reales en cada "archivo de sincronización de gradle".

Multi-dex nativo

Uno de los pasos más lentos de la compilación apk es convertir el código de bytes de Java en un solo archivo dex. La habilitación de multidex nativo (minSdk 21 solo para compilaciones de depuración) ayudará a las herramientas a reducir la cantidad de trabajo (verifique la respuesta de Aksel Willgert a continuación).

Dependencias

Prefiere @aardependencias sobre subproyectos de biblioteca.

Busque un paquete en mavenCentral , jCenter o use jitpack.io para construir cualquier biblioteca desde github. Si no está editando las fuentes de la biblioteca de dependencias, no debe compilarla cada vez con las fuentes de su proyecto.

Antivirus

Considere excluir archivos de proyecto y caché del escaneo antivirus. Obviamente, esto es una compensación con la seguridad (¡no intentes esto en casa!). Pero si cambia mucho de una rama a otra, el antivirus volverá a analizar los archivos antes de permitir que el proceso de Gradle lo use, lo que ralentiza el tiempo de compilación (en particular, el proyecto de sincronización de AndroidStudio con los archivos de Gradle y las tareas de indexación). Mida el tiempo de compilación y procese la CPU con y sin antivirus habilitado para ver si está relacionado.

Perfilando una construcción

Gradle tiene soporte incorporado para proyectos de creación de perfiles . Diferentes proyectos están utilizando una combinación diferente de complementos y scripts personalizados. Usar --profileayudará a encontrar cuellos de botella.

Puede ignorar las comprobaciones de actualización de Gradle hasta la fecha.

Para Windows con Android Studio 1.5: vaya a File -> Settings -> Build, Execution, Deployment -> Build tools -> Gradle -> Check Offline work (as shown in image)

abajo de ~ 30 + segundos a ~ 3 segundos

Busqué esto en todas partes y finalmente encontré una solución que funciona para nosotros. Habilitar compilaciones paralelas (en OSX:preferences -> compiler -> gradle -> "Compile independent modules in parallel" y habilitar 'hacer proyecto automáticamente' lo redujo de ~ 1 minuto a ~ 20 segundos. Gracias a / u / Covalence.

http://www.reddit.com/r/androiddev/comments/1k3nb3/gradle_and_android_studio_way_slower_to_build/

Recientemente compré un nuevo SSD y pasé de Windows a Linux. Mis tiempos de compilación ahora son un orden de magnitud más rápido y ya no son molestos.

Aunque no responde directamente a su pregunta de por qué es más lento que el eclipse, muestra que el proceso está limitado por el disco y una actualización a un SSD podría ser una solución (algo costosa). Supongo que habrá personas buscando en Google el problema y terminando aquí, quienes podrían apreciar mi experiencia.

Acelerar Gradle Build en Android Studio 3.2.1

¿Alguna vez sintió que está esperando que las compilaciones se completen en Android Studio por minutos? Yo también. Y es bastante molesto. Afortunadamente, hay algunas formas que puede utilizar para mejorar esto. Android usa Gradle para construir. La última versión es 4.6 tiene un gran aumento de rendimiento con respecto a las versiones anteriores (consulte las Notas de la versión para más detalles).

Paso 1: Actualice la versión de Gradle Una forma más fácil de lograr esto es ir a: Abrir la Configuración del módulo (su proyecto)> Estructura del proyecto

ACTUALIZAR

Cambiar a la versión de Gradle: 4.6 y cambiar a la versión del complemento de Android: 3.2.1

Descargue la distribución Gradle Release de https://services.gradle.org/distributions/gradle-4.6-all.zip y cópielo en la carpeta Gradle:

El último paso es agregar su descripción en Configuración> Gradle

No olvide hacer clic en Aplicar para guardar los cambios.

Paso 2: Habilite el modo fuera de línea, el demonio Gradle y la compilación paralela para el proyecto El modo fuera de línea le dice a Gradle que ignore las actualizaciones hasta la fecha. Gradle solicita dependencias cada vez y tener esta opción hace que solo use lo que ya está en la máquina para las dependencias. Vaya a Gradle desde la configuración de Android Studio y haga clic en el cuadro de trabajo Fuera de línea.

2. Vaya a Compiler from Android studio Setting y agregue "- offline" en el cuadro de línea de comandos y haga clic en Compilar módulos independientes en paralelo.

El siguiente paso es habilitar el demonio Gradle y la compilación paralela para su proyecto. Las compilaciones paralelas harán que sus proyectos con múltiples módulos (compilaciones multiproyecto en Gradle) se construyan en paralelo, lo que debería hacer que los proyectos grandes o modulares se construyan más rápido.

Esta configuración podría habilitarse modificando un archivo llamado gradle.properties en el directorio de scripts de Gradle (es decir, ~ / .gradle / gradle.properties) .Algunas de estas opciones (p. Ej., Módulos Complie en paralelo) están disponibles en Android Studio y también están habilitadas allí por predeterminado, pero ponerlos en el archivo gradle.properties los habilitará cuando compile desde la terminal y también se asegurará de que sus colegas usen la misma configuración. Pero si estás trabajando en un equipo, a veces no puedes cometer esto.

# When configured, Gradle will run in incubating parallel mode.
# This option should only be used with decoupled projects. More details, visit org.gradle.parallel=true
# When set to true the Gradle daemon is used to run the build. For local developer builds this is our favorite property.
# The developer environment is optimized for speed and feedback so we nearly always run Gradle jobs with the daemon.
 org.gradle.daemon=true

El uso del demonio hará que sus compilaciones se inicien más rápido, ya que no tendrá que iniciar toda la aplicación Gradle cada vez. El Gradle Daemon no está habilitado de forma predeterminada, pero se recomienda siempre habilitarlo para las máquinas de los desarrolladores (pero dejarlo deshabilitado para los servidores de integración continua). Las preguntas frecuentes sobre este modo se pueden encontrar aquí https://docs.gradle.org/current/userguide/gradle_daemon.html . La configuración de compilaciones paralelas podría no ser segura para algunos proyectos. El requisito es que todos sus módulos deben estar desacoplados o su construcción podría fallar (consulte http://gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects para más detalles).

Paso 3: Habilite la configuración de memoria incremental de dexign y ajuste Puede acelerar sus compilaciones activando la desintoxicación incremental. En el archivo de compilación de su módulo:

Agregue esta opción a su bloque de Android:

dexOptions {
    incremental true
}

En ese bloque dexOptions también puede especificar el tamaño de almacenamiento dinámico para el proceso dex, por ejemplo:

dexOptions {
    incremental true
    javaMaxHeapSize "12g"
}

Donde "12g" es 12GB de memoria. Puede encontrar información adicional sobre esto aquí google.github.io/android-gradle-dsl/current/ También puede configurar los parámetros de Gradle en el archivo de configuración, por ejemplo, aumente el tamaño máximo de almacenamiento dinámico en caso de que tenga un proyecto grande:

# Specifies the JVM arguments used for the daemon process.
# The setting is particularly useful for tweaking memory settings.
# Default value: -Xmx10248m -XX:MaxPermSize=256m
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Vea toda la lista de parámetros aquí: https://docs.gradle.org/current/userguide/userguide_single.html#sec:gradle_configuration_properties para más detalles.

Paso 4: Deshabilite el antivirus Considere excluir los proyectos y los archivos de caché del escaneo antivirus. Obviamente, esto es una compensación con la seguridad. Pero si cambia mucho de una rama a otra, el antivirus volverá a analizar los archivos antes de permitir que el proceso de Gradle lo use, lo que ralentiza el tiempo de compilación (en particular, el proyecto de sincronización de Android Studio con los archivos de Gradle y las tareas de indexación). Mida el tiempo de compilación y procese la CPU con y sin antivirus habilitado para ver si está relacionado. Espero que esto ayude. Deje un comentario si tiene alguna pregunta o algún otro consejo para mejorar el rendimiento de la compilación.

enlace útil

Si usa los servicios de Google Play, depender solo de las bibliotecas que necesita en lugar de todo el blob puede hacer que las cosas sean más rápidas.

Si su única necesidad son los mapas, use:

compile 'com.google.android.gms:play-services-maps:6.5.+'

en vez de:

compile 'com.google.android.gms:play-services:6.5.+'

Este último trae 20k métodos (ver blog) en el classpath, lo que podría inclinar el recuento total de métodos por encima de 64k.

Eso forzaría el uso de proguard o multidex incluso para compilaciones de depuración. Para uno de mis proyectos tuve los siguientes tiempos de compilación

• compilación multidex (con biblioteca de soporte) ~ 40 segundos
• proguard build ~ 20seg
• construir cuando el método limita <64k ~ 5seg

Si se desarrolla en SDK 21+, sería posible optimizar las compilaciones multidex como se indica en la documentación de Android

android {
    productFlavors {
        // Define separate dev and prod product flavors.
        dev {
            // dev utilizes minSDKVersion = 21 to allow the Android gradle plugin
            // to pre-dex each module and produce an APK that can be tested on
            // Android Lollipop without time consuming dex merging processes.
            minSdkVersion 21
        }
        prod {
            // The actual minSdkVersion for the application.
            minSdkVersion 14
        }
    }
    ...
}

La respuesta aceptada es para versiones anteriores de Android Studio y la mayoría de ellas todavía funciona. La actualización de Android Studio lo hizo un poco más rápido. No se moleste en especificar el tamaño del montón, ya que aumentará automáticamente con el aumento de Xms y Xmx. Aquí hay alguna modificación con las VMoptions

1. En la carpeta bin hay un archivo studio.vmoptions para establecer la configuración del entorno. En mi caso, esto es studio64.vmoptions Agregue las siguientes líneas si aún no están agregadas y guarde el archivo. En mi caso tengo 8GB de RAM.

   -Xms4096m
   -Xmx4096m
   -XX:MaxPermSize=2048m
   -XX:+CMSClassUnloadingEnabled
   -XX:+CMSPermGenSweepingEnabled 
   -XX:+HeapDumpOnOutOfMemoryError
   -Dfile.encoding=utf-8`

2. Inicia Android Studio. Vaya a Archivo-> Configuración-> Compilación, Ejecución, Implementación-> Compilador

   • Compruebe compilar módulos independientes en paralelo
   • En las opciones de la línea de comandos, escriba: --offline
   • Marque Hacer proyecto automáticamente
   • Marque configurar bajo demanda

En caso de usar mac, al principio no pude encontrar las vmoptions. De todos modos, aquí hay un buen artículo sobre cómo podemos cambiar las vmoptions en MAC OSX . Citando de este artículo aquí.

Abra su terminal y ponga este comando para abrir las vmoptions en MAC OSX:

open -e /Applications/Android\ Studio.app/Contents/bin/studio.vmoptions

Simplemente cree un archivo llamado gradle.properties en el siguiente directorio:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Agregue esta línea al archivo:

org.gradle.daemon=true

Para mí, la velocidad ahora es igual a Eclipse.

Fuente: https://www.timroes.de/2013/09/12/speed-up-gradle/

Puede acelerar el proceso si usa gradle desde la línea de comandos. Hay mucha optimización que hacer para los desarrolladores de IDE. Pero es solo una versión temprana.

Para obtener más información, lea esta discusión sobre g + con algunos de los desarrolladores.

Si alguien está trabajando en un proyecto que se sincroniza a través de Subversion y esto sigue sucediendo, creo que esto puede retrasar el proceso de flujo de trabajo en Android Studio. Por ejemplo, si funciona muy lento mientras: desplazarse en una clase, xml, etc., mientras mi aplicación aún se está ejecutando en mi dispositivo.

• Vaya a Control de versiones en Preferencias y configure Subversion en Ninguno.

Actualizar después de Android Studio 2.3

Todas las respuestas son geniales, y animo a usar esos métodos con este para mejorar la velocidad de construcción.

Después del lanzamiento de Android 2.2 en septiembre de 2016, Android lanzó la función de caché de compilación experimental para acelerar el gradlerendimiento de la compilación, que ahora es oficial desde Android Studio 2.3 Canary. (Nota de lanzamiento oficial)

Presenta una nueva función de caché de compilación, que está habilitada de forma predeterminada, puede acelerar los tiempos de compilación (incluidas las compilaciones completas, las compilaciones incrementales y la ejecución instantánea) almacenando y reutilizando archivos / directorios que se crearon en compilaciones anteriores del mismo Android o de diferentes proyecto.

Cómo utilizar:

Agregue la siguiente línea en su gradle.propertiesarchivo

android.enableBuildCache = true
# Set to true or false to enable or disable the build cache. If this parameter is not set, the build cache is enable by default.

Limpia el caché:

• Se requiere una nueva tarea de Gradle cleanBuildCachepara que limpie más fácilmente el caché de compilación. Puede usarlo escribiendo lo siguiente en su terminal:

  ./gradlew cleanBuildCache

• O bien, puede limpiar el caché para Android Studio 2.2 eliminando todos los archivos almacenados en la ubicación

  C:\Users\<username>\.android\build-cache

Después de cambiar esta configuración, la duración de mi compilación 10 minutos cambió a ~ 10 segundos.

Paso 1:

Configuración (ctrl + Alt + S) ->

Compilación, Ejecución, Implementación ->

Compilador ->

escriba " --offline" en el cuadro de opciones de la línea de comandos.

Paso 2:

marque la casilla de verificación "Compilar módulos independientes en paralelo".

y haga clic en Aplicar -> Aceptar

Referencia: https://www.sundoginteractive.com/blog/speed-up-gradle-in-android-studio

Desventaja:

No podrá desplegar las últimas versiones de las dependencias identificadas en su archivo build.gradle. Se ejecuta más rápido porque utiliza una instantánea en caché de esas bibliotecas importadas.

Nota importante : cuando implemente la aplicación, elimine esta configuración y compílela con las últimas versiones de dependencias.

Resuelto el mío con

File -> Settings -> Build, Execution, Deployment -> Build Tools -> Gradle -> Offline work

Las construcciones de Gradle pasaron de 8 minutos a 3 segundos.

Esto es lo que ayudó a este programador principiante de Android (antiguo programador profesional, hace años) a acelerar Android Studio 2.2. Sé que esto es una repetición, pero, resumiendo en un solo lugar.

Las compilaciones iniciales aún pueden ser brutalmente lentas, pero los reinicios de las aplicaciones en ejecución ahora suelen ser muy tolerables. Estoy usando una PC subóptima: CPU AMD Quad-Core A8-7410, 8 MB de RAM, no SSD HD, Win 10. (Y esta es mi primera publicación de desbordamiento de pila ...;)

EN CONFIGURACIÓN -> GRADLE:

Sí para "Trabajo sin conexión" (esta es quizás la configuración más importante).

EN CONFIGURACIÓN -> COMPILADOR:

sí para "Compilar módulos independientes en paralelo" (no estoy seguro de si esto realmente ayuda a utilizar CPU multinúcleo).

EN ESCRITOS DE GRADLE , "build.gradle (Módulo: aplicación)":

defaultConfig {
    ...
   // keep min high so that restarted apps can be hotswapped...obviously, this is hugely faster.
   minSdkVersion 14
   ...
    // enabling multidex support...does make big difference for me.
    multiDexEnabled true

TAMBIÉN EN LOS ESCRITOS DE GRADLE , "gradle.properties (Propiedades del proyecto)":

org.gradle.jvmargs = -Xmx3048m -XX: MaxPermSize = 512m -XX: + HeapDumpOnOutOfMemoryError -Dfile.encoding = UTF-8

org.gradle.parallel = true org.gradle.daemon = true

Además , las pruebas en un dispositivo físico en lugar del emulador me están funcionando bien; una tableta pequeña que se pone de pie es conveniente.

Solo otro consejo para mejorar el rendimiento:

Android Studio 3.0 incluye un nuevo compilador DEX llamado D8.

"El compilador dex funciona principalmente bajo el capó en el desarrollo diario de su aplicación, pero afecta directamente el tiempo de compilación de su aplicación, el tamaño del archivo .dex y el rendimiento del tiempo de ejecución".

"Y al comparar el nuevo compilador D8 con el compilador DX actual, D8 compila más rápido y genera archivos .dex más pequeños, al mismo tiempo que tiene el mismo o mejor rendimiento en tiempo de ejecución de la aplicación".

D8 es opcional; utilícelo para ponerlo en la gradle del proyecto.

android.enableD8=true

Más información: https://android-developers.googleblog.com/2017/08/next-generation-dex-compiler-now-in.html

PD. Mejora mi tiempo de construcción en aproximadamente un 30%.

Esta configuración es muy rápida para mí (aproximadamente 2 segundos la construcción)

build.gradle

android {

    dexOptions {
        incremental true
        preDexLibraries = false
        jumboMode = false
        maxProcessCount 4
        javaMaxHeapSize "6g"
    }
}

gradle.properties

org.gradle.daemon=true
org.gradle.parallel=true
org.gradle.jvmargs=-Xmx8192M

mi PC:

• CPU Intel (R) Pentium (R) CPU G2030 @ 3.00GHz, 3000 Mhz, 2 procesadores principales, 2 procesadores lógicos
• x64
• Microsoft Windows 7 Professional
• (RAM) 16,0 GB

archivos de proyecto
: todos ubicados en HD local

Por favor siga los siguientes pasos.

1. Habilitar el modo fuera de línea: verifique debajo de la pantalla de impresión.

   https://i.stack.imgur.com/RF9uG.png

2. Habilitar Ejecución instantánea: verifique debajo de la pantalla de impresión.

   https://i.stack.imgur.com/mvHKJ.png

   Si desea obtener más información sobre la ejecución instantánea, visite el sitio para desarrolladores de Android.

Puede intentar abrir el menú de gradle en el lado derecho del estudio y ensamblar solo los módulos que ha cambiado, luego ejecutar el comando de instalación. Cuando presiona ejecutar, ensambla todo, independientemente de los cambios que haya realizado en el código que está ensamblando

Estoy lejos de ser un experto en Gradle, pero mi entorno tenía la siguiente línea en .gradle / init.gradle

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenRepo name: 'libs-repo', url: 'http://guest-vm/artifactory/repo'
        }
    }
}

Sin embargo, no tengo idea de por qué esa línea estaba allí, pero trato de cambiar a

gradle.projectsLoaded {
    rootProject.allprojects {
        repositories {
            mavenCentral()
        }
    }
} 

y ahora finalmente puedo trabajar sin jurar el esquema buildind de Android Studio y Gradle.

En nuestro caso específico, el problema se debió a tener el complemento retrolambda , que obligó a todos los proyectos y subproyectos a recompilarse cada vez que intentamos iniciar nuestra aplicación, incluso si no se había modificado el código en nuestros módulos principales.

Eliminar la retrolamba nos lo arregló. Espero que ayude a alguien.

Solo intenta esto primero. Es mi experiencia personal.

Yo tuve el mismo problema. Lo que hice fue desactivar permanentemente el antivirus (el mío era Avast Security 2015). Justo después de deshabilitar el antivirus, todo salió bien. La gradle terminó con éxito. A partir de ahora, en cuestión de segundos, la gradle está terminando (solo toma 5-10 segundos).

Hola, sé que esta es una respuesta muy tardía, pero tal vez ayude a alguien
en mi caso que estaba usando

compile 'com.android.support:support-v4:23.1.1'

en mi aplicación, dependencia de Gradle,
pero en una de mis bibliotecas era

 compile 'com.android.support:support-v4:23.0.1'

Después de cambiar todo a la última versión, mi problema se resolvió.

Seguir los pasos lo hará 10 veces más rápido y reducirá el tiempo de construcción en un 90%

Primero cree un archivo llamado gradle.properties en el siguiente directorio:

/home/<username>/.gradle/ (Linux)
/Users/<username>/.gradle/ (Mac)
C:\Users\<username>\.gradle (Windows)

Agregue esta línea al archivo:

org.gradle.daemon=true
org.gradle.parallel=true

Y verifica estas opciones en Android Studio

USE este sudo dpkg --add-architecture i386 sudo apt-get update sudo apt-get install libncurses5: i386 libstdc ++ 6: i386 zlib1g: i386

Android Studio no puede construir un nuevo proyecto, se agotó el tiempo de espera mientras se esperaba el proceso del esclavo

Un cambio trivial (a un resoruce xml) todavía tomó 10 minutos . Como @rivare dice en su respuesta, la construcción de una línea de comandos es más rápida (redujo esto a 15 segundos ).
Aquí hay algunos pasos para al menos hacer una compilación trivial rápidamente desde la línea de comandos para Windows.

1. Vaya a la raíz de sus proyectos (donde está el gradlew.bat):

   cd c: \ android \ MaskActivity

2. ejecutar la compilación :

   gradlew assembleDebug

3. desinstale la apk del teléfono directamente (arrástrela para desinstalar).

4. Cuando finalice la compilación, elimine el GRAN proceso de Java utilizando el Administrador de tareas de Windows.

O si tiene herramientas Unix en su máquina Windows:

ps

Se muestran los "pid":

kill -9 <pid>

5. Ahora instalar tu apk:

   adb -d install C: \ Android \ MaskActivity \ app \ build \ salidas \ apk \ app-debug.apk

De acuerdo con la documentación de Android , agregue esto en el archivo gradle del módulo de la aplicación.

android {
    ...
    dexOptions {
    preDexLibraries true
    maxProcessCount 8
    }
}

Para ejecutar entornos de Android en máquinas de baja configuración.

1. Cierre las pestañas web no necesarias en el navegador
2. Para usuarios de antivirus, excluya la carpeta de compilación que se genera automáticamente

3. Android Studio tiene un montón predeterminado de 1.2 Gb que puede disminuir a 512 MB Ayuda> Editar opciones de VM personalizadas studio.vmoptions -Xmx512m Layouts performace se acelerará

4. Para Gradle, uno de los componentes principales en el estudio de Android Mkae seguro como ahora 3.0beta es el último

Los siguientes consejos pueden afectar la calidad del código, por lo tanto, utilice con precaución:

1. Studio contiene el Modo seguro de energía cuando se enciende, cerrará las operaciones en segundo plano que contienen pelusas, completan el código, etc.

2. Puede ejecutar manualmente lintcheck cuando sea necesario ./gradlew lint

3. La mayoría de los emuladores de Android utilizan en promedio un consumo de 2 GB de RAM, por lo que, si es posible, use un dispositivo Android real, esto reducirá la carga de recursos en su computadora. Alternativamente, puede reducir la RAM del emulador y reducirá automáticamente el consumo de memoria virtual en su computadora. puede encontrar esto en la configuración del dispositivo virtual y la configuración avanzada.

4. El modo sin conexión de Gradle es una función para usuarios con ancho de banda limitado para deshabilitar la descarga de dependencias de compilación. Reducirá la operación en segundo plano que ayudará a aumentar el rendimiento del estudio de Android.

5. Android Studio ofrece una optimización para compilar múltiples módulos en paralelo. En máquinas con poca RAM, esta característica probablemente tendrá un impacto negativo en el rendimiento. Puede deshabilitarlo en el cuadro de diálogo de configuración del compilador.