Android studio Gradle construir acelerar

Definitivamente marca la diferencia: Cómo Speed Acelerar el tiempo de compilación de Gradle

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

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

Añade esta línea al archivo:

org.gradle.daemon=true

Después de cambiar esta configuración, mi tiempo de compilación se redujo 10 minutos a 10 segundos.

Paso 1:

Ajustes (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 "Compilar módulos independientes en paralelo".

& haga clic en Aplicar - > Aceptar

Paso 3: En tu gradle.archivo de propiedades - > Añadir las siguientes líneas

org.gradle.jvmargs=-Xmx2048M -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.daemon=true

Actualización:

Si estás usando Android studio 2.0 o superior, prueba el Instant Run

Configuración → Compilación, Ejecución, Implementación → Ejecución instantánea → Habilitar instantánea Ejecutar.

Más información sobre Instant Run - https://developer.android.com/studio/run/index.html#instant-run

Pude reducir mi compilación de gradle de 43 segundos a 25 segundos en mi viejo portátil core2duo (ejecutando linux mint) agregando lo siguiente al gradle.archivo de propiedades en android studio

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

Fuente sobre por qué la configuración daemon hace que las compilaciones sean más rápidas: https://www.timroes.de/2013/09/12/speed-up-gradle /

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

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

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

Añade esta línea al archivo:

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

Y marque esta opción en Android Studio

Hay una versión más reciente de gradle (ver 2.4).

Puede configurar esto para su (s) proyecto (s) abriendo el diálogo 'Estructura del proyecto' desde el menú Archivo,

Project Structure -> Project -> Gradle version

Y póngalo en '2.4'.
Puedes leer más sobre cómo aumentar el rendimiento en este enlace.

Con Android Studio 2.1 puede habilitar "Dex En proceso" para compilaciones de aplicaciones más rápidas.

Puede obtener más información al respecto aquí: https://medium.com/google-developers/faster-android-studio-builds-with-dex-in-process-5988ed8aa37e#.vijksflyn

Esto es lo que hice y mi velocidad de construcción de gradle mejoró dramáticamente! de 1 minuto a 20 segundos para la primera compilación y las siguientes se convirtieron en de 40 segundos a 5 segundos.

En el gradle .archivo properties Añadir esto:

org.gradle.jvmargs=-Xmx8192M -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

En los Argumentos de la Línea de comandos a través de Ir a Archivo > Otros ajustes> Ajustes predeterminados > Compilar, Ejecutar, Implementar> Complier y agregar los siguientes argumentos a los Argumentos de la Línea de comandos

Añadir esto:

--debug --stacktrace -a, --no-rebuild -q, --quiet --offline

Trate de evitar el uso de un Mac/PC que tiene solo 8 GB de RAM al hacer el desarrollo de Android. Tan pronto como inicias incluso 1 emulador (Genymotion o de otro modo), tus tiempos de compilación se vuelven extremadamente lentos en Android Studio con compilaciones de gradle. Esto sucede incluso si realiza un simple cambio de una línea a 1 archivo de origen.

Cerrar el emulador y usar un dispositivo real ayuda mucho, pero por supuesto esto es muy limitante y menos flexible. Reducir la configuración de uso de RAM del emulador puede ayudar, pero el la mejor manera es asegurarse de que su computadora portátil tenga al menos 12-16 GB de RAM.

Actualización (junio de 2017): Ahora hay varios buenos medium.com artículos que explican cómo acelerar las compilaciones de Gradle de Android Studio en detalle, e incluso funciona en máquinas de 8 GB:

• Cómo reducir el tiempo de compilación de Gradle en un 65% : https://medium.com/@kevalpatel2106/how-to-decrease-your-gradle-build-time-by-65-310b572b0c43
• ¡Haz que tus compilaciones Gradle vuelvan a ser rápidas!: https://medium.com/@wasyl/make-your-gradle-builds-fast-again-ea323ce6a435

El consenso resumido es:

Crea un gradle .propiedades archivo (ya sea global en ~/.gradle/gradle.properties o local al proyecto), y agregue las siguientes líneas:

org.gradle.daemon=true
org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.configureondemand=true

dexOptions {
    incremental true
    javaMaxHeapSize "4g"
}

1. Habilitar el trabajo sin conexión

2. Mejore el rendimiento de Gradle agregando el siguiente código en gradle.properties

Org.gradle.daemon = true
org.gradle.paralelo=verdadero

Guía paso a Paso:http://www.viralandroid.com/2015/08/how-to-make-android-studio-fast.html

De acuerdo con esta página del Equipo de Android de Wikimedia Apps, una buena manera de optimizar las compilaciones de Gradle es agregar estas líneas a tu ~/.gradle / gradle.propiedades

org.gradle.daemon=true                                                          
org.gradle.parallel=true
org.gradle.configureondemand=true
org.gradle.jvmargs=-Xmx2048M

Para aquellos que no tienen el archivo hay dos maneras de hacerlo:

1. Agregue el archivo localmente en su proyecto creando un archivo llamado gradle.propiedades en la raíz del proyecto or,

2. Puede configurarlos globalmente para todos sus proyectos creando los mismos archivo en su directorio personal (%UserProfile%.gradle on Windows ,~/.gradle en Linux y Mac OS X)

   Es una buena práctica establecer las propiedades en su directorio personal, en lugar de a nivel de proyecto.

También puede usar la línea de comandos para un mejor rendimiento.Puede usar el comando ./ gradlew <task name> desde dentro de la carpeta raíz de tu proyecto desde linux o usa gradlew.archivo bat como gradlew <task name>.la primera vez que ejecuta uno de los comandos anteriores para una versión de Gradle dada, descargará la distribución de Gradle correspondiente y la usará para ejecutar la compilación.

Al importar un proyecto de Gradle a través de su wrapper, tu IDE puede solicitar el uso de la distribución 'all' de Gradle. Esto está perfectamente bien y ayuda al IDE a completar el código para los archivos de compilación. Esto no solo significa que no tienes que instalar Gradle manualmente, sino que también estás seguro de usar la versión de Gradle para la que está diseñada la compilación. Esto hace que sus compilaciones históricas sean más confiables. para obtener más información, consulte Ejecutando una compilación con el Wrapper

Para compilaciones más rápidas, aumente el tamaño máximo del montón para el demonio Gradle a más de 2048 MB.

Para hacer este conjunto
org.gradle.jvmargs=-Xmx2048M
en el proyecto gradle.propiedades.

Pocos comandos podemos añadir al gradle.archivo de propiedades:

Org.gradle.configureondemand = true - Este comando le dirá a gradle que solo compile los proyectos que realmente necesita compilar. Utilice Daemon-org.gradle.daemon = true-Daemon mantiene la instancia del gradle en funcionamiento en segundo plano incluso después de que finalice la compilación. Esto eliminará el tiempo necesario para inicializar el gradle y disminuirá significativamente el tiempo de compilación.

Org.gradle.parallel = true-Permitir gradle para construir su proyecto en paralelo. Si tienes varios módulos en tu proyecto, al habilitarlo, gradle puede ejecutar operaciones de compilación para módulos independientes de forma paralela.

Increase Heap Size - org.gradle.jvmargs= - Xmx3072m-XX: MaxPermSize = 512m-XX: + HeapDumpOnOutOfMemoryError-Dfile.encoding = UTF-8: Desde android studio 2.0, gradle usa dex en el proceso para reducir los tiempos de compilación del proyecto. En general, al construir las aplicaciones, múltiples procesos dx se ejecutan en diferentes Instancias de VM. Pero a partir de Android Studio 2.0, todos estos procesos dx se ejecutan en una sola VM y esa VM también se comparte con gradle. Esto reduce significativamente el tiempo de compilación, ya que todo el proceso dex se ejecuta en las mismas instancias de VM. Pero esto requiere una memoria más grande para acomodar todos los procesos dex y gradle. Eso significa que necesitas aumentar el tamaño del montón requerido por el demonio gradle. Por defecto, el tamaño del montón para el demonio es de aproximadamente 1GB.

Asegúrese de que la dependencia dinámica no se utiliza. es decir, no usar ejecución ' com.androide.soporte: appcompat-v7: 27.0.+'. Este comando significa que gradle se conectará y comprobará la versión más reciente cada vez que compile la aplicación. En su lugar, utilice versiones fijas, es decir, 'com.androide.soporte: appcompat-v7: 27.0.2 '

Añadir un archivo build.gradle:

android {
...
dexOptions {
        javaMaxHeapSize "4g" //specify the heap size for the dex process
    }
...
}

Espero que ayude.

Estoy ejecutando un i7 de 5a generación con Windows 10 y un estado sólido de 1 TB. Comprimí la carpeta de proyectos de Android Studio y obtuve un aumento del 80%. Espero que esto ayude.

Luego lo combiné con las soluciones anteriores ie (org.gradle.parallel = true, org.gradle.daemon = true). El aumento de rendimiento fue bastante impresionante.

Además:

Todas las respuestas anteriores son totalmente correctas, pero debo declarar como un desarrollador de Android experiencia (de 4 años y medio) que: No Android / Gradle desarrollador debe estar trabajando en una máquina con una unidad de spinner, es necesario bifurcar para un Estado sólido. Todos pulsamos ese botón de reproducción en el IDE 100s de veces por día. Cuando pasé de un spinner a SSD (post Gradle), mi velocidad y eficiencia fue literalmente 2 – 4 veces más rápida y te prometo que NO estoy exagerando aquí.

Ahora no estoy hablando de tener una máquina con un SSD pequeño y un spinner grande, estoy hablando de 1 SSD grande. Si ya tiene una máquina con un SSD pequeño y un gran spinner puede actualizar el pequeño spinner para decir un SSD de 500 GB y configurar el SSD como su unidad principal del sistema operativo con sus herramientas de desarrollador instaladas en él.

Así que si usted está trabajando en un entorno de ritmo rápido por favor mostrar este post a su jefe. Un SSD decente de 1 TB le costará alrededor de £300 (IVA incluido), o alrededor de £160 para un SSD de 500 GB. Dependiendo de si eres un desarrollador de Android junior o senior, la unidad se pagará por sí misma (en gastos salariales) en 1 – 2 semanas hábiles, o aproximadamente 2 y media a 5 días hábiles si invierte en un SSD más pequeño; digamos 500 GB.

Muchos desarrolladores pueden argumentar que este no es el caso, pero es el caso de Gradle, ya que el sistema Gradle es muy difícil en el acceso directo al disco. Si trabajas con. NET/C # / VB Net u otras herramientas de desarrollo no notarás mucha diferencia, pero la diferencia en Gradle es ENORME. Si actúas en este post te prometo que no te decepcionarás. Personalmente estoy usando fifth gen i7 con 8GB RAM que originalmente venía con un 1TB Spinner y yo lo actualizamos a un Samsung SSD 840 EVO 1TB y nunca he mirado hacia atrás desde entonces. Yo compré el mío de: https://www.aria.co.uk .

Espero que esto ayude. También debo decir que este NO es un post comercialmente motivado, solo estoy recomendando Aria ya que los he usado muchas veces antes y siempre han sido confiables.

A menudo sucede cuando habilita multidex en su proyecto. Esto puede potencialmente ralentizar su proceso de desarrollo!! Según doc:

La configuración Multidex requiere un tiempo de procesamiento de compilación significativamente mayor porque el sistema de compilación debe tomar decisiones complejas sobre qué clases deben incluirse en el archivo DEX primario y qué clases pueden incluirse en archivos DEX secundarios. Esto significa que las compilaciones incrementales que usan multidex normalmente toman más tiempo y potencialmente puede ralentizar su proceso de desarrollo.

Pero puedes optimizar esto:

Para mitigar los tiempos de compilación incrementales más largos, debe usar pre-dexing para reutilizar la salida multidex entre compilaciones.

Si usas Android Studio 2.3 y versiones posteriores, el IDE utiliza automáticamente esta función al implementar tu aplicación en un dispositivo que ejecute Android 5.0 (nivel de API 21) o versiones posteriores.

Por lo que necesita establecer la minSdkVersion a 21 o más alto!

Pero si la versión de producción necesita soportar minSdkVersion inferior a 21, por ejemplo 19

Puede utilizar productFlavors para configurar minSdkVersion 21 para usted dev versión:

    android {
    defaultConfig {
        ...
        multiDexEnabled true
        // The default minimum API level you want to support.
        minSdkVersion 15
    }
    productFlavors {
        // Includes settings you want to keep only while developing your app.
        dev{
            //the IDE automatically uses  pre-dexing feature to mitigate longer incremental when deploying your app to a device running Android 5.0 !
            minSdkVersion 21
        }
        prod {

        }
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'),
                                                 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile 'com.android.support:multidex:1.0.3'
}