AFAIK, actuellement, Flutter n'ajoutera libflutter.so qu'à un dossier de plate-forme sélectionné dans la version APK. La solution de contournement qui a fonctionné pour moi était de forcer build.gradle à faire uniquement du 32 bits (à l'exclusion de toutes les bibliothèques 64 bits + Intel)

release {

    ...
            ndk{
                abiFilters "armeabi-v7a"
            }
}

cc @Hixie

@swavkulinski, comment

Similaire à https://github.com/flutter/flutter/issues/18939

J'ai le même problème - mais flutter.so n'est pas inclus dans le dossier "armeabi-v7a.
N'a que des bibliothèques tierces pour x86 et armeabi-v7a - mais pas arm64.
Voudrais construire flutter uniquement pour "armeabi-v7a avec
ndk{
abiFilters "armeabi-v7a" // ne fonctionne pas non plus"armeabi", "x86",
}
et défini comme plate-forme cible comme @mravn-google le suggère à android-arm.

APK sans spécifier l'arche et ne pas inclure les bibliothèques

APK avec bibliothèques et aucune spécification de bras

APK avec spécifier l'arche et inclure les bibliothèques

Une suggestion sur la façon de déboguer d'autres étapes ?

@xxseabxx j'ai le même problème

J'ai le même problème, la construction pour 32 bits exclura les périphériques 64 bits, mais cela fonctionne sur eux. La construction pour 64 en spécifiant --target-platform android-arm64 fonctionne sur les appareils 64 bits, mais plante sur les appareils 32 bits. De plus, Google limitera le téléchargement d'apks à 64 bits en 2019.

Équipe Flutter, veuillez résoudre ce problème de base !

Équipe Flutter, veuillez résoudre ce problème de base !

Ai-je donc tort de dire que flutter ne peut prendre en charge que les apk de version 32 ou 64 bits, mais pas les deux ?

pas de chance ici ?

Je pense que le commentaire de xxseabxx pourrait fonctionner mais je ne l'ai pas essayé...

J'ai aussi le même problème.

Dans toutes mes dépendances, j'ai isolé au moins un paquet à l'origine du problème, j'ai rempli un rapport de bogue en conséquence : https://github.com/azihsoyn/flutter_mlkit/issues/36

Pour isoler le problème, pour chacune de mes dépendances/plugins :

1) Créez un projet flutter vide

2) Remplacez main.dart par

l'exemple de code du package (ex : https://pub.dartlang.org/packages/flutter_html_view#-example-tab-)

3) Mettez à jour pubspec.yaml en conséquence

4) courir

$ flutter build apk

Il s'est avéré que celui qui a créé était flutter_mlkit.

Je veux pouvoir cibler à la fois les architectures 32 et 64.

Avoir le même problème. --target-platform=android-arm64 fonctionne pour moi mais j'aimerais prendre en charge le 32 bits jusqu'à ce que Google débranche le 32 bits

Équipe Flutter, veuillez résoudre ce problème de base !

beaucoup de troisième SDK ne fonctionne pas, je pense que c'est urgent

Je peux reproduire cela lors de l'ajout de Mapbox à l'application Android.

J'ai aussi le même problème. J'utilise baiduMap dans mon projet, le modèle bebug est ok, la version crash.
user flutter build apk --release --target-platform=android-arm64 dans mon téléphone est ok, mais le téléphone 32 bits va planter.Flutter Team, veuillez résoudre ce problème dès que possible.

Semblable à https://github.com/azihsoyn/flutter_mlkit/issues/36 , cela fonctionne pour moi, l'apk peut fonctionner sur les téléphones 32 bits et 64 bits. @peace2knowledge

cela devrait être un problème très important pour la version apk

existe-t-il une solution à ce problème ?

1. extraire lib/armeabi-v7a/libflutter.so de $<FLUTTER>/bin/cache/artifacts/engine/android-arm-release/flutter.jar
2. copier le fichier armeabi-v7a/libflutter.so dans $<project>/android/jniLibs/armeabi-v7a/
3. modifiez $<project>/android/app/build.gradle comme ci-dessous :

android {
...
    buildTypes {
        release {
            // TODO: Add your own signing config for the release build.
            // Signing with the debug keys for now, so `flutter run --release` works.
            signingConfig signingConfigs.debug
            ndk {
                abiFilters "arm"
            }
        }
        debug {
            ndk {
                abiFilters "arm"
            }
        }
}
    }

Pour NDK, la chaîne d'outils 64 bits nécessite minSdkVersion >= 21.

Cela m'a débloqué (avec l'ensemble minSdkVersion approprié):

minSdkVersion=16

flutter build apk --release --target-platform=android-arm
flutter run --release --target-platform=android-arm

minSdkVersion=21

flutter build apk --release --target-platform=android-arm64
flutter run --release --target-platform=android-arm64

Supprimez tous les abiFilters, cela fonctionne pour moi.

@zoechi @Hixie bosse douce. Je rencontre également ce problème lorsque j'essaie de l'intégrer à une application existante, ce qui est notre cas d'utilisation le plus important pour le moment.

mindsdk=21, mais n'a pas encore mis à jour la plate-forme cible

@neiljaywarner un pouce levé sur le commentaire initial serait plus efficace pour augmenter la priorité

1. extraire lib/armeabi-v7a/libflutter.so de $<FLUTTER>/bin/cache/artifacts/engine/android-arm-release/flutter.jar
2. copier le fichier armeabi-v7a/libflutter.so dans $<project>/android/jniLibs/armeabi-v7a/
3. modifiez $<project>/android/app/build.gradle comme ci-dessous :

android {
...
    buildTypes {
        release {
            // TODO: Add your own signing config for the release build.
            // Signing with the debug keys for now, so `flutter run --release` works.
            signingConfig signingConfigs.debug
            ndk {
                abiFilters "arm"
            }
        }
        debug {
            ndk {
                abiFilters "arm"
            }
        }
}
    }

Cela n'a pas fonctionné pour moi - il a généré un APK qui manquait le dossier lib (et était donc la moitié de la taille de mon apk précédent).

Nous avons également constaté que si nous implémentons la solution 32 bits uniquement que certains ont publiée (par exemple https://medium.com/flutterpub/flutter-app-couldnt-find-libflutter-so-c95ad81cbccd), il en résulte un non -application performante. En particulier, lors d'un test sur un Samsung S6 et S9, nous constatons un défilement très lent sur une grande liste.

Je ne pense pas que le problème soit seulement le bras manquant64 libflutter.so .

J'ai essayé d'ajouter la bibliothèque manquante à l'APK en créant pour arm64, en copiant libflutter.so , puis en reconstruisant et en ajoutant manuellement la bibliothèque arm64 à l'APK, en réalignant et en signant à nouveau :

flutter build apk --target-platform=android-arm64
mkdir -p tmp/lib/arm64-v8a
cp build/app/intermediates/transforms/mergeJniLibs/release/0/lib/arm64-v8a/libflutter.so tmp/lib/arm64-v8a/
flutter build apk
cp build/app/outputs/apk/release/app-release.apk tmp/
cd tmp
aapt add app-release.apk lib/arm64-v8a/libflutter.so
zipalign 4 app-release.apk app-release-aligned.apk
apksigner sign --ks keystore.jks app-release-aligned.apk

L'APK résultant contient libflutter.so pour armeabi-v7a et arm64-v8a, mais se bloque au lancement avec l'erreur suivante :

12-22 09:53:29.274 7457 7457 F flutter : [FATAL:flutter/runtime/dart_vm.cc(403)] Error while initializing the Dart VM: Snapshot not compatible with the current VM configuration: the snapshot requires 'product no-type_checks no-asserts no-error_on_bad_type sync_async reify_generic_functions arm-eabi softfp' but the VM has 'product no-type_checks no-asserts no-error_on_bad_type sync_async reify_generic_functions arm64-sysv'

Je suppose que des actifs d'instantanés distincts doivent également être expédiés pour chaque arc. Pour l'instant, créer deux APK distincts est la seule solution qui fonctionne pour moi.

c'est un problème assez merdique à rencontrer après avoir passé du temps à écrire un frontend en flutter uniquement pour découvrir que la version ne construit pas correctement l'apk.

vais-je rencontrer le même problème une fois que j'aurai commencé à utiliser iOS ?

A quelle heure peut résoudre ce problème?

Est-ce juste que nos fichiers gradle ne savent pas comment regrouper tous les bons bits pour les deux ? @jason-simmons @cbracken le sait peut-être ?

Ou @FaisalAbid pourrait?

Est-ce juste que nos fichiers gradle ne savent pas comment regrouper tous les bons bits pour les deux ? @jason-simmons @cbracken le sait peut-être ?

Ou @FaisalAbid pourrait?

Par bons bits, je suppose que vous entendez plus que libflutter.so, par ce commentaire : https://github.com/flutter/flutter/issues/18494#issuecomment -449557182

Pour le moment, je pense que la seule solution est de créer des APK 32 bits jusqu'à ce qu'il y ait un correctif. Notez cependant que nous avons constaté des problèmes de performances avec le 32 bits (bien que du code non optimal avec de grandes listes).

Cela fonctionne bien pour moi de créer des APK séparés de 64 bits et de 32 bits et de les télécharger sur Google (ils s'occupent de fournir automatiquement le bon APK aux bons appareils).

Vous faites un build avec abiFilters défini sur armeabi-v7a et --target-platform=android-arm , téléchargez cet APK, puis faites un autre build avec abiFilters défini sur arm64-v8a et --target-platform=android-arm64 et téléchargez celui-là aussi.

Notez que vous devez également utiliser un code de version différent pour chaque APK, donc incluez quelque chose dans le code de version pour indiquer qu'il s'agit de 64 ou 32 bits, comme vous le feriez pour le niveau DPI ou API.

Actuellement, la meilleure option consiste à définir abiFilters de manière conditionnelle à partir de la plate-forme cible

        ndk {
            if (project.hasProperty('target-platform') &&
               project.property('target-platform') == 'android-arm64') {
                abiFilters 'arm64-v8a'
            } else {
                abiFilters 'armeabi-v7a'
            }
        }

Le problème que j'ai est que maintenant je dois télécharger deux apks avec des codes de version différents
La vraie solution à cela est de pouvoir créer des bundles Android avec plusieurs plates-formes cibles. Les bundles d'applications sont actuellement dans Flutter Master, mais je n'ai pas pu le faire fonctionner pour cela

Le Play Store nécessitera 64 bits à partir du 1er août.

En supposant qu'il y aura toujours des appareils 32 bits qui voudront exécuter nos applications après le 1er août, comment s'assurer que 32 bits ET 64 bits sont inclus dans les versions de version ?

https://android-developers.googleblog.com/2019/01/get-your-apps-ready-for-64-bit.html

_Toutes les nouvelles applications et mises à jour d'applications qui incluent du code natif sont nécessaires pour fournir des versions 64 bits en plus des versions 32 bits lors de la publication sur Google Play._

Cette exigence est facilement satisfaite dès maintenant avec les applications Flutter en créant simplement deux APK - un pour les appareils 32 bits et un pour les appareils 64 bits - et en téléchargeant les deux dans le cadre de la même version. Google Play fournira automatiquement l'APK approprié à l'appareil approprié. Je fais ça et ça marche bien. Je suis d'accord avec d'autres commentateurs pour dire que ce n'est pas _idéal_, mais à l'OMI, ce n'est vraiment pas vraiment un problème d'intégrer cette partie de votre flux de travail.

Ce serait formidable si cela pouvait être corrigé dans un proche avenir. L'approche multi-APK n'est qu'une solution temporaire jusqu'à ce que Flutter crée des APK avec plusieurs versions d'architecture .so, comme le font les autres projets Android.

Cela nécessite beaucoup de manipulations manuelles (codes de version, système de build, automatisation) et les bundles d'applications Android étaient censés soulager les développeurs des étapes de build manuelles.

Actuellement, ce problème ne mentionne que les versions 32 et 64 bits, mais il existe également x86, x64 et certains développeurs en Chine parlent toujours de la prise en charge des mips.

Flutter ne devrait-il pas prendre en charge autant des 7 architectures Android avec la plus petite taille d'apk que possible ?

https://proandroiddev.com/reducing-apk-size-by-using-abi-filters-and-apk-split-74a68a885f4e

@MarcelEdward Cela devrait - cependant, à

Pour la taille d'un APK spécifique à la plate-forme qui doit être aussi optimisé/petit que possible.

Pendant le développement, il peut être pénible de réinstaller un APK en taille réelle à chaque fois que vous modifiez le code natif. Une astuce consiste à utiliser des abifilters pour limiter la construction de débogage à l'architecture de vos téléphones de test. Je ne sais pas si cela est aussi pertinent maintenant, étant donné que Flutter prend en charge le rechargement à chaud.

https://github.com/flutter/flutter/issues/17829 concerne les ensembles d'applications aap, mais je ne peux trouver que 32 bits lors de la compilation With flutter build apk

Donc, quand je comprends richt, nous devons créer deux versions séparées avec au moins 32 et 64 les télécharger toutes les deux, puis l'application créera miraculeusement un aap afin que le consommateur obtienne la version optimisée pour son architecture spécifique

@MarcelEdward Le Play Store ne crée pas de bundle d'applications. Il sert simplement l'APK approprié à l'appareil en fonction de l'architecture de l'appareil. Cela a été pris en charge bien avant l'arrivée des bundles d'applications, non seulement pour l'architecture, mais aussi pour la taille/la résolution de l'écran, le niveau de l'API et d'autres différenciateurs. Vous pouvez en savoir plus à ce sujet ici .

Vous pouvez en voir un bon exemple en consultant les 13 variantes de Google Maps ici (notez qu'APKMirror n'a rien à voir avec cette fonctionnalité autre que d'être un moyen simple d'obtenir une liste des variantes pour une application donnée). Le Play Store propose l'APK approprié à partir de ces variantes pour votre appareil en fonction de ses caractéristiques.

Si vous avez utilisé un app bundle, vous n'aurez qu'à télécharger le bundle une fois au lieu de télécharger plusieurs APK, mais je crois comprendre que le Play Store génère ensuite les différentes variantes d'APK pour vous, donc le résultat final est similaire mais il y a moins de travail pour vous de vous automatiser. (Les bundles d'applications prennent également en charge les nouveaux modules chargés dynamiquement, mais c'est une autre histoire.)

Il semble donc que la fonctionnalité souhaitée ici soit de pouvoir exécuter flutter build avec deux arguments --target-platform et que flutter automatiquement les deux architectures dans l'APK, n'est-ce pas ?

@Hixie n'est pas libflutter.so généré une seule fois par version de flutter et type de version ? Dans ce cas, vous auriez 8 variantes (32,64,x86,x86_64). Je pense que ceux-ci devraient simplement être sélectionnés lorsqu'une application flutter est créée et filtrée en fonction du téléphone cible ou du cas d'utilisation. Gradle peut assez bien faire le filtrage.

L'architecture d'un téléphone est quelque chose d'assez bas, je n'ai aucune idée de l'architecture des personnes qui utilisent nos applications. Flutter compile 32 bits lorsqu'aucune architecture n'est spécifiée, donc je suppose que 32 bits convient à tous. Mais maintenant, le jeu store nécessitera 64 bits en août, donc lorsque 32 bits conviennent à tous et que 64 bits sont requis, ces deux-là devraient être intégrés à une version de version ?

Je n'ai pas moi-même de téléphone Android, donc je suppose que cela fonctionnera sur un simulateur. Jusqu'à ce que les utilisateurs de notre application disent le contraire.

@ MarcelEdward2 Ce n'est pas seulement 32 bits contre 64 bits. Il existe quatre architectures prises en charge par Android NDK moderne :

• armeabi-v7a
• arm64-v8a
• x86
• x86_64

Pour le moment, Flutter crée par défaut un APK contenant du code natif compilé pour armeabi-v7a uniquement. Cela fonctionnera bien sur arm64-v8a, mais avec une pénalité de performances par rapport à quelque chose compilé pour arm64-v8a en natif. Cependant, il fonctionnera sous un émulateur ARM sur x86 ou x86_64, en supposant que l'appareil en intègre un. Si le périphérique x86/x86_64 n'a pas d'émulateur ARM, il ne fonctionnera pas du tout.

Encore une fois, l'exigence d'août ne vous oblige pas à produire un APK ou un AAB universel contenant les deux architectures. Cela nécessite simplement que chaque version que vous créez contienne (au moins) un APK adapté aux appareils 64 bits. Des modifications dans Flutter pour permettre de créer un APK/AAB universel prenant en charge plusieurs architectures seraient bien en termes de workflow de développeur, mais vous pouvez répondre à cette exigence avec ou sans de telles améliorations.

Édité pour ajouter : personnellement, je pense qu'un support de première classe pour les bundles d'applications est le meilleur moyen d'améliorer la situation multi-arch.

appbundle ressemble à la solution à l'avenir ... Je suppose que la prochaine étape est la suivante : #29303

Si je comprends bien ce bogue, il est très lié au passage à .aab comme format de sortie par défaut pour flutter build et à ce que .aab inclue les versions 32 et 64 bits :
https://developer.android.com/studio/projects/dynamic-delivery

J'avais cru comprendre qu'une partie de ce travail était peut-être déjà en cours. @dnfield le sait peut-être.

/cc @mklim

Il semble que .aab aiderait, mais peut-être pas vraiment nécessaire. Le problème est-il aussi simple que d'ajouter à la fois les binaires de bras 32 et 64 bits à l'APK ?

Ahh je vois. C'est parce que nous aurions besoin d'inclure également l'instantané AOT pour l'arche cible. Et pour le moment, nous mettons simplement cela dans les actifs, nous ne mettons pas de version par architecture sous libs . Si nous pouvions mettre l'instantané AOT dans le dossier libs spécifique à l'architecture, cela pourrait fonctionner, sinon nous voudrions utiliser le format .aab pour cette raison.

Nous voulons faire cela de toute façon pour prendre en charge la création de .AAR pour les cas d'utilisation d'add2app. Je vais m'y atteler.

ndk {
            if (project.hasProperty('target-platform') &&
               project.property('target-platform') == 'android-arm64') {
                abiFilters 'arm64-v8a'
            } else {
                abiFilters 'armeabi-v7a'
            }
        }

Cela a fonctionné pour moi après des jours de dépannage

La solution publiée par @AppleEducate ne fonctionne pas lorsque j'essaie d'exécuter l'application sur l'émulateur.

Mettez-le dans la section de libération

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm

2. télécharger app-armeabi-v7a-release.apk sur le Play Store

3. incrémenter versionCode

4. courir flutter build apk --release --target-platform=android-arm64

5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.

Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

@edTheGuy00 Je doute qu'il soit intéressant de voir la taille du téléchargement sur le Play Store. Les téléphones Android demanderont de toute façon un espace libre temporaire de plus de 125 ans et refuseront d'utiliser un stockage externe pour le déballage. C'est tout ce que les utilisateurs sauront sur la taille de l'application, peu importe combien une application utilise après l'installation. Il demandera plus de 125 Mo d'espace libre pour l'installation.

Veuillez permettre d'inclure toutes les architectures possibles. Peu m'importe si le téléchargement sur le Play Store sera de 250 Mo.

Ce serait bien si Flutter utilisait l'espace gigabites sur le stockage externe pour l'installation sur un téléphone Android. C'est si le flutter peut influencer l'installation sur un téléphone Android

Je pense que le script flutter.gradle devrait inclure tous les ABI dans l'APK final (APK universel), puis activer par défaut les APK fractionnés. Les outils Android sélectionneront le bon APK à télécharger sur l'appareil connecté et tout va bien. L'APK universel final peut ensuite être téléchargé sur le play-store, ou soit les APK divisés pour chaque ABI.

En attendant, comme solution, vous pouvez l'ajouter au bas de votre build.gradle dans votre répertoire android\app .

// Include both 32bit and 64bit arm libflutter.so files into your APK
project.afterEvaluate {
    assembleRelease.doLast {
        String src
        if(project.hasProperty('target-platform') &&
            project.property('target-platform') == 'android-arm64') {
            // If we are building the 64bit then we also want to add the 32bit libflutter.so
            src = "$flutterRoot/bin/cache/artifacts/engine/android-arm-release/flutter.jar"
        }else{
            // If we are building the opposite (32bit), we include the 64bit libflutter.so
            src = "$flutterRoot/bin/cache/artifacts/engine/android-arm64-release/flutter.jar"
        }
        copy {
            from zipTree(src)
            include 'lib/*/libflutter.so'
            into "$buildDir/intermediates/jniLibs/release/0/"
        }
    }
}

Je recommande également d'ajouter ceci à votre section buildTypes > release . Cela garantira que votre APK de version contient les deux ABI.

ndk {
    abiFilters 'armeabi-v7a', 'arm64-v8a'
}

Après une collaboration avec

project.afterEvaluate {
    assembleRelease.doFirst {

        String src
        if(project.hasProperty('target-platform') &&
                project.property('target-platform') == 'android-arm64') {
            // If we are building the 64bit then we also want to add the 32bit libflutter.so
            src = "$flutterRoot/bin/cache/artifacts/engine/android-arm-release/flutter.jar"
        }else{
            // If we are building the opposite (32bit), we include the 64bit libflutter.so
            src = "$flutterRoot/bin/cache/artifacts/engine/android-arm64-release/flutter.jar"
        }
        copy {
            from zipTree(src)
            include 'lib/*/libflutter.so'
            into "src/main/jniLibs/"
            eachFile {
                it.path = it.path.replaceFirst("lib/", "")
            }
        }
    }
}

Mise à jour : après avoir essayé d'exécuter cet APK sur l'appareil, il échoue et n'est donc pas une solution viable. L'erreur est "Erreur lors de l'initialisation de la VM Dart : Instantané non compatible avec la configuration actuelle de la VM :
l'instantané nécessite 'product use_bare_instructions no-"asserts" causal_async_stacks arm-eabi softfp'
mais la VM a 'product use_bare_instructions no-"asserts" causal_async_stacks arm64-sysv'"

Ahh je vois. C'est parce que nous aurions besoin d'inclure également l'instantané AOT pour l'arche cible. Et pour le moment, nous mettons simplement cela dans les actifs, nous ne mettons pas de version par architecture sous libs . Si nous pouvions mettre l'instantané AOT dans le dossier libs spécifique à l'architecture, cela pourrait fonctionner, sinon nous voudrions utiliser le format .aab pour cette raison.

Nous voulons faire cela de toute façon pour prendre en charge la création de .AAR pour les cas d'utilisation d'add2app. Je vais m'y atteler.

@dnfield avez-vous déjà réussi à cela ?

Travailler à travers la pièce de plug-in pour le moment. Nous avons essayé d'en prioriser certaines parties pour résoudre les problèmes d'Android X, mais nous devrions en voir d'autres.

@gerryhigh et moi-même

Mais pour le moment, la seule solution consiste à exécuter le build deux fois et à télécharger plusieurs APK sur le Play Store.

flutter build apk --release --target-platform=android-arm
flutter build apk --release --target-platform=android-arm64

Cela peut être mieux réalisé en activant les APK fractionnés. Plus de détails peuvent être trouvés ici : https://developer.android.com/studio/build/configure-apk-splits

@slightfoot oui c'est la meilleure solution que j'ai trouvée jusqu'à présent, comme mentionné dans mon commentaire là-haut https://github.com/flutter/flutter/issues/18494#issuecomment -477502287

@slightfoot si j'ai bien compris, il ne serait pas possible de construire un APK universel car certains codes se trouvent dans le dossier assets ce qui ne permet pas de diviser les fichiers selon l'architecture ciblée comme le dossier lib ?

L'instantané construit pour chaque architecture est différent. Copiez simplement le moteur libflutter.so pour que l'instantané ne puisse pas être chargé si l'architecture de l'instantané ne correspond pas à l'architecture du moteur de flutter.
Donc, actuellement, il n'y a aucun moyen pour nous de créer un apk universel qui contient toutes les architectures à moins de séparer les fichiers d'instantané et d'inclure le fichier d'instantané pour chaque architecture.

Je suis un peu confus quant à pourquoi c'est même un problème.

Les versions de débogage créent libflutter.so dans x86_64, x86, armeabi-v7a et arm64-v8a.

Les versions de version devraient faire exactement la même chose.

AGP (Android Gradle Plugin) inclut déjà la fonctionnalité pour filtrer les architectures, donc si un utilisateur souhaite le faire pour une version de version, il peut modifier son build.gradle.

@eseidel @dnfield Je ne pense pas vraiment que cela soit résolu par Android App Bundles - ils ne sont pas encore la sortie Android par défaut et lors de l'exécution à partir de l'IDE, les apks seront utilisés pendant un certain temps, mais j'en suis sûr.

Les AAB sont une autre raison pour laquelle Flutter devrait inclure toutes les architectures de libflutter. Ainsi, le Play Store peut filtrer l'architecture qu'il fournit aux appareils.

@athornz le problème n'est pas avec libflutter.so mais avec la compilation de votre code Dart jusqu'à un AOT snapshot versions de débogage incluent la VM Dart afin que tout votre code dart s'exécute simplement JIT sur la VM , mais les versions de version compilent votre code de fléchettes dans un instantané et placent cet instantané dans un dossier d'actifs. Idéalement, le snapshot devrait être compilé pour chaque architecture et placé à côté de libflutter.so mais ce n'est pas le cas pour le moment. Ainsi, bien que vous puissiez inclure libflutter.so pour toutes les architectures, l'instantané ne fonctionnera que pour l'architecture pour laquelle il a été compilé.

Un plan pour résoudre ce problème ?

Google Play Store demande au développeur de fournir une assistance 64 bits après le 1er août 2019.

https://android-developers.googleblog.com/2019/01/get-your-apps-ready-for-64-bit.html

L'exigence 64 bits : ce que cela signifie pour les développeurs
À compter du 1er août 2019 :
_Toutes les nouvelles applications et mises à jour d'applications qui incluent du code natif sont nécessaires pour fournir des versions 64 bits en plus des versions 32 bits lors de la publication sur Google Play._
Extension : Google Play continuera d'accepter les mises à jour 32 bits uniquement pour les jeux existants qui utilisent Unity 5.6.6 ou une version antérieure jusqu'en août 2021.
À compter du 1er août 2021 :
Google Play cessera de servir les applications sans versions 64 bits sur les appareils compatibles 64 bits, ce qui signifie qu'elles ne seront plus disponibles dans le Play Store sur ces appareils.
Cela inclura les jeux construits avec Unity 5.6.6 ou une version antérieure.

@trevorwang, nous pouvons déjà créer 64 bits et les télécharger avec 32 bits sur le Play Store. Ce n'est donc pas un problème.

@slightfoot Voulez-vous dire que je dois créer un autre APK 64 bits et le télécharger sur Google Play ?

Comme vous le savez, Google Play n'est pas disponible en Chine continentale. Nous préférons un APK universel pour prendre en charge toutes les plateformes.

@trevorwang à peu près. Voici comment je procède https://github.com/flutter/flutter/issues/18494#issuecomment -477502287

Le fractionnement ne fonctionne pas dans le fichier gradfle. Vous devez faire quelque chose avec l'un des fichiers build.gradle pour que Flutter sache comment compiler différentes architectures. Ou Google Play rejettera la deuxième compilation.

Merci @edTheGuy00

Mais nous avons vraiment besoin d'un APK universel comprenant tous les abis pour le marché chinois.

@trevorwang, vous pouvez créer pour chaque cible et indiquer explicitement à quelle architecture chaque APK est destiné. C'est ainsi que cela se fait pour la plupart des sites miroirs APK.

La limitation 64 bits n'est qu'une limitation du Google Play Store. Vous pouvez toujours déployer l'APK armeabi-v7a uniquement et tout le monde pourra exécuter votre application.

Construire des APK séparés par architecture est une solution de contournement et certainement pas une solution pour tout le monde.

Une fois que la limitation Google Play 64 bits entrera en vigueur, ce problème affectera la plupart des développeurs Flutter, nous avons donc vraiment besoin d'une solution qui permette plusieurs architectures au sein d'un apk/bundle.

Juste un petit rappel

L'équipe Flutter utilise le nombre de « pouces levés » sur un problème GitHub comme guide de sa priorité.

Je pense que cette question devrait être prioritaire.

Merci pour le travail de @gerryhigh et @slightfoot

J'ai ajouté le flutter à une application existante et j'ai résolu ce problème par la solution de contournement suivante.
_Veuillez l'ajouter à votre module d'application du projet hôte._

Ceci est le script pour le mode Debug, veuillez le modifier en conséquence pour la publication.

project.afterEvaluate {
    assembleDebug.doLast {
        def flutterRoot = System.getenv("FLUTTER_HOME")
        def archTypes = ["arm", "arm64"]
        archTypes.forEach { item ->
            copy {
                from zipTree("$flutterRoot/bin/cache/artifacts/engine/android-$item/flutter.jar")
                include 'lib/*/libflutter.so'
                into "$buildDir/intermediates/jniLibs/debug/"
                eachFile {
                    it.path = it.path.replaceFirst("lib/", "")
                }
            }
        }
    }
}

Des développements récents ?

Ce que j'ai fini par faire, puisque je voulais

• apks séparés pour chaque architecture
• ne pas avoir à modifier manuellement le code de version
• exécuter une seule commande pour produire les apks

1. Ajouté ceci à gradle. Il ajoute 1 ou 2 à la fin du code de version, donc la version 1004 devient 10041 pour arm et 10042 pour arm64.

ext.platformCodes = ['android-arm': 1, 'android-arm64' : 2]
android.applicationVariants.all { variant ->
    variant.outputs.each { output ->
        int code = 0
        if (project.hasProperty('target-platform')) {
            code = project.ext.platformCodes.get(project.property('target-platform'))
        }
        output.versionCodeOverride = variant.versionCode * 10 + code
    }
}

1. Pour produire les apks, j'utilise une commande de terminal plus longue (que vous pouvez mettre dans un script). Il exécute la compilation deux fois et crée des copies des apks à la fin :

flutter clean; flutter build apk --release --target-platform=android-arm; mv build/app/outputs/apk/release/app-release.apk build/app/outputs/apk/release/app-release-arm32.apk; flutter build apk --release --target-platform=android-arm64; mv build/app/outputs/apk/release/app-release.apk build/app/outputs/apk/release/app-release-arm64.apk;

J'espère que cela t'aides.

C'est donc un problème que je rencontre également. J'ai créé un ensemble d'applications au lieu d'un apk et lorsque je l'ai téléchargé sur Google, il m'envoie un avertissement et ne me laisse pas le tester en alpha.

J'ai utilisé la codemagie pour le faire, y a-t-il un moyen de le signer et de le mettre dans un paquet ? ou utiliser la codemagie pour le pointer ?

Je suis confronté au même problème que je pensais ne devrait pas exister du tout.

Comment se fait-il que ce soit sur les "Objectifs" de Milestone.

P2 : Ce sont des tâches qui, selon nous, méritent d'être corrigées dans les années à venir. Cela inclut des problèmes que nous avons identifiés qui pourraient bloquer la livraison complète d'applications larges destinées aux consommateurs, des problèmes d'exactitude et des bogues liés au polissage et à la qualité. La date de ce jalon est totalement arbitraire et vise simplement à trier le jalon de manière appropriée.

Il s'agit déjà d'un problème critique et deviendra un incontournable plus tard cette année une fois que Google appliquera la limitation 64 bits.

J'ai franchi le cap à ce sujet. Pas encore de date solide.

Soyons clairs : il est possible, mais difficile, de se conformer aux nouvelles directives aujourd'hui. Nous voulons rendre cela plus facile.

Donc, la méthode @andreidiaconu a fonctionné pour moi tant que je construis manuellement l'application.

Mais j'ai utilisé codemagic pour construire et déployer.

C'est donc un gâchis, Flutter doit le faire construire.

Pour le moment, je ne me soucie pas vraiment de savoir si c'est compliqué. Si c'est compliqué, il sera automatisé par un script. La question est de savoir si c'est possible et comment car Google Play Console me prévient :

Cette version n'est pas conforme à l'exigence Google Play 64 bits
Les APK ou bundles d'applications suivants sont disponibles pour les appareils 64 bits, mais ils n'ont qu'un code natif 32 bits : 6.
À partir du 1er août 2019, toutes les versions doivent être conformes à l'exigence Google Play 64 bits.
Incluez du code natif 64 bits et 32 bits dans votre application. Utilisez le format de publication Android App Bundle pour vous assurer automatiquement que chaque architecture d'appareil ne reçoit que le code natif dont elle a besoin. Cela évite d'augmenter la taille globale de votre application.

Je ne veux pas d'une solution qui nécessite des codes de version différents et je veux une solution qui fonctionne avec Android App Bundles (AAB).

Avertissement
Cette version n'est pas conforme à l'exigence Google Play 64 bits

Les APK ou bundles d'applications suivants sont disponibles pour les appareils 64 bits, mais ils n'ont qu'un code natif 32 bits : 3.

Toute solution?

J'ai franchi le cap à ce sujet. Pas encore de date solide.

Soyons clairs : il est possible, mais difficile, de se conformer aux nouvelles directives aujourd'hui. Nous voulons rendre cela plus facile.

Les documents doivent-ils être mis à jour avec des instructions sur la façon de procéder pour les apk et les app bundles ? Tout ce que j'ai vu jusqu'à présent, ce sont des tas de code et de configuration que je ne sais pas exactement où mettre. Je pourrais probablement le comprendre avec quelques essais et erreurs, mais ce n'est pas idéal.

même problème

Merci pour le travail de @gerryhigh et @slightfoot

J'ai ajouté le flutter à une application existante et j'ai résolu ce problème par la solution de contournement suivante.
_Veuillez l'ajouter à votre module d'application du projet hôte._

Ceci est le script pour le mode Debug, veuillez le modifier en conséquence pour la publication.

project.afterEvaluate {
    assembleDebug.doLast {
        def flutterRoot = System.getenv("FLUTTER_HOME")
        def archTypes = ["arm", "arm64"]
        archTypes.forEach { item ->
            copy {
                from zipTree("$flutterRoot/bin/cache/artifacts/engine/android-$item/flutter.jar")
                include 'lib/*/libflutter.so'
                into "$buildDir/intermediates/jniLibs/debug/"
                eachFile {
                    it.path = it.path.replaceFirst("lib/", "")
                }
            }
        }
    }
}

Cette solution/solution de contournement semble la plus prometteuse, merci @trevorwang ! Cependant, j'ai des problèmes à mettre en œuvre cela dans un projet Flutter existant. Avez-vous un exemple de fichier build.gradle ou quelque chose d'équivalent qui en ferait une démonstration ?

VEUILLEZ NOTER QUE CELA NE RÉSOUDRA PROBABLEMENT PAS VOTRE PROBLÈME - VOIR CI-DESSOUS

Grâce à la réponse de @trevorwang et à la suggestion de @noinskit, j'ai réussi à inclure des bibliothèques natives 64 bits dans les versions de version avec un petit ajout à ./android/app/build.gradle indiqué ci-dessous.
Vous pouvez également consulter l'intégralité du fichier ici .

afterEvaluate {
    mergeReleaseJniLibFolders.doLast {
        def archTypes = ["arm-release", "arm64-release"]
        archTypes.forEach { item ->
            copy {
                from zipTree("$flutterRoot/bin/cache/artifacts/engine/android-$item/flutter.jar")
                include 'lib/*/libflutter.so'
                into "$buildDir/intermediates/jniLibs/release/"
                eachFile {
                    it.path = it.path.replaceFirst("lib/", "")
                }
            }
        }
    }
}

@SPodjasek merci ! Je suis arrivé à quelque chose de similaire. Dans mon cas, je dois changer assembleRelease dans votre extrait de code en mergeReleaseJniLibFolders , sinon le fichier *.so supplémentaire se retrouvera sous "intermédiaires/...", mais pas dans l'apk final.

@noinskit Il semble que ma solution précédente était sujette aux erreurs. Après avoir exécuté flutter clean il a généré des aab avec seulement des bibliothèques 32 bits. Remplacer assembleRelease par mergeReleaseJniLibFolders semble fonctionner également après le nettoyage de la version true.

@SPodjasek devez-vous modifier d'autres options ?

Voici mon app.gradle

def flutterRoot = localProperties.getProperty('flutter.sdk')
if (flutterRoot == null) {
    throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file.")
}

afterEvaluate {
    mergeReleaseJniLibFolders.doLast {
        def archTypes = ["arm-release", "arm64-release"]
        archTypes.forEach { item ->
            copy {
                from zipTree("$flutterRoot/bin/cache/artifacts/engine/android-$item/flutter.jar")
                include 'lib/*/libflutter.so'
                into "$buildDir/intermediates/jniLibs/release/"
                eachFile {
                    it.path = it.path.replaceFirst("lib/", "")
                }
            }
        }
    }
}

Mes deux répertoires intermédiaires/jniLibs/release/ arm64-v8a et armeabi-v7a ont libflutter.so comme prévu, mais l'APK de la version finale manque toujours de libflutter.so dans arm64-v8a.

Voici la capture d'écran

@function1983 Vous pouvez voir mon build.gradle complet ici .
Depuis ma version flutter :

[✓] Flutter (Channel beta, v1.5.4, on Linux, locale pl_PL.UTF-8)
    • Flutter version 1.5.4 at .../development/flutter
    • Framework revision b593f5167b (2 weeks ago), 2019-04-22 07:51:33 -0700
    • Engine revision ca31a7c57b
    • Dart version 2.3.0 (build 2.3.0-dev.0.1 cf4444b803)

[✓] Android toolchain - develop for Android devices (Android SDK version 28.0.3)
    • Android SDK at .../Android/Sdk
    • Android NDK location not configured (optional; useful for native profiling support)
    • Platform android-28, build-tools 28.0.3
    • Java binary at: .../development/android-studio/jre/bin/java
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b16-5323222)
    • All Android licenses accepted.

[✓] Android Studio (version 3.4)
    • Android Studio at .../development/android-studio
    • Flutter plugin version 35.2.1
    • Dart plugin version 183.6270
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b16-5323222)

J'ai essayé d'utiliser la solution de » @SPodjasek pour construire un appbundle qui comprend les 64 et les versions 32 bits. Il se construit avec succès, je peux le télécharger sur Google Play Console et je peux l'installer sur les téléphones 32 et 64 bits. Mais l'application se bloque lorsqu'elle est lancée sur un appareil Android-arm64 pour une raison quelconque (elle semble fonctionner sur un ancien téléphone Android 32 bits avec lequel j'étais en train de tester).

Voici l'erreur que j'obtiens sur le périphérique 64 bits :

Message d'abandon : '[ FATAL:flutter/runtime/dart_vm.cc (416)] Erreur lors de l'initialisation de la VM Dart : instantané non compatible avec la configuration actuelle de la VM : l'instantané nécessite 'product use_bare_instructions no-"asserts" causal_async_stacks arm-eabi softfp ' mais la VM a 'product use_bare_instructions no-"asserts" causal_async_stacks arm64-sysv'

Je ne sais pas ce que je peux faire... Je devrais peut-être m'en tenir aux périphériques 64 bits uniquement pour le moment.

@Torrunt cette erreur est due au fait que le moteur essaie de charger l'instantané AOT pour 32 bits et en trouve un pour 64.

Nous travaillons à être en mesure de produire un AAB qui a les deux afin que le magasin puisse les séparer correctement.

@SPodjasek En utilisant cela, la taille de mon fichier app-release.apk a augmenté de 11,1 Mo à 15,7 Mo

@SPodjasek En utilisant cela, la taille de mon fichier app-release.apk a augmenté de 11,1 Mo à 15,7 Mo

Oui, car il inclut de force libflutter.so pour 32 et 64 bits. Si vous n'en avez pas besoin, conservez la valeur par défaut actuelle pour inclure uniquement le 32 bits et attendez que l'équipe Flutter s'en occupe correctement.

on dirait qu'il y a plusieurs possibilités :

• attendez que l'équipe de flutter résolve le problème de l'architecture 32 vs 64 pour que Google Play Store accepte à nouveau les builds de flutter
• nous devons limiter les appareils Android utilisés à 32 bits uniquement, donc les applications flutter ne fonctionneront que sur des appareils 32 bits
• nous devons en quelque sorte convaincre Google de ne pas appliquer le 64 bits sur le Play Store. (Je me demande quelle est la différence entre 32 et 64 bits, quelque chose comme des nombres plus gros ?)
• installez les 32 applications d'une manière ou d'une autre sur des appareils 64 bits mais pas dans le Play Store ...

Remarque pour les personnes utilisant --target-platform pour construire pour android-arm et android-arm64 séparément et télécharger deux APK.
Faites attention que certains plugins utilisent des bibliothèques natives qui peuvent cibler les deux, et flutter ne filtre pas les dossiers des bibliothèques, donc votre APK "32 bits" ciblera toujours arm64 également et il plantera car libflutter.so n'est pas présent et les instantanés AOT sont construit pour armv7.

Vous devrez donc filtrer explicitement l'abi cible dans votre fichier build.gradle.

Je pense que le flutter build apk --target-platform ... devrait logiquement faire ce filtrage.

En utilisant la solution de arm-eabi par rapport à arm64-sysv . Je pense que la meilleure solution, qui a fonctionné pour moi, consiste simplement à construire pour 32 bits pour le moment jusqu'à ce que tout soit réglé (la solution de @swavkulinski ici ):

Dans votre niveau app build.gradle :

android {
    // ...
    buildTypes {
        release {
            // ...
            ndk {
                abiFilters "armeabi-v7a"
            }
        }
    }
}

Résumant le problème du sujet - il ne sera pas possible de créer un tel APK pour armeabi-v7a et arm64-v8a. Flutter utilise des instantanés AOT qui dépendent de l'ABI, donc avec APK, la seule solution possible serait d'utiliser plusieurs builds APK.
La solution serait d'utiliser App Bundles, qui, pour l'instant, a également quelques problèmes (#31922).
Après la fusion de #32787, il est désormais possible d'utiliser des App Bundles.

Comment définir la saveur et mon fichier cible (-t lib/another_main.dart, par exemple) lors de la génération d'un ensemble d'applications Android via Android Studio ? oh

Cela sera pris en charge via flutter build appbundle après la fusion de https://github.com/flutter/flutter/pull/32787 !

@swavkulinski, comment

C'était encore possible à l'époque. Maintenant, vous devez vous limiter à 64 bits. Nous avons été verrouillés par la bibliothèque tierce NDK qui était uniquement en 32 bits.

@blasten
Cela ajoutera-t-il également le support pour flutter build apk --release ? Ou est-il prévu de supprimer progressivement la prise en charge des APK au profit des app bundles à long terme ? J'aime bien la relative simplicité du gros APK.

@zimmi Correct. Les bundles d'applications devraient être la voie à suivre. Vous pouvez toujours utiliser flutter build apk --release si nécessaire. Qu'est-ce qui est plus simple dans un gros APK par rapport à AAB ?

Qu'est-ce qui est plus simple dans un gros APK par rapport à AAB ?

AAB n'est pas un fichier d'installation. Android lui-même ne peut pas l'utiliser. C'est un format de fichier pour Google Play Store uniquement. Donc besoin d'apk quand :

• Installation directement sur l'appareil.
• Application de distribution directe.
• Distribution via tout autre marché d'applications à l'exception de Google Play Store. (Amazon et toute la Chine).

Je vois. Merci pour le fond.

En outre, vous pouvez extraire les APK de l'AAB à l'aide de bundletool .

@blasten
Merci pour votre confirmation!
Concernant le commentaire de simplicité : Ce que @audkar a dit. De plus, avec les AAB, le développeur doit réfléchir aux scénarios de défaillance potentiels causés par des actifs manquants. Les tests sur toutes les configurations de périphériques possibles sont difficiles, donc si ces pannes se produisent, c'est probablement en production.

La taille de l'application peut être un prix que certains sont prêts à payer pour cette tranquillité d'esprit.

Je suis sûr qu'il existe de meilleurs endroits pour discuter des mérites de chaque approche que cette question, je ne veux pas la faire dérailler.

/cc @jonahwilliams, nous build apk .
Doit-on aussi changer la valeur par défaut pour build apk ?

Le support de Fat apk est définitivement nécessaire. Il existe de nombreux outils (distribution bêta, etc.) qui ne fonctionnent pas encore avec les bundles d'applications.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?

Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

@blasten Je suis passé au canal principal, mis à niveau et créé l'appbundle, cela a bien fonctionné. Ensuite, téléchargez-le sur la console de jeu et tous les avertissements ont disparu. (macOS 10.14.4)

Impressionnant! Je compilerai mon build ce soir après avoir apporté mes modifications.

L'ensemble ne semble pas fonctionner, mais l'application se bloque lors du téléchargement.

Issue: java.lang.RuntimeException: Unable to instantiate activity ComponentInfo{com.mattetti.sounds/com.mattetti.sounds.MainActivity}: java.lang.ClassNotFoundException: Didn't find class "com.mattetti.sounds.MainActivity" on path: DexPathList[[zip file "/data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/base.apk", zip file "/data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/split_config.arm64_v8a.apk", zip file "/data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/split_config.xxhdpi.apk"],nativeLibraryDirectories=[/data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/lib/arm64, /data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/base.apk!/lib/arm64-v8a, /data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/split_config.arm64_v8a.apk!/lib/arm64-v8a, /data/app/com.mattetti.sounds-ewwlQg0QphABpwu8t14HWA==/split_config.xxhdpi.apk!/lib/arm64-v8a, /system/lib64]]

Il semble que com.mattetti.sounds.MainActivity ne soit pas dans le bundle ?

Je ne sais pas pourquoi, comment puis-je vérifier pourquoi il a été supprimé ?

@mattetti Utilisez -vous un module Flutter ? Est-ce que MainActivity étend FlutterActivity ?

@blasten
voici mes dépendances

environment:
  sdk: ">=2.2.2 <3.0.0"

dependencies:
  flutter:
    sdk: flutter
  rxdart: ^0.22.0
  shared_preferences: ^0.5.2
  http: ^0.12.0
  cached_network_image: ^0.8.0
  url_launcher: ^5.0.2

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^0.1.2

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_launcher_icons: "^0.7.0"

dependency_overrides:
  # requried for flutter_icons at this point
  image: 2.0.7

Mais je viens aussi de remarquer que j'ai renommé le package de mon application mais que je n'ai pas changé le chemin d'accès à mon fichier MainActivity.java qui est toujours android/app/src/main/java/com/example/old_name/ qui pourrait être le problème. Demain, j'essaierai de changer de chemin et de pousser un autre paquet.

bonjour @blasten , j'ai essayé de créer l'appbundle et j'ai eu cette erreur

[  +48 ms] FAILURE: Build failed with an exception.
[   +3 ms] * What went wrong:
[        ] Failed to capture snapshot of input files for task ':app::flutter:package:packLibsDevRelease' property
'rootSpec$2$1' during up-to-date check.
[        ] > java.io.IOException: The filename, directory name, or volume label syntax is incorrect
[        ] * Try:
[        ] Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log
output. Run with --scan to get full insights.
[        ] * Get more help at https://help.gradle.org
[        ] Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0.
[        ] See https://docs.gradle.org/4.6/userguide/command_line_interface.html#sec:command_line_warnings
[        ] BUILD FAILED in 1m 28s

Mon projet utilise la saveur et c'est la commande que j'exécute

flutter build appbundle --flavor stage -t lib/main-stage.dart -v

L'app bundle comprendra-t-il également mapping.txt ? Lors du téléchargement de bundles d'applications sur Google Play Console via Codemagic, aucun mapping.txt n'est inclus, donc pas de tests automatisés ou de rapports de pré-lancement - que vous avez lors du téléchargement d'un apk :(

donc la question est :

L'équipe Flutter fera-t-elle une mise à jour pour la version 64 bits ou pas avant août afin que nous puissions télécharger et mettre à jour nos applications créées avec flutter ou non ?

@YazeedAlKhalaf Oui. Vous pouvez utiliser flutter build appbundle aujourd'hui et vous obtiendrez un ensemble d'applications contenant 32 et 64 bits.

@mattetti le problème est-il résolu ?

@nohli mapping.txt ressemble à une demande de fonctionnalité. N'hésitez pas à déposer un nouveau bug.

@skybur pouvez-vous exécuter flutter doctor ? Votre projet Flutter est-il une application ou un module ?

@blasten Mon projet est une application.

Voici le résultat du flutter doctor

[√] Flutter (Channel master, v1.6.1-pre.68, on Microsoft Windows [Version 10.0.17763.503], locale en-US)
    • Flutter version 1.6.1-pre.68 at D:\Devs\Flutter\testappbundle\flutter
    • Framework revision d5aae54a28 (22 hours ago), 2019-05-20 23:19:18 -0400
    • Engine revision 301f560bd8
    • Dart version 2.3.1 (build 2.3.1-dev.0.0 b48c8b1d1c)

[√] Android toolchain - develop for Android devices (Android SDK version 28.0.3)
    • Android SDK at D:\AndroidSDK
    • Android NDK location not configured (optional; useful for native profiling support)
    • Platform android-28, build-tools 28.0.3
    • ANDROID_HOME = D:\AndroidSDK
    • ANDROID_SDK_ROOT = D:\AndroidSDK
    • Java binary at: D:\AndroidStudio\jre\bin\java
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1136-b06)
    • All Android licenses accepted.

[√] Android Studio (version 3.2)
    • Android Studio at D:\AndroidStudio
    • Flutter plugin version 31.3.1
    • Dart plugin version 181.5656
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1136-b06)

[√] VS Code, 64-bit edition (version 1.33.1)
    • VS Code at C:\Program Files\Microsoft VS Code
    • Flutter extension version 3.0.2

[!] Connected device
    ! No devices available

! Doctor found issues in 1 category.

@blasten : obtenir la même erreur que skybur

Essayer d'utiliser flutter build appbundle puis télécharger dans le magasin, puis ouvrir à partir d'un téléphone Android :
Crash instantané à l'ouverture.

journal adb :
05-22 09:40:52.404 27305 27305 E flutter : [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings. 05-22 09:40:52.404 27305 27305 E flutter : [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from. 05-22 09:40:52.404 27305 27305 E flutter : [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance. 05-22 09:40:52.404 27305 27305 F flutter : [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM. 05-22 09:40:52.404 27305 27305 F libc : Fatal signal 6 (SIGABRT), code -6 in tid 27305 (tform.atomicdex) 05-22 09:40:52.432 27339 27339 I crash_dump64: obtaining output fd from tombstoned 05-22 09:40:52.433 1417 1417 I /system/bin/tombstoned: received crash request for pid 27305 05-22 09:40:52.434 27339 27339 I crash_dump64: performing dump of process 27305 (target tid = 27305) 05-22 09:40:52.434 27339 27339 F DEBUG : *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** 05-22 09:40:52.434 27339 27339 F DEBUG : Build fingerprint: 'lge/judyln_lao_com/judyln:8.0.0/OPR1.170623.032/190501244a6e5.FGN:user/release-keys' 05-22 09:40:52.434 27339 27339 F DEBUG : Revision: '12' 05-22 09:40:52.434 27339 27339 F DEBUG : ABI: 'arm64' 05-22 09:40:52.434 27339 27339 F DEBUG : pid: 27305, tid: 27305, name: PACKAGE_NAME >>> PACKAGE_NAME <<< 05-22 09:40:52.434 27339 27339 F DEBUG : signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- 05-22 09:40:52.435 27339 27339 F DEBUG : Abort message: '[FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM. 05-22 09:40:52.435 27339 27339 F DEBUG : ' 05-22 09:40:52.435 27339 27339 F DEBUG : x0 0000000000000000 x1 0000000000006aa9 x2 0000000000000006 x3 0000000000000008 05-22 09:40:52.435 27339 27339 F DEBUG : x4 0000000007d0bf68 x5 0000000007d0bf68 x6 0000000007d0bf68 x7 0000000007d0bfd8 05-22 09:40:52.435 27339 27339 F DEBUG : x8 0000000000000083 x9 8644075c81e36b5a x10 00000077ccff6a48 x11 8644075c81e36b5a 05-22 09:40:52.435 27339 27339 F DEBUG : x12 8644075c81e36b5a x13 0000000000000020 x14 ffffffffffffffdf x15 00000077ca27ec68 05-22 09:40:52.435 27339 27339 F DEBUG : x16 00000077ca2732b8 x17 00000077ca205a44 x18 0000000000000048 x19 0000000000006aa9 05-22 09:40:52.435 27339 27339 F DEBUG : x20 0000000000006aa9 x21 0000007fe4fb81b8 x22 00000077b3dffba0 x23 00000077bd29d7a0 05-22 09:40:52.435 27339 27339 F DEBUG : x24 00000077aa79a150 x25 0000000000000000 x26 0000000000000000 x27 0000000000000002 05-22 09:40:52.435 27339 27339 F DEBUG : x28 0000000000000000 x29 0000007fe4fb81a0 x30 00000077ca1aa8e4 05-22 09:40:52.435 27339 27339 F DEBUG : sp 0000007fe4fb8160 pc 00000077ca205a4c pstate 0000000060000000 05-22 09:40:52.436 27339 27339 F DEBUG : 05-22 09:40:52.436 27339 27339 F DEBUG : backtrace: 05-22 09:40:52.436 27339 27339 F DEBUG : #00 pc 0000000000079a4c /system/lib64/libc.so (tgkill+8) 05-22 09:40:52.436 27339 27339 F DEBUG : #01 pc 000000000001e8e0 /system/lib64/libc.so (abort+88) 05-22 09:40:52.436 27339 27339 F DEBUG : #02 pc 000000000001d61c /data/app/PACKAGE_NAME-F-z4qH6HT271dk7M7oI8Uw==/split_config.arm64_v8a.apk (offset 0xea7000)

@Kiruel, je ne

App bundle n'est rien de plus qu'un APK fractionné automatisé, et il n'y a pas de fractionnement sur le dossier des actifs. Ainsi, les instantanés ne ciblent toujours qu'une seule architecture.

Il me manque probablement quelque chose mais à mon avis, la seule solution maintenant est de créer un APK pour chaque architecture avec le filtrage ndk correspondant dans le fichier gradle. Et puis téléchargez chacun de ces APK.

si nous ne pouvons pas résoudre ce problème avec APK, il n'y a aucune chance que l'app bundle puisse fonctionner non plus.

@ndusart Je ne pense pas que ce soit vrai. La documentation de l'ensemble d'applications dit :

res/, lib/ et assets/ : ces répertoires sont identiques à ceux d'un APK typique. Lorsque vous chargez votre app bundle, Google Play inspecte ces répertoires et ne met en package que les fichiers qui satisfont à la configuration de l'appareil cible, tout en préservant les chemins d'accès aux fichiers.

Il peut donc en quelque sorte diviser les actifs.

@jereksel, cela indique simplement que ces répertoires fonctionnent exactement de la même manière dans l'app bundle que dans apk et que le dossier assets/ n'est pas divisé. Il est utilisé pour stocker des actifs dans une structure de fichiers très spécifique dans l'application, il n'est pas destiné à être analysé par le système d'exploitation ou quoi que ce soit.

Si je me trompe, dites-moi simplement comment nous pouvons diviser ce dossier en fonction de l'ABI cible.

Et cette citation ne fait que confirmer ce que je dis, si cela n'est pas possible pour le moment avec APK, cela ne sera pas possible avec l'app bundle car ces dossiers fonctionnent exactement de la même manière dans les deux sens.

Je n'ai pas vu d'actifs divisés moi-même, mais j'ai trouvé ceci :

https://medium.com/google-developer-experts/exploring-the-android-app-bundle-ca16846fa3d7

assets.pb — C'est l'équivalent d'une table de ressources pour les actifs d'application et ne sera présent que si vous utilisez des actifs dans votre application.

Donc, je suppose qu'Android Studio ne divise pas les actifs, mais les bundles d'applications eux-mêmes prennent en charge cela.

Avez-vous des documents officiels ? Tout cela semble très peu fiable.
L'article suivant, https://medium.com/mindorks/android-app-bundle-aab-98de6dad8ba8 , indique que nous pouvons ajouter un suffixe au nom des dossiers dans assets/ pour le diviser, mais actuellement cela ne peut être fait sur la langue.

Donc, cela ne semble pas encore stable et ne devrait pas être basé sur pour le moment. Les snapshots de VM doivent être soit déportés dans le dossier lib/ si cela est possible, soit la commande flutter doit être livrée avec une fonctionnalité complète pour créer un APK pour une cible spécifique (il y a encore du travail à faire là-dessus pour être accessible à un grand nombre de personnes) et retarder la production d'un app bundle lorsqu'il est prêt.

@blasten

Je suis passé au canal principal, mis à niveau et créé l'appbundle. Malheureusement, l'application se bloque après avoir été téléchargée depuis Google Play Store avec le logcat suivant

2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
2019-05-22 09:42:14.824 6995-6995/? A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?

Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

@blasten

Je suis passé au canal principal, mis à niveau et créé l'appbundle. Malheureusement, l'application se bloque après avoir été téléchargée depuis Google Play Store avec le logcat suivant

2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
2019-05-22 09:42:14.824 6995-6995/? A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?
Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

J'ai le même problème, même si je n'ai pas encore de logs.

@skybur, le problème que vous rencontrez peut être lié à https://github.com/flutter/flutter/issues/33119. Si tel est le cas, ce correctif devrait le corriger.

@ndusart
Oui vous avez raison. J'ai vérifié le code source de bundletool et la répartition des actifs uniquement par langue :
https://github.com/google/bundletool/blob/master/src/main/java/com/android/tools/build/bundletool/splitters/ModuleSplitter.java#L286

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm
2. télécharger app-armeabi-v7a-release.apk sur le Play Store
3. incrémenter versionCode
4. courir flutter build apk --release --target-platform=android-arm64
5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.

Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

Il y a une chose importante à vous dire les gars. Si vous utilisez la méthode que je cite. Vous devrez peut-être commenter le paramètre lorsque vous souhaitez continuer à déboguer votre application. Je suis confronté à l'erreur Gradle build n'a pas réussi à produire un package Android et est resté bloqué pendant quelques heures, faisant quelques gradlew clean ...etc, et j'ai finalement découvert que cela devrait être commenté !

J'espère que cela a aidé quelqu'un à sauter le pas.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?

Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

flutter build appbundle fonctionne ! Je n'ai pas besoin d'ajouter ce paramètre, et je fais juste le code. Cependant, cela prend un peu de temps à compiler, mais c'est le seul moyen de passer Google Play maintenant.

@Tokenyet avez-vous pu télécharger l'application depuis le Play Store et l'exécuter après avoir téléchargé le .aab ? Si tel est le cas, pourriez-vous coller la sortie de flutter doctor ?

@blasten

Je suis passé au canal principal, mis à niveau et créé l'appbundle. Malheureusement, l'application se bloque après avoir été téléchargée depuis Google Play Store avec le logcat suivant

2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
2019-05-22 09:42:14.824 6995-6995/? A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?
Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

Exactement la même chose ici, lorsque j'essaie d'exécuter mon application depuis le Play Store (créé en tant qu'appbundle). De quels journaux avez-vous besoin pour résoudre ce problème ?

Cela vous sera utile :

1. Téléchargez bundletool depuis https://developer.android.com/studio/command-line/bundletool
2. Exécutez flutter build appbundle (Veuillez indiquer si vous passez un indicateur ou si vous avez apporté des modifications _personnalisées_ à un script Gradle)
3. Exécutez bundletool build-apks --bundle=build/app/outputs/bundle/release/app.aab --output=out.apks pour extraire l'ensemble APK.
4. Exécutez unzip -l out.apks et enfin flutter doctor et collez la sortie des deux commandes dans votre commentaire.

Si possible:

Testez localement sur l'appareil en utilisant le bundletool et l'ensemble APK. Ce sont les étapes , collez le logcat dans votre commentaire.

Je ne parviens pas à reproduire le problème bien que je n'ai testé qu'en local en utilisant bundletool .

@blasten L'erreur précédente est donc corrigée mais j'ai rencontré une autre erreur. Je suppose que cela est causé par quelque chose dans mon projet. Y a-t-il un moyen de déboguer cela ?

[+6084 ms] Failed to execute aapt
[  +17 ms] com.android.ide.common.process.ProcessException: Failed to execute aapt
[   +1 ms]      at com.android.builder.core.AndroidBuilder.processResources(AndroidBuilder.java:809)
[   +1 ms]      at com.android.build.gradle.internal.res.LinkAndroidResForBundleTask.taskAction(LinkAndroidResForBundleTask.kt:128)
[   +1 ms]      at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
[   +1 ms]      at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
[   +1 ms]      at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
[        ]      at java.lang.reflect.Method.invoke(Method.java:498)
[        ]      at org.gradle.internal.reflect.JavaMethod.invoke(JavaMethod.java:73)
[   +4 ms]      at org.gradle.api.internal.project.taskfactory.StandardTaskAction.doExecute(StandardTaskAction.java:46)
[   +1 ms]      at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:39)
[        ]      at org.gradle.api.internal.project.taskfactory.StandardTaskAction.execute(StandardTaskAction.java:26)
[   +3 ms]      at org.gradle.api.internal.AbstractTask$TaskActionWrapper.execute(AbstractTask.java:788)
[  +29 ms]      at org.gradle.api.internal.AbstractTask$TaskActionWrapper.execute(AbstractTask.java:755)
[   +1 ms]      at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter$1.run(ExecuteActionsTaskExecuter.java:124)
[   +1 ms]      at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:336)
[   +2 ms]      at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:328)
[   +1 ms]      at org.gradle.internal.progress.DefaultBuildOperationExecutor.execute(DefaultBuildOperationExecutor.java:199)
[   +9 ms]      at org.gradle.internal.progress.DefaultBuildOperationExecutor.run(DefaultBuildOperationExecutor.java:110)
[        ]      at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeAction(ExecuteActionsTaskExecuter.java:113)
[        ]      at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeActions(ExecuteActionsTaskExecuter.java:95)
[   +1 ms]      at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:73)
[        ]      at org.gradle.api.internal.tasks.execution.OutputDirectoryCreatingTaskExecuter.execute(OutputDirectoryCreatingTaskExecuter.java:51)
[   +1 ms]      at org.gradle.api.internal.tasks.execution.SkipUpToDateTaskExecuter.execute(SkipUpToDateTaskExecuter.java:59)
[        ]      at org.gradle.api.internal.tasks.execution.ResolveTaskOutputCachingStateExecuter.execute(ResolveTaskOutputCachingStateExecuter.java:54)
[        ]      at org.gradle.api.internal.tasks.execution.ValidatingTaskExecuter.execute(ValidatingTaskExecuter.java:59)
[   +5 ms]      at org.gradle.api.internal.tasks.execution.SkipEmptySourceFilesTaskExecuter.execute(SkipEmptySourceFilesTaskExecuter.java:101)
[        ]      at org.gradle.api.internal.tasks.execution.FinalizeInputFilePropertiesTaskExecuter.execute(FinalizeInputFilePropertiesTaskExecuter.java:44)
[   +1 ms]      at org.gradle.api.internal.tasks.execution.CleanupStaleOutputsExecuter.execute(CleanupStaleOutputsExecuter.java:91)
[   +1 ms]      at org.gradle.api.internal.tasks.execution.ResolveTaskArtifactStateTaskExecuter.execute(ResolveTaskArtifactStateTaskExecuter.java:62)
[  +12 ms]      at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:59)
[   +4 ms]      at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:54)
[        ]      at org.gradle.api.internal.tasks.execution.ExecuteAtMostOnceTaskExecuter.execute(ExecuteAtMostOnceTaskExecuter.java:43)
[        ]      at org.gradle.api.internal.tasks.execution.CatchExceptionTaskExecuter.execute(CatchExceptionTaskExecuter.java:34)
[        ]      at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker$1.run(DefaultTaskGraphExecuter.java:256)
[        ]      at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:336)
[        ]      at org.gradle.internal.progress.DefaultBuildOperationExecutor$RunnableBuildOperationWorker.execute(DefaultBuildOperationExecutor.java:328)
[        ]      at org.gradle.internal.progress.DefaultBuildOperationExecutor.execute(DefaultBuildOperationExecutor.java:199)
[        ]      at org.gradle.internal.progress.DefaultBuildOperationExecutor.run(DefaultBuildOperationExecutor.java:110)
[   +1 ms]      at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker.execute(DefaultTaskGraphExecuter.java:249)
[   +6 ms]      at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter$EventFiringTaskWorker.execute(DefaultTaskGraphExecuter.java:238)
[        ]      at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.processTask(DefaultTaskPlanExecutor.java:123)
[        ]      at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.access$200(DefaultTaskPlanExecutor.java:79)
[        ]      at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker$1.execute(DefaultTaskPlanExecutor.java:104)
[   +1 ms]      at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker$1.execute(DefaultTaskPlanExecutor.java:98)
[   +1 ms]      at org.gradle.execution.taskgraph.DefaultTaskExecutionPlan.execute(DefaultTaskExecutionPlan.java:663)
[   +1 ms]      at org.gradle.execution.taskgraph.DefaultTaskExecutionPlan.executeWithTask(DefaultTaskExecutionPlan.java:597)
[        ]      at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor$TaskExecutorWorker.run(DefaultTaskPlanExecutor.java:98)
[  +14 ms]      at org.gradle.internal.concurrent.ExecutorPolicy$CatchAndRecordFailures.onExecute(ExecutorPolicy.java:63)
[   +1 ms]      at org.gradle.internal.concurrent.ManagedExecutorImpl$1.run(ManagedExecutorImpl.java:46)
[   +4 ms]      at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
[   +1 ms]      at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
[   +2 ms]      at org.gradle.internal.concurrent.ThreadFactoryImpl$ManagedThreadRunnable.run(ThreadFactoryImpl.java:55)
[   +1 ms]      at java.lang.Thread.run(Thread.java:745)
[  +26 ms] Caused by: java.util.concurrent.ExecutionException: java.util.concurrent.ExecutionException: com.android.builder.internal.aapt.v2.Aapt2Exception: AAPT2 error: check logs for details
[   +4 ms]      at com.google.common.util.concurrent.AbstractFuture.getDoneValue(AbstractFuture.java:503)
[   +1 ms]      at com.google.common.util.concurrent.AbstractFuture.get(AbstractFuture.java:482)
[        ]      at com.google.common.util.concurrent.AbstractFuture$TrustedFuture.get(AbstractFuture.java:79)
[        ]      at com.android.builder.internal.aapt.AbstractAapt.link(AbstractAapt.java:34)
[        ]      at com.android.builder.core.AndroidBuilder.processResources(AndroidBuilder.java:807)
[        ]      ... 51 more
[        ] Caused by: java.util.concurrent.ExecutionException: com.android.builder.internal.aapt.v2.Aapt2Exception: AAPT2 error: check logs for details
[   +1 ms]      at com.google.common.util.concurrent.AbstractFuture.getDoneValue(AbstractFuture.java:503)
[        ]      at com.google.common.util.concurrent.AbstractFuture.get(AbstractFuture.java:462)
[        ]      at com.google.common.util.concurrent.AbstractFuture$TrustedFuture.get(AbstractFuture.java:79)
[        ]      at com.android.builder.internal.aapt.v2.QueueableAapt2.lambda$makeValidatedPackage$1(QueueableAapt2.java:166)
[   +4 ms]      at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
[   +1 ms]      at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
[   +1 ms]      ... 1 more
[   +1 ms] Caused by: com.android.builder.internal.aapt.v2.Aapt2Exception: AAPT2 error: check logs for details
[   +1 ms]      at com.android.builder.png.AaptProcess$NotifierProcessOutput.handleOutput(AaptProcess.java:443)
[   +1 ms]      at com.android.builder.png.AaptProcess$NotifierProcessOutput.err(AaptProcess.java:395)
[        ]      at com.android.builder.png.AaptProcess$ProcessOutputFacade.err(AaptProcess.java:312)
[        ]      at com.android.utils.GrabProcessOutput$1.run(GrabProcessOutput.java:104)
[        ] FAILURE: Build failed with an exception.
[        ] * What went wrong:
[        ] Execution failed for task ':app:bundleProdReleaseResources'.
[        ] > Failed to execute aapt
[        ] * Try:
[        ] Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
[   +5 ms] * Get more help at https://help.gradle.org
[        ] BUILD FAILED in 30s
[ +324 ms] Running Gradle task 'bundleProdRelease'... (completed in 31.5s)

@blasten je suis toutes tes pas mes logs :

➜  PROJECT_NAME git:(master) ✗ unzip -l out.apks
Archive:  out.apks
  Length      Date    Time    Name
---------  ---------- -----   ----
 43369811  01-01-1970 01:00   standalones/standalone-armeabi_tvdpi.apk
 43327197  01-01-1970 01:00   standalones/standalone-armeabi_hdpi.apk
 43319503  01-01-1970 01:00   standalones/standalone-armeabi_mdpi.apk
 43320027  01-01-1970 01:00   standalones/standalone-armeabi_ldpi.apk
 43346424  01-01-1970 01:00   standalones/standalone-armeabi_xxhdpi.apk
 43350403  01-01-1970 01:00   standalones/standalone-armeabi_xxxhdpi.apk
 43332970  01-01-1970 01:00   standalones/standalone-armeabi_xhdpi.apk
 50349155  01-01-1970 01:00   standalones/standalone-armeabi_v7a_ldpi.apk
 50348629  01-01-1970 01:00   standalones/standalone-armeabi_v7a_mdpi.apk
 50398968  01-01-1970 01:00   standalones/standalone-armeabi_v7a_tvdpi.apk
 50356358  01-01-1970 01:00   standalones/standalone-armeabi_v7a_hdpi.apk
 50362126  01-01-1970 01:00   standalones/standalone-armeabi_v7a_xhdpi.apk
 50375565  01-01-1970 01:00   standalones/standalone-armeabi_v7a_xxhdpi.apk
 50379553  01-01-1970 01:00   standalones/standalone-armeabi_v7a_xxxhdpi.apk
 50660246  01-01-1970 01:00   standalones/standalone-arm64_v8a_ldpi.apk
 50659718  01-01-1970 01:00   standalones/standalone-arm64_v8a_mdpi.apk
 50710027  01-01-1970 01:00   standalones/standalone-arm64_v8a_tvdpi.apk
 50667415  01-01-1970 01:00   standalones/standalone-arm64_v8a_hdpi.apk
 50673185  01-01-1970 01:00   standalones/standalone-arm64_v8a_xhdpi.apk
 50686641  01-01-1970 01:00   standalones/standalone-arm64_v8a_xxhdpi.apk
 43345757  01-01-1970 01:00   standalones/standalone-x86_mdpi.apk
 43346287  01-01-1970 01:00   standalones/standalone-x86_ldpi.apk
 43396086  01-01-1970 01:00   standalones/standalone-x86_tvdpi.apk
 50690619  01-01-1970 01:00   standalones/standalone-arm64_v8a_xxxhdpi.apk
 43359247  01-01-1970 01:00   standalones/standalone-x86_xhdpi.apk
 43353470  01-01-1970 01:00   standalones/standalone-x86_hdpi.apk
 43372688  01-01-1970 01:00   standalones/standalone-x86_xxhdpi.apk
 43376653  01-01-1970 01:00   standalones/standalone-x86_xxxhdpi.apk
 43340224  01-01-1970 01:00   standalones/standalone-x86_64_ldpi.apk
 43339701  01-01-1970 01:00   standalones/standalone-x86_64_mdpi.apk
 43390033  01-01-1970 01:00   standalones/standalone-x86_64_tvdpi.apk
 43347418  01-01-1970 01:00   standalones/standalone-x86_64_hdpi.apk
    57027  01-01-1970 01:00   splits/base-ldpi.apk
    56501  01-01-1970 01:00   splits/base-mdpi.apk
    61951  01-01-1970 01:00   splits/base-hdpi.apk
    67741  01-01-1970 01:00   splits/base-xhdpi.apk
    81187  01-01-1970 01:00   splits/base-xxhdpi.apk
    85188  01-01-1970 01:00   splits/base-xxxhdpi.apk
   105385  01-01-1970 01:00   splits/base-tvdpi.apk
 43353194  01-01-1970 01:00   standalones/standalone-x86_64_xhdpi.apk
    11313  01-01-1970 01:00   splits/base-ca.apk
    11211  01-01-1970 01:00   splits/base-da.apk
    12040  01-01-1970 01:00   splits/base-fa.apk
    11659  01-01-1970 01:00   splits/base-ja.apk
    12486  01-01-1970 01:00   splits/base-ka.apk
    12511  01-01-1970 01:00   splits/base-pa.apk
    12856  01-01-1970 01:00   splits/base-ta.apk
    11195  01-01-1970 01:00   splits/base-nb.apk
    12001  01-01-1970 01:00   splits/base-be.apk
    11420  01-01-1970 01:00   splits/base-de.apk
    13041  01-01-1970 01:00   splits/base-ne.apk
    12674  01-01-1970 01:00   splits/base-te.apk
 43366615  01-01-1970 01:00   standalones/standalone-x86_64_xxhdpi.apk
    11179  01-01-1970 01:00   splits/base-af.apk
    12151  01-01-1970 01:00   splits/base-bg.apk
    12353  01-01-1970 01:00   splits/base-th.apk
    11228  01-01-1970 01:00   splits/base-fi.apk
    12537  01-01-1970 01:00   splits/base-si.apk
    12551  01-01-1970 01:00   splits/base-hi.apk
    11939  01-01-1970 01:00   splits/base-kk.apk
    11615  01-01-1970 01:00   splits/base-vi.apk
    12059  01-01-1970 01:00   splits/base-mk.apk
    11440  01-01-1970 01:00   splits/base-sk.apk
    11961  01-01-1970 01:00   splits/base-uk.apk
    12344  01-01-1970 01:00   splits/base-el.apk
    11342  01-01-1970 01:00   splits/base-gl.apk
    13334  01-01-1970 01:00   splits/base-ml.apk
    11350  01-01-1970 01:00   splits/base-nl.apk
    11371  01-01-1970 01:00   splits/base-pl.apk
    11311  01-01-1970 01:00   splits/base-sl.apk
    11428  01-01-1970 01:00   splits/base-tl.apk
    11825  01-01-1970 01:00   splits/base-am.apk
    12685  01-01-1970 01:00   splits/base-km.apk
    12615  01-01-1970 01:00   splits/base-bn.apk
    11223  01-01-1970 01:00   splits/base-in.apk
    12832  01-01-1970 01:00   splits/base-kn.apk
    11958  01-01-1970 01:00   splits/base-mn.apk
    12621  01-01-1970 01:00   splits/base-lo.apk
    11425  01-01-1970 01:00   splits/base-ko.apk
    11395  01-01-1970 01:00   splits/base-ro.apk
    11438  01-01-1970 01:00   splits/base-sq.apk
    13612  01-01-1970 01:00   splits/base-fr.apk
    11647  01-01-1970 01:00   splits/base-ar.apk
    11278  01-01-1970 01:00   splits/base-hr.apk
    12447  01-01-1970 01:00   splits/base-mr.apk
    12943  01-01-1970 01:00   splits/base-or.apk
    14244  01-01-1970 01:00   splits/base-sr.apk
    11316  01-01-1970 01:00   splits/base-tr.apk
    11973  01-01-1970 01:00   splits/base-ur.apk
    11308  01-01-1970 01:00   splits/base-bs.apk
    12525  01-01-1970 01:00   splits/base-as.apk
    13704  01-01-1970 01:00   splits/base-es.apk
    11367  01-01-1970 01:00   splits/base-cs.apk
    11222  01-01-1970 01:00   splits/base-is.apk
    11360  01-01-1970 01:00   splits/base-ms.apk
    11323  01-01-1970 01:00   splits/base-et.apk
    11283  01-01-1970 01:00   splits/base-it.apk
    11550  01-01-1970 01:00   splits/base-lt.apk
    14605  01-01-1970 01:00   splits/base-pt.apk
    11377  01-01-1970 01:00   splits/base-eu.apk
    12409  01-01-1970 01:00   splits/base-gu.apk
    11651  01-01-1970 01:00   splits/base-hu.apk
    12048  01-01-1970 01:00   splits/base-ru.apk
    11616  01-01-1970 01:00   splits/base-lv.apk
    11314  01-01-1970 01:00   splits/base-zu.apk
    11260  01-01-1970 01:00   splits/base-sv.apk
    11539  01-01-1970 01:00   splits/base-iw.apk
    11283  01-01-1970 01:00   splits/base-sw.apk
    12110  01-01-1970 01:00   splits/base-hy.apk
 43370609  01-01-1970 01:00   standalones/standalone-x86_64_xxxhdpi.apk
    11904  01-01-1970 01:00   splits/base-ky.apk
    11430  01-01-1970 01:00   splits/base-az.apk
    13395  01-01-1970 01:00   splits/base-my.apk
    11296  01-01-1970 01:00   splits/base-uz.apk
    15398  01-01-1970 01:00   splits/base-zh.apk
    23877  01-01-1970 01:00   splits/base-en.apk
   107757  01-01-1970 01:00   splits/base-armeabi.apk
   134023  01-01-1970 01:00   splits/base-x86.apk
   127969  01-01-1970 01:00   splits/base-x86_64.apk
 42926206  01-01-1970 01:00   splits/base-master.apk
 21480838  01-01-1970 01:00   splits/base-arm64_v8a_2.apk
 17508309  01-01-1970 01:00   splits/base-armeabi_v7a_2.apk
   217751  01-01-1970 01:00   splits/base-armeabi_2.apk
   311771  01-01-1970 01:00   splits/base-x86_2.apk
   308537  01-01-1970 01:00   splits/base-x86_64_2.apk
  7136923  01-01-1970 01:00   splits/base-armeabi_v7a.apk
  7447993  01-01-1970 01:00   splits/base-arm64_v8a.apk
 42926200  01-01-1970 01:00   splits/base-master_2.apk
    16537  01-01-1970 01:00   toc.pb
---------                     -------
1759809847                     129 files
➜  PROJECT_NAME git:(master) ✗ flutter doctor
Doctor summary (to see all details, run flutter doctor -v):
[✓] Flutter (Channel master, v1.6.1-pre.68, on Mac OS X 10.14.5 18F132, locale en-GB)

[✓] Android toolchain - develop for Android devices (Android SDK version 28.0.3)
[✓] iOS toolchain - develop for iOS devices (Xcode 10.2.1)
[!] Android Studio (version 3.3)
    ✗ Flutter plugin not installed; this adds Flutter specific functionality.
    ✗ Dart plugin not installed; this adds Dart specific functionality.
[✓] VS Code (version 1.34.0)
[✓] Connected device (1 available)

! Doctor found issues in 1 category.

@jereksel @ndusart
En fait, cela s'appelle Assets Targeting et cela vous permet de cibler/diviser des répertoires dans des actifs basés sur l'API graphique, la compression du langage et de la texture.
Comme on le voit ici : .../bundletool/model/targeting/TargetedDirectorySegment.java

En ce qui concerne le flutter@master actuel d'AAB, cela fonctionne pour moi localement - en utilisant bundletool pour tester et installer sur un appareil réel. J'ai désactivé le fractionnement sur la densité et la langue dans mon build.gradle donc build-apks me donne ceci :

  Length      Date    Time    Name
---------  ---------- -----   ----
  6872466  1970-01-01 01:00   splits/base-arm64_v8a.apk
  6726824  1970-01-01 01:00   splits/base-master.apk
 13289718  1970-01-01 01:00   standalones/standalone-armeabi_v7a.apk
 13594392  1970-01-01 01:00   standalones/standalone-arm64_v8a.apk
  6567785  1970-01-01 01:00   splits/base-armeabi_v7a.apk
      429  1970-01-01 01:00   toc.pb
---------                     -------
 47051614                     6 files

En le testant sur Test Lab, j'ai aussi tout vert.
J'attends toujours que Play Store traite cette version pour tester cette chaîne.

@Tokenyet avez-vous pu télécharger l'application depuis le Play Store et l'exécuter après avoir téléchargé le .aab ? Si tel est le cas, pourriez-vous coller la sortie de flutter doctor ?

Je peux télécharger l'application depuis le Play Store et l'exécuter. Vous pouvez [essayer] (https://play.google.com/store/apps/details?id=com.bumbystudio.starry_clock). (Edit : Oups, ça ne marche pas... depuis PlayStore)

Ci-dessous se trouve mon flutter doctor selon vos besoins. J'espère que cela a aidé.

[√] Flutter (Channel master, v1.6.1-pre.88, sur Microsoft Windows [Version 10.0.17134.765], locale zh-TW)

[√] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[√] Android Studio (version 3.3)
[√] VS Code, édition 64 bits (version 1.30.2)
[!] Appareil connecté
! Aucun appareil disponible

Cela fonctionne bien pour moi !

Types de construction {
Libération {
// À FAIRE : ajoutez votre propre configuration de signature pour la version finale.
// Signature avec les clés de débogage pour le moment, donc flutter run --release fonctionne.
signatureConfig signatureConfigs.debug
}
déboguer {
ndk {
abiFilters 'armeabi-v7a'
}
}
}

@SPodjasek toujours, nous devons diviser assets/ fonction de l'ABI. Comment cela peut-il être fait actuellement ?

J'ai installé sur mon appareil et il semble que cela ne fonctionne pas. Tout ce que j'ai eu était un
écran noir.

Merci,

Purusothaman Ramanujam

Le jeu. 23 mai 2019, 18:43 Tokenyet, [email protected] a écrit :

@Tokenyet https://github.com/Tokenyet avez-vous pu télécharger l'application
depuis le Play Store et exécutez-le après avoir téléchargé le fichier .aab? Si c'est le
cas, voudriez-vous coller la sortie de Flutter Doctor ?

Je peux télécharger l'application depuis le Play Store et l'exécuter. Tu pourrais le donner
un essai
https://play.google.com/store/apps/details?id=com.bumbystudio.starry_clock
.

Vous trouverez ci-dessous mon médecin de flutter selon vos besoins. J'espère que cela a aidé.

[√] Flutter (Channel master, v1.6.1-pre.88, sur Microsoft Windows [Version
10.0.17134.765], paramètres régionaux zh-TW)

[√] Chaîne d'outils Android - développer pour les appareils Android (version Android SDK
28.0.3)
[√] Android Studio (version 3.3)
[√] VS Code, édition 64 bits (version 1.30.2)
[!] Appareil connecté
! Aucun appareil disponible

-
Vous recevez ceci parce que vous êtes abonné à ce fil.
Répondez directement à cet e-mail, consultez-le sur GitHub
https://github.com/flutter/flutter/issues/18494?email_source=notifications&email_token=AAIHDZYY47H6PUQQJYEO4J3PW2J7RA5CNFSM4FFE2B7KYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVLOWC21WJGOD19
ou couper le fil
https://github.com/notifications/unsubscribe-auth/AAIHDZZXV67JCNVJYLVA3WLPW2J7RANCNFSM4FFE2B7A
.

@ndusart À ce stade, c'est impossible - peut-être déposez une demande de fonctionnalité sur bundletool et Google envisagera de la mettre en œuvre.

@SPodjasek donc c'est ce que je dis, tout ce problème va dans le mauvais sens.

Toutes les discussions semblent se terminer par " ne vous inquiétez pas, quand nous pourrions créer des bundles d'applications, tout irait bien " mais ce n'est totalement pas le cas en ce moment et dans un avenir proche.
C'est un peu décevant de voir l'équipe Flutter laisser les gens penser que c'est possible de cette façon.

flutter devrait être en mesure de fournir un moyen de créer facilement un APK fractionné soit en effectuant le fractionnement lui-même, soit en réussissant à déplacer les instantanés de la VM dans le dossier lib/ et à laisser le fractionnement fonctionner (nous pourrions alors également utiliser des bundles d'applications )

Résumons:

1. Flutter prendra en charge les gros APK via flutter build apk ... .
2. Si vous voulez essayer cette fonctionnalité _tout de suite_ essayez flutter build appbundle dans la branche master. Si les bundles d'applications ne fonctionnent pas pour votre cas d'utilisation, alors (1) devrait couvrir les cas restants.

D'accord @blasten, j'ai regardé dans le code maître et les instantanés sont déplacés dans le dossier lib :
https://github.com/flutter/flutter/blob/dc28ba8919604ff19ea7cbad8d9400516347b08a/packages/flutter_tools/gradle/flutter.gradle#L470 -L481

Il ne s'agit donc pas simplement d'ajouter la prise en charge de l'ensemble d'applications. C'est plus clair maintenant.
Un peu d'explication aurait cependant été apprécié car il a été indiqué que le problème était le dossier des actifs et aucune information n'a été donnée.

Merci pour votre travail.

@ndusart - @blasten a apporté des modifications à l'intégration Android afin qu'il recherche maintenant les blobs binaires dans le dossier lib , afin que vous puissiez regrouper les deux types si je ne me trompe pas...

Si les snapshots sont déplacés dans lib, alors peut-être que #30846 sera également corrigé ?

@blasten
Je suis passé au canal principal, mis à niveau et créé l'appbundle. Malheureusement, l'application se bloque après avoir été téléchargée depuis Google Play Store avec le logcat suivant

2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm.cc(241)] Could not setup VM data to bootstrap the VM from.
2019-05-22 09:42:14.824 6995-6995/? E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
2019-05-22 09:42:14.824 6995-6995/? A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.

flutter build appbundle est maintenant en master, une personne volontaire veut-elle l'essayer ?
Nous avons eu une discussion pour prendre en charge une liste de plates-formes dans build apk , vous pouvez donc faire quelque chose comme ceci : flutter build apk --target-platform android-arm,android-arm64

J'ai le même problème, même si je n'ai pas encore de logs.

Pareil ici. Avait une erreur. Maître mis à niveau et exécuté flutter build appbundle . Je me suis débarrassé de l'erreur mais l'application se bloque à l'ouverture.

J'ai essayé de télécharger un appbundle en utilisant la dernière version de Flutter Master sur l'App Store avec les dernières modifications. L'erreur 64 bits a disparu maintenant, mais mon application se bloque immédiatement.

Ce qui est vraiment étrange, c'est que l'exécution de la version 64 bits à l'aide des commandes ci-dessous fonctionne correctement.
flutter build apk --target-platform android-arm64
api d'installation de flutter

Il ne plante que lorsque l'application est installée via l'appbundle dans l'Appstore. Pour l'instant, j'ai rétabli l'Appstore à l'apk 32 bits.

Je n'ai rien de spécial dans mon gradle.build

minSdkVersion 21
targetSdkVersion 28
versionCode flutterVersionCode.toInteger()
versionName flutterVersionName
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
multiDexEnabled vrai

J'exécute Flutter (Channel master, v1.6.4-pre.13, sur Mac OS X 10.14.5 18F132, locale en-US)

Existe-t-il un moyen de tester ces bundles avant de les télécharger sur l'Appstore ? Est-ce un problème connu sur lequel Google travaille ou dois-je apporter des modifications à mon fichier gradle ?

@chitwoob Veuillez suivre les étapes : https://github.com/flutter/flutter/issues/18494#issuecomment -495049530

@blasten Je rencontre un problème avec l'outil bundle qui n'est pas lié à ce problème.

Je reçois
Erreur : Échec du démarrage du serveur ADB

En courant
build-apks --connected-device --bundle=./app.aab --output=./my_app.apks --adb

J'ai correctement installé adb. Lorsque j'essaie adb logcat, cela fonctionne bien.

Ça va être un long commentaire, mais cela a complètement résolu le problème

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm
2. télécharger app-armeabi-v7a-release.apk sur le Play Store
3. incrémenter versionCode
4. courir flutter build apk --release --target-platform=android-arm64
5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.

Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

Suivre ces étapes donnait « La version de Gradle n'a pas réussi à produire un package Android ». Erreur
_ Après une heure de débogage, trouvé le correctif. _

Pour créer différentes applications pour x86 et x64, procédez comme suit :

Étape 1 : Incluez l'extrait de code dans le fichier app/build.gradle . Le fichier ressemblera à :

....
    lintOptions {
        disable 'InvalidPackage'
    }

    splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

    defaultConfig {
....

Étape 2 : Créez une version d'apk en utilisant flutter build apk --release
Cela créera l'apk basé sur x86 dans le dossier build/app/outputs/apk/app.apk
Téléchargez cet apk sur Google Play Store.
x86 fait jusqu'à maintenant

À ce stade, ne lancez pas flutter clean
Je faisais cela et j'obtenais des erreurs lors de la construction de l'apk x64

Étape 3: Maintenant, ouvrez pubspec.yaml et changez le version de
version: 1.0.0+1 à version: 1.0.0+2

Le nombre à côté de + est le code de version

Étape 4 : Exécutez maintenant la commande
flutter build apk --release --target-platform=android-arm64

Une fois cette commande terminée, accédez à build/app/outputs/apk/release/ . Vous y trouverez un apk avec le nom app-arm64-v8a-release.apk . Ceci est votre fichier apk 64 bits avec un code de version différent.

Maintenant, téléchargez cet apk x64 sur Play Store... et c'est parti. Vous avez téléchargé des applications x86 et x64 sur Play Store.

Ça va être un long commentaire, mais cela a complètement résolu le problème

[...]
Pour créer différentes applications pour x86 et x64, procédez comme suit :

Étape 1 : Incluez l'extrait de code dans le fichier app/build.gradle . Le fichier ressemblera à :

....
    lintOptions {
        disable 'InvalidPackage'
    }

    splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

    defaultConfig {
....

Étape 2 : Créez une version d'apk en utilisant flutter build apk --release
[...]

D'accord avec ta réponse. Fonctionne pour moi, même si je n'ai pas eu à suivre l'étape 1 (j'ai utilisé un build.gradle par défaut)

Ensuite, il vous suffit d'incrémenter votre numéro de build et votre version pour que Google Play l'accepte.

J'ai toujours des problèmes avec flutter build appbundle sur ma main.

Ça va être un long commentaire, mais cela a complètement résolu le problème

[...]
Pour créer différentes applications pour x86 et x64, procédez comme suit :
Étape 1 : Incluez l'extrait de code dans le fichier app/build.gradle . Le fichier ressemblera à :

....
    lintOptions {
        disable 'InvalidPackage'
    }

    splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

    defaultConfig {
....

Étape 2 : Créez une version d'apk en utilisant flutter build apk --release
[...]

D'accord avec ta réponse. Fonctionne pour moi, même si je n'ai pas eu à suivre l'étape 1 (j'ai utilisé un build.gradle par défaut)

Ensuite, il vous suffit d'incrémenter votre numéro de build et votre version pour que Google Play l'accepte.

J'ai toujours des problèmes avec flutter build appbundle sur ma main.

Ca ne fonctionne pas. Je suis tellement bouleversé. L'application s'est écrasée lors d'une tentative de déploiement sur un émulateur x86 ainsi que sur un périphérique de bras réel. Essayé avec le canal maître/bêta/stable. Aucune version prête. C'est toujours le bouchon du spectacle pour nous. La commande Appbundle génère un ensemble installable pour le jeu, mais pendant l'exécution, l'application affiche uniquement l'écran de démarrage, puis se bloque. L'équipe Flutter s'il vous plaît fournir une solution claire ou WA.

@mormih merci pour votre patience -- nous travaillons sur la reproduction. Si cela ne vous dérange pas, pourriez-vous m'envoyer un e-mail ([email protected]) comprenant les éléments suivants, cela pourrait m'aider :

• Votre plate-forme hôte que vous utilisez pour construire.
• La commande que vous utilisez pour créer l'application.
• Exécutez votre commande de construction avec --bug-report (par exemple flutter build appbundle --bug-report ) et attachez le fichier bugreport.zip associé
• Attachez le bundle d'applications généré afin que nous puissions essayer de l'exécuter sur des appareils locaux
• Joindre les résultats de adb bugreport après avoir essayé d'exécuter l'application

Merci!

@tvolkert J'ai également le problème de plantage avec le message suivant :

Échec de la vérification : vm. Doit être capable d'initialiser la VM.

Ma plate-forme hôte est un mac et macOS 10.14.5. Avez-vous pu le reproduire ou souhaitez-vous que je suive les étapes que vous avez écrites ci-dessus ? En outre, cela devrait peut-être avoir un ticket dédié car il s'agit d'un problème distinct de celui de l'OP.

@mormih Je ne suis pas sûr, mais avez-vous essayé d'inclure également x86 dans la liste abi ?

include "armeabi-v7a", "arm64-v8a", "x86"

flutter build appbundle (sur le maître) n'a pas fonctionné pour moi non plus, l'écran de démarrage est bloqué comme d'autres l'ont noté...

La seule solution de contournement que j'ai trouvée pour la sortie (dans le Play Store) pour le 32 et le 64 bits jusqu'à présent est la suivante. (Partiement couvert dans le fil mais pourrait aider quelqu'un):

1. Créez un apk avec le filtre v7 activé + la commande build apk par défaut :
   Dans votre fichier app/build.gradle :
   defaultConfig { ... ndk{ abiFilters "armeabi-v7a" } }
   puis courir
   flutter build apk
   (par défaut --release)

2. Bump votre numéro de build dans pubspec.yaml.
   Par exemple de version: 1.1.0+6 à version: 1.1.0+7

3. Créez un apk avec le filtre v8 sur + build avec arm64 comme plate-forme cible :
   mettez maintenant à jour le build.gradle comme :
   defaultConfig { ... ndk{ abiFilters "arm64-v8a" } }
   puis courir
   flutter build apk --release --target-platform android-arm64

Inclut la surcharge d'avoir à télécharger 2 apks (et donc à créer 2 numéros de build) mais au moins cela semble faire le travail et je peux publier pour les appareils 32 et 64 bits...

Remarque : j'ai abandonné x86 car cela n'implique qu'un très petit groupe d'appareils mobiles (et potentiellement aucun de mes utilisateurs), de plus je n'ai pas besoin d'une version de version dans l'émulateur (le débogage est suffisant pour les tests). Mais cela pourrait bien sûr ne pas être le cas pour d'autres.

La méthode

Quelque part dans les commentaires, quelqu'un a laissé ça.

Cela a fonctionné pour moi et son seul code de terminal.
Il génère 2 fichiers que je déteste et crée 2 versions.

@ezmegy Merci ! Tu sauves ma journée

Merci @ezmegy , votre "truc" fonctionne !

Merci @ezmegy !
J'aimerais partager mon flux de travail actuel qui pourrait être utile :

Créez des versions de build sur app/build.gradle par architecture

flavorDimensions 'arch'
    productFlavors {
        arm32 {
            dimension 'arch'
            ndk {
                abiFilters 'armeabi-v7a'
            }
        }
        arm64 {
            dimension 'arch'
            ndk {
                abiFilters 'arm64-v8a'
            }
        }

Ensuite, je peux construire les deux avec :
flutter build apk --flavor arm32
et
flutter build apk --flavor arm64 --target-platform android-arm64
sans modifier le gradle à chaque build

En ce qui concerne le code de version, je préférerais en définir un par défaut et dériver les autres de celui-ci
Par exemple, définissez arm32 avec 1.0.0+10000 et générez le code de version pour le arm64 qui est 1.0.0+10000
Cela devrait être facile à générer à l'aide de bash (ou dans fastfile si vous utilisez fastlane)

Vous pouvez définir le numéro de build en utilisant des arguments --build-number ou via fastlane si vous en utilisez un

Ce script de code de version m'aide dans CI/CD 😄

CMIIW

Pour moi ça a plutôt bien marché
https://github.com/flutter/flutter/issues/10728#issuecomment-461375218

Ça va être un long commentaire, mais cela a complètement résolu le problème

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm
2. télécharger app-armeabi-v7a-release.apk sur le Play Store
3. incrémenter versionCode
4. courir flutter build apk --release --target-platform=android-arm64
5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.
Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

Suivre ces étapes donnait « La version de Gradle n'a pas réussi à produire un package Android ». Erreur
_ Après une heure de débogage, trouvé le correctif. _

Pour créer différentes applications pour x86 et x64, procédez comme suit :

Étape 1 : Incluez l'extrait de code dans le fichier app/build.gradle . Le fichier ressemblera à :

....
    lintOptions {
        disable 'InvalidPackage'
    }

    splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

    defaultConfig {
....

Étape 2 : Créez une version d'apk en utilisant flutter build apk --release
Cela créera l'apk basé sur x86 dans le dossier build/app/outputs/apk/app.apk
Téléchargez cet apk sur Google Play Store.
x86 fait jusqu'à maintenant

À ce stade, ne lancez pas flutter clean
Je faisais cela et j'obtenais des erreurs lors de la construction de l'apk x64

Étape 3: Maintenant, ouvrez pubspec.yaml et changez le version de
version: 1.0.0+1 à version: 1.0.0+2

Le nombre à côté de + est le code de version

Étape 4 : Exécutez maintenant la commande
flutter build apk --release --target-platform=android-arm64

Une fois cette commande terminée, accédez à build/app/outputs/apk/release/ . Vous y trouverez un apk avec le nom app-arm64-v8a-release.apk . Ceci est votre fichier apk 64 bits avec un code de version différent.

Maintenant, téléchargez cet apk x64 sur Play Store... et c'est parti. Vous avez téléchargé des applications x86 et x64 sur Play Store.

Cela fonctionne pour moi aussi sans étape 1. Merci à tous. J'ai utilisé des filtres ndk ndk {
abiFilters "armeabi-v7a", "x86"
}
dans le fichier gradle de construction. Je ne sais pas si c'est obligatoire ou pas. En dehors de cela, j'avais suivi toutes les étapes de l'étape 2 et téléchargé deux apk, un pour 32 bits et un autre pour 64 bits.

Auparavant, j'avais téléchargé un appbundle, cette fois j'avais téléchargé des fichiers apk. Fonctionne bien. Je dois vérifier avec appbundle et essayer de réparer sans télécharger deux apk.

Noter :
Avant de faire ce processus, mon application s'est écrasée dans les appareils arm-64 bits suivants
Redmi MI,
Redmi 3S Prime
Honneur 8x

A travaillé dans les appareils arm-64 bits suivants
Samsung Galaxy J4
Samsung On8

Salut l'équipe Flutter,

Svp. envisagez également d'autres marchés d'applications tels que ceux de la Chine. En Chine, nous ne sommes pas autorisés à utiliser Google Play Store, à la place, nous avons de nombreux marchés d'applications tels que ceux de XiaoMi, de HuaWei et d'Ali, etc.

Sur ces marchés d'applications, nous ne sommes PAS autorisés à fournir des versions d'apk dans différentes architectures, nous ne pouvons télécharger qu'UN ET UN SEUL apk par version, et cette version remplacera l'apk de la version précédente. Ce qui signifie que le contournement actuel consiste à utiliser "armeabi-v7a".

Corrigez-moi si je me trompe, en utilisant "armeabi-v7a", tous les appareils 64 bits exécuteront libflutter.so 32 bits, et je suppose que ce sera plus lent.

Je suggérerais donc que l'équipe flutter puisse fournir une méthode pour nous permettre de créer un apk qui inclut à la fois libflutter.so 32 bits et 64 bits, bien que la taille de l'apk soit plus grande. (En Chine, nous avons généralement une vitesse Internet très rapide et nous payons peu pour avoir des plans d'utilisation 4G infinis, et les gens ne se soucient généralement pas de la taille de l'apk)

Salut l'équipe Flutter,

Svp. envisagez également d'autres marchés d'applications tels que ceux de la Chine. En Chine, nous ne sommes pas autorisés à utiliser Google Play Store, à la place, nous avons de nombreux marchés d'applications tels que ceux de XiaoMi, de HuaWei et d'Ali, etc.

Sur ces marchés d'applications, nous ne sommes PAS autorisés à fournir des versions d'apk dans différentes architectures, nous ne pouvons télécharger qu'UN ET UN SEUL apk par version, et cette version remplacera l'apk de la version précédente. Ce qui signifie que le contournement actuel consiste à utiliser "armeabi-v7a".

Corrigez-moi si je me trompe, en utilisant "armeabi-v7a", tous les appareils 64 bits exécuteront libflutter.so 32 bits, et je suppose que ce sera plus lent.

Je suggérerais donc que l'équipe flutter puisse fournir une méthode pour nous permettre de créer un apk qui inclut à la fois libflutter.so 32 bits et 64 bits, bien que la taille de l'apk soit plus grande. (En Chine, nous avons généralement une vitesse Internet très rapide et nous payons peu pour avoir des plans d'utilisation 4G infinis, et les gens ne se soucient généralement pas de la taille de l'apk)

Dans votre cas, vous pouvez fournir le 32 bits standard et tout ira bien, non ?
L'avertissement 64 bits est uniquement pour Google Play. Je pense que ce n'est pas un problème pour la Chine.
(S'il vous plait corrigez moi si je me trompe.)

@ KunalT6569 Je suppose que l' étape 3 comme vous l'avez déclaré :

Étape 3 : Ouvrez maintenant pubspec.yaml et modifiez la version de
version : 1.0.0+1 à version : 1.0.0+2

est nécessaire pour autoriser le téléchargement des deux fichiers apk sur la console Google Play, n'est-ce pas ?

J'ai une autre question - une fois que les deux fichiers apk sont prêts, vous les téléchargez simplement via la section App releases\New Release\Browse Files , n'est-ce pas ?

@angel1st Oui, l' étape 3 est requise car Google Play n'autorisera pas le téléchargement de deux apks avec les mêmes codes de version.

Pour télécharger plusieurs apks sur Google Play, je me suis référé à cette vidéo.
https://www.youtube.com/watch?v=rMl_oLlf_g0

POUR VOTRE INFORMATION:

Notre plan actuel est de publier une version bêta en utilisant l'une des dernières versions de développement dans les 10 prochains jours. Ensuite, notre plan est d'attendre jusqu'à ce que nous ayons un processus documenté mis à jour sur la façon d'expédier sur Android qui ne déclenche pas les avertissements concernant les versions 64 bits du Play Store, d'avoir un moyen de conditionner un APK qui prend en charge 64 bits, et de prouver nous pouvons publier la galerie en utilisant ce processus, et dès que nous l'avons fait, suivre le processus pour publier une nouvelle version bêta que nous pousserons ensuite à stabiliser une semaine environ plus tard.

Cela signifie que nous aurons probablement une version bêta début juin et une version bêta fin juin ou début juillet qui deviendra stable peu de temps après.

@Hixie Il y a un autre problème survenu ici
app bundle par le dernier flutter (maître à partir de maintenant) ne générant pas les versions x86, x86_64
Fichiers produits par la branche master

Fichiers générés par l'ancienne version avec Android Studio

Le comportement attendu est d'inclure également les versions x86 et x86_64 dans le fichier produit par la nouvelle version

@canewsin indépendamment de ce problème, nous ne fournissons pas de binaires de version x86 (https://github.com/flutter/flutter/issues/9253) - est l'"ancienne version" dans https://github.com/flutter/ flutter/issues/18494#issuecomment -497118805 faisant référence à une version de débogage ?

J'ai le même problème, la construction pour 32 bits exclura les périphériques 64 bits, mais cela fonctionne sur eux. La construction pour 64 en spécifiant --target-platform android-arm64 fonctionne sur les appareils 64 bits, mais plante sur les appareils 32 bits. De plus, Google limitera le téléchargement d'apks à 64 bits en 2019.

Équipe Flutter, veuillez résoudre ce problème de base !

configuration par défaut {
....
versionName flutterVersionName
ndk.abiFiltres 'armeabi-v7a','arm64-v8a','x86','x86_64'
}
// prêt!

J'ai compilé mon application avec la dernière branche principale de flutter et téléchargée sur Play Store en tant que bundle d'applications, mais l'application plante sur l'appareil. Ce journal est extrait du laboratoire de test.

05-31 07:50:28.384: D/AndroidRuntime(11036): --------- beginning of crash
05-31 07:50:28.384: E/AndroidRuntime(11036): FATAL EXCEPTION: main
05-31 07:50:28.384: E/AndroidRuntime(11036): Process: in.canews.social, PID: 11036
05-31 07:50:28.384: E/AndroidRuntime(11036): java.lang.RuntimeException: Unable to create application in.canews.social.App: java.lang.NullPointerException: Attempt to get length of null array
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.ActivityThread.handleBindApplication(ActivityThread.java:5794)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.ActivityThread.-wrap1(Unknown Source:0)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1661)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.os.Handler.dispatchMessage(Handler.java:105)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.os.Looper.loop(Looper.java:164)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.ActivityThread.main(ActivityThread.java:6541)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at java.lang.reflect.Method.invoke(Native Method)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at com.android.internal.os.Zygote$MethodAndArgsCaller.run(Zygote.java:240)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:767)
05-31 07:50:28.384: E/AndroidRuntime(11036): Caused by: java.lang.NullPointerException: Attempt to get length of null array
05-31 07:50:28.384: E/AndroidRuntime(11036):    at io.flutter.view.FlutterMain.listLibs(FlutterMain.java:381)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at io.flutter.view.FlutterMain.initAot(FlutterMain.java:412)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at io.flutter.view.FlutterMain.startInitialization(FlutterMain.java:164)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at io.flutter.view.FlutterMain.startInitialization(FlutterMain.java:143)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at io.flutter.app.FlutterApplication.onCreate(FlutterApplication.java:22)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.Instrumentation.callApplicationOnCreate(Instrumentation.java:1118)
05-31 07:50:28.384: E/AndroidRuntime(11036):    at android.app.ActivityThread.handleBindApplication(ActivityThread.java:5791)
05-31 07:50:28.384: E/AndroidRuntime(11036):    ... 8 more
05-31 07:50:28.392: W/ActivityManager(897):   Force finishing activity in.canews.social/.MainActivity

Docteur Flutter -v

C:\flutter\flutter\bin>flutter doctor -v
[√] Flutter (Channel master, v1.6.7-pre.7, on Microsoft Windows [Version 10.0.17763.503], locale en-IN)
    • Flutter version 1.6.7-pre.7 at C:\flutter\flutter
    • Framework revision 6884146925 (2 days ago), 2019-05-29 12:52:05 -0700
    • Engine revision 8dc3a4cde2
    • Dart version 2.3.2 (build 2.3.2-dev.0.0 e3edfd36b2)


[√] Android toolchain - develop for Android devices (Android SDK version 28.0.3)
    • Android SDK at C:\Users\PramUkesh\AppData\Local\Android\sdk
    • Android NDK location not configured (optional; useful for native profiling support)
    • Platform android-28, build-tools 28.0.3
    • Java binary at: C:\Program Files\Android\Android Studio\jre\bin\java
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)
    • All Android licenses accepted.

[√] Android Studio (version 3.4)
    • Android Studio at C:\Program Files\Android\Android Studio
    • Flutter plugin version 35.3.1
    • Dart plugin version 183.6270
    • Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)

[√] VS Code (version 1.34.0)
    • VS Code at C:\Users\PramUkesh\AppData\Local\Programs\Microsoft VS Code
    • Flutter extension version 3.0.2

[√] Connected device (1 available)
    • Z2 Plus • 2e9087c2 • android-arm64 • Android 9 (API 28)

• No issues found!

@canewsin semble que ce problème a été résolu dans https://github.com/flutter/engine/pull/9078. Dans votre arborescence Flutter, mettez à jour votre branche principale locale, git fetch upstream && git merge upstream/master

Après avoir vu des questions répétées, qui ont déjà répondu dans les commentaires précédents, j'ai écrit un court article documentant les options dont nous disposons maintenant https://medium.com/@truongsinh/flutter -android-64-bit-so-what-the-fuss -15da6f8e3a46. Voici le TLDR :

@truongsinh , nous finalisons également la prise en charge de l'utilisation de flutter build appbundle pour créer un bundle d'applications contenant à la fois des binaires 32 et 64 bits à déployer sur le Play Store. Voir https://github.com/flutter/flutter/issues/31922 pour plus d'informations - veuillez l'essayer et nous faire savoir si vous rencontrez des problèmes.

@truongsinh , nous finalisons également la prise en charge de l'utilisation de flutter build appbundle pour créer un bundle d'applications contenant à la fois des binaires 32 et 64 bits à déployer sur le Play Store. Voir #31922 pour plus d'informations - veuillez l'essayer et nous faire savoir si vous rencontrez des problèmes.

Oui, j'attends toujours que flutter build appbundle produise l'application qui ne se bloque pas ou ne plante pas :D

Oui, j'attends toujours que Flutter build appbundle produise une application qui ne se bloque pas ou ne plante pas :D

Reconnu . Si vous avez un cas reproductible de ce qui se passe que nous pouvons examiner, ce serait formidable. Si vous vouliez créer un fichier .aab non signé à partir de la version 1.7.1 et me l'envoyer par e-mail ([email protected]), je vous en serais reconnaissant !

Pour info, l'annonce suivante a été envoyée à [email protected] concernant notre support 64 bits.

https://groups.google.com/forum/#!topic/flutter -announce/oIzwT9EDczc

J'ai aussi ce problème.

Lorsque je crée un bundle d'applications dans Android Studios, je peux le charger correctement sur mon simulateur, mais l'application plante lorsque je la télécharge depuis le Play Store

Salut les gars qui utilisent la branche flutter master et créent des bundles d'applications
si vous déboguez votre application, votre application fonctionne correctement
certains visages se bloquent lors du téléchargement depuis le Play Store, si cela se produit, vous devez vérifier si votre ensemble d'applications fonctionne sur votre appareil, car le mode de débogage produit des binaires JIT et le mode de publication produit des binaires AOT. Actuellement, leurs emplacements sont également différents, je pense donc pour tester votre application correctement
produisez apk à partir de l'app bundle pour une configuration spécifique basée sur votre appareil et désinstallez complètement l'application de débogage de votre appareil et installez cette nouvelle application de sortie à partir de l'app bundle si elle plante, elle plantera lorsqu'elle sera téléchargée depuis le Play Store ou autrement, j'espère que cela aidera les autres. .

Réf pour la sortie vers l'APK à partir de votre ensemble d'applications à partir de la ligne de commande
https://developer.android.com/studio/command-line/bundletool

Pour info, les plantages dans les bundles d'applications sont mieux suivis sur https://github.com/flutter/flutter/issues/31922. Cependant, postez ici :

Salut tout le monde,

TLDR :

Nous avons identifié le problème avec les plantages lors du téléchargement depuis le Play Store et travaillons sur un correctif, à livrer dans le même délai que celui décrit ci-dessus dans https://github.com/flutter/flutter/issues/31922#issuecomment -498880614

Explication de haut niveau

Pour ceux que cela intéresse, l'explication un peu longue est qu'avec les appareils exécutant Android Marshmallow ou une version ultérieure, le Play Store détectera les applications qui sont conditionnées sous forme de bundles d'applications contenant plusieurs ABI - et il installera ces applications sur l'appareil sous la forme de "split APK". Lorsqu'il le fait, les fichiers .so qu'il contient ne sont pas extraits de l'archive zip APK, ce qui est différent du comportement des APK non divisés. Étant donné que le mécanisme actuel du moteur Flutter

La solution consiste simplement à dlopen les bibliothèques, et Android résout où se trouvent les bibliothèques (c'est-à-dire dans une archive ou non). Cependant, les fichiers .so nécessaires n'ont jamais été de véritables bibliothèques au départ - ils n'étaient que des gouttes binaires de données que nous avons chargées dans la machine virtuelle Dart. Ainsi, dans le cadre de cela, nous en faisons des bibliothèques ELF (par exemple https://github.com/dart-lang/sdk/commit/6d608fb52bc1926a73d986d73ab228b77cfb7ca2 et https://github.com/flutter/flutter/pull/33696).

4. flutter build apk --release --target-platform=android-arm64

J'obtiens cette erreur après avoir ajouté l'extrait de code à build.gradle
Gradle build failed to produce an Android package.

1. flutter build apk --release --target-platform=android-arm64

J'obtiens cette erreur après avoir ajouté l'extrait de code à build.gradle
Gradle build failed to produce an Android package.

https://developer.android.com/distribute/best-practices/develop/64-bit

Quelqu'un pourrait-il résoudre le problème ? J'ai une application sur Flutter qui ne fonctionne que sur son apk 32 bits mais les 64 ne fonctionnent pas ou ne s'installent pas. Je teste sur un téléphone portable 64 bits

@CgarciaTC s'il vous plaît voir https://github.com/flutter/flutter/issues/18494#issuecomment -500101807 pour la mise à jour la plus récente

Salut tout le monde,

Nous pensons que les correctifs ont tous atterri sur la pointe de l'arbre sur le canal master . Si vous souhaitez les essayer, voici comment :

• flutter build appbundle

  Par défaut, l'App Bundle contient votre code Dart et le runtime Flutter compilé pour armeabi-v7a (32 bits) et arm64-v8a (64 bits)

• flutter build apk --split-per-abi

  Cette commande générera deux APK :

  build/app/outputs/apk/release/app-armeabi-v7a-release.apk
build/app/outputs/apk/release/app-arm64-v8a-release.apk

• flutter build apk

  Cela se traduira par un gros APK qui contient votre code compilé pour toutes les ABI cibles. Ces APK seront plus volumineux que leurs homologues divisés, ce qui obligera l'utilisateur à télécharger des binaires natifs qui ne sont pas applicables à l'architecture de son appareil.

flutter build apk --split-per-abi
Cette commande générera deux APK :
build/app/outputs/apk/release/app-armeabi-v7a-release.apk
build/app/outputs/apk/release/app-arm64-v8a-release.apk

@tvolkert - dans ce scénario particulier, qu'en est-il de chaque numéro de version ? Pour autant que je sache, ils doivent différer, nous pouvons donc télécharger les deux dans Google Play. Cette partie est-elle gérée d'une manière ou d'une autre, lorsque les apks sont construits ? Si non, comment faut-il le gérer ?

@angel1st, il est géré automatiquement lors de la création des APK, conformément aux instructions de https://developer.android.com/studio/build/configure-apk-splits#configure -APK-versions

@tvolkert existe-t-il des informations sur le moment où cela atterrira dans un canal stable ?

@ndusart , https://github.com/flutter/flutter/issues/18494#issuecomment -498880287

Peut confirmer que cela fonctionne (après être passé au maître) sur plusieurs appareils Android. Quelle bouée de sauvetage, merci.

@tvolkert Merci beaucoup. Un calendrier pour intégrer cela dans Flutter stable?

@harsha973 voir https://github.com/flutter/flutter/issues/18494#issuecomment -498880287

@harsha973 vous

@PerLycke désolé pour ça.

J'ai vérifié le canal principal, mis à niveau le flutter et maintenant je ne peux pas vraiment créer l'application, en utilisant la commande :
flutter build apk --release --flavor production -t lib/main.dart
le résultat est:

* What went wrong:                                                                                                 
Execution failed for task ':app:transformNativeLibsWithMergeJniLibsForProductionRelease'.                          
> More than one file was found with OS independent path 'lib/armeabi-v7a/libapp.so' 

Les réponses aux problèmes similaires de StackOverflow n'aident pas vraiment.

@MichaelRFairhurst flutter build apk --release a bien fonctionné pour moi, alors peut-être que les nouvelles mises à jour sur master nécessitent également une mise à jour de vos paramètres de saveur.

Je sais que ce n'est pas une réponse, désolé, mais au moins un point dans la bonne direction.

Quand le correctif passera-t-il en version bêta ?

@derolf s'il vous plaît voir https://github.com/flutter/flutter/issues/18494#issuecomment -498880287 comme la mise à jour la plus récente avec les délais cibles.

Salut tout le monde,

Ces correctifs sont désormais disponibles dans le canal dev , à la version v1.7.4 ou ultérieure.

En essayant de comprendre ce truc 64 bits, j'ai le même problème que @michalsuryntequiqo et je ne peux rien construire maintenant via CLI. Il se construit et fonctionne correctement via Android Studio....
courir flutter build apk --flavor=dev -t lib/main-dev.dart

[   +3 ms] FAILURE: Build failed with an exception.
[   +1 ms] * What went wrong:
[        ] Execution failed for task ':app:transformNativeLibsWithMergeJniLibsForDevRelease'.
[        ] > More than one file was found with OS independent path 'lib/armeabi-v7a/libapp.so'
[        ] * Try:
[        ] Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output. Run with --scan to get full insights.
[        ] * Get more help at https://help.gradle.org
[        ] BUILD FAILED in 1m 3s
[ +370 ms] Running Gradle task 'assembleDevRelease'... (completed in 64.0s)
[   +4 ms] "flutter apk" took 69,789ms.
[        ] "flutter apk" took 69,789ms.

docteur

Éditer:
juste essayé avec le commit juste avant 8627ff433b4658195e66b9c0034902116f53d580 et il produit l'apk avec l'erreur habituelle Gradle build failed to produce an Android package. cause de https://github.com/flutter/flutter/issues/24106

@blasten Une idée de comment faire pour que cela fonctionne à nouveau avec vos modifications ?

Edit 2 :
Nouveau numéro ouvert pour cela : https://github.com/flutter/flutter/issues/34598

J'ai lu la documentation flutter aujourd'hui et j'ai trouvé:

Depuis la ligne de commande :

Entrez le cd
(Remplaceravec le répertoire de votre application.)
Exécutez flutter build apk --split-per-abi
(La commande flutter build est par défaut --release.)
Cette commande génère deux fichiers APK :

/build/app/outputs/apk/release/app-armeabi-v7a-release.apk
/build/app/outputs/apk/release/app-arm64-v8a-release.apk

https://flutter.dev/docs/deployment/android#build-an-apk

@eugenio-tesio quels codes de version sont utilisés, lors de l'utilisation de --split-per-abi ?

Je l'ai vu dans la documentation et j'ai pensé à le publier ici. Je ne l'ai pas testé.
J'avais exécuté la commande et cela n'a pas fonctionné. Ça dit:

Impossible de trouver une option nommée "split-per-abi".

Exécutez 'flutter -h' (ou 'flutter-h') pour les commandes et options de flutter disponibles.

docteur flutter:

Flutter 1.6.3 • bêta du canal • https://github.com/flutter/flutter.git
Framework • révision bc7bc94083 (il y a 4 semaines) • 2019-05-23 10:29:07 -0700
Moteur • révision 8dc3a4cde2
Outils • Dart 2.3.2 (build 2.3.2-dev.0.0 e3edfd36b2)

Exécution de "flutter pub upgrade" dans consumos_app... 19,8s

Docteur flutter en cours d'exécution...
Résumé du docteur (pour voir tous les détails, exécutez flutter doctor -v) :
[√] Flutter (Channel beta, v1.6.3, sur Microsoft Windows [Versión 10.0.17134.829], locale es-AR)
[√] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[√] Android Studio (version 3.4)
[√] IntelliJ IDEA Édition Ultime (version 2019.1)
[√] Code VS (version 1.26.1)
[√] VS Code, édition 64 bits (version 1.33.1)
[!] Appareil connecté
! Aucun appareil disponible

Je pense que cette fonction sera bientôt disponible.

Je l'ai vu dans la documentation et j'ai pensé à le publier ici. Je ne l'ai pas testé.
J'avais exécuté la commande et cela n'a pas fonctionné. Ça dit:

Impossible de trouver une option nommée "split-per-abi".
Exécutez 'flutter -h' (ou 'flutter -h') pour les commandes et options de flutter disponibles.

docteur flutter:

Flutter 1.6.3 • bêta du canal • https://github.com/flutter/flutter.git
Framework • révision bc7bc94 (il y a 4 semaines) • 2019-05-23 10:29:07 -0700
Moteur • révision 8dc3a4cde2
Outils • Dart 2.3.2 (build 2.3.2-dev.0.0 e3edfd36b2)
Exécution de "flutter pub upgrade" dans consumos_app... 19,8s
Docteur flutter en cours d'exécution...
Résumé du docteur (pour voir tous les détails, exécutez flutter doctor -v) :
[√] Flutter (Channel beta, v1.6.3, sur Microsoft Windows [Versión 10.0.17134.829], locale es-AR)
[√] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[√] Android Studio (version 3.4)
[√] IntelliJ IDEA Édition Ultime (version 2019.1)
[√] Code VS (version 1.26.1)
[√] VS Code, édition 64 bits (version 1.33.1)
[!] Appareil connecté
! Aucun appareil disponible

Je pense que cette fonction sera bientôt disponible.

N'oubliez pas qu'il s'agit du canal dev / à partir de la version 1.7.4 uniquement. Vous utilisez le canal beta / version 1.6.3

Je viens de l'essayer (construire et publier à l'aide de Codemagic) et cela a très bien fonctionné. Merci!

Cependant, Google se plaint toujours que je n'utilise pas appbundle. Compte tenu de cet avertissement, publier des apks n'a peut-être pas trop de sens ?

J'utiliserais appbundle - mais cela empêche les tests automatisés de Google (générant le rapport de pré-lancement) de fonctionner. Dois-je ouvrir un nouveau problème pour cela?

@nohli Nous avons mis à jour les documents pour refléter les dernières informations sur les bundles d'applications/APK : https://flutter.dev/docs/deployment/android#building -the-app-for-release.

N'hésitez pas à signaler le problème concernant les tests automatisés de Google.

Je crée mon application à partir du bundle, mais après avoir exécuté sur des appareils 64 bits, il manque libflutter.so en créant une application pour les appareils 32 bits et 64 bits. Comment ajouter libflutter.so pour les deux architectures dans un seul fichier bundle ?

@nohli Nous avons mis à jour les documents pour refléter les dernières informations sur les bundles d'applications/APK : https://flutter.dev/docs/deployment/android#building -the-app-for-release.

N'hésitez pas à signaler le problème concernant les tests automatisés de Google.

@blasten La procédure indiquée dans le lien n'a pas produit d'APK 64 bits dans le bundle. Lorsque j'ai téléchargé le bundle, le Google Play Store avait la même erreur intacte indiquant que votre APK n'est pas compatible 64 bits.

@ wal33d006 voir la clause de non-responsabilité en haut de la page - elle ne s'applique qu'aux v1.7.4 ou versions ultérieures (actuellement les canaux de développement ou maître).

@ wal33d006 voir la clause de non-responsabilité en haut de la page - elle ne s'applique qu'aux v1.7.4 ou versions ultérieures (actuellement les canaux de développement ou maître).

@tvolkert Je ne peux même pas créer mon application via les canaux de développement ou maître.

Voici mon résultat lorsque je le construis sur des canaux de développement ou maître :

Message du compilateur :
file:///Users/waleed/.pub-cache/hosted/pub.dartlang.org/cached_network_image-0.5.1/lib/cached_network_image. dart:199 :38 : erreur : le type d'argument « void Function(ImageInfo, bool) » ne peut pas être affecté au type de paramètre « ImageStreamListener ».

• 'ImageInfo' provient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
• 'ImageStreamListener' vient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en 'ImageStreamListener'.
  oldImageStream?.removeListener(_handleImageChanged);
  ^
  file:///Users/waleed/.pub-cache/hosted/pub.dartlang.org/cached_network_image-0.5.1/lib/cached_network_image. dart:200 :32 : Erreur : Le type d'argument « void Function(ImageInfo, bool) » ne peut pas être affecté au type de paramètre « ImageStreamListener ».
• 'ImageInfo' provient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
• 'ImageStreamListener' vient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en 'ImageStreamListener'.
  _imageStream.addListener(_handleImageChanged);
  ^
  file:///Users/waleed/.pub-cache/hosted/pub.dartlang.org/cached_network_image-0.5.1/lib/cached_network_image. dart:210 :34 : erreur : le type d'argument « void Function(ImageInfo, bool) » ne peut pas être affecté au type de paramètre « ImageStreamListener ».
• 'ImageInfo' provient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
• 'ImageStreamListener' vient de ' package:flutter/src/painting/image_stream.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/painting/image_stream.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en 'ImageStreamListener'.
  _imageStream?.removeListener(_handleImageChanged);
  ^
  file:///Users/waleed/.pub-cache/hosted/pub.dartlang.org/cached_network_image-0.5.1/lib/cached_network_image. dart:465 :31 : Erreur : le type d'argument 'Null Function(StringBuffer)' ne peut pas être affecté au type de paramètre 'IterableUne fonction()'.
• 'StringBuffer' vient de ' dart:core '.
• 'Iterable' vient de ' dart:core '.
• 'DiagnosticsNode' provient de ' package:flutter/src/foundation/diagnostics.dart ' ('file:///Users/waleed/Developer/flutter-sdk/flutter/packages/flutter/lib/src/foundation/diagnostics.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en 'IterableUne fonction()'.
  informationCollector : (informations StringBuffer) {
  ^
  Le compilateur s'est arrêté de manière inattendue.

ÉCHEC : la génération a échoué avec une exception.

• Où:
  Script '/Users/waleed/Developer/flutter-sdk/flutter/packages/flutter_tools/gradle/flutter.gradle' ligne : 638

• Qu'est ce qui ne s'est pas bien passé:
  L'exécution a échoué pour la tâche ': app:compileflutterBuildReleaseArm '.

  Processus 'commande'/Users/waleed/Developer/flutter-sdk/flutter/bin/flutter'' terminé avec une valeur de sortie non nulle 1

• Essayer:
  Exécutez avec l'option --stacktrace pour obtenir la trace de la pile. Exécutez avec l'option --info ou --debug pour obtenir plus de sorties de journal. Exécutez avec --scan pour obtenir des informations complètes.

• Obtenez plus d'aide sur https://help.gradle.org

ÉCHEC DE LA CONSTRUCTION en 14s
Exécution de la tâche Gradle 'bundleRelease'...
Exécution de la tâche Gradle 'bundleRelease'... Terminé 15.0s
Gradle task bundleLa libération a échoué avec le code de sortie 1

@wal33d006 package:cached_network_image est maintenant la version 0.8.0 et vous utilisez 0.5.1 -- il semble que lors de l'exécution avec la nouvelle version de Flutter, vous devez mettre à jour votre contrainte de version dans vos pubspec.yaml et flutter packages upgrade

@tvolkert, vous dites que dans la v1.7.4, le fichier libflutter.so est automatiquement ajouté pour les périphériques 64 bits lorsque nous construisons le bundle à l'aide de la commande flutter build appbundle ?

@ nimesh1997 oui , bien que la version qui le rend stable sera probablement une version plus récente.

@tvolkert J'ai changé mon canal en canal principal ### et j'ai également mis à niveau la version ### package:cached_network_image vers la 0.8.0 en changeant à l'intérieur de pubspec.yaml. Mais lors de l'exécution de la mise à niveau des packages flutter. L'erreur s'affiche ci-dessous comme ceci :
**Parce que cached_network_image >=0.7.0 dépend de flutter_cache_manager ^0.3.2 qui dépend de path_provider ^0.5.0+1, cached_network_image >=0.7.0 requiert path_provider ^0.5.0+1.

@nimesh1997 pouvez-vous déposer un problème séparé et me mettre en

@tvolkert Quand la version 1.7.4 de flutter sera-t-elle disponible dans le canal stable et lorsque l'erreur mentionnée ci-dessous sera résolue dans la version 1.7.4 de flutter à cause de cette erreur, elle ne fonctionnera pas sur les appareils 64 bits (libflutter.so est manquant) ?

Voici le résultat que je reçois lorsque je lance flutter v1.7.4 ou version ultérieure : -

Message du compilateur :
file:///home/zunroof-dev-4/package_flutter/flutter/.pub-cache/hosted/pub.dartlang.org/flutter_image-1.0.0/lib/network. fléchette:75 :31:
Erreur : Le type d'argument 'Null Function(StringBuffer)' ne peut pas être affecté au type de paramètre 'IterableUne fonction()'.

• 'StringBuffer' vient de ' dart:core '.
• 'Iterable' vient de ' dart:core '.
• 'DiagnosticsNode' provient de ' package:flutter/src/foundation/diagnostics.dart ' ('file:///home/zunroof-dev-4/package_flutter/flutter/packages/flutter/lib/src/foundation/diagnostics.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en 'IterableUne fonction()'.
  informationCollector : (informations StringBuffer) {
  ^
  file:///home/zunroof-dev-4/package_flutter/flutter/.pub-cache/hosted/pub.dartlang.org/flutter_image-1.0.0/lib/network. dart : 168 : 65 : Erreur : le type d'argument « String » ne peut pas être affecté au type de paramètre « DiagnosticsNode ».
• 'DiagnosticsNode' provient de ' package:flutter/src/foundation/diagnostics.dart ' ('file:///home/zunroof-dev-4/package_flutter/flutter/packages/flutter/lib/src/foundation/diagnostics.dart ').
  Essayez de changer le type du paramètre ou de convertir l'argument en « DiagnosticsNode ».
  contexte : '$runtimeType n'a pas réussi à charger ${instructions.uri}',
  ^
  Le compilateur s'est arrêté de manière inattendue.

Erreur de compilation, ne génère pas de journaux et flutter doctor -v ne signale pas d'erreurs. que devrais-je faire?

Si vous déployez l'application sur le Play Store, il est recommandé d'utiliser l'application
bundles ou diviser l'APK pour réduire la taille de l'APK.
Pour générer un app bundle, exécutez :
flutter build appbundle --target-platform android-arm,android-arm64
En savoir plus sur : https://developer.android.com/guide/app-bundle
Pour diviser les APK par ABI, exécutez :
flutter build apk --target-platform android-arm, android-arm64
--split-per-abi
En savoir plus sur :
https://developer.android.com/studio/build/configure-apk-splits#configur
e-abi-split
Initialisation de gradle... 7,4s
Résolution des dépendances... 4,3s
registerResGeneratingTask est obsolète, utilisez registerGeneratedResFolders(FileCollection)
registerResGeneratingTask est obsolète, utilisez registerGeneratedResFolders(FileCollection)
registerResGeneratingTask est obsolète, utilisez registerGeneratedResFolders(FileCollection)
Exécution de la tâche Gradle 'assembleRelease'...
Exécution de la tâche Gradle 'assembleRelease'... Terminé 9,0s

La construction de Gradle n'a pas réussi à produire un package Android.

@leonardop21 essayez avec

flutter run -v

@canewsin

OH MON DIEU. Je n'ai aucune idée de quoi faire maintenant

La construction de Gradle n'a pas réussi à produire un package Android.

0 throwToolExit (package:flutter_tools/src/base/common.dart:28:3)

1 _buildGradleProjectV2

(paquet :flutter_tools/src/android/gradle.dart :514 :7)

2 _asyncThenWrapperHelper.

(dart:async-patch/async_patch.dart:77:64)

3 _rootRunUnary (dart:async/zone.dart:1132:38)

4 _CustomZone.runUnary (dart:async/zone.dart:1029:19)

5 _FutureListener.handleValue (dart:async/future_impl.dart:126:18)

6 Future._propagateToListeners.handleValueCallback

(dart:async/future_impl.dart:639:45)

7 Future._propagateToListeners (dart:async/future_impl.dart:668:32)

8 Future._complete (dart:async/future_impl.dart:473:7)

9 _SyncCompleter.complete (dart:async/future_impl.dart:51:12)

10 _AsyncAwaitCompleter.complete (dart:async-patch/async_patch.dart:28:18)

11 _completeOnAsyncReturn (dart:async-patch/async_patch.dart:294:13)

12 runCommandAndStreamOutput (paquet :flutter_tools/src/base/process.dart)

13 _asyncThenWrapperHelper.

(dart:async-patch/async_patch.dart:77:64)

14 _rootRunUnary (dart:async/zone.dart:1132:38)

15 _CustomZone.runUnary (dart:async/zone.dart:1029:19)

16 _FutureListener.handleValue (dart:async/future_impl.dart:126:18)

17 Future._propagateToListeners.handleValueCallback

(dart:async/future_impl.dart:639:45)

18 Future._propagateToListeners (dart:async/future_impl.dart:668:32)

19 Future._completeWithValue (dart:async/future_impl.dart:483:5)

20 Future._asyncComplete.

(dart:async/future_impl.dart:513:7)

21 _rootRun (dart:async/zone.dart:1124:13)

22 _CustomZone.run (dart:async/zone.dart:1021:19)

23 _CustomZone.runGuarded (dart:async/zone.dart:923:7)

24 _CustomZone.bindCallbackGuarded.

(dart:async/zone.dart:963:23)

25 _microtaskLoop (dart:async/schedule_microtask.dart:41:21)

26 _startMicrotaskLoop (dart:async/schedule_microtask.dart:50:5)

27 _runPendingImmediateCallback

(fléchette:isolate-patch/isolate_patch.dart:116:13)

28 _RawReceivePortImpl._handleMessage

(dart:isolate-patch/isolate_patch.dart:173:5)

Nous avons mis à jour nos documents pour indiquer comment vous pouvez créer des APK avec des binaires 32 bits et 64 bits. https://flutter.dev/docs/deployment/android#building -the-app-for-release .

Veuillez utiliser le canal dev : v1.7.9 ou supérieur. L'équipe s'efforce de promouvoir les derniers changements de la version bêta d'ici ce vendredi (28/06/2019).

Message du compilateur :
file:///Users/systemgnk/Desktop/flutter/.pub-cache/hosted/pub.dartlang.org/flare_flutter-1.5.2/lib/flare. dart : 1033 : 18 : Erreur : le type d'argument « Int32List » ne peut pas être affecté au type de paramètre « Uint16List ».

• « Int32List » provient de « dart:typed_data ».
• 'Uint16List' vient de 'dart:typed_data'.
  Essayez de changer le type du paramètre ou de convertir l'argument en « Uint16List ».
  indices : _indices, textureCoordinates : _uvBuffer) ;
  ^
  Le compilateur s'est arrêté de manière inattendue.

ÉCHEC : la génération a échoué avec une exception.

• Où:
  Script '/Users/systemgnk/Desktop/flutter/packages/flutter_tools/gradle/flutter.gradle' ligne : 631

• Qu'est ce qui ne s'est pas bien passé:
  L'exécution a échoué pour la tâche ': app:compileflutterBuildReleaseArm '.

  Processus 'command'/Users/systemgnk/Desktop/flutter/bin/flutter'' terminé avec une valeur de sortie non nulle 1

• Essayer:
  Exécutez avec l'option --stacktrace pour obtenir la trace de la pile. Exécutez avec l'option --info ou --debug pour obtenir plus de sorties de journal. Exécutez avec --scan pour obtenir des informations complètes.

• Obtenez plus d'aide sur https://help.gradle.org

ÉCHEC DE LA CONSTRUCTION en 22s
Exécution de la tâche Gradle 'assembleRelease'...
Exécution de la tâche Gradle 'assembleRelease'... Terminé 23.3s
La tâche de Gradle assembleRelease a échoué avec le code de sortie 1

[✓] Flutter (Channel dev, v1.7.10, sur Mac OS X 10.13.6 17G65, locale en-US)
• Flutter version 1.7.10 sur /Users/systemgnk/Desktop/flutter
• Révision du cadre 9a3a7490c8 (il y a 2 jours), 25-06-2019 15:59:15 +0200
• Révision du moteur ae8e6d9f46
• Dart version 2.4.0

[✓] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
• SDK Android sur /Users/systemgnk/Library/Android/sdk
• Emplacement Android NDK non configuré (facultatif ; utile pour la prise en charge du profilage natif)
• Plate-forme Android-28, outils de construction 28.0.3
• Java binaire sur : /Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/java
• Environnement d'exécution OpenJDK version Java (build 1.8.0_152-release-1248-b01)
• Toutes les licences Android acceptées.

[✓] Xcode - développer pour iOS et macOS (Xcode 10.1)
• Xcode sur /Applications/Xcode.app/Contents/Developer
• Xcode 10.1, version de build 10B61
• CocoaPods version 1.6.0

[✓] Outils iOS - développer pour les appareils iOS
• ios-déployer 1.9.4

[✓] Chrome - développer pour le Web
• Chrome sur /Applications/Google Chrome.app/Contents/MacOS/Google Chrome

[✓] Android Studio (version 3.3)
• Android Studio sur /Applications/Android Studio.app/Contents
• Plugin Flutter version 33.3.1
• Plugin Dart version 182.5215
• Environnement d'exécution OpenJDK version Java (build 1.8.0_152-release-1248-b01)

[✓] Appareil connecté (4 disponibles)
• SDK Android conçu pour x86 • émulateur-5554 • android-x86 • Android 7.0 (API 24) (émulateur)
• iPhone du système • 73145c33ee6d180a2db3d4a96b908ceb4c49065b • ios • iOS 12.3.1
• macOS • macOS • darwin-x64 • Mac OS X 10.13.6 17G65
• Chrome • Chrome • Web-javascript • Google Chrome 75.0.3770.100

• Aucun problème n'a été trouvé!

J'ai toujours un problème avec la construction d'apk.
Je n'étais disponible que pour créer un apk 32 bits dans un canal stable.

Je pense que je dois attendre que l'équipe Flutter corrige ce bogue plutôt que d'utiliser le SDK de développement ou de canal principal.

Merci.

@JaeyoungChu Se référer à 2d-inc/Flare-Flutter#79

@ctrysbita Merci pour le lien. J'ai changé le canal en master et changé le type de _indices de Int32List à Uint16List.
apk qui est téléchargé sur le Play Store n'a pas d'avertissement pour 64 bits et il s'exécute après l'installation à partir de la page de test du Play Store.

J'ai d'autres problèmes avec le sdk de flutter de canal de développement, tels que la non-ouverture de la boîte de dialogue d'autorisation pour l'emplacement et la carte Google ne s'affiche pas dans ios et ne peut pas afficher un gros fichier image par http (image réseau mise en cache). Ces problèmes ne sont pas sûrs en raison du canal de développement, mais lorsque je suis revenu à stable et que je reconstruis, tous les problèmes ont disparu. Je n'ai pas beaucoup de temps pour creuser ces problèmes, donc ce n'est pas sûr à 100%. Désolé pour cela, mais peut-être que quelqu'un a des indices sur ces problèmes.

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm
2. télécharger app-armeabi-v7a-release.apk sur le Play Store
3. incrémenter versionCode
4. courir flutter build apk --release --target-platform=android-arm64
5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.

Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

OÙ? O ajoutons-nous la section des fractionnements au fichier gradle ?? Je l'ai ajouté entre flutter {} et dépendances {} et il ne construira pas le premier APK comme il est dit :

Veuillez vérifier la configuration de votre projet Gradle dans le dossier android/.

Il est donc clair que ce n'est pas correct, car c'est le seul changement que j'ai apporté au projet depuis ma dernière version.

@ArtfulDodgerB92 Merci pour la solution. quel canal avez-vous utilisé pour créer l'apk et la version ?

OÙ? O ajoutons-nous la section des fractionnements au fichier gradle ?? Je l'ai ajouté entre flutter {} et dépendances {} et il ne construira pas le premier APK comme il est dit :

Veuillez vérifier la configuration de votre projet Gradle dans le dossier android/.

Il est donc clair que ce n'est pas correct, car c'est le seul changement que j'ai apporté au projet depuis ma dernière version.

@ArtfulDodgerB92, il devrait être dans la section android{} , comme écrit ici : https://developer.android.com/studio/build/configure-apk-splits.html

Pour info, l'annonce suivante a été envoyée à [email protected] concernant notre support 64 bits.

https://groups.google.com/forum/#!topic/flutter -announce/oIzwT9EDczc

des nouvelles d'une prochaine version bêta ?

@nohli, nous avons retardé la version bêta de quelques jours pour récupérer un correctif (revenir à la validation) sur https://github.com/flutter/flutter/issues/35291. Nous travaillons pour sortir une version bêta dès que possible.

Ceci est maintenant en direct sur le canal bêta, dans la version v1.7.8+hotfix.2

Ceci est maintenant en direct sur le canal bêta, dans la version v1.7.8+hotfix.2

ool comment générer la version apk ?

Ceci est maintenant en direct sur le canal bêta, dans la version v1.7.8+hotfix.2

ool comment générer la version apk ?

Voici les instructions https://flutter.dev/docs/deployment/android

Ceci est maintenant en direct sur le canal bêta, dans la version v1.7.8+hotfix.2

ool comment générer la version apk ?

Voici les instructions https://flutter.dev/docs/deployment/android

j'ai essayé mais ne fonctionne pas à 32

j'ai essayé mais ne fonctionne pas à 32

Qu'entendez-vous par 32 ? Comme "Je peux générer un gros apk, et cet apk fonctionne sur un périphérique 64 bits, mais plante sur un périphérique 32 bits" ?

Pouvez-vous poster le résultat de flutter doctor , votre étape par étape (par exemple c'est l'étape 2 de progard https://flutter.dev/docs/deployment/android#step-2---enable- obfuscation-andor-minification), générez-vous un APK ou un AAB, et quel appareil testez-vous ?

devons-nous encore mettre
ndk { abiFilters 'armeabi-v7a' , 'x86', 'armeabi' } dans la gradle n'est plus nécessaire après le correctif sur la bêta ??

@ksamj ce n'est pas nécessaire.

j'ai essayé mais ne fonctionne pas à 32

Qu'entendez-vous par 32 ? Comme "Je peux générer un gros apk, et cet apk fonctionne sur un périphérique 64 bits, mais plante sur un périphérique 32 bits" ?

Pouvez-vous poster le résultat de flutter doctor , votre étape par étape (par exemple c'est l'étape 2 de progard https://flutter.dev/docs/deployment/android#step-2---enable- obfuscation-andor-minification), générez-vous un APK ou un AAB, et quel appareil testez-vous ?

Résumé du docteur (pour voir tous les détails, exécutez flutter doctor -v) :
[✓] Flutter (Channel beta, v1.7.8+hotfix.2, sur Mac OS X 10.14.5 18F132, locale ru-RU)

[✓] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[✓] Xcode - développer pour iOS et macOS (Xcode 10.2.1)
[✓] Outils iOS - développer pour les appareils iOS
[✓] Android Studio (version 3.4)
[✓] Appareil connecté (1 disponible)

• Aucun problème n'a été trouvé!

Résumé du docteur (pour voir tous les détails, exécutez flutter doctor -v) :
[✓] Flutter (Channel beta, v1.7.8+hotfix.2, sur Mac OS X 10.14.5 18F132, locale ru-RU)

[✓] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[✓] Xcode - développer pour iOS et macOS (Xcode 10.2.1)
[✓] Outils iOS - développer pour les appareils iOS
[✓] Android Studio (version 3.4)
[✓] Appareil connecté (1 disponible)

• Aucun problème n'a été trouvé!
Résumé du docteur (pour voir tous les détails, exécutez flutter doctor -v) :
[✓] Flutter (Channel beta, v1.7.8+hotfix.2, sur Mac OS X 10.14.5 18F132, locale ru-RU)

[✓] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
[✓] Xcode - développer pour iOS et macOS (Xcode 10.2.1)
[✓] Outils iOS - développer pour les appareils iOS
[✓] Android Studio (version 3.4)
[✓] Appareil connecté (1 disponible)

• Aucun problème n'a été trouvé!
construire apk
J'ai tout fait comme dans la notice mais ça ne s'installe pas en 32 bit

J'ai tout fait comme dans la notice mais ça ne s'installe pas en 32 bit

Une capture d'écran/un journal montrant que l'installation d'apk 32 bits sur l'appareil 32 bits n'a pas réussi, et de quel modèle d'appareil s'agit-il ?

Salut tout le monde,

v1.7.8+hotfix.2 a été publié sur le canal stable, donc ce correctif est maintenant disponible dans tous les canaux. Merci à tous pour votre patience et votre aide en cours de route !

J'ai tout fait comme dans la notice mais ça ne s'installe pas en 32 bit

Une capture d'écran/un journal montrant que l'installation d'apk 32 bits sur l'appareil 32 bits n'a pas réussi, et de quel modèle d'appareil s'agit-il ?

merci pour votre aide, j'ai essayé de créer un appbundle et cela a fonctionné.

@tvolkert Même problème, veuillez le vérifier. https://github.com/flutter/flutter/issues/31962#issuecomment -509458960

@nimesh1997 ce problème n'a rien à voir avec celui-ci. Si vous n'avez pas trouvé les réponses fournies dans le problème lié utiles, vous pourriez peut-être envisager de publier une question Stackoverflow avec votre problème.

@tvolkert - juste pour clarifier - le correctif ci-dessus peut être utilisé pour créer des apks séparés selon les instructions de Flutter
Par conséquent, il ne sera pas nécessaire d'apporter d'autres modifications au fichier gradle comme décrit dans les solutions partielles précédentes
Merci pour vous et le reste de l'équipe excellent travail et livraison à temps!

Je viens de compiler une de mes applications avec le correctif le plus récent. En conséquence, le app-production-armeabi-v7a-release.apk compilé ne peut pas fonctionner sur Galaxy S3 mini (Android OS 4.1.2) - après l'écran de démarrage, l'application se ferme sans aucune notification.
Je suis cependant capable d'exécuter avec succès le même apk sur un téléphone 64, par exemple le Galaxy S8.
voici comment je lance le flutter à partir de la ligne de commande :

flutter build apk --target="lib/config/main_production.dart" --flavor=production --split-per-abi

et voici mon flutter doctor -v

[√] Flutter (Channel stable, v1.7.8+hotfix.2, sur Microsoft Windows [Version 10.0.17763.557], locale en-US)
• Flutter version 1.7.8+hotfix.2 sur E:\DevToolsflutter
• Révision du cadre 2e540931f7 (il y a 7 jours), 2019-07-02 09:31:07 -0700
• Révision du moteur b1cb0d9e9b
• Dart version 2.4.0

[√] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 28.0.3)
• SDK Android sur E:\DevTools\Android\Sdk
• Emplacement Android NDK non configuré (facultatif ; utile pour la prise en charge du profilage natif)
• Plate-forme Android-28, outils de construction 28.0.3
• ANDROID_SDK_ROOT = E:\DevTools\Android\Sdk
• Java binaire sur : E:\DevTools\android-studio\jre\bin\java
• Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)
• Toutes les licences Android acceptées.

[√] Android Studio (version 3.4)
• Studio Android sur E:\DevTools\android-studio
• Plugin Flutter version 37.0.1
• Plugin Dart version 183.6270
• Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)

[√] Appareil connecté (1 disponible)
• SDK Android conçu pour x86 • émulateur-5554 • android-x86 • Android 8.1.0 (API 27) (émulateur)

• Aucun problème n'a été trouvé!

De plus, le fat apk ne peut pas non plus s'exécuter - après l'installation (sur le même appareil arm-32) et l'exécuter, il se ferme.
S'il vous plaît laissez-moi savoir comment procéder et résoudre le problème, merci!

@angel1st est-il possible que vous puissiez partager votre fichier AAB et/ou APK ici afin que nous puissions vous aider à résoudre les problèmes ?

@truongsinh - bien sûr, les voici :

app-production-releases.zip

J'ai téléchargé les deux APK, bien que le problème présumé concerne la version arm-32, comme indiqué ci-dessus.

Les gars, en attendant, quelqu'un serait-il si gentil et dirait (s'il le savait) ce qui se passerait après le 1er août sur Google Play Store, au cas où vous n'auriez pas la version arm-64 de votre application - l'apk s'arrêterait-il pour être servi aux appareils arm64 ou vous ne pourrez pas télécharger la version arm32 uniquement ou les deux ?

@angel1st J'ai pu exécuter l'application (app-production-armeabi-v7a-release.apk) sur Android 4.4.2 Galaxy S4. Belle application !

Je soupçonne que cela est très spécifique au Galaxy S3 mini / Android OS 4.1.2. En attendant, j'ai demandé cette configuration pour voir si je peux reproduire le problème.

@angel1st voici la source la plus informative : https://android-developers.googleblog.com/2019/01/get-your-apps-ready-for-64-bit.html

L'exigence [trucs 64 bits] ne s'applique pas à :

• APK ou app bundles ciblant explicitement Wear OS ou Android TV, qui sont des facteurs de forme qui ne prennent actuellement pas en charge le code 64 bits.
• APK ou app bundles qui ne sont pas distribués sur des appareils exécutant Android 9 Pie ou une version ultérieure.

À compter du 1er août 2019 :

• Toutes les nouvelles applications et mises à jour d'applications qui incluent du code natif sont nécessaires pour fournir des versions 64 bits en plus des versions 32 bits lors de la publication sur Google Play.

En d'autres termes, les applications continuent d'être distribuées, bien que vous ne puissiez pas télécharger une nouvelle version d'une application existante ou publier une nouvelle application sans conformité.

@angel1st J'ai pu reproduire ce problème sur un Galaxy S3 mini sous Android OS 4.1.2.

Le logcat est :

[ERROR:flutter/fml/platform/posix/native_library_posix.cc(16)] Could not open library 'libapp.so' due to error 'Cannot load library: load_library[1093]: Library 'libapp.so' not found'.
07-10 00:16:50.298 8739-8739/? E/flutter: [ERROR:flutter/fml/platform/posix/native_library_posix.cc(16)] Could not open library 'libapp.so' due to error 'Cannot load library: load_library[1093]: Library 'libapp.so' not found'.
07-10 00:16:50.298 8739-8739/? E/flutter: [ERROR:flutter/runtime/dart_vm_data.cc(19)] VM snapshot invalid and could not be inferred from settings.
07-10 00:16:50.298 8739-8739/? E/flutter: [ERROR:flutter/runtime/dart_vm.cc(238)] Could not setup VM data to bootstrap the VM from.
07-10 00:16:50.298 8739-8739/? E/flutter: [ERROR:flutter/runtime/dart_vm_lifecycle.cc(89)] Could not create Dart VM instance.
07-10 00:16:50.298 8739-8739/? A/flutter: [FATAL:flutter/shell/common/shell.cc(218)] Check failed: vm. Must be able to initialize the VM.

J'ai déposé https://github.com/flutter/flutter/issues/35838 entre-temps.

cc @jason-simmons

@truongsinh - merci pour la vue d'ensemble.

@blasten - merci pour le retour rapide. Autant que je sache, il n'y a rien que je puisse faire à l'ATM mais surveiller #35838 avec les doigts croisés, cela sera-t-il résolu à un moment donné ce mois-ci ? Je pense que le même problème apparaîtra sur tout autre apk pour Android 4.1.2 compilé avec le correctif le plus récent ?
Pour info - l'apk de l'application compilé avec la précédente version stable de flutter n'a pas ce problème (S3 mini avec Android 4.1.2 est l'un de mes appareils de test).

Quelqu'un d'autre a reçu un e-mail de Google aujourd'hui, disant

« Action requise : mettez à jour vos applications pour qu'elles soient compatibles 64 bits d'ici le 1er août 2019 »

bien que publiant déjà les versions 32 bits et 64 bits ?

Ça dit

D'ici le 1er août 2019, toutes les applications qui utilisent du code natif doivent fournir une version 64 bits afin de publier une mise à jour. A la date d'envoi de cet e-mail, au moins une de vos applications* ne répond pas encore au critère

*Remarque : Cette liste d'applications reflète la meilleure estimation de Google au moment de l'envoi de cet e-mail. (...)

Je suppose que la "meilleure estimation" de Google n'est pas correcte ?

Merci pour l'équipe Flutter. Je mets à niveau Flutter et je construis sur un canal stable et l'avertissement a disparu.
J'espère ne pas avoir de bug avec les testeurs mais pour l'instant je n'ai pas encore trouvé de bug avec un vrai appareil !

Merci à l'équipe Flutter, la mise à niveau de Flutter avec le correctif résout ce problème lors de la création de .aab

Merci à l'équipe flutter pour cette réalisation. Maintenant pour continuer programmé!

@angel1st J'ai également des problèmes sur certains appareils Samsung.

https://github.com/flutter/flutter/issues/36128

@ abdullayev007 - merci ! Je vous suggère de jeter un œil à #35838, cela pourrait être lié d'une manière ou d'une autre.

J'ai tout fait comme dans la notice mais ça ne s'installe pas en 32 bit

Une capture d'écran/un journal montrant que l'installation d'apk 32 bits sur l'appareil 32 bits n'a pas réussi, et de quel modèle d'appareil s'agit-il ?

L'appareil est un Samsung M10

@tvolkert Veuillez me donner une solution pour résoudre le problème suivant :
https://github.com/flutter/flutter/issues/36063

Merci

J'ai essayé la dernière version de flutter du canal de développement - v1.8.4. J'ai également créé un nouveau projet - le projet Vanilla Flutter et j'ai essayé d'en créer une version signée. Il se construit et la taille de l'application n'est que de 10,4 Mo. Mais j'ai essayé toutes les étapes ci-dessus dans ce sentier, rien n'y fait. Quelqu'un peut-il donner un ensemble clair d'étapes pour prendre une construction que nous pouvons pousser vers Playstore avec aab ou apk avec un émulateur et un périphérique local de flutter. Cela fait plus d'une semaine, nous avons un projet basé sur Flutter qui ne passe pas à la prod sur Android, mais nous sommes en mesure de publier sur l'Appstore sur iOS. Un peu d'aide sera super.

`[✓] Flutter (Channel dev, v1.8.4, sur Mac OS X 10.14.5, locale en-US)
• Flutter version 1.8.4 sur /Users/muthu/muthu/devapps/flutter
• Révision du cadre 954714c967 (il y a 7 jours), 2019-08-02 10:10:39 -0700
• Révision du moteur 26368225b5
• Dart version 2.5.0 (build 2.5.0-dev.1.0 bd049f5b53)

[!] Chaîne d'outils Android - développer pour les appareils Android (Android SDK version 29.0.1)
• SDK Android sur ../Library/Android/sdk
• Emplacement Android NDK non configuré (facultatif ; utile pour la prise en charge du profilage natif)
• Plate-forme android-29, outils de construction 29.0.1
• Java binaire sur : /Applications/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/java
• Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)
✗ Statut de la licence Android inconnu.
Essayez de réinstaller ou de mettre à jour votre gestionnaire de SDK Android.
Voir https://developer.android.com/studio/#downloads ou visitez https://flutter.dev/setup/#android -setup
pour des instructions détaillées.

[✓] Xcode - développer pour iOS et macOS (Xcode 10.3)
• Xcode sur /Applications/Xcode.app/Contents/Developer
• Xcode 10.3, Build version 10G8
• CocoaPods version 1.7.3

[✓] Android Studio (version 3.4)
• Android Studio sur /Applications/Android Studio.app/Contents
• Plugin Flutter version 38.2.1
• Plugin Dart version 183.6270
• Java version OpenJDK Runtime Environment (build 1.8.0_152-release-1343-b01)

[✓] Code VS (version 1.36.1)
• VS Code sur /Applications/Visual Studio Code.app/Contents
• Extension de flottement version 3.3.0

[✓] Appareil connecté (3 disponibles)
• SDK Android conçu pour x86 • émulateur-5554 • android-x86 • Android 9 (API 28)
(émulateur)`

@muthufmass , veuillez déposer un nouveau problème avec des détails sur ce qui ne fonctionne pas et comment reproduire l'échec. Merci!

Quelqu'un peut-il donner un ensemble clair d'étapes pour prendre une construction que nous pouvons pousser vers Playstore

https://flutter.dev/docs/deployment/android

Quelqu'un peut-il donner un ensemble clair d'étapes pour prendre une construction que nous pouvons pousser vers Playstore

https://flutter.dev/docs/deployment/android

Ces étapes sont déjà suivies, cela ne fonctionne pas sur la version de la version prod. la construction de débogage fonctionne ! Je trouve clairement une différence, dans la version debug, les fichiers .so de flutter sont présents, mais pas avec la version release. Ce sont ceux qui créent des problèmes pour installer l'apk sur l'émulateur ou sur des appareils avec apk signé.

@muthufmass , veuillez déposer un nouveau problème avec des détails sur ce qui ne fonctionne pas et comment reproduire l'échec. Merci!

J'espère avoir partagé les étapes claires ci-dessus. Nouvelle création d'applications à l'aide de flutter create - code vanille avec le dernier SDK flutter. Impossible de créer une version finale, alors que les versions de débogage fonctionnent correctement. Différence significative entre la version prod et dev d'apk sur la taille. J'ai essayé toutes les étapes ci-dessus, impossible de créer une version finale qui s'exécute. La construction se déroule très rapidement et le fichier contient moins de 11 Mo avec la version, tandis qu'avec le débogage apk, il est d'environ 40 Mo +. Debug apk fonctionne, tandis que la version prod signée apk ne s'installe même pas.

@muthufmass lorsque vous déposez le nouveau numéro, veuillez inclure la version du SDK Android, le modèle de l'appareil, la sortie du médecin et les étapes à partir de flutter create .

@muthufmass ainsi que la sortie adb logcat.

Ce problème est clos - veuillez déposer un nouveau problème afin que nous puissions le suivre correctement.

a soulevé un ticket séparé maintenant https://github.com/flutter/flutter/issues/37935

Si vous avez des saveurs dans votre projet et que vous souhaitez prendre en charge à la fois x64 et x32, ajoutez simplement le dossier jniLibs à votre dossier de saveurs et cela fonctionne très bien, comme celui-ci

comment puis-je faire cela dans adobe animate cc
besoin de plus d'informations

La console Google Play a récemment commencé à désactiver le bouton de déploiement en raison de divers avertissements. Et l'un de ces avertissements utilise apk au lieu du fichier .aab. Il existe des solutions pour créer un fichier .aab si le projet a été créé dans Android Studio ou Unity. Mais que se passe-t-il si apk a été créé par Animate CC ou Haxe/Flash Develop ? Y a-t-il un moyen de convertir?

@newapproach, ce n'est pas clair pour moi si votre commentaire a quelque chose à voir avec Flutter ? Seriez-vous prêt à déposer un nouveau problème avec plus de détails ? Merci!

J'ai le même problème - mais flutter.so n'est pas inclus dans le dossier "armeabi-v7a.
N'a que des bibliothèques tierces pour x86 et armeabi-v7a - mais pas arm64.
Voudrais construire flutter uniquement pour "armeabi-v7a avec
ndk{
abiFilters "armeabi-v7a" // ne fonctionne pas non plus"armeabi", "x86",
}
et défini comme plate-forme cible comme @mravn-google le suggère à android-arm.

APK sans spécifier l'arche et ne pas inclure les bibliothèques

APK avec bibliothèques et aucune spécification de bras

APK avec spécifier l'arche et inclure les bibliothèques

Une suggestion sur la façon de déboguer d'autres étapes ?

J'ai trouvé cette erreur aussi, elle est corrigée ?? Pourriez-vous m'aider?

Je recommande de demander sur Stack Overflow ou d'ouvrir un nouveau bogue. Je doute que ce bogue fermé soit le bon endroit pour que les gens vous aident à résoudre le problème ci-dessus. Merci!

C'était ma solution :

1. en app gradle

splits {
        // Configures multiple APKs based on ABI.
        abi {
            // Enables building multiple APKs per ABI.
            enable true
            // By default all ABIs are included, so use reset() and include to specify that we only
            // want APKs for armeabi-v7a and arm64-v8a.

            // Resets the list of ABIs that Gradle should create APKs for to none.
            reset()

            // Specifies a list of ABIs that Gradle should create APKs for.
            include "armeabi-v7a", "arm64-v8a"

            // Specifies that we do not want to also generate a universal APK that includes all ABIs.
            universalApk false
        }
    }

1. courir flutter build apk --release --target-platform=android-arm
2. télécharger app-armeabi-v7a-release.apk sur le Play Store
3. incrémenter versionCode
4. courir flutter build apk --release --target-platform=android-arm64
5. télécharger app-arm64-v8a-release.apk sur le Play Store

Google Play Store servira l'application en fonction de l'architecture de l'appareil. Les appareils 32 bits sont heureux, les appareils 64 bits sont heureux et je suis heureux de savoir que la taille de mon APK reste relativement petite tout en servant les deux architectures.

Si nous incluons la prise en charge des deux architectures dans le même APK, attendez-vous à ce que la taille de votre application soit supérieure à 10 Mo

ne fonctionne pas .. quand je le vois sur Playstore sur pixel 2, il est dit non pris en charge pour cet appareil

Cela fonctionne, de nombreuses applications bien connues ont déployé plusieurs APK de cette façon et ont laissé le Play Store servir celui qui convient à l'appareil approprié pendant longtemps.

Les bundles d'applications sont la façon moderne de le faire, cependant.

Cela fonctionne, de nombreuses applications bien connues ont déployé plusieurs APK de cette façon et ont laissé le Play Store servir celui qui convient à l'appareil approprié pendant longtemps.

Les bundles d'applications sont la façon moderne de le faire, cependant.

Je ne sais pas pourquoi cela ne s'affiche pas sur le Playstore pixel 2 pour moi alors... Je suis exactement deux fois, au cas où...
J'ai utilisé app bundle et mon application plante donc je cherche des alternatives

Ce fil a été automatiquement verrouillé car il n'y a eu aucune activité récente après sa fermeture. Si vous rencontrez toujours un problème similaire, veuillez ouvrir un nouveau bogue, y compris la sortie de flutter doctor -v et une reproduction minimale du problème.