error - android annotations github

AndroidAnotaciones Actividad no generada, vacía

Question

Estoy intentando crear un proyecto usando AndroidAnnotations en Android Studio. Cuando construyo y ejecuto el proyecto, todo parece compilarse bien, pero solo obtengo una actividad en blanco para la aplicación. Además, no parece que algo sea generado por AndroidAnnotations.

He agregado androidannotations-api-2.7.1.jar como una dependencia para mi proyecto, y he habilitado el proceso de anotación con la ruta del procesador, la ruta a androidannotations-2.7.1.jar , que está en una carpeta separada de androidannotations-api-2.7.1.jar . He verificado las fuentes generadas por la tienda en relación con el contenido raíz del módulo, y he probado muchos directorios diferentes para las fuentes, desde generated , a gen/aa , hasta (actual) build/source/aa para que coincida donde parece que se crean los archivos generados Android Studio. Nada ha funcionado. Cambié el nombre de la actividad en el manifiesto a Activity_ y configuré la configuración para iniciar esto cuando se ejecuta el proyecto.

Las únicas otras dependencias que tengo son android-support-v4 y ActionBarSherlock. He intentado con ambos desactivados, sin ningún resultado. Inicialmente planeé usar Roboguice junto con AndroidAnnotations, pero lo he desactivado por el momento para tratar de enfocarme en este tema.

También estoy usando, o estoy tratando de usar, Gradle. Este es actualmente mi build.gradle :

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

apply plugin: ''android''

dependencies {
  compile files(''libs/android-support-v4.jar'')
  compile files(''libs/actionbarsherlock-4.3.1.jar'')
  compile files(''libs/androidannotations-api-2.7.1.jar'')
}

android {
  compileSdkVersion 17
  buildToolsVersion "17.0.0"

  defaultConfig {
    minSdkVersion 7
    targetSdkVersion 17
  }
}

Sin embargo, realmente no me he dado cuenta de cómo funciona Gradle, así que mayormente agregué las dependencias manualmente como lo haría con un proyecto normal, luego puse las líneas de compilación en Gradle para que el proyecto se compilara correctamente. Sé que probablemente esta no sea la forma correcta de usarlo.

Mi actividad y su diseño son bastante estándar, solo los copié de la guía oficial para comenzar con AndroidAnnotations.

ACTUALIZACIÓN: Así que volví a Maven para probar la compilación con eso, y noté algo extraño. Parece que incluso con la forma en que lo tengo configurado en Maven, no se genera nada. Sin embargo, con la compilación Maven puedo ejecutar el proyecto sin cambiar el nombre de la actividad en el manifiesto a Activity_ y el proyecto se compilará y ejecutará correctamente. Esto es muy extraño y parece que podría confundir aún más el problema o simplificarlo si también es indicativo de algo con Gradle.

Answer 1

agregar dependencias no hace nada. La tarea JavaCompile debe ser notificada sobre el procesador de anotación. Fue posible acceder a la tarea JavaCompile en la versión 0.3:

configurations {
    compile
    androidannotations.extendsFrom(compile) 
}

dependencies {
    compile ''org.androidannotations:androidannotations-api:3.0-SNAPSHOT''
    androidannotations ''org.androidannotations:androidannotations:3.0-SNAPSHOT''
}

android.buildVariants.each {
  variant ->
    variant.javaCompile.options.compilerArgs += [
        ''-classpath'', configurations.compile.asPath,
        ''-processorpath'', configurations.androidannotations.asPath,
        ''-processor'', ''org.androidannotations.AndroidAnnotationProcessor'',
        ''-AandroidManifestFile='' + variant.processResources.manifestFile
    ]
}

Para el complemento Gradle 0.4 en adelante, las tareas de compilación deben adjuntarse de forma diferente. Gracias a Artiom @ Android Project, aquí se muestra cómo debe verse todo build.gradle

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

repositories {
 mavenCentral()
 maven {
    url ''https://oss.sonatype.org/content/repositories/snapshots/''
 }
}

configurations {
 compile
 androidannotations.extendsFrom(compile)
}

dependencies {
 compile files(''libs/android-support-v4.jar'')
 compile ''org.androidannotations:androidannotations-api:3.0-SNAPSHOT''
 androidannotations ''org.androidannotations:androidannotations:3.0-SNAPSHOT''
}

android {
 compileSdkVersion 17
 buildToolsVersion "17.0.0"

 defaultConfig {
    minSdkVersion 7
    targetSdkVersion 16
    packageName "org.labaa.aa"
    testPackageName "org.labaa.aa.test"
    testInstrumentationRunner "org.labaa.aa.test.Runner"

 }
}

