para - manual de programacion android pdf

Excluir variantes de compilación específicas

Question

Tengo los dos tipos de compilación predeterminados: depurar / liberar y un par de sabores: prod / dev.

Ahora quiero excluir la variante de compilación de desarrollo, pero mantener todas las otras combinaciones posibles. ¿Hay una manera de lograr esto?

Answer 1

Filtro de variantes

Utilice la varianteFiltro del plugin android gradle para marcar ciertas combinaciones como ignoradas. Aquí hay un ejemplo de la documentación oficial que funciona con las dimensiones de sabor y muestra cómo se puede usar:

android {
  ...
  buildTypes {...}

  flavorDimensions "api", "mode"
  productFlavors {
    demo {...}
    full {...}
    minApi24 {...}
    minApi23 {...}
    minApi21 {...}
  }

  variantFilter { variant ->
      def names = variant.flavors*.name
      // To check for a certain build type, use variant.buildType.name == "<buildType>"
      if (names.contains("minApi21") && names.contains("demo")) {
          // Gradle ignores any variants that satisfy the conditions above.
          setIgnore(true)
      }
  }
}

Como dice el comentario, también puedes verificar buildType así:

android {
    variantFilter { variant ->
        def names = variant.flavors*.name
        if(variant.buildType.name == ''release'' && names.contains("myforbiddenflavor")) {
            setIgnore(true)
        }
    }
}

Answer 2

Cuando se trabaja con dimensiones de sabor, pruebe este

variantFilter { variant ->
    def dim = variant.flavors.collectEntries {
        [(it.productFlavor.dimension): it.productFlavor.name]
    }

    if (dim.dimensionOne == ''paid'' && dim.dimensionSecond == ''someVal'') {
        variant.setIgnore(true);
    }
}

Answer 3

La respuesta de @ ade.se no funcionó para mí. Pero he luchado un poco, y he escrito esto, eso funciona muy bien:

android {
compileSdkVersion 22
buildToolsVersion ''20.0.0''

variantFilter { variant ->
    if (variant.buildType.name.equals(''debug'') || variant.buildType.name.equals(''release'')) {
        variant.setIgnore(true);
    }
}

defaultConfig {
    applicationId "com.fewlaps.quitnow"
    minSdkVersion 15
    targetSdkVersion 22
    versionCode 35
    versionName "1.35"
}

El código que debe agregar es el variantFilter uno, pero he pegado un poco del contexto para que sea fácil de entender.

Answer 4

Las soluciones aquí no me funcionaron, me encontré con esta publicación y agregué esto a build.gradle en mi aplicación y me solucionó el problema

gradle.taskGraph.whenReady { graph ->
  graph.allTasks.findAll { it.name ==~ /.*MyVariant.*/ }*.enabled = false
}

Esto es lo que hace: espera a que Gradle ensamble la lista completa de tareas para ejecutar y luego marca todas las tareas que coinciden con el patrón del nombre como deshabilitado.

NOTA La coincidencia es exacta: la expresión anterior le permite hacer coincidir cualquier tarea que tenga "MyVariant" en algún lugar de su nombre y es sensible a mayúsculas y minúsculas.

Answer 5

Si usa dimensiones de sabor, haga esto:

flavorDimensions "device", "server"

productFlavors {
    emulator {
        dimension = "device"
    }
    phone {
        dimension = "device"
    }
    staging {
        dimension = "server"
    }
    production {
        dimension = "server"
    }
}

android.variantFilter { variant ->
    def device = variant.getFlavors().get(0).name
    def server = variant.getFlavors().get(1).name
    def isRelease = variant.buildType.name.equals(''release'')
    def isDebug = variant.buildType.name.equals(''debug'')

    // Disable emulatorProductionRelease build variant
    if (device.equals(''emulator'') && server.equals(''production'') && isRelease) {
        variant.setIgnore(true)
    }
}

Es fácil de leer y puede dirigirse a variantes de compilación específicas.

Answer 6

Usando filtros de variantes como otros, encontré que era más fácil hacer esto comparando el nombre de la variante con una lista de variantes que quiero conservar.

Entonces en mi archivo app/build.gradle tengo algo como:

android {
    variantFilter { variant ->
        def needed = variant.name in [
                ''stagingQuickDebug'',       // for development
                ''stagingFullDebug'',        // for debugging all configurations
                ''stagingFullCandidate'',    // for local builds before beta release
                ''stagingFullRelease'',      // for beta releases
                ''productionFullCandidate'', // for local builds before going public
                ''productionFullRelease''    // for public releases
        ]
        variant.setIgnore(!needed)
    }
    buildTypes {
        debug {
        }
        release {
        }
        candidate.initWith(release)
    }
    flavorDimensions "server", "build"
    productFlavors {
        staging {
            dimension "server"
            buildConfigField "String", "API_URL", ''"https://example-preprod.com/"''
        }
        production {
            dimension "server"
            buildConfigField "String", "API_URL", ''"https://example.com/"''
        }
        quick {
            dimension "build"
            minSdkVersion 21
            resConfigs("en", "xxhdpi")
        }
        full {
            dimension "build"
        }
    }
}

Answer 7

Vea la respuesta del filtro Variant anterior.

Vieja respuesta:

No es posible en este momento, pero es algo que queremos agregar. Probablemente pronto

Mientras tanto, podrías deshabilitar la tarea de ensamblar, creo. Algo como esto:

android.applicationVariants.all { variant ->
   if ("devRelease".equals(variant.name)) {
       variant.assembleTask.enabled = false
   }
}