oak_tree

Description:

oak tree

"State on demand for the widgets that need it"
Simple state management library for apps
Features #
Injection focused, simple state management that's decoupled.
Lets you inject managers (think of viewmodels or blocs) that hold your business logic for their widget and make changes anywhere without needing to pass it in
Getting started #
Getting started is fast and easy - there's only 4 steps
Step one: add the intialization code to your main.dart. #
This sets up the app to handle the manager injection
void main() async {
await setupOakTree(callback: () {
// we'll add more here in step 4
});
runApp(const MyApp());
}
copied to clipboard
Step two: Create a manager #
Managers are simple classes that extend the BaseManager.
Note - There's some bells and whistles under the hood but don't worry about those yet.
We'll create a manager with only one set of business logic to keep it easy to understand
A few things to note - "setViewState" is a function from the BaseManager. It updates the view state of the current manager. There are 4 state: idle, busy, error, and success.
The great thing about managers is they have two kinds of state: view state and internal state.
The view state is ultra-generic and let you handle simple view state that should work for 90% - 99% of tasks. The internal state can be anything: an enum, an int, error message - anything. You can have as many as you want. You can even mix the two together. Don't worry about that now though - there'll be more examples later
import 'package:oak_tree/oak_tree.dart';

class TestManager extends BaseManager {
int counter = 0;

void increase() async {
setViewState(ViewState.busy);
counter++;
await Future.delayed(const Duration(seconds: 2));
setViewState(ViewState.idle);
}
}
copied to clipboard
Step three: Create a view #
This view will bind the view to it's manager
Note - Notice how the build function returns a builder that uses the type "TestManager". This is how you bind the TestView to the TestManager and get access to the internal state and functions.
You can see how the builder is checking the view state to determine how to build the view.
You'll also notice the textbutton has access to the manager's function we just built called "increase". Without needing to set the state - the widget will rebuild itself with the most up to date state automatically.
import 'package:flutter/material.dart';
import 'package:oak_tree/oak_tree.dart';
import 'package:test_app/test_manager.dart';

class TestView extends StatelessWidget {
@override
Widget build(BuildContext context) {
return BaseView<TestManager>(
builder: (BuildContext context, TestManager manager, _) {
if (manager.viewstate.isBusy) {
return const CircularProgressIndicator();
}

return Column(
children: [
Text('Counter: ${manager.counter}'),
TextButton(
onPressed: () {
manager.increase();
},
child: const Text('Tap to increase'),
)
],
);
},
);
}
}

copied to clipboard
Step Four: Add manager to the setupOakTree function #
Go back to your main.dart and make this change:
void main() async {
await setupLocator(callback: () {
oak.registerLazySingleton(() => TestManager()); // <------ That's the change
});
runApp(const MyApp());
}
copied to clipboard
This change adds your manager to the magic. Now you can do all sorts of great things like accessing this manager from other managers, it'll allow you to manipulate the state of any manager and subsequently update the view of the manager that it's bound to.
Done! You're ready to start building your app using OakTree
Usage #
Include short and useful examples for package users. Add longer examples
to /example folder.
const like = 'sample';
copied to clipboard
Additional information #
Tell users more about the package: where to find more information, how to
contribute to the package, how to file issues, what response they can expect
from the package authors, and more.