afterEvaluate { project ->
 android.applicationVariants.each { variant ->
    variant.javaCompile.options.compilerArgs += [
            ''-classpath'', configurations.compile.asPath,
            ''-processorpath'', configurations.androidannotations.asPath,
            ''-processor'', ''org.androidannotations.AndroidAnnotationProcessor'',
            ''-AandroidManifestFile='' + variant.processResources.manifestFile
    ]
 }
}

Esto no actualizará las dependencias de Android Studio. Agregue androidannotations-api manualmente. Ejecutar compilación desde la línea de comando gradle installDebug

Al compilar desde Andoid Studio, desactive el inicio de la aplicación; de lo contrario, el iniciador se quejará de la ausencia de actividad anotada.

Answer 2

Un posible problema es que la clase R no se encuentra. Android Studio no coloca el R.java en el directorio gen por defecto como eclipse. La solución es entrar en Configuración del proyecto -> Facetas -> Seleccionar la faceta de Android para su proyecto -> Pestaña Compilador, y cambiar los "Archivos de R.java y Manifest.java" de "Ejecutar recursos de proceso Maven tarea antes de Make" a "Generado por IDE".

Answer 3

Esto es similar a la respuesta de robotoaster, pero funciona en 0.4.1 y coloca los archivos fuente java generados en un nuevo directorio (coherente con las otras carpetas fuente generadas), lo que permite a Android Studio ver el origen y dejar de quejarse. También funciona con más procesadores de anotación. Simplemente agregue sus procesadores de anotación a la configuración "apt".

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath ''com.android.tools.build:gradle:0.4.1''
    }
}
apply plugin: ''android''

repositories {
    mavenCentral()
}

ext.daggerVersion = ''1.0.0'';
ext.androidAnnotationsVersion = ''2.7.1'';

configurations {
    apt
}

dependencies {
    apt "com.googlecode.androidannotations:androidannotations:${androidAnnotationsVersion}"
    compile "com.googlecode.androidannotations:androidannotations-api:${androidAnnotationsVersion}"
    apt "com.squareup.dagger:dagger-compiler:${daggerVersion}"
    compile "com.squareup.dagger:dagger:${daggerVersion}"
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 17
    }
}

android.applicationVariants.all { variant ->
    aptOutput = file("${project.buildDir}/source/apt_generated/${variant.dirName}")
    println "****************************"
    println "variant: ${variant.name}"
    println "manifest:  ${variant.processResources.manifestFile}"
    println "aptOutput:  ${aptOutput}"
    println "****************************"

    variant.javaCompile.doFirst {
        println "*** compile doFirst ${variant.name}"
        aptOutput.mkdirs()
        variant.javaCompile.options.compilerArgs += [
                ''-processorpath'', configurations.apt.getAsPath(),
                ''-AandroidManifestFile='' + variant.processResources.manifestFile,
                ''-s'', aptOutput
        ]
    }
}

ACTUALIZACIÓN : Aún funciona para compilar, pero con Android Studio 0.1.1 ya no puede editar la estructura de su proyecto con la interfaz de usuario , por lo que no puede decirle a AS que mire la nueva carpeta de origen. Me gustaría agregar la carpeta a un conjunto de origen, pero las variantes no parecen tener realmente sus propios conjuntos de fuentes, por lo que aún no estoy seguro de dónde ubicarlos .

ACTUALIZACIÓN 2 : puede obtener Android Studio 0.1.1 para reconocer los archivos fuente generados por apt haciendo clic con el botón derecho en build / source / apt_generated / debug en el navegador del proyecto y seleccionando Mark Directory As-> Source Root

ACTUALIZACIÓN 3 : desde el plugin de gradle 0.5.5 android.applicationVariants.each ya no funciona. Use android.applicationVariants.all lugar. Consulte el registro de cambios en android.com : el acceso al contenedor de variantes no obliga a crear la tarea. Esto significa Android. [Aplicación | Biblioteca | Prueba] Las variantes estarán vacías durante la fase de evaluación. Para usarlo, use .all en lugar de .each

Answer 4

con las respuestas aquí y la ayuda de + Hugo Visser que me contestó en mi pregunta de Google+ obtuve esta configuración de build.grade, que permite construcciones de calidad superior Y también agrega la ruta de salida apt en Android Studio como directoras de origen.

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath ''com.android.tools.build:gradle:0.5.+''
    }
}
apply plugin: ''android''

repositories {
    mavenCentral()

    maven {
        url ''https://oss.sonatype.org/content/repositories/snapshots/''
    }
}

ext.androidAnnotationsVersion = ''3.0-SNAPSHOT'';

configurations {
    apt
}

dependencies {
    compile ''com.android.support:support-v4:13.0.+''

    apt "org.androidannotations:androidannotations:${androidAnnotationsVersion}"
    compile "org.androidannotations:androidannotations-api:${androidAnnotationsVersion}"
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 17
    }
}

