Annotation Processors support improvements about j2objc-gradle

[confile]

Solution found. See: http://stackoverflow.com/questions/30018865/access-project-extensions-during-task-creation

We can do:

tasks.create(name: "j2objcTranslate", type: J2objcTranslateTask, dependsOn: 'j2objcCycleFinder') 

and at the very end of the file:

j2objcTranslate {
    description "Translates all the java source files in to Objective-C using j2objc"
    srcFiles = J2objcUtils.addJavaFiles(project, 
        files(fileTree(dir: project.projectDir,
                    include: "**/*.java",
                    exclude: project.relativePath(buildDir))), 
        project.j2objcConfig.generatedSourceDirs)
    destDir = file("${buildDir}/j2objc")
}

It works but currently I get 50 files less translated than in the previous solution. MAy you have an idea why.

[brunobowden]

@advayDev1 - should we even have a generatedSourceDirs setting at all? Would it be better for those to be created as source sets instead?

sourceSets {
    apt{
        java{
            srcDir 'build/source/apt'
        }
    }
}

Does this cover all the cases? It would be good to drop this current custom code:

tasks.create(name: 'j2objcTranslate', type: TranslateTask, dependsOn: 'j2objcCycleFinder') {
    additionalSrcFiles = files(
            fileTree(dir: "build/source/apt",
                     include: "**/*.java")
    )
    ...
}

[confile]

@brunobowden good idea:

If this

sourceSets {
    apt{
        java{
            srcDir 'build/source/apt'
        }
    }
}

replaces this:

  generatedSourceDirs "build/source/apt" 

then I am fine with it and strongly support it.

[confile]

@advayDev1 I am also interested in your comment here?

[brunobowden]

@advayDev1 - interested in your thoughts on this

[advayDev1]

sorry didn't see this... i don't think this is right. sourcesets can't just be created automatically using that kind of syntax. we would have to setup named sourcesets for each type of code that could be generated.

assuming you are using annotation processors:
isn't the right solution to have the same annotation processors that run in your standard javac run also run in the j2objc phase and then consume them the same way?

[brunobowden]

@hvisser - Hugo, since you wrote the android-apt plugin, we would appreciate your insights on working with annotation processors for our J2ObjC Gradle Plugin. It takes an existing Java project and then converts it to Objective-C so that it can be built and run on iOS. It uses the J2ObjC project from Google.

Note that this is designed to work with a Java project so that the code can be used server side as well. At the same time, we'd like it to work well within Android Studio where most of the development will be. If you have some insights on this, then it would be great to hear from you.

[hvisser]

OK, I'll try. I can't fully grasp what you are trying to solve in this issue though :) I think the issue is that annotation processors can generate source code that also has to be treated by j2obc?

In essence android-apt just adds some flags to javac to control where the source output lives. Then it uses an API in the build tools to make sure AS will actually use that location as a valid source location. It still has to live under build/generated because all other folders are hidden by AS. Setting the source location used to be done using source sets, but that was quite hacky since it involved modifying source sets after a specific phase in Gradle.

I don't think you can really know where these generated sources end up, because it's sort of an internal thing for javac. It is possible to run javac in a mode that just generates the code from annotations. Maybe you could invoke that command to generate the source in a place where you like to have it for conversion, but you'd have to keep in mind the class path and processor paths that where passed into the original java compile task. And on Android there's a new compile task incubating which is different from JavaCompile so that would need another treatment.

[brunobowden]

@hvisser, please excuse me for not being clearer on this while we figure it out. The basic goal we're aiming for is that whatever project you can build with the Gradle JavaPlugin... you can build the same project as a J2ObjC converted library to run on iOS. We've got growing support for multi-project dependencies. Annotation processors is another upcoming issue.

I think it's best that we first look in to this further as to how best to do it for Java only projects. If you don't mind, please lurk on this thread and give feedback where you can. I can see that this is an area that will need more research from us.

[hvisser]

For Java only projects the same probably applies. Without any plugin, javac will generate the .java files in the classes dir. Configuring additional dirs with java sources like you seem to have now in the plugin sounds like the most flexible option I guess at some extra configuration costs. I'm happy to help out where I can anyway!

[advayDev1]

I like @hvisser's soln from reply 1, para 3:
It is possible to run javac in a mode that just generates the code from annotations.

However, I think we should FR annotation processor running against j2objc. It would be ideal to call j2objc with the same arguments javac would be called, just like we (are supposed to) do with sourcepath and classpath. Then we don't have to coordinate work between javac and j2objc.

[brunobowden]

@tomball - we're formulating some thoughts around how annotation processors work with J2ObjC. With the philosophy of keeping j2objc and javac using the same command line. What are the current limitations if any with J2ObjC's annotation processor support? I see it was initially supported in the 0.9.6 release.

[tomball]

All j2objc does is run the batch compiler and add all generated Java
sources to its sources list. We'll certainly accept contributions that add
javac annotation flags that can be mapped directly to the Eclipse batch
compiler invocation, but we don't have the bandwidth to invest in major
changes. Developers already have the workaround of running "javac
-proc:only" and transpiling the generated sources separately, if they have
exotic processing requirements.

On Thu, Jul 16, 2015 at 11:32 AM Bruno Bowden [email protected]
wrote:

@tomball https://github.com/tomball - we're formulating some thoughts
around how annotation processors work with J2ObjC. With the philosophy of
keeping j2objc and javac using the same command line. What are the current
limitations if any with J2ObjC's annotation processor support? I see it was
initially supported in the 0.9.6 release.

—
Reply to this email directly or view it on GitHub
#45 (comment)
.

[advayDev1]

We've redone our annotation processor support in the 0.5 release.
It is intended to work the Gradle/Javac's default handing of annotation processors.

Check out #517 for more info.
If the new support is not working for you, please file new bugs. What is mentioned in this bug is long obsolete.