Android RoboBinding与retro-lambda的整合

我想在我的android项目中同时使用和

将RoboBinding添加到项目中时，可以选择将其与AspectJ一起使用。但是，每当我打开它时，代码中的lambda表达式都会产生以下编译错误：

错误：错误位于（没有可用的源信息）
/mnt/fcee58daee58daee588f30/AndroidstudioProjects/SpeechACall/app/src/main/java/com/voicesense/personality\u profiling\u dialer/GcmRegistrationHandler.java:1:0:：0无法解析类型java.lang.invoke.MethodHandles。它是从必需的.class文件间接引用的
失败：生成失败，出现异常。
*出了什么问题：
任务“：app:compiledBugAspectJ”的执行失败。
>无法解析类型java.lang.invoke.MethodHandles。它是从必需的.class文件间接引用的
*尝试：
使用--stacktrace选项运行以获取堆栈跟踪。使用--info或--debug选项运行以获得更多日志输出。

这是我的

build.gradle

文件

buildscript {
    repositories {
        mavenCentral()
        maven() {
            name 'RoboBinding AspectJPlugin Maven Repository'
            url "https://github.com/RoboBinding/RoboBinding-aspectj-plugin/raw/master/mavenRepo"
        }
    }

    dependencies {
        classpath 'me.tatarka:gradle-retrolambda:2.4.1'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.+'
        classpath 'org.robobinding:aspectj-plugin:0.8.+'
    }
}

repositories {
    mavenCentral()
}

apply plugin: 'retrolambda'
apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'
apply plugin: 'org.robobinding.android-aspectj'

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.1"

    defaultConfig {
        applicationId "com.voicesense.hr_dialer"
        minSdkVersion 15
        targetSdkVersion 21
    }

    signingConfigs {
        release {
            storeFile file("../../../../../../home/amitai/personality-profiling-dialer_key.keystore")
            storePassword System.getenv("KSTOREPWD")
            keyAlias "alias_name"
            keyPassword System.getenv("KEYPWD")
        }
    }

    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-project.txt'
            signingConfig signingConfigs.release
        }
    }

    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

retrolambda {
    jvmArgs '-noverify'
}

ext {
    //robobindingVersion = 'latest.integration'
    robobindingVersion = '0.8.9'
}


dependencies {
    compile files('libs/acra-4.5.0.jar')
    compile files('libs/ksoap2-android-assembly-3.0.0-jar-with-dependencies.jar')
    compile 'com.google.android.gms:play-services:6.1.71'
    compile 'com.android.support:support-v4:21.0.3'
    compile 'com.android.support:support-v13:20.0.0'
    //compile 'com.netflix.rxjava:rxjava-android:0.20.7'
    compile 'io.reactivex:rxandroid:0.24.0'
    //compile 'com.googlecode.libphonenumber:geocoder:2.16'
    compile 'com.googlecode.libphonenumber:libphonenumber:7.0'
    compile ("org.robobinding:robobinding:$robobindingVersion:with-aop-and-dependencies") {
        exclude group: 'com.google.guava', module: 'guava'
    }

    aspectPath ("org.robobinding:robobinding:$robobindingVersion:with-aop-and-dependencies") {
        exclude group: 'com.google.guava', module: 'guava'
    }
    apt "org.robobinding:codegen:$robobindingVersion"

}

是一个压缩的Android Studio项目，可用于复制（包含一个相关的

build.gradle

文件和一个无法编译的lambda表达式）

经过调查，我发现这与AspectJ与Java8不兼容有关。

---

我相信并有同样的问题。有什么建议吗？

我自己制作的插件支持aspectj和retrolambda。

当项目使用retrolambda时。在编译retrolamda之后，必须使用ant iajc重新编译这些类

    project.configurations {
        aspectjTaskClasspath
        aspectsInPath
    }

    project.repositories {
        mavenCentral()
    }

    def aspectjVersion = '1.8.5';
    project.dependencies {
        //AspectJ
        aspectjTaskClasspath "org.aspectj:aspectjtools:$aspectjVersion"
        compile "org.aspectj:aspectjrt:$aspectjVersion"
    }

    project.afterEvaluate {
        project.android.applicationVariants.all { variant ->

            def buildTypeName = variant.name.capitalize()
            def hasRetrolambda = project.plugins.hasPlugin('me.tatarka.retrolambda')

            def copyDir = new File("${project.buildDir.absolutePath}/copyClasses")
            if (copyDir.exists()) {
                copyDir.deleteDir()
            }
            copyDir.mkdirs()

            def copyClassTask = project.task("copy${buildTypeName}Classes", type: Copy) {
                from variant.javaCompile.destinationDir
                into copyDir
                doLast {
                    variant.javaCompile.destinationDir.deleteDir()
                    variant.javaCompile.destinationDir.mkdirs()
                }
            }

            def aspectsInPaths = [];
            def aspectsInPathsAbsolute = [];
            def aopTask = project.task("compile${buildTypeName}AspectJ") {
                doFirst {
                    project.configurations.aspectsInPath.each {
                        aspectsInPaths.add(it);
                        aspectsInPathsAbsolute.add(it.absolutePath);
                    }
                }

                doLast {
                    ant.taskdef(
                            resource: "org/aspectj/tools/ant/taskdefs/aspectjTaskdefs.properties",
                            classpath: project.configurations.aspectjTaskClasspath.asPath
                    )
                    ant.iajc(
                            source: project.android.compileOptions.sourceCompatibility,
                            target: project.android.compileOptions.targetCompatibility,
                            fork: "true",
                            destDir: variant.javaCompile.destinationDir,
                            bootClasspath: project.android.bootClasspath.join(File.pathSeparator),
                            inpathDirCopyFilter: "java/**/*.class"
                    ) {
                        classpath {
                            variant.javaCompile.classpath.each {
                                if (!aspectsInPathsAbsolute.contains(it)) {
                                    pathElement(location: it)
                                }
                            }
                        }
                        inpath {
                            pathElement(location: copyDir)
                            aspectsInPaths.each {
                                if (!it.name.startsWith("aspectjrt")) {
                                    pathElement(location: it)
                                }
                            }
                        }
                    }
                }
            }
            aopTask.dependsOn(copyClassTask);

            def filterPreDexTask = project.task("filter${buildTypeName}PreDex") {
                doLast {
                    def finalPreDexJars = []
                    project.tasks["preDex${buildTypeName}"].inputFiles.each {
                        if (it.name.startsWith("aspectjrt") ||
                                !aspectsInPathsAbsolute.contains(it.absolutePath)) {
                            finalPreDexJars.add(it)
                        }
                    }
                    project.tasks["preDex${buildTypeName}"].inputFiles = finalPreDexJars
                }
            }
            project.tasks["preDex${buildTypeName}"].dependsOn(filterPreDexTask)



            if (hasRetrolambda) {
                project.tasks["compileRetrolambda$buildTypeName"].finalizedBy(aopTask)
            } else {
                project.tasks["compile${buildTypeName}Java"].finalizedBy(aopTask)
            }

        }
    }

---

我知道现在是时候了，但是你找到解决办法了吗？我实际上已经不再使用RoboBinding了。。所以没有。。