release.jenkinsfile

pipeline {
    agent {
        label 'ubuntu-18.04 && x64 && hw'
    }

    options {
        // Сколько последних сборок храним?
        buildDiscarder(logRotator(numToKeepStr: '10'))
        // Отключаем параллельный запуск
        disableConcurrentBuilds()
    }

    environment {
        JAVA_HOME = '/usr/lib/jvm/java-8-openjdk-amd64/'
    }

    stages {
        stage('Prepare') {
            steps {
                withCredentials([
                    string(credentialsId: 'DGIS_DIRECTORY_APP_KEY', variable: 'DIRECTORY_KEY'),
                    string(credentialsId: 'DGIS_MAP_API_KEY', variable: 'MAP_KEY'),
                    string(credentialsId: 'NSDK_UNSTRIPPED_LIBS_BASE_URL', variable: 'UNSTRIPPED_LIBS_URL'),
                    file(credentialsId: 'NSDK_DEMOAPP_GOOGLE_SERVICES', variable: 'GOOGLE_SERVICES')
                ]) {
                    script {
                        def localProperties = """\
                            sdk.dir=/opt/android-sdk/

                            dgisMapApiKey=${env.MAP_KEY}
                            dgisDirectoryApiKey=${env.DIRECTORY_KEY}

                            dgisUnstrippedLibsUrl=${env.UNSTRIPPED_LIBS_URL}
                        """.stripIndent()

                        writeFile file: "local.properties", text: localProperties

                        sh 'echo "\ndgisUnstrippedLibsDir=\$(pwd)/build/app/nativeLibs" >> local.properties'

                        sh "cat ${env.GOOGLE_SERVICES} > app/google-services.json"
                    }
                }
            }
        }

        stage('Build') {
            steps {
                withCredentials([
                    usernamePassword(
                        'credentialsId': 'buildserver-v4core',
                        'usernameVariable': 'ARTIFACTORY_USERNAME',
                        'passwordVariable': 'ARTIFACTORY_PASSWORD'
                    )
                ]) {
                    sh(
                        label: 'Building project',
                        script: "./gradlew clean build test lint bundle"
                    )
                }
            }
        }

        stage('Test') {
            steps {
                sh(
                    label: "Подготовка образа эмулятора",
                    script: """
                        echo no | \
                            /opt/android-sdk/tools/bin/avdmanager \
                            create avd \
                            -n webgl-tests \
                            -k "system-images;android-29;google_apis;x86_64" \
                            -f
                    """
                )

                timeout(2) {
                    sh(
                        label: "Поднятие эмулятора",
                        script: """
                            /opt/android-sdk/emulator/emulator \
                                -memory 2048 \
                                -partition-size 2048 \
                                -no-boot-anim \
                                -noaudio \
                                -no-snapshot \
                                -no-window \
                                -avd webgl-tests > /dev/null 2>&1 &
                        """
                    )

                    // Скрипт для проверки инициализации эмулятора, т.к. запускаем его не в
                    // интерактивном режиме.
                    sh(
                        label: "Ожидание загрузки эмулятора",
                        script: """
                            while [ -z "\$(/opt/android-sdk/platform-tools/adb devices | awk '{print \$2}' | grep device)" ];
                            do
                                echo "Waiting for emulator to boot"
                                sleep 5
                            done
                            echo "Emulator booted"
                        """
                    )
                }
                script {
                    try {
                        timeout(10) {
                            sh(
                                label: "Подготовка logcat",
                                script: """
                                    /opt/android-sdk/platform-tools/adb logcat -c
                                """
                            )

                            sh(
                                label: "Тесты",
                                script: "./gradlew connectedAndroidTest --info"
                            )
                        }
                    }
                    finally {
                        publishHTML(target: [
                            reportName: 'App tests results',
                            alwaysLinkToLastBuild: true,
                            reportDir: 'build/app/reports/androidTests/connected',
                            reportFiles: 'index.html',
                            keepAll: true,
                            allowMissing: false,
                        ])

                        timeout(1) {
                            sh(
                                label: 'Saving logcat',
                                script: """
                                    /opt/android-sdk/platform-tools/adb logcat -d > logcat.txt
                                """
                            )
                        }

                        archiveArtifacts(artifacts: 'logcat.txt', allowEmptyArchive: true)
                    }
                }
            }
        }

        stage('Signing artifacts') {
            steps {
                withCredentials([
                        file(credentialsId: 'RELEASE_KEYSTORE', variable: 'RELEASE_KEYSTORE'),
                        string(credentialsId: 'RELEASE_KEYSTORE_PASSWORD', variable: 'RELEASE_KEYSTORE_PASSWORD'),
                        string(credentialsId: 'NSDK_RELEASE_KEY_ALIAS', variable: 'RELEASE_KEY_ALIAS'),
                        string(credentialsId: 'NSDK_RELEASE_KEY_PASSWORD', variable: 'RELEASE_KEY_PASSWORD'),
                ]) {
                    // Signing output bundle
                    sh """
                        jarsigner \
                            -keystore \$RELEASE_KEYSTORE \
                            -storepass \$RELEASE_KEYSTORE_PASSWORD \
                            -keypass \$RELEASE_KEY_PASSWORD \
                            build/app/outputs/bundle/release/app-release.aab \
                            \$RELEASE_KEY_ALIAS
                    """
                    sh 'jarsigner -verify build/app/outputs/bundle/release/app-release.aab -keystore \$RELEASE_KEYSTORE'

                    // Signing output apk
                    sh """
                        /opt/android-sdk/build-tools/29.0.3/apksigner sign \
                            --ks \$RELEASE_KEYSTORE \
                            --key-pass env:RELEASE_KEY_PASSWORD \
                            --ks-pass env:RELEASE_KEYSTORE_PASSWORD \
                            --ks-key-alias \$RELEASE_KEY_ALIAS \
                            --out build/app/outputs/apk/release/app-release.apk \
                            build/app/outputs/apk/release/app-release-unsigned.apk
                    """
                    sh '/opt/android-sdk/build-tools/29.0.3/apksigner verify build/app/outputs/apk/release/app-release.apk'
                }
            }
        }

        stage('Release deploy') {
            steps {
                sh './gradlew app:uploadCrashlyticsSymbolFileRelease'

                archiveArtifacts(artifacts: 'build/app/outputs/apk/release/app-release.apk')
                archiveArtifacts(artifacts: 'build/app/outputs/bundle/release/app-release.aab')
                archiveArtifacts(artifacts: 'build/app/outputs/apk/debug/app-debug.apk')
                archiveArtifacts(artifacts: 'build/app/outputs/bundle/debug/app-debug.aab')
            }
        }
    }
}