¿Cómo configurar gradle y android studio para hacer una versión de compilación?

Quiero crear una aplicación para Android y empezar a firmarla. Para eso necesito tener la versión de lanzamiento de apk. La documentación de Google sugiere solo formas de Eclipse y hormiga para tener versiones de lanzamiento: http://developer.android.com/tools/publishing/app-signing.html#releasecompile

Sin embargo, no puedo encontrar cómo forzar la versión de lanzamiento de la compilación gradle de apk. build.gradletampoco da pistas. gradlew taskssugiere, que no hay una configuración de versión de instalación, pero existe una versión de desinstalación:

Install tasks
-------------
installDebug - Installs the Debug build
installTest - Installs the Test build for the Debug build
uninstallAll - Uninstall all applications.
uninstallDebug - Uninstalls the Debug build
uninstallRelease - Uninstalls the Release build
uninstallTest - Uninstalls the Test build for the Debug build

Mi build.gradle:

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.5.+'
    }
}
apply plugin: 'android'

repositories {
    mavenCentral()
}

dependencies {
    compile 'com.android.support:support-v4:13.0.+'
    compile files('libs/android-support-v4.jar')
    compile project(":libraries:ActionBarSherlock")
    compile project(":libraries:CollabsibleSearchMenu")
}

android {
    compileSdkVersion 18
    buildToolsVersion "18.0.1"

    defaultConfig {
        minSdkVersion 8
        targetSdkVersion 16
    }
}

¿Qué me estoy perdiendo?

en la última versión de Android Studio, puedes hacer lo siguiente:

./gradlew assembleRelease

o aRpara abreviar. Esto producirá un apk de lanzamiento sin firmar. La construcción de un apk firmado se puede hacer de manera similar o puede usar Build -> Generate Signed Apk en Android Studio.

Vea los documentos aquí

Aquí está mi build.gradle como referencia:

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath 'com.android.tools.build:gradle:0.5.+'
  }
}
apply plugin: 'android'

dependencies {
  compile fileTree(dir: 'libs', include: '*.jar')
}

android {
compileSdkVersion 17
buildToolsVersion "17.0.0"

sourceSets {
    main {
        manifest.srcFile 'AndroidManifest.xml'
        java.srcDirs = ['src']
        resources.srcDirs = ['src']
        aidl.srcDirs = ['src']
        renderscript.srcDirs = ['src']
        res.srcDirs = ['res']
        assets.srcDirs = ['assets']
    }

    // Move the tests to tests/java, tests/res, etc...
    instrumentTest.setRoot('tests')

    // Move the build types to build-types/<type>
    // For instance, build-types/debug/java, build-types/debug/AndroidManifest.xml, ...
    // This moves them out of them default location under src/<type>/... which would
    // conflict with src/ being used by the main source set.
    // Adding new build types or product flavors should be accompanied
    // by a similar customization.
    debug.setRoot('build-types/debug')
    release.setRoot('build-types/release')

}

buildTypes {
    release {

    }
}

1. abra el Build Variantspanel, que normalmente se encuentra en el lado inferior izquierdo de la ventana :

2. establecer debugenrelease
3. shift+f10 ¡¡correr!!

luego, Android Studio ejecutará la assembleReleasetarea e instalará xx-release.apk en su dispositivo.

No es necesario actualizar gradle para hacer una aplicación de lanzamiento en Android Studio.Si fueras un usuario de eclipse, entonces será muy fácil para ti. Si eres nuevo, sigue los pasos

1: Vaya a "Crear" en la sección de la barra de herramientas. 2: Elija la opción "Generar APK firmado ...".

3: complete el formulario abierto y vaya al siguiente 4: si ya tiene .keystore o .jks, elija ese archivo, ingrese su contraseña y alias y la contraseña respectiva. 5: O no tiene el archivo .keystore o .jks, luego haga clic en el botón Crear nuevo ... como se muestra en la imagen 1 y luego complete el formulario.

El proceso anterior fue construir manualmente. Si desea que Android Studio firme automáticamente su aplicación

En Android Studio, puede configurar su proyecto para firmar su APK de lanzamiento automáticamente durante el proceso de compilación:

En el navegador del proyecto, haga clic derecho en su aplicación y seleccione Abrir configuración del módulo. En la ventana Estructura del proyecto, seleccione el módulo de su aplicación en Módulos. Haga clic en la pestaña Firma. Seleccione su archivo de almacén de claves, ingrese un nombre para esta configuración de firma (ya que puede crear más de uno) e ingrese la información requerida. Figura 4. Cree una configuración de firma en Android Studio.

Haga clic en la pestaña Tipos de compilación. Seleccione la versión de lanzamiento. En Configuración de firma, seleccione la configuración de firma que acaba de crear. Figura 5. Seleccione una configuración de firma en Android Studio.

4: Lo más importante que hace debuggable = false en gradle.

    buildTypes {
        release {
           minifyEnabled false
          proguardFiles getDefaultProguardFile('proguard-  android.txt'), 'proguard-rules.txt'
        debuggable false
        jniDebuggable false
        renderscriptDebuggable false
        zipAlignEnabled true
       }
     }

visite para obtener más información en developer.android.com

Para activar la installReleasetarea, simplemente necesita un signingConfig. Eso es todo.

De http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Android-tasks :

Finalmente, el complemento crea tareas de instalación / desinstalación para todos los tipos de compilación (depuración, lanzamiento, prueba), siempre que se puedan instalar (lo que requiere firma).

Esto es lo que quieres:

Install tasks
-------------
installDebug - Installs the Debug build
installDebugTest - Installs the Test build for the Debug build
installRelease - Installs the Release build
uninstallAll - Uninstall all applications.
uninstallDebug - Uninstalls the Debug build
uninstallDebugTest - Uninstalls the Test build for the Debug build
uninstallRelease - Uninstalls the Release build   <--- release

A continuación se muestra cómo obtener la installReleasetarea:

Ejemplo build.gradle:

buildscript {
    repositories {
        jcenter()
    }

    dependencies {
        classpath 'com.android.tools.build:gradle:1.2.3'
    }
}

apply plugin: 'com.android.application'

android {
  compileSdkVersion 22
  buildToolsVersion '22.0.1'

  defaultConfig {
    applicationId 'demo'
    minSdkVersion 15
    targetSdkVersion 22
    versionCode 1
    versionName '1.0'
  }

  signingConfigs {
      release {
          storeFile <file>
          storePassword <password>
          keyAlias <alias>
          keyPassword <password>
      }
  }

  buildTypes {
    release {
        signingConfig signingConfigs.release
    }
  }
}

Este es un procedimiento para configurar la versión de lanzamiento de ejecución

1- Cambie las variantes de compilación a la versión de lanzamiento.

2- Estructura de proyecto abierta.

3- Cambie la configuración predeterminada a $ signingConfigs.release

Para compilar con la versión de lanzamiento como se muestra a continuación: