tools - Gradle build lento en transformClassesWithDexForDebug

gradle wrapper

Question

La creación de mi aplicación de Android tarda unos 90 segundos ( "rápido" ), hasta 3 minutos por cada actualización de mi código. Es una completa pérdida de tiempo, ya que realmente y supongo que una solución debe estar al alcance. Intenté investigar el problema y encontré diferentes publicaciones de blog y respuestas SO con sugerencias, la mayoría de las cuales he intentado.

• Tengo el archivo gradle.properties con org.gradle.deamon = true
• Ejecuto en Android Studio con Gradle Prefence para hacer trabajo sin conexión (mejorado, pero aún lento)
• Corro en la línea de comando (que es más rápido, pero aún lento)
• En build.gradle, defaultConfig, tengo multiDexEnabled establecido en false
• En build.gradle, dexOptions, tengo preDexLibraries establecido en falso
• En gradle-wrapper.properties obtengo una versión reciente de gradle (2.8) (los cambios de velocidad significativos ocurrieron en 2.4)

El proceso que parece tomar mucho tiempo, aproximadamente el 85% del tiempo de compilación total es : aplicación: transformClassesWithDexForDebug

¿Qué está haciendo realmente ese proceso? Puedo encontrar personas que tienen fallas, pero funciona bien para mí, excepto por el hecho de que lleva mucho tiempo. ¿Y lo necesito, ya que realmente no necesito a Dex en este momento?

Además, tengo 13 dependencias y 3 dependencias testCompile. Ya señalo paquetes de juego específicos, así que no estoy compilando cosas que no necesito. Si entiendo las cosas correctamente, Gradle está construyendo todas esas bibliotecas que cada proyecto construye también. Si eso es correcto, ¿hay alguna forma de saltear eso? ¿Puedo construirlos yo mismo como bibliotecas envueltas e incluirlos sin la necesidad de que se procesen cada vez? Eso podría hacerme perder algo de flexibilidad para futuros cambios en las dependencias, pero en este punto siento que estoy perdiendo más de una hora al día fácilmente en espera de gradle. No estoy seguro de si la flexibilidad vale tanto para mí.

Estoy ansioso por obtener sugerencias sobre cómo puedo mejorar mi proceso de compilación. Gracias de antemano.

Answer 1

¿Su aplicación tiene una base de datos? ¿El DB tiene un tamaño grande?

En caso afirmativo:

• eliminar la base de datos de la carpeta de activos (o donde sea que la guarde) y hacer una compilación
• medir la diferencia en tiempos de construcción
• EN MI CASO: fue una diferencia dramática de 45 segundos a 15 segundos

Si no:

• Monitoree la consola Gradle durante las compilaciones incrementales y vea qué operación lleva más tiempo

Answer 2

Actualizar a Android Studio 2.1 y Android Gradle Plugin v2.1.0 me ha solucionado en gran medida este problema. Después de instalar el IDE actualizado, también se le pedirá que actualice su complemento Gradle. Sabrá que tiene la versión correcta si su archivo raíz build.gradle tiene la siguiente línea:

classpath ''com.android.tools.build:gradle:2.1.0''

IMPORTANTE: además de actualizar, también necesita aumentar la cantidad de memoria asignada al demonio Gradle a 2048mb, para que pueda realizar este costoso paso de desintoxicación en el proceso. Para hacerlo, agregue lo siguiente a su archivo raíz gradle.properties:

org.gradle.jvmargs = -Xmx2048m

Tuve tiempos de construcción similarmente lentos como los de la pregunta anterior, pero después de actualizar mis velocidades de construcción aumentaron dramáticamente. Consulte las notas de la versión de Android Gradle Plugin v2.1.0 aquí para obtener más información:

http://developer.android.com/tools/revisions/gradle-plugin.html

Answer 3

