How to create my own android library and host it

Question

I'm working on creating a log-in screen to be used with multiple different android applications. What would be the best way to package it so that other people could use my log-in function on their apps. It would be preferred that it would auto-sync for them in-case we were to make changes. ***EDIT**** It seems packaging it into a library module is the best option. How does one go about uploading this module so that if we make an update to this module it will seamlessly update without having to pull from github for example.

Thanks!

Answer 1

If you've pushed your code to GitHub then sharing the library (aar) is easy with JitPack.

Your users will just need to add the repository to their build.gradle:

repositories {
    jcenter()
    maven { url "https://jitpack.io" }
}

and then your GitHub repository as dependency:

dependencies {
    // ...
    compile 'com.github.YourUsername:Repo:Release'
}

The nice thing is that you don't have to upload your library. Behind the scenes JitPack will check out the code from GitHub and compile it. As you publish a new release on GitHub it becomes available for others to use.

There is also a guide on how to prepare an Android project.

Answer 2

make the package or jar depending on your source, and post it on git hub the you can refer to the git from your ide to import or check for updates.

Answer 3

You can package the library into an AAR format. It will also contain the resources you used in your login module. After that you can push the AAR library format to bintray (which is free, and allows you to setup your own repository).

Your collaborators can then access the library using a dependency that looks like:

compile 'com.newsom:awesome-login-screen:0.5'

Check this starter tutorial if you are using AndroidStudio/Gradle and would like to push it to bintray. https://github.com/jimcoven/android-bintray-kit

Answer 4

Make the relevant classes into a library module - you already seem to know how to do that - and then use the Gradle Bintray plugin to upload it to JCenter.

Let's say you set group in build.gradle to com.ryan-newsom, version to 1.0 and the project name is android-log-in-screen.

(part of) android-log-in-screen/build.gradle:

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:0.6"
    }
}

apply plugin: 'com.jfrog.bintray'

group = 'com.ryan-newsom'
version = '1.0'

bintray {
    // Omitted for brevity, refer to the examples on GitHub.
}

You (or anyone else) can then use it in your project by adding the following:

(part of) other-project/build.gradle:

repositories {
    jcenter()
}

dependencies {
    compile "com.ryan-newsom:android-log-in-screen:1.0"
}

The library will then be pulled from JCenter and added to the classpath.

Answer 5

The best way to create a lib and make it available to other developers is creating a AAR so that developers can import it in their project using dependencies.

The process is quite long. These are the main steps you should follow to publish your lib:

• Register an account and create a new ticket (https://issues.sonatype.org)
• Download (if you use OS X) GPGTools (http://www.gpgtools.org/)
• Modify project gradle files
• Create signing key Build
• sign and publish your files to the Staging repository

I wrote a post about it and to have more details you can look here. This is a piece of gradle file called maven_push.gradle:

apply plugin: 'maven'
apply plugin: 'signing'

def sonatypeRepositoryUrl
if (isReleaseBuild()) {
    println 'RELEASE BUILD
    sonatypeRepositoryUrl = hasProperty('RELEASE_REPOSITORY_URL') ? RELEASE_REPOSITORY_URL
            : "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
} else {
    println 'SNAPSHOT BUILD'
    sonatypeRepositoryUrl = hasProperty('SNAPSHOT_REPOSITORY_URL') ? SNAPSHOT_REPOSITORY_URL
            : "https://oss.sonatype.org/content/repositories/snapshots/"

}

def getRepositoryUsername() {
    return hasProperty('nexusUsername') ? nexusUsername : ""
}

def getRepositoryPassword() {
    return hasProperty('nexusPassword') ? nexusPassword : ""
}

afterEvaluate { project ->
    uploadArchives {
        repositories {
            mavenDeployer {
                beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }

                pom.artifactId = POM_ARTIFACT_ID

                repository(url: sonatypeRepositoryUrl) {
                    authentication(userName: getRepositoryUsername(), password: getRepositoryPassword())
                }

                pom.project {
                    name POM_NAME
                    packaging POM_PACKAGING
                    description POM_DESCRIPTION
                    url POM_URL

                    scm {
                        url POM_SCM_URL
                        connection POM_SCM_CONNECTION
                        developerConnection POM_SCM_DEV_CONNECTION
                    }

                    licenses {
                        license {
                            name POM_LICENCE_NAME
                            url POM_LICENCE_URL
                            distribution POM_LICENCE_DIST
                        }
                    }

                    developers {
                        developer {
                            id POM_DEVELOPER_ID
                            name POM_DEVELOPER_NAME
                        }
                    }
                }
            }
        }
    }

    signing {
        required { isReleaseBuild() && gradle.taskGraph.hasTask("uploadArchives") }
        sign configurations.archives
    }

    task androidJavadocs(type: Javadoc) {
        source = android.sourceSets.main.allJava
        classpath += project.files(android.plugin.getRuntimeJarList().join(File.pathSeparator))
    }

    task androidJavadocsJar(type: Jar, dependsOn: androidJavadocs) {
        classifier = 'javadoc'
        //basename = artifact_id
        from androidJavadocs.destinationDir
    }

    task androidSourcesJar(type: Jar) {
        classifier = 'sources'
        //basename = artifact_id
        from android.sourceSets.main.allSource
    }

    artifacts {
        //archives packageReleaseJar
        archives androidSourcesJar
        archives androidJavadocsJar
    }
}

while gradle.properties is:

VERSION_NAME= 
VERSION_CODE=1
GROUP=
POM_DESCRIPTION=
POM_URL=
POM_SCM_URL= POM_SCM_CONNECTION=
POM_SCM_DEV_CONNECTION=scm:[email protected]:
POM_LICENCE_NAME=The Apache Software License, Version 2.0 POM_LICENCE_URL=http://www.apache.org/licenses/LICENSE-2.0.txt POM_LICENCE_DIST=repo 
POM_DEVELOPER_ID=
POM_DEVELOPER_NAME=

There is another way but i did not try it and it seems to be easier. Give a look at jitpack.

Hope it helps you.