def getSourceSetName(variant) {
    return new File(variant.dirName).getName();
}

android.applicationVariants.all { variant ->
    def aptOutputDir = project.file("build/source/apt")
    def aptOutput = new File(aptOutputDir, variant.dirName)
    println "****************************"
    println "variant: ${variant.name}"
    println "manifest:  ${variant.processResources.manifestFile}"
    println "aptOutput:  ${aptOutput}"
    println "****************************"

    android.sourceSets[getSourceSetName(variant)].java.srcDirs+= aptOutput.getPath()

    variant.javaCompile.options.compilerArgs += [
            ''-processorpath'', configurations.apt.getAsPath(),
            ''-AandroidManifestFile='' + variant.processResources.manifestFile,
            ''-s'', aptOutput
    ]

    variant.javaCompile.source = variant.javaCompile.source.filter { p ->
        return !p.getPath().startsWith(aptOutputDir.getPath())
    }

    variant.javaCompile.doFirst {
        aptOutput.mkdirs()
    }
}

ACTUALIZACIÓN: actualizado para gradle android plugin 0.5.5; cambiado android.applicationVariants.each a android.applicationVariants.all

Answer 5

esta es una actualización de la respuesta que hace las siguientes cosas:

• funciona con Android Studio 0.1.9
• elimina errores de sintaxis de IDE (incluso en reconstrucciones)
• usa androidannotaciones sin daga

Para lograr esto copio la salida para construir / fuente / r que permanecerá marcada como fuente durante las reconstrucciones.

import groovy.io.FileType

buildscript {
}

apply plugin: ''android''

repositories {
    mavenCentral()
}

ext.androidAnnotationsVersion = ''2.7.1'';

configurations {
    apt
}

dependencies {
    apt "com.googlecode.androidannotations:androidannotations:${androidAnnotationsVersion}"
    compile "com.googlecode.androidannotations:androidannotations-api:${androidAnnotationsVersion}"
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 10
        targetSdkVersion 16
    }
}

android.applicationVariants.each { variant ->
    aptOutput = file("${project.buildDir}/source/r/${variant.dirName}")
    println "****************************"
    println "variant: ${variant.name}"
    println "manifest:  ${variant.processResources.manifestFile}"
    println "aptOutput:  ${aptOutput}"
    println "****************************"

    variant.javaCompile.doFirst {
        println "*** compile doFirst ${variant.name}"
        aptOutput.mkdirs()

        aptOutput.eachFileRecurse FileType.FILES, {
            if (it.name.equals(''R.java'')) {
                return
            }
            it.delete()
        }

        variant.javaCompile.options.compilerArgs += [
                ''-processorpath'', configurations.apt.getAsPath(),
                ''-AandroidManifestFile='' + variant.processResources.manifestFile,
                ''-s'', aptOutput
        ]
    }
}

Las sugerencias de mejora aún bastante hacky son bienvenidas

EDITAR el modo android-apt

Recientemente se lanzó un paquete llamado android-apt https://bitbucket.org/hvisser/android-apt/overview que facilita mucho las cosas (la versión 1.1 tiene las necesidades de soporte de anotaciones de Android)

Simplemente actualice su build.gradle así:

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath "com.neenbedankt.gradle.plugins:android-apt:1.1"
    }
}

apply plugin: ''android-apt''

apt {
    arguments {
        androidManifestFile variant.processResources.manifestFile
    }
}

dependencies {
    apt ''com.googlecode.androidannotations:androidannotations:2.7.+''
}

Un gran agradecimiento para hvisser el creador de android-apt

Answer 6

El proyecto ahora tiene documentación actualizada para este caso. Un proyecto de ejemplo completo también existe.

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        // replace with the current version of the Android plugin
        classpath ''com.android.tools.build:gradle:0.7.3+''
        // the latest version of the android-apt plugin
        classpath ''com.neenbedankt.gradle.plugins:android-apt:1.2+''
    }
}

apply plugin: ''android''
apply plugin: ''android-apt''

repositories {
    mavenCentral()
}

android {
    compileSdkVersion 19
    buildToolsVersion "19.0.1"

    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 19
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            runProguard false
            proguardFiles getDefaultProguardFile(''proguard-android.txt''), ''proguard-rules.txt''
        }
    }
}

apt {
    arguments {
        androidManifestFile variant.processResources.manifestFile

        // If you''re using Android NBS flavors you should use the following line instead of hard-coded packageName
        //resourcePackageName android.defaultConfig.packageName
        resourcePackageName "com.example.your.package.name"

        // You can set optional annotation processing options here, like these commented options:
        // logLevel ''INFO''
        // logFile ''/var/log/aa.log''
    }
}

dependencies {
    apt "org.androidannotations:androidannotations:3.0+"
    compile "org.androidannotations:androidannotations-api:3.0+"
}