Editar: en este punto, recomiendo ejecutar Android Studio 2.x junto con su instalación 1.5. Obtiene acceso a la ejecución instantánea, que realmente ayuda, así como a todas las herramientas actualizadas. Si te estás quedando en 1.5 sigue leyendo ...

He logrado acelerar las compilaciones de depuración de Android Studio 1.5 de 2 minutos a 30 segundos. Esto podría no funcionar con su ejecución de línea de comandos, pero podría ser más rápido.

Usando esta configuración, su primera compilación IDE toma la misma cantidad de tiempo , pero las compilaciones incrementales son más rápidas , incluso si modifica las clases. Pierde algo de ganancia si modifica las bibliotecas adjuntas.

Paso 1. (Si ya tienes la suerte de apuntar minSdkVersion de> = 21, omite esto).

La respuesta de @vanomart de tener un sabor de depuración minSdkVersion de> = 21 no es incorrecta, pero la única parte necesaria es agregar lo siguiente al módulo (aplicación) build.gradle y garantizar que se dirija al desarrollador mientras se depura en la pestaña Construir variantes:

android {
[...]
productFlavors {
dev {
minSdkVersion 21 //The important bit.
}
prod {
minSdkVersion 15 //Example. Set to your real requirement.
}
}

Paso 2. Construcciones incrementales y libs de desintoxicación previa.

En su módulo (aplicación) build.gradle establezca la siguiente configuración. Esto es más rápido para las compilaciones de IDE, no tanto para los servidores de creación que comienzan desde cero cada compilación.

android {
[...]
dexOptions {
preDexLibraries true
javaMaxHeapSize "2g" // Use gig increments depending on needs
incremental true
}

Fuente, haciendo (en parte) inversa de "Mejora del rendimiento del servidor de compilación": http://tools.android.com/tech-docs/new-build-system/tips#TOC-Improving-Build-Server-performance

Paso 3. Asegúrese de estar utilizando la última versión de buildToolsVersion en el módulo (aplicación) build.gradle .

android {
buildToolsVersion "23.0.2"
[...]

"... actualice la versión de las herramientas de compilación en todos sus módulos a la última (23.0.2). [...] utilizará una nueva versión más rápida de dex, que ayuda a que tanto la ejecución instantánea como la compilación completa sean un poco más rápidas ".

Fuente: http://tools.android.com/tech-docs/instant-run

Paso 4. Utiliza las últimas herramientas de compilación de Gradle

En su proyecto build.gradle , configúrelo como último (actualmente 2.0.0-alpha6)

buildscript {
dependencies {
classpath ''com.android.tools.build:gradle:2.0.0-alpha6''

Lista de actualizaciones: http://tools.android.com/tech-docs/new-build-system

Paso 5. Use la última envoltura de Gradle. Modifique gradle-wrapper.properties , actualice esta línea para usar 2.10:

distributionUrl=https/://downloads.gradle.org/distributions/gradle-2.10-all.zip
#Alternative url if the above does not work:
#distributionUrl=https://services.gradle.org/distributions/gradle-2.10-all.zip

En las preferencias de Android Studio, asegúrese de tener seleccionado "Usar el envoltorio de Gradle predeterminado". Recomiendo reiniciar Android Studio para garantizar que se reinicie el demonio Gradle.

"En muchos casos, Gradle 2.9 es mucho más rápido que Gradle 2.8 cuando realiza compilaciones incrementales".

Fuente: docs.gradle.org/current/release-notes

Answer 4

Eso parece ser parte del nuevo mecanismo de ejecución instantánea introducido en la vista previa de Android Studio 2.0, que es responsable de instrumentar todos los métodos en su aplicación para crear una rama de ejecución para el parche de código futuro. Me temo que por eso es extremadamente lento.

Es extraño que esta tarea aún se lleve a cabo incluso si Instant Run está deshabilitado. Tengo que degradar "com.android.tools.build:gradle" a 1.3.0 para evitar esa tarea.

Answer 5

Estaba enfrentando el mismo problema y me tomó alrededor de 10 horas finalmente resolverlo, así que sé lo que siente.

Busqué mucho en Google, hice las mismas cosas de configuración que tú e incluso si ayudó un poco, compilar y ejecutar la aplicación real todavía fue una molestia (a veces me tomó 2-3 minutos cuando cambié una línea de código) , pero cuando hice más trabajo, usualmente me tomó 8 minutos y mi computadora estaba totalmente congelada durante ese tiempo).

Pero suficientes conversaciones, arreglemos esto. Lo que hace ''app: transformClassesWithDexForDebug'' es resolver algunas dependencias para las versiones del sistema operativo Dalvik (anteriores a la 5.0, api 21) y lo que es importante: lleva mucho tiempo. No lo necesitará para el desarrollo, porque puede probar su aplicación en> = 21, por lo tanto, cree un sabor de producto separado para el desarrollo y el lanzamiento. Aquí está mi construcción gradle que hace uso de ella:

apply plugin: ''com.android.application''
final VERSION_MAJOR = 0
final VERSION_MINOR = 0
final VERSION_PATCH = 0
final VERSION_BUILD = 1
android {
compileSdkVersion 23
buildToolsVersion "23.0.1"
defaultConfig {
applicationId "com.app"
minSdkVersion 15
targetSdkVersion 23
multiDexEnabled true
versionName "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}.${VERSION_BUILD}"
versionCode VERSION_MAJOR * 10000000 + VERSION_MINOR * 100000 + VERSION_PATCH * 1000 + VERSION_BUILD
}
dexOptions {
incremental = true;
preDexLibraries = false
javaMaxHeapSize "2g"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile(''proguard-android.txt''), ''proguard-rules.pro''
}
}
productFlavors {
dev {
minSdkVersion 21
applicationId = "com.app.test"
}
prod {
minSdkVersion 15
applicationId = "com.app" // you don''t need it, but can be useful
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_7
targetCompatibility JavaVersion.VERSION_1_7
}
packagingOptions {
exclude ''META-INF/DEPENDENCIES.txt''
exclude ''META-INF/LICENSE.txt''
exclude ''META-INF/NOTICE.txt''
exclude ''META-INF/NOTICE''
exclude ''META-INF/LICENSE''
exclude ''META-INF/DEPENDENCIES''
exclude ''META-INF/notice.txt''
exclude ''META-INF/license.txt''
exclude ''META-INF/dependencies.txt''
exclude ''META-INF/LGPL2.1''
exclude ''META-INF/ASL2.0''
}
lintOptions {
checkReleaseBuilds false
abortOnError true
}
}
afterEvaluate {
tasks.matching {
it.name.startsWith(''dex'')
}.each { dx ->
if (dx.additionalParameters == null) {
dx.additionalParameters = [''--multi-dex'']
} else {
dx.additionalParameters += ''--multi-dex''
}
}
}
dependencies {
compile fileTree(include: [''*.jar''], dir: ''libs'')
...
}

Lo siguiente es asegurarse de que realmente está creando su aplicación con esta variante de compilación . Haga clic en Ver -> Windows de herramientas -> Herramientas de compilación y asegúrese de tener la variante de compilación establecida en ''devDebug''

Para algunas personas esto podría ser suficiente. Encontré muchos hilos aquí en SO y también en reddit que terminaron con este sabor del producto, pero en realidad esto no me ayudó en absoluto. Lo que me ayudó es actualizar gradle manualmente. Como ya trató de hacerlo, creo que está en el camino correcto, pero sugeriría usar la versión 2.9 más reciente de gradle, que tiene un " 40% de rendimiento mejorado " sobre 2.8.

Answer 6

La única solución que funcionó para mí fue deshabilitar la ejecución instantánea.

Android Studio -> Preferencias -> Compilación, ejecución, implementación -> Ejecución instantánea -> Desmarque ''Activar ejecución instantánea [...]''

La construcción pasó de más de 2 minutos a 40 segundos.