Publish AAR to jCenter and Maven Central

Publish AAR to jCenter and Maven Central

Publish AAR to jCenter and Maven Central
=================

[![Twitter](https://img.shields.io/badge/Twitter-@LopezMikhael-blue.svg?style=flat)](http://twitter.com/lopezmikhael)

Now I'm going to list how to publish an Android libray to jCenter and then syncronize it with Maven Central:

1. I use "Android Studio" and I have this simple android lib that I would like to be available on maven: [CircularImageView](https://github.com/lopspower/CircularImageView)

2. In the library folder(module) I have the lib code abovementioned. And applying in the build.gradle of this folder `apply plugin: 'com.android.library'` I got as output an .aar in the build/outputs/aar/ directory of the module's directory

  Warning: The module name is very important. So I renamed my module "CircularImageView-Library" in "circularimageview". Indeed, this name is your artifactId. ([Previous probleme](http://stackoverflow.com/questions/33104152/publish-github-android-library-to-maven-central/33121335))

3. Register to [Sonatype](https://issues.sonatype.org/secure/Dashboard.jspa), I registered with username `lopspower`

4. In the [Sonatype OSS Repository](https://issues.sonatype.org/secure/Dashboard.jspa) I registered a project opening a new Issue:<br>
`Create → Create Issue → Community Support - Open Source Project Repository Hosting → New Project → with groupid com.github.lopspower`<br>
Remember that "only one JIRA issue per top-level groupId is necessary. You have all the necessary permissions to deploy any new artifacts to this groupId or any sub-groups".

5. Register to Bintray with a `username`, the one used by me is: `lopspower`

6. Enable the automatically signing of the uploaded content:<br>
from Bintray [profile url](https://bintray.com/profile/edit) → GPG Signing → copy paste your gpg armored `public` and `private` keys.<br>

  UNIX/MAC:
  You can find respectively these two keys in files `public_key_sender.asc` and `private_key_sender.asc`
  if you execute the following code (the `-a` or `--armor` option in `gpg`is used to generate ASCII-armored key pair):

  ``` bash
  gpg --gen-key    # generates the key pair
  gpg --list-keys  # get your PubKeyId (this value is used in the line below)
  gpg --keyserver hkp://pool.sks-keyservers.net --send-keys PubKeyId  # publish your Key
  gpg -a --export lopez.mikhael@gmail.com > public_key_sender.asc
  gpg -a --export-secret-key lopez.mikhael@gmail.com > private_key_sender.asc
  ```
  
  WINDOWS:
  Generated your gpg key with [http://www.gpg4win.org/](http://www.gpg4win.org/)

7. In the same [web page](https://bintray.com/profile/edit) you can configure the auto-signing from:<br>
`Repositories → Maven → Check the "GPG Sign uploaded files automatically" → Update`

8. In the same [web page](https://bintray.com/profile/edit) you can find your `Bintray API Key` (simply copy it for a later use)

9. In the same [web page](https://bintray.com/profile/edit) you can configure your `Sonatype OSS User` (created at previous step 3) from the `Account` link

10. Add these two lines to the `build.gradle` in the root of your project
  ``` gradle
  classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
  classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.1'
  ```
So that your `build.gradle` in the root looks like this:
  ``` gradle
  buildscript {
      repositories {
          jcenter()
      }
      dependencies {
          classpath 'com.android.tools.build:gradle:1.3.0'
          classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'
          classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.1'
      }
  }
  
  allprojects {
      repositories {
          jcenter()
      }
  }
  ```
11. Modify the `build.gradle` located inside the library folder.<br>
  I modified mine from this:
  ``` gradle
  apply plugin: 'com.android.library'
  
  android {
      compileSdkVersion 23
      buildToolsVersion "23.0.1"
  
      defaultConfig {
          minSdkVersion 11
          targetSdkVersion 23
          versionCode 4
          versionName "2.0.1"
      }
      buildTypes {
          release {
              minifyEnabled false
              proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
          }
      }
  }
  
  dependencies {
      compile fileTree(dir: 'libs', include: ['*.jar'])
  }
  ```
  To this one:

  ``` gradle
  apply plugin: 'com.android.library'
  apply plugin: 'com.github.dcendents.android-maven'
  apply plugin: "com.jfrog.bintray"
  
  // This is the library version used when deploying the artifact
  version = "2.0.1"
  
  android {
      compileSdkVersion 23
      buildToolsVersion "23.0.1"
  
      defaultConfig {
          minSdkVersion 11
          targetSdkVersion 23
          versionCode 4
          versionName version
      }
      buildTypes {
          release {
              minifyEnabled false
              proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
          }
      }
  }
  
  dependencies {
      compile fileTree(dir: 'libs', include: ['*.jar'])
  }
  
  def siteUrl = 'https://github.com/lopspower/CircularImageView'      // Homepage URL of the library
  def gitUrl = 'https://github.com/lopspower/CircularImageView.git'   // Git repository URL
  group = "com.mikhaellopez"                                          // Maven Group ID for the artifact
  
  install {
      repositories.mavenInstaller {
          // This generates POM.xml with proper parameters
          pom {
              project {
                  packaging 'aar'
  
                  // Add your description here
                  name 'com.mikhaellopez:circularimageview' // TODO 
                  description = 'Description of your project HERE' // TODO
                  url siteUrl
  
                  // Set your license
                  licenses {
                      license {
                          name 'The Apache Software License, Version 2.0'
                          url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                      }
                  }
                  developers {
                      developer {
                          id 'lopspower' // TODO
                          name 'Mikhael Lopez' // TODO
                          email 'lopez.mikhael@gmail.com' // TODO
                      }
                  }
                  scm {
                      connection gitUrl
                      developerConnection gitUrl
                      url siteUrl
                  }
              }
          }
      }
  }
  
  task sourcesJar(type: Jar) {
      from android.sourceSets.main.java.srcDirs
      classifier = 'sources'
  }
  
  task javadoc(type: Javadoc) {
      source = android.sourceSets.main.java.srcDirs
      classpath += project.files(android.getBootClasspath().join(File.pathSeparator))
  }
  
  task javadocJar(type: Jar, dependsOn: javadoc) {
      classifier = 'javadoc'
      from javadoc.destinationDir
  }
  artifacts {
      archives javadocJar
      archives sourcesJar
  }
  
  Properties properties = new Properties()
  properties.load(project.rootProject.file('local.properties').newDataInputStream())
  
  // https://github.com/bintray/gradle-bintray-plugin
  bintray {
      user = properties.getProperty("bintray.user")
      key = properties.getProperty("bintray.apikey")
  
      configurations = ['archives']
      pkg {
          repo = "maven"
          // it is the name that appears in bintray when logged
          name = "com.mikhaellopez:circularimageview" // TODO
          websiteUrl = siteUrl
          vcsUrl = gitUrl
          licenses = ["Apache-2.0"]
          publish = true
          version {
            gpg {
                sign = true //Determines whether to GPG sign the files. The default is false
                passphrase = properties.getProperty("bintray.gpg.password") //Optional. The passphrase for GPG signing'
            }
        }        
      }
  }
  ```

12. Add to the `local.properties` in the root of the project the following lines (remember that this file should never be uploaded on your public repository):

  ``` gradle
  bintray.user=<your bintray username>
  bintray.apikey=<your bintray api key>
    
  bintray.gpg.password=<your gpg signing password>
  bintray.oss.user=<your sonatype username>
  bintray.oss.password=<your sonatype password>
  ```
  
13. Open "Android Studio" terminal and execute:

  ``` bash
  gradlew bintrayUpload
  ```
  
  Warning : If you don't have permission to execute gradlew : `$ chmod +x gradlew`

14. From [Bintray](https://bintray.com/) → My Recent Packages → com.mikhaellopez:circularimageview (this is here only after the execution of the previous point 13) → Add to Jcenter → Check the box → Group Id = "com.mikhaellopez".<br>
This will request a review and public listing of your library on jCenter repository. This request can be quite long. You will receive a confirmation email but you can check [jcenter.bintray.com](http://jcenter.bintray.com/) to see if your library is syncronise.

  Now you can import your library with jcenter like that :

  build.gradle (Project):
  ``` gradle
  repositories {
    jcenter()
  }
  ```
  
  build.gradle (Module):
  ``` gradle
  dependencies {
    compile 'com.mikhaellopez:circularimageview:2.0.1'
  }
  ```
  
  If you use the default of Android Studio, jcenter() you could simply import like this (for me it doesn't work without the   exactly version, i.e. with the plus gives me an error). To do that you need to sync with Maven Central (Next Step)
  
  ``` gradle
  dependencies {
    compile 'com.mikhaellopez:circularimageview:+'
  }
  ```

15. Finally Sync all with Maven Central following: Bintray → My Recent Packages → com.mikhaellopez:circularimageview → Maven Central → Sync. You can check [repo.maven.apache.org/maven2/](https://repo.maven.apache.org/maven2/) to see if your library is syncronise.

  Warning : It isn't clear but the "User token password" actually corresponds to the password of your Sonatype account.

16. Now your library should be automatically imported both from Maven Central and from Bintray, you can import with something like this:<br>

  build.gradle (Project):
  ``` gradle
  repositories {
    mavenCentral()
  }
  ```

  build.gradle (Module):
  ``` gradle
  dependencies {
    compile 'com.mikhaellopez:circularimageview:+'
  }
  ```

***

:books: Best Android Gists
=================

You can see other best Android Gists or offer your just here [https://github.com/lopspower/BestAndroidGists](https://github.com/lopspower/BestAndroidGists) :+1:.