[移动开发]Flutter语言国际

Intl实现多语言切换

安装 Intl 插件

安装完成再重启AndroidStudio后生效

添加项目依赖

flutter_localizations:
sdk: flutter

自动生成目录

点击Tools->Flutter Intl -> Initialze for the Project

此时会自动在pubspec.yaml文件中添加 flutter_intl: enabled: true，并且生成 lib->generated-> intl 和 l10n 目录以及相对应的文件，请勿手动修改

添加语言支持

Tools -> Flutter Intl -> Add locale
选择对应语言，例如zh，en。如果有繁体支持，港台分别为zh_TW/zh_HK.
选定后，会在l10n文件夹下自动创建对应文件，例如 intl_en.arb/intl_zh.arb

项目代码应用

编辑arb文件

intl_en.arb

{
  "test" : "测试"
}

intl_zh.arb

{
  "test" : "Test"
}

中英文切换

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        // 切换中英文
        locale: const Locale('zh', ''),
        // locale: const Locale('en', ''),
        localizationsDelegates: const [
          S.delegate,
          GlobalMaterialLocalizations.delegate,
          GlobalCupertinoLocalizations.delegate,
          GlobalWidgetsLocalizations.delegate
        ],
        supportedLocales: [
          const Locale('zh', ''),
          ...S.delegate.supportedLocales
        ],
        title: 'Flutter Demo',
        theme: ThemeData(primarySwatch: Colors.blue),
        home: const MyHomePage(title: 'Flutter Demo Home Page'));
  }

调用字符串

S.current.test

S.of(context).test

自定义实现多语言切换

代码实现

/// 字符串基类
abstract class BaseString {
  String get home;
  String get list;
  String get more;
}

/// 字符串-中文类
class CNString extends BaseString {

  @override
  String get home => '首页';

  @override
  String get list => '列表';

  @override
  String get more => '更多';

}

/// 字符串英文类
class ENString extends BaseString {
  @override
  String get home => 'Home';

  @override
  String get list => 'List';

  @override
  String get more => 'More';
}

/// 字符串资源
class String591 {
  // 中文
  static const String languageCN = 'CN';

  // 英文
  static const String languageEN = 'EN';

  // 中文字符串对象
  static final BaseString cnString = CNString();

  // 英文字符串对象
  static final BaseString enString = ENString();

  /// 切换语言（cn：中文版； en：英文版）
  static changeLanguage(String language) {
    if (null != language && language.isNotEmpty) {
      SpUtil().put(SpKey.SP_APP_LANGUAGE, language);
    }
  }

  /// 获取语言类型（cn：中文版； en：英文版）
  static String getLanguageType() {
    return SpUtil().getString(SpKey.SP_APP_LANGUAGE, defaultValue: languageCN);
  }

  /// 工厂模式，考虑多语言扩展性，字符串复用性等等
  static BaseString create() {
    String language =
        SpUtil().getString(SpKey.SP_APP_LANGUAGE, defaultValue: languageCN);
    if (language == languageEN) {
      // 英文版
      return enString;
    } else {
      // 中文版
      return cnString;
    }
  }

  /// 返回一个字符串(弃用，该方法不利于后续扩展和维护)
  static getString({String cn = '', String en = ''}) {
    String language =
        SpUtil().getString(SpKey.SP_APP_LANGUAGE, defaultValue: languageCN);
    if (language == languageEN) {
      // 英文版
      return en;
    } else {
      // 中文版
      return cn;
    }
  }
}

字符串使用

String591.create().home

缓存类引用

  # 轻量级缓存
  # https://pub.dev/packages/shared_preferences/install
  shared_preferences: ^2.0.6

import 'package:shared_preferences/shared_preferences.dart';

/// 轻量级缓存
class SpUtil {
  /// *******************************  同步  ******************************* ///

  // 声明缓存对象
  SharedPreferences _prefs;

  // static _instance，_instance会在编译期被初始化，保证了只被创建一次
  static final SpUtil _instance = SpUtil._internal();

  /// 提供了一个工厂方法来获取该类的实例
  factory SpUtil() {
    return _instance;
  }

  /// 通过私有方法_internal()隐藏了构造方法，防止被误创建
  SpUtil._internal() {
    _init();
  }

  /// 初始化
  void _init() async {
    _prefs = await SharedPreferences.getInstance();
  }

  /// 保存对象
  void put(String key, Object value) {
    if (null != value && null != _prefs) {
      if (value is int) {
        _prefs.setInt(key, value);
      } else if (value is double) {
        _prefs.setDouble(key, value);
      } else if (value is bool) {
        _prefs.setBool(key, value);
      } else if (value is String) {
        _prefs.setString(key, value);
      } else if (value is List) {
        _prefs.setStringList(key, value);
      }
    }
  }

  /// 获取对象(整型)
  int getInteger(String key, {int defaultValue = 0}) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      return _prefs.getInt(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(字符串)
  String getString(String key, {String defaultValue = ''}) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      return _prefs.getString(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(布尔型)
  bool getBoolean(String key, {bool defaultValue = false}) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      return _prefs.getBool(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(浮点型)
  double getDouble(String key, {double defaultValue = 0}) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      return _prefs.getDouble(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(字符串集合)
  List<String> getList(String key, {List<String> defaultValue}) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      return _prefs.getStringList(key);
    } else {
      return defaultValue;
    }
  }

  /// 移除指定元素
  void removeKey(String key) {
    if (null != _prefs &&
        null != key &&
        key.isNotEmpty &&
        _prefs.containsKey(key)) {
      _prefs.remove(key);
    }
  }

  /// 清空整个缓存
  void clearAll() {
    if (null != _prefs) {
      _prefs.clear();
    }
  }

  /// *******************************  异步  ******************************* ///

  /// 保存对象
  static asyncPut(String key, Object value) async {
    if (null != value) {
      SharedPreferences prefs = await SharedPreferences.getInstance();
      if (value is int) {
        await prefs.setInt(key, value);
      } else if (value is double) {
        await prefs.setDouble(key, value);
      } else if (value is bool) {
        await prefs.setBool(key, value);
      } else if (value is String) {
        await prefs.setString(key, value);
      } else if (value is List) {
        await prefs.setStringList(key, value);
      }
    }
  }

  /// 获取对象(整型)
  static Future<int> asyncGetInteger(String key, {int defaultValue = 0}) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      return prefs.getInt(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(字符串)
  static Future<String> asyncGetString(String key,
      {String defaultValue = ''}) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      return prefs.getString(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(布尔型)
  static Future<bool> asyncGetBoolean(String key,
      {bool defaultValue = false}) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      return prefs.getBool(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(浮点型)
  static Future<double> asyncGetDouble(String key,
      {double defaultValue}) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      return prefs.getDouble(key);
    } else {
      return defaultValue;
    }
  }

  /// 获取对象(字符串集合)
  static Future<List<String>> asyncGetList(String key,
      {List<String> defaultValue}) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      return prefs.getStringList(key);
    } else {
      return defaultValue;
    }
  }

  /// 移除指定元素
  static void asyncRemoveKey(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs &&
        null != key &&
        key.isNotEmpty &&
        prefs.containsKey(key)) {
      prefs.remove(key);
    }
  }

  /// 清空整个缓存
  static void asyncClearAll() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    if (null != prefs) {
      prefs.clear();
    }
  }
}