Develop Reference

Gradle project is not able to find JavaFX Application class despite adding JavaFX plugin

I am new to both Gradle and JavaFX. I have added the JavaFX plugin to my build.gradle following this and this. However, my main class Library.java is not able to detect the Application class of JavaFX when I am trying to extend it.
build.gradle
plugins {
// Apply the java-library plugin to add support for Java Library
id 'java-library'
id 'application'
id 'org.openjfx.javafxplugin' version '0.0.8'
}
repositories {
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
mavenCentral()
}
dependencies {
// This dependency is exported to consumers, that is to say found on their compile classpath.
api 'org.apache.commons:commons-math3:3.6.1'
// This dependency is used internally, and not exposed to consumers on their own compile classpath.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
}
jar {
manifest {
attributes 'Main-Class': 'Chess.Library'
}
}
mainClassName = 'Chess.Library'
Screenshot of Library Class
There's no Application from javafx package at all. What am I missing here?
I am using Spring Tool Suite 4.0 as my IDE with Buildship Gradle plugin if that's of any help. I am also running on Oracle Java 13
Edit 1:
I have added the changes suggested and this is how my build.gradle now looks
plugins {
// Apply the java-library plugin to add support for Java Library
id 'java-library'
id 'application'
id 'org.openjfx.javafxplugin' version '0.0.8'
}
repositories {
// Use jcenter for resolving dependencies.
// You can declare any Maven/Ivy/file repository here.
jcenter()
mavenCentral()
}
dependencies {
// This dependency is exported to consumers, that is to say found on their compile classpath.
api 'org.apache.commons:commons-math3:3.6.1'
// This dependency is used internally, and not exposed to consumers on their own compile classpath.
implementation 'com.google.guava:guava:28.0-jre'
// Use JUnit test framework
testImplementation 'junit:junit:4.12'
}
jar {
manifest {
attributes 'Main-Class': 'Chess.Library'
}
}
javafx {
version = "13"
modules = [ 'javafx.controls' ]
}
mainClassName = 'Chess.Library'
But the problem is still there
I also checked my Project and External Dependencies, there are all the libraries except for javafx

I fixed the issue myself although not sure what was causing it, but my project's buildpath had an unbounded Java 13. Fixing that and restarting the IDE took care of it

Why does gradle try to download a Kotlin compiler during :app:lint?

I was trying to gradle build a plain Java Android project. It was an ADT project imported to Android Studio. To my astonishment, at one point Gradle tried to download the Kotlin compiler!
* What went wrong:
Execution failed for task ':app:lint'.
> Could not resolve all files for configuration ':app:lintClassPath'.
> Could not download kotlin-compiler.jar (com.android.tools.external.com-intellij:kotlin-compiler:26.2.0)
> Could not get resource 'https://dl.google.com/dl/android/maven2/com/android/tools/external/com-intellij/kotlin-compiler/26.2.0/kotlin-compiler-26.2.0.jar'.
> Read timed out
Why the heck did gradle attempt downloading a big package like the Kotlin compiler
How do I prevent that?
More generally, how do make gradle ask me before it tries to download anything or at least prevent it from downloading non-dependencies? Such things should be installed by my distro's package manager, after all!

1) Because Gradle supports linting Kotlin code, which requires parsing it, which is implemented using classes in the Kotlin compiler.
2) By not using the lint task I guess?
3) The Kotlin compiler is a dependency. Gradle requires a specific version of this dependency in a specific layout and in a specific location, and it can't use a version installed by your package manager.

change
buildscript {
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
}
}
allprojects {
repositories {
google()
jcenter()
}
}
to
buildscript {
repositories {
google()
maven {
url "https://maven2.google.com"
}
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
}
}
allprojects {
repositories {
google()
maven {
url "https://maven2.google.com"
}
jcenter()
}
}

Android studio "Could not find method implementation() for arguments"

I'm very new to Android studio and Gradle so please be specific with your suggestions.
I downloaded this git repository because I needed a template of an app with OCR integrated into it. The project was built in Eclipse so I used the Android Studio Import tool to convert it to an Android Studio project. After attempting to build the project and resolving the first few errors by clicking on the links inside the errors, I got the "Could not find method implementation()" error which I can't seem to resolve.
NOTE - I installed Android Studio just today so I have everything updated.
This is what my build.gradle file looks like:
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
jcenter()
google()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.1.3'
implementation 'com.rmtheis:tess-two:9.0.0'
}
}
allprojects {
repositories {
jcenter()
google()
}
}

You need to add this
implementation 'com.rmtheis:tess-two:9.0.0'
in build.gradle app file under dependencies instead of build.gradle project file.
build.gradle
dependencies {
//...
implementation 'com.rmtheis:tess-two:9.0.0'
//...
}

Error:(30, 0) Could not find method compile() for arguments

