web-dev-qa-db-fra.com

Comment créer différentes versions de mon application Flutter pour qa/dev/prod?

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?

dartflutter
12
Seth Ladd

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

14
Seth Ladd

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());
}
  • importer 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.

9
Jacob Phillips

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

3
Günter Zöchbauer

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"));
     }
}
0
inf3ction

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

0
siva kumar