Je construis une application Flutter, et j'ai des variables avec des valeurs différentes pour différents environnements (QA, dev, prod, etc.). Quel est le bon moyen d’organiser mon application afin que je puisse facilement construire un environnement d’assurance qualité, de développement, de développement et autres?
Une façon de le faire: créez différents fichiers main_<environment>.Dart
dans le répertoire lib/
de votre projet.
Chaque main_<environment>.Dart
contient les configurations/valeurs spécifiques à l'environnement (telles que les différents noms de base de données, etc.). Chaque main_<environment>.Dart
importe ensuite la bibliothèque de l'application réelle et l'exécute en transmettant les valeurs/configurations de l'environnement.
Ensuite, choisissez le fichier .Dart
à construire: flutter run -t lib/main_debug.Dart
En s'inspirant de l'idée de Seth, voici un exemple qui configure une variable globale représentant la BuildEnvironment
nommée env
.
env.Dart
import 'package:meta/meta.Dart';
enum BuildFlavor { production, development, staging }
BuildEnvironment get env => _env;
BuildEnvironment _env;
class BuildEnvironment {
/// The backend server.
final String baseUrl;
final BuildFlavor flavor;
BuildEnvironment._init({this.flavor, this.baseUrl});
/// Sets up the top-level [env] getter on the first call only.
static void init({@required flavor, @required baseUrl}) =>
_env ??= BuildEnvironment._init(flavor: flavor, baseUrl: baseUrl);
}
main_dev.Dart
import 'package:flutter/material.Dart';
import 'env.Dart';
import 'app.Dart';
void main() {
BuildEnvironment.init(
flavor: BuildFlavor.development, baseUrl: 'http://dev.example.com');
assert(env != null);
runApp(App());
}
main_prod.Dart
import 'package:flutter/material.Dart';
import 'env.Dart';
import 'app.Dart';
void main() {
BuildEnvironment.init(
flavor: BuildFlavor.production, baseUrl: 'http://example.com');
assert(env != null);
runApp(App());
}
env.Dart
pour exposer la variable env
.exécutez et créez l'application à l'aide de l'option target
.
flutter run -t lib/main_dev.Dart
flutter build -t lib/main_dev.Dart
Pour intégrer VS Code, définissez les configurations de lancement:
.vscode/launch.json
{
"version": "0.2.0",
"configurations": [
{
"name": "development",
"program": "lib/main_dev.Dart",
"request": "launch",
"type": "Dart"
},
{
"name": "production",
"program": "lib/main_prod.Dart",
"request": "launch",
"type": "Dart"
}
]
}
J'avais initialement prévu d'utiliser les arguments de ligne de commande transmis à la fonction main
de Dart, mais je ne pense pas que les arguments puissent actuellement être passés sur la ligne de commande avec flutter run
ou flutter build
, bien que VS Code et Android Studio prennent en charge la transmission d'arguments à main
. Il semble également que semble une variante de construction, car une argumentation en ligne de commande à main
n'est pas appropriée, car les arguments peuvent être passés après au processus de construction.
Les modes Release et Debug peuvent maintenant être acquis en utilisant
const bool isProduction = bool.fromEnvironment('Dart.vm.product');
Parce que c'est une constante, cela fonctionne avec la secousse des arbres.
Donc, code comme
if(isProduction) {
// branch 1
} else {
// branch 2
}
n'inclurait qu'une de ces deux branches dans le code de production en fonction de isProduction
Information additionnelle :
J'ai eu le même problème et utilisé la solution proposée par Seth Ladd. Par conséquent, j’avais également besoin d’une configuration différente pour chaque version de l’application (dev/prod) et je ne souhaite pas écrire la configuration dans le fichier main_dev.Dart ou dans le fichier main_prod.Dart.
J'ai écrit un simple paquet Flutter qui consiste à séparer les fichiers de configuration et à les charger au démarrage de l'application. La configuration est alors disponible sur chaque ligne de code de votre application.
https://github.com/Ephenodrom/Flutter-Global-Config
Comment l'utiliser :
Créez un fichier json sous assets/cfg/$ file.json
Ajouter assets/cfg à votre pubspec.yaml
Chargement de différents fichiers de configuration au démarrage de l'application:
import 'package:flutter/material.Dart';
import 'package:global_configuration/global_configuration.Dart';
void main() async{
await GlobalConfiguration().loadFromAsset("app_settings");
await GlobalConfiguration().loadFromAsset("env_dev_settings");
runApp(MyApp());
}
class MyApp extends StatelessWidget {
...
}
Utilisation de la configuration dans votre application:
import 'package:flutter/material.Dart';
import 'package:global_configuration/global_configuration.Dart';
class CustomWidget extends StatelessWidget {
CustomWiget(){
// Access the config in the constructor
print(GlobalConfiguration().getString("key1"); // prints value1
}
@override
Widget build(BuildContext context) {
// Access the config in the build method
return new Text(GlobalConfiguration().getString("key2"));
}
}
Vous pouvez simplement implémenter des variantes de construction.
Sous 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.release
}
debug{
applicationIdSuffix ".dev"
signingConfig signingConfigs.debug
}
qa{
applicationIdSuffix ".qa"
signingConfig signingConfigs.qa
}
}
Dans iOS:
ajouter une configuration en sélectionnant projet-> coureur-> configuration ajouter un de plus