I get this error. I'm pretty confused because i check everything in sdk manager and it's all updated (i think so).
Error:(30, 0) Could not find method compile() for arguments
[com.android.support:appcompat-v7:+] on object of type
org.gradle.api.internal.artifacts.dsl.dependencies.DefaultDependencyHandler.
Please install the Android Support Repository from the Android SDK
Manager. Open Android SDK Manager
Is there something wrong with my code in build.grandle:
// Top-level build file where you can add configuration options common to all sub-projects/modules.
buildscript {
repositories {
google()
jcenter()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.0.0'
// NOTE: Do not place your application dependencies here; they belong
// in the individual module build.gradle files
}
}
allprojects {
repositories {
google()
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
dependencies {
compile 'com.android.support:appcompat-v7:+'
}
or is something missing...?

You can't use the compile() DSL in the top level file.
Delete this block:
dependencies {
compile 'com.android.support:appcompat-v7:+'
}
and add the dependency in the dependencies block inside the app/build.gradle file.

You should not use "compile" when using Gradle build tools 3.0.0.
"compile" has been replaced with "implementation".
And you can't add dependencies in the project build.gradle file.
You have to add dependencies in the module build.gradle file.
So in the build.gradle file in the "app" directory, add these lines:
dependencies {
implementation 'com.android.support:appcompat-v7:+'
}
The "dependencies" block might already be there, if so, just add the contents to the original block.

Transitive dependencies not resolved for aar library using gradle

I have investigated a while and probably saw most popular answers here related to aar and transitive dependencies but somehow it is still not clear for me how to make this working.
So:
I have android library with given gradle config:
apply plugin: 'android-library'
apply plugin: 'android-maven'
version = "1.0.0"
group = "com.somepackage"
buildscript {
repositories {
mavenCentral()
mavenLocal()
}
dependencies {
classpath 'com.github.dcendents:android-maven-plugin:1.0'
}
}
android {
compileSdkVersion 19
buildToolsVersion '19.0.3'
defaultConfig {
minSdkVersion 10
}
}
repositories {
maven { url 'http://www.bugsense.com/gradle/' }
}
dependencies {
provided 'com.google.android.gms:play-services:+'
provided 'com.android.support:appcompat-v7:+'
compile 'com.google.code.gson:gson:2.2.4'
compile 'com.bugsense.trace:bugsense:3.6'
compile 'commons-net:commons-net:3.3'
}
Then I am deploying it to local maven repo with gradle install. POM file of the deployed library looks like this:
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>com.sprezzat</groupId>
<artifactId>app</artifactId>
<version>1.0.0</version>
<packaging>aar</packaging>
<dependencies>
<dependency>
<groupId>com.bugsense.trace</groupId>
<artifactId>bugsense</artifactId>
<version>3.6</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.3</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.2.4</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
And finally gradle config of my android application using above library as a dependency:
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:0.9.+'
}
}
apply plugin: 'android'
repositories {
mavenCentral()
mavenLocal()
}
android {
compileSdkVersion 15
buildToolsVersion "19.0.2"
defaultConfig {
minSdkVersion 10
targetSdkVersion 18
}
}
dependencies {
compile 'com.google.android.gms:play-services:+'
compile 'com.android.support:appcompat-v7:+'
compile 'com.somepackage:LIBRARY_NAME:1.0.0#aar'
}
And after deploying application on phone I am getting NoClassDefFoundError for classes belonging to compile dependencies of my android library.
Inspecting my android application dependencies using gradle dependencies:
apk - Classpath packaged with the compiled main classes.
+--- com.google.android.gms:play-services:+ -> 4.3.23
| \--- com.android.support:support-v4:19.0.1 -> 19.1.0
+--- com.android.support:appcompat-v7:+ -> 19.1.0
| \--- com.android.support:support-v4:19.1.0
\--- com.somepackage:LIBRARY_NAME:1.0.0
According to above tree, all transitive dependencies are not detected. Where is the problem and how should it be done correctly?

I have solved my problem by setting transitive attribute for my aar dependency:
compile ('com.somepackage:LIBRARY_NAME:1.0.0#aar'){
transitive=true
}

you should not use "#aar", if use "#" is become "Artifact only notation", if you want to use "#" and want have dependence transitive, you should add "transitive=true"

Try this if you are using aar locally:
compile(project(:your-library-name)) {
transitive=true
}

I was having a similar problem and felt I could share the steps of solving the problem.
The basic idea of not being able to use the transitive dependencies while you are publishing your own aar is actually not having the .pom file generated with the expected transitive dependencies.
I was using 'maven-publish' plugin for my android aar dependency to publish it in my own private maven repository. The transitive dependencies were not resolved when my other projects were adding my aar dependency in their build.gradle. Hence here what I did to modify the .pom file while publishing my aar.
An important thing to note here that, the dependencies which you want to have the transitive behavior should be imported using the api in your library project's build.gradle file like the following.
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
api 'com.android.volley:volley:1.0.0'
api "com.google.code.gson:gson:$globalGsonVersion"
}
Now as I said earlier, I was using maven-publish plugin to publish the aar dependency and hence my publishing task in the gradle looks like the following.
publishing {
publications {
mavenAar(MavenPublication) {
from components.android
}
mavenJava(MavenPublication) {
pom.withXml {
def dependenciesNode = asNode().appendNode('dependencies')
// Iterate over the api dependencies (we don't want the test ones), adding a <dependency> node for each
configurations.api.allDependencies.each {
def dependencyNode = dependenciesNode.appendNode('dependency')
dependencyNode.appendNode('groupId', it.group)
dependencyNode.appendNode('artifactId', it.name)
dependencyNode.appendNode('version', it.version)
}
}
}
}
repositories {
maven {
// Your repository information goes here
}
}
}
Hence, I used another mavenJava task to publish the .pom file in my private maven repo so that when the aar file is added as a dependency to some other module, it gets the .pom information and download the transitive dependency.
To complete the answer, this is how you should add the dependency in the build.gradle file for your own published aar to me imported.
api('com.example.masudias:my_lib:1.0.0#aar') {
transitive = true
}

Transitive dependency
transitive means that the consumer(e.g. app) includes a producer and all producer's dependencies(e.g. libraries). It increase build time and can create some issues with dependency versions
By default, Gradle dependency has transitive = true
api ('com.package:library:0.0.1')
//the same
api ('com.package:library:0.0.1') {
transitive = true
}
When you use #artifact notation it has transitive = false
api ('com.package:library:0.0.1#aar')
//the same
api ('com.package:library:0.0.1#aar') {
transitive = false
}

For me complete publishing solution looks like this:
apply plugin: 'com.github.dcendents.android-maven'
group = GROUP
version = VERSION
// you could move it to env variable or property
def publishFlavorless = true
def firstTask = null
android.libraryVariants.all { variant ->
if (variant.name.toLowerCase().contains("debug")) {
// Workaround for https://github.com/gradle/gradle/issues/1487
if (publishFlavorless && firstTask == null) {
def bundleTask = tasks["bundle${variant.name.capitalize()}Aar"]
firstTask = bundleTask
artifacts {
archives(firstTask.archivePath) {
builtBy firstTask
name = project.name
}
}
}
return
}
def bundleTask = tasks["bundle${variant.name.capitalize()}Aar"]
artifacts {
archives(bundleTask.archivePath) {
classifier variant.flavorName
builtBy bundleTask
name = project.name
}
}
}
install {
repositories.mavenInstaller {
// This generates POM.xml with proper parameters
pom.project {
name POM_NAME
artifactId POM_ARTIFACT_ID
// For aar it is equal to 'aar' with jar transitive dependencies won't work
packaging POM_PACKAGING
description POM_DESCRIPTION
}
}
}
The transitive = true block is required as well ...

AAR file doesn't contain transitive dependencies. So even if use api instead of implementation it wont work.
In our team we had developed a library to use in our applications and we wanted it to be for internal use only. Earlier we used to include whole module that seems to work. Later we decided to move to aar file but we were also facing same issue of classpath not found. After some research we came to know that we can also use local maven repo. We decided to use that.
Here is step by step process
Publishing repo
1.In your Library's root build.gradle file you need to include
id 'com.github.dcendents.android-maven' version '2.0' apply false
2.In you library's module level build.gradle file you need to add
a) In plugins
id 'maven-publish'
b) At bottom of gradle file add
publishing {
publications {
release(MavenPublication) {
groupId = 'com.demo.android'
artifactId = 'qrcodescanner'
version = '1.0.0'
afterEvaluate {
from components.release
}
}
}
repositories {
maven {
name = "qrcodescanner"
url = "${project.buildDir}/repo"
}
}
}
3.Depends on the name you have given a gradle tasks will be generated you can check using gradlew tasks or by using gradle window at top right corner in android studio, Our was
publishReleasePublicationToQrcodescannerRepository
4.Run it and repo will be generated in given path
gradlew publishReleasePublicationToQrcodescannerRepository
Final step you need to publish it to maven local using
gradlew publishToMavenLocal
if it doesn't work you can try gradlew clean and gradlew build before executing it.
Using local repo
1.You need to add mavenLocal() in root level build.gradle file of your project you wanted to use it in like this before other central repos
allprojects {
repositories {
mavenLocal()
google()
jcenter()
maven { url "https://jitpack.io" }
mavenCentral()
}
}
Now you need to include your dependency in the project like we do with other dependencies as well
implementation 'com.demo.android:qrcodescanner:1.0.0'
keep in mind format should groupdId:artifactId:version
That's it.
References :
Publish Library
Local Maven

Simply adding #aar at the end of the dependency is what worked for me.
dependencies {
implementation 'org.videolan.vlc:libvlc:3.0.13#aar'
}