remote_config_feature_manager 3.0.4
remote_config_feature_manager: ^3.0.4 copied to clipboard
Firebase Remote Config feature manager for developer preferences, experiments, A/B tests etc.
Remote Config Feature Manager for Flutter #
[]
Feature manager allows you to hide some unfinished/secret feature from your users, or experiments, that can be managed from remote data source or local settings.
If you need only local feature toggles or preferences use Feature Manager
Getting Started #
- Installation
- Basic Usage
- If you want to use A/B testing or feature toggling with Firebase Remote Config use Remote Config Feature Manager
Installation #
Add
dependencies:
remote_config_feature_manager: ^latest_version
dev_dependencies:
build_runner:
feature_manager_generator: ^latest_version
to your pubspec.yaml
, and run
flutter packages get
in your project's root directory.
Setup Firebase Remote Config in your project. #
To get started with Firebase Remote Config for Flutter, please see the documentation available at https://firebase.flutter.dev
Basic Usage #
Creating Features with Code Generation
Starting from version 3.0.0, feature_manager
supports code generation to simplify feature creation and management.
Steps to Use Code Generation:
- Add Annotations to Your Features
Create a Dart file (e.g., app_features.dart) and define your features using the provided annotations:
import 'package:feature_manager/annotations.dart';
import 'package:feature_manager/feature.dart';
import 'package:feature_manager/feature_manager.dart';
part 'features.g.dart';
@FeatureManagerInit()
class AppFeatures {
AppFeatures({
required this.textFeature,
required this.booleanFeature,
required this.doubleFeature,
required this.integerFeature,
required this.jsonFeature,
});
factory AppFeatures.instance() => _$AppFeatures();
@FeatureOptions(
key: 'dev-prefs-text-pref',
remoteSourceKey: 'REMOTE-KEY-dev-prefs-text-pref',
title: 'Text pref',
description: 'This is text preference',
defaultValue: 'Some default text',
)
final TextFeature textFeature;
@FeatureOptions(
key: 'dev-prefs-bool-pref',
title: 'Toggle pref',
description: 'This is toggle preference',
defaultValue: false,
)
final BooleanFeature booleanFeature;
@FeatureOptions(
key: 'dev-prefs-double-pref',
title: 'Number double pref',
description: 'This is number double preference',
defaultValue: 2.2,
)
final DoubleFeature doubleFeature;
@FeatureOptions(
key: 'dev-prefs-integer-pref',
title: 'Number integer pref',
description: 'This is number integer preference',
defaultValue: 1,
)
final IntegerFeature integerFeature;
@FeatureOptions(
key: 'dev-prefs-json-pref',
title: 'Json pref',
description: 'This is json preference',
defaultValue: {"value": "Json default value"},
)
final JsonFeature jsonFeature;
}
- Annotations: Use the
@FeatureManagerInit()
annotation on the AppFeatures class to indicate that code should be generated. - Feature Fields: Annotate each feature field with
@FeatureOptions()
and provide the necessary parameters. - Factory Constructor: The factory AppFeatures.instance() returns an instance of the generated class _$AppFeatures().
- Part Directive: The part
'features.g.dart'
; directive tells Dart where to find the generated code.
- Run the Code Generator
Execute the following command to generate the feature classes:
flutter packages pub run build_runner build
- Use the Generated Features
Import the generated file and use the features in your code:
import 'features.dart';
// The generated part file is automatically included due to the 'part' directive.
void main() {
final appFeatures = AppFeatures.instance();
// Access individual features
final textValue = appFeatures.textFeature.value;
final isEnabled = appFeatures.booleanFeature.isEnabled;
// Access all features using the extension
for (final feature in appFeatures.values) {
print('Feature key: ${feature.key}');
}
}
- Accessing Features: You can access each feature via the instance of AppFeatures.
- Using the Extension: An extension AppFeaturesExt is generated to provide a values getter, which returns a list of all features.
Activate feature manager #
To fetch and active feature values use activate function. You should call RemoteConfigFeatureManager.getInstance()
function to initialize RemoteConfigFeatureManager instance with its dependencies. After that you can use RemoteConfigFeatureManager.instance
all over the app.
...
final featureManager =
await RemoteConfigFeatureManager.getInstance();
await featureManager.activate(
Features.values,
minimumFetchInterval: const Duration(
minutes: 5,
),
);
...
If you want to initialize FirebaseRemoteConfig elsewhere, you can just use refresh function to map remote values to your features.
...
featureManager.refresh(Features.values);
...
Using Features
To check whether a feature is enabled using RemoteConfigFeatureManager, you can create an instance via dependency injection (e.g., Provider, GetIt) or directly:
import 'package:feature_manager/feature_manager.dart';
final featureManager = RemoteConfigFeatureManager.instance;
final appFeatures = AppFeatures.instance();
// Check if a feature is enabled
final isEnabled = featureManager.isEnabled(appFeatures.booleanFeature);
Alternatively, since each feature provides an isEnabled property, you can directly access it:
final isEnabled = featureManager.booleanFeature.isEnabled;
// OR
final isEnabled = appFeatures.booleanFeature.isEnabled;
Modify remote feature values in Firebase Console
Modify feature values in DEBUG (develop) mode
To do it, you can simply open DeveloperPreferences screen in any part of your app. You should pass list of your features as parameter for this screen.
P.S. You should hide this button for production builds.
Navigator.of(context).push(
MaterialPageRoute(
builder: (BuildContext context) =>
DeveloperPreferencesScreen(Features.values),
),
);
Feature parameters #
Parameter | Default | Description |
---|---|---|
key String | required | This key will be used to store value in local storage. |
type FeatureType | FeatureType.feature |
It can be used to separate local features and experiments driven by some remote provider. |
remoteSourceKey String | Key from remote source. | |
description String | Description that will be used inside Developer Preferences Screen. | |
value Object? | Null | Stored value of the Feature. Will be fetched from local storage. |
defaultValue Object? | Null | Default value of the Feature. Will be returned by FeatureManager if stored value is Null |
enum FeatureType { feature, experiment }
enum FeatureValueType { text, toggle, doubleNumber, integerNumber, json }
Contributions #
Feel free to contact me (agetman@bedcode.dev) or create Pull Requests/Issues for this repository :)