android-build

KO | EN

gitlite — search

#python #java #python3 #arduino #golang #machine-learning #rust #html #flask #javascript #seismology #nodejs

★ 14 Open GitHub ↗

Example project and instructions for building and distributing Android projects for CI servers

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

#Rocketmade Jenkins CI Setup Guide for Android

Distributing builds for Android will rely on the Crashlytics framework.

##1. Add the Fabric Maven repo, and the Fabric gradle to the classpath

_build.gradle_
```gradle
buildscript {
    repositories {
        maven { url 'https://maven.fabric.io/public' }
    }

dependencies {
        classpath 'io.fabric.tools:gradle:1.+'
    }
}
```

##2. Add the Fabric plugin AFTER the com.android.application plugin

_build.gradle_
```gradle
apply plugin: 'com.android.application'
apply plugin: 'io.fabric'
```

##3. Add the Fabric Maven repository below the apply plugin command

_build.gradle_
```gradle
repositories {
    maven { url 'https://maven.fabric.io/public' }
}

```

##4. Add the release notes, and the name of the distribution group to `buildTypes` or `productFlavors`

_build.gradle_
```gradle
def releaseNotes = 'git log --pretty=format:"%s" --since "yesterday"'.execute([], project.rootDir).text.trim()

android {
  buildTypes {
      release {
        ...
      }
      debug {
        ...
      }
      staging {
          debuggable false
          applicationIdSuffix ".stg"
          versionNameSuffix " Stg"
          signingConfig signingConfigs.release
          ext.betaDistributionReleaseNotes=releaseNotes
          ext.betaDistributionGroupAliases="INSERT DISTRIBUTION GROUP NAME HERE"
      }
  }
}
```

##5. Add the Crashlytics sdk to the gradle dependencies

_build.gradle_
```gradle
compile('com.crashlytics.sdk.android:crashlytics:+@aar') {
    transitive = true;
}
```

##6. Create a Fabric.properties file in the app/ directory, include the info:

_fabric.properties_
```ini
apiSecret=YOUR_BUILD_SECRET
apiKey=YOUR_API_KEY
```

_AndroidManifest.xml_
##7. Include the API key in your AndroidManifest.xml

```xml
<meta-data
            android:name="io.fabric.ApiKey"
            android:value="API_KEY"/>

```

##8. Start Crashlytics in your Application subclass onCreate

_MyApplication.java_
```java
private void setupFabric() {
    // Set up Crashlytics, disabled for debug builds
    Crashlytics crashlyticsKit = new Crashlytics.Builder()
            .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
            .build();

// Initialize Fabric with the debug-disabled crashlytics.
    Fabric.with(this, crashlyticsKit);
}
```

##9. Create a new Jenkins project

* Log in to the CI server, Click "New Item", and enter the Project name with Freestyle project selected

* On the next page, enter the Project Name and Description

* Under the Source Code Management section, select git and enter the repository URL. For example, `git@github.com:organization-name/repo-name.git`

* Under branches to build, enter `**dev`

* If you want to be able to trigger builds from the command line, check the box `Trigger builds remotely`  and enter an authentication token of your choosing.

##10. Distribute

Enter the following script into the `Execute shell` section:

```bash
# These might already be set, but set them to your ANDROID_HOME and JAVA_HOME locations if not
export ANDROID_HOME="/Users/ci/Android/android-sdk-macosx"
export JAVA_HOME=$(/usr/libexec/java_home)

./gradlew clean
./gradlew assembleDebug
./gradlew crashlyticsUploadDistributionDebug

```

##11. Save the Jenkins project

That's it! The CI server now has everything it needs to build the project.

##12. Trigger CI builds from the command line

Create a file name `ci.sh` in your project root. Add the following script:

_ci.sh_
```bash
#!/bin/bash

# Usage: run ./ci.sh to trigger a CI Build.
# Get $JENKINS_USERNAME and $JENKINS_API_TOKEN from environment (store in a .env file and use AutoEnv)

JENKINS_URL="JENKINS_URL/job/PROJECT_NAME/build?token=BUILD_TOKEN" # replace with your URL
curl -u $JENKINS_USERNAME:$JENKINS_API_TOKEN $JENKINS_URL
```

and add the following to a `.env` file in the project root:

_.env_
```bash
export JENKINS_USERNAME="YOUR-USERNAME-GOES-HERE"
export JENKINS_API_TOKEN="YOUR-API-TOKEN-GOES-HERE"
```

To get JENKINS_API_TOKEN, log into Jenkins, click on your name in the top right corner, click `configure` on the left, then click `Show API Token..`

You can now either run `source .env`, or use [AutoEnv](https://github.com/kennethreitz/autoenv) to automatically source your `.env` files when you `cd` into your project.

Run `./ci.sh` to remotely trigger a CI build.

android-build

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README