fluttin

Description:

fluttin

Fluttin #
A pragmatic lightweight dependency injection framework for Flutter developers.
Getting Started #
This is the Flutter version of koin, which is almost the same as the original koin in use.
It's just that dart's closure doesn't support receiver type, so it looks a bit complicated in this class
But the principle is the same.
For the concept of DI, please refer to the official website of koin: https://insert-koin.io/
You need to execute startFluttin at the beginning of the project.
class MyApp extends StatefulWidget {
const MyApp({Key? key}) : super(key: key);
@override
State<StatefulWidget> createState() {
return MyAppState();
}
}

class MyAppState extends State<MyApp> {

@override
void initState() {
super.initState();
initFluttin();
}

// This widget is the root of your application.
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: const MyHomePage(title: 'Flutter Demo Home Page'),
);
}

Future<void> initFluttin() async {
startFluttin((FluttinApplication application) {
application.modules(<Module>[
Modules.module,
Modules.screenModule,
Modules.serviceModule,
Modules.dbModule,
]);
});
}
}
copied to clipboard
Then create modules.dart in libs/

class Modules {
static Module module = module((Module module) {
module.factory((Scope scope, DefinitionParameters parameters) =>
MyGameRepository(
scope.get(), scope.get(), scope.get(), scope.get(), scope.get()));
});

static Module screenModule = module((Module module) {
module.scope<ScreenScope>((scopeSet) {});
});

static Module serviceModule = module((Module module) {
module.single((Scope scope, DefinitionParameters parameters) =>
ServiceManager.instance);
module.single((Scope scope, DefinitionParameters parameters) =>
scope.get<ServiceManager>().gatewayService);
});

static Module dbModule = module((Module module) {
module.single(
(Scope scope, DefinitionParameters parameters) => DBUtils.appDatabase);
module.single((Scope scope, DefinitionParameters parameters) =>
scope.get<AppDatabase>().screenDao);
});
}
copied to clipboard
You don’t need to pay attention to how other classes are generated in this class

class MyGameRepository {
MyGameRepository(this._appInfoDao, this._downloadPackageDao,
this._taskInfoDao, this._userAppDao, this._appVirtualDao);

final AppInfoDao _appInfoDao;
final DownloadPackageDao _downloadPackageDao;
final DownloadTaskDao _taskInfoDao;
final UserAppDao _userAppDao;
final AppVirtualDao _appVirtualDao;

}
copied to clipboard
The following is a simple instruction: #

If you want to use it, you can directly use inject() to generate it

class _XXState extends State<XXWidget> {
MyGameRepository _myGameRepository = inject();
@override
Widget build(BuildContext context) {
return Scaffold();
}
}
copied to clipboard


If you want to write a module, there are several ways to provide it:

factory: Each inject() generates a new instance.
single: Only the first inject() will be a new instance, and the instance generated for the
first time will be used later. It is equivalent to the concept of singleton.
scoped: When the scope condition is met, only the first inject() will be a new instance,
and it will be reused later.
for example:
scope=UserScope, which means that when the user is logged in, the same instance will be output from inject(),
When the user logs out and then logs in again, the new instance will be tried again.
It can be understood as a singleton in user login.



If other classes will be used in the class I want to generate

scope.get()
module.factory((Scope scope, DefinitionParameters parameters) =>
MessageScreenCubit(scope.get(), scope.get());
copied to clipboard




If I want to dynamically pass in parameters

DefinitionParameters
messageScreenCubit = inject(parameters: () {
return DefinitionParameters(values: [
widget.conversation,
widget.conversationId,
widget.targetUserId,
]);
});
copied to clipboard
module.factory((Scope scope, DefinitionParameters parameters) {
return MessageScreenCubit(conversation: parameters[0],
conversationId: parameters[1],
userId: parameters[2],
);
});
copied to clipboard




If I want to provide different implementations for an interface in the module


qualifier
class _XXState extends State<XXWidget> {
Animal animal = inject(qualifier: StringQualifier('dog'));

@override
Widget build(BuildContext context) {
return Scaffold();
}
}
copied to clipboard
module.factory<Animal>(
(Scope scope, DefinitionParameters parameters) => Dog(),
qualifier: StringQualifier('dog')
);
module.factory<Animal>(
(Scope scope, DefinitionParameters parameters) => Cat(),
qualifier: StringQualifier('cat')
);
copied to clipboard