DEV Community: Simon Pham

Store key-value data in Flutter using hive - but easier

Simon Pham — Tue, 28 Mar 2023 13:41:00 +0000

Introduction

A while ago, I posted a post about how to store key-value data using shared_preferences package.

However, shared_preferences is not pure Dart and depends on the platform, which might not be a good performance choice. So, I decided to look for another approach, and I found hive.

After using the package for several projects, I grew tired of writing/copying boilerplate code just to store my key-value data. I came up with an idea of writing a wrapper package for hive. This package should meet these criteria:

Support data encryption
Support Lazy loading of data
Support store data using Enum key
Support Listenable
And be EASY to use.

Guide to use:

You can either define your boxes as Singleton classes or use a service locator like
get_it.

Let's take a look at the guide to define a simple SettingsBox to store your settings using singleton class approach.

1. Define box keys 🔑

enum Settings {
  key, // Use as box key. You can use a String constant instead.

  /// Other keys below...
  themeMode,
  counter,
}

2. Define a box 📦


import 'package:easy_hive/easy_hive.dart';

class SettingsBox extends EasyBox {
  @override
  String get boxKey => Settings.key.toString();

  /// Singleton.
  static final SettingsBox _instance = SettingsBox._();

  factory SettingsBox() => _instance;

  SettingsBox._();
}

3. Initialize box 🚀


import 'package:easy_hive/easy_hive.dart';

Future<void> main() async {
  await EasyBox.initialize();

  await SettingsBox().init();

  // runApp...
}

4. Define getter & setter for your data 💄

extension GeneralSettingsExtension on SettingsBox {
  ThemeMode get themeMode {
    final index = get(
      Settings.themeMode,
      defaultValue: 0,
    );
    return ThemeMode.values[index];
  }

  set themeMode(ThemeMode value) => put(Settings.themeMode, value.index);

  int get counter => get(Settings.counter, defaultValue: 0);

  set counter(int value) => put(Settings.counter, value);
}

5. Use it anywhere 🔥

  Text(
    'You have pushed: ${SettingsBox().counter} times.',
    style: Theme.of(context).textTheme.headlineMedium,
  ),
  FilledButton(
    onPressed: () {
      SettingsBox().counter++;
    },
    child: Text('Increment'),
  ),
  FilledButton(
    onPressed: () {
      SettingsBox().themeMode = ThemeMode.dark;
    },
    child: Text('Dark Theme'),
  ),

Advanced Usage 😈

Enable encryption 🔐

1. Install easy_hive_encryption:

2. Add `EncryptionMixin` to your box class:

class SettingsBox extends EasyBox with EncryptionMixin {
  @override
  String get boxKey => Settings.key.toString();

  /// Override encryption key name (optional).
  @override
  String get encryptionKeyName => "your-own-key-name";
}

3. Follow flutter_secure_storage's guide for specific platform setup.

Enable lazy loading 🐢

1. Add `LazyMixin` to your box class:

class SettingsBox extends EasyBox with LazyMixin {
  @override
  String get boxKey => Settings.key.toString();
}

2. Use `await` to `get` your value:

extension GeneralSettingsExtension on SettingsBox {
  Future<ThemeMode> getThemeMode() async {
    final index = await get(
      Settings.themeMode,
      defaultValue: 0,
    );
    return ThemeMode.values[index];
  }
}

Listen to value changes 🎧

Recommended: Use `RefreshableBox` + provider:

1. Extends `RefreshableBox` instead of `EasyBox`:

class SettingsBox extends RefreshableBox {
  @override
  String get boxKey => Settings.key.toString();
}

2. Use it as a provider:

  ChangeNotifierProvider(
    create: (_) => SettingsBox(),
    child: SomeWidget(),
  ),

// Inside SomeWidget.
Text(
  'You have pushed: '
  '${context.select((SettingsBox _) => _.counter)} times.',
),

For more info, see provider package.

Or if you don't want `RefreshableBox`:

Just use `ValueListenableBuilder` to listen to changes.

ValueListenableBuilder(
  valueListenable: [
    Settings.counter,
  ].of(SettingsBox()),
  builder: (context, _, __) {
    return Text(
      '${SettingsBox().counter}',
    );
  },
),

This guide is taken from easy_hive repository.

Happy Coding 🦊

How to fix Ubuntu NVIDIA driver is not loaded

Simon Pham — Mon, 01 Feb 2021 17:15:31 +0000

I was using Ubuntu 20.04 on my PC with NVIDIA GTX 1060 card. Even after installed the driver from Additional Drivers, I got the below error when running nvidia-smi to check if the driver is working.

$ nvidia-smi

NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver. Make sure that the latest NVIDIA driver is installed and running.

nvidia-settings 
ERROR: NVIDIA driver is not loaded
ERROR: Unable to load info from any available system

After a lot of searching, I ended up with this solution:

To resolve the above issue, you can do these simple steps:
Step 1: Make sure you have nvidia-prime installed:

sudo apt install nvidia-prime

Step 2: Run these commands in Terminal:

sudo prime-select nvidia
sudo rm /lib/modprobe.d/blacklist-nvidia.conf
sudo update-initramfs -u

Step 3: Reboot

sudo reboot

Step 4: Check again

nvidia-smi

And ta-da! It's working.

Using SharedPreferences in Flutter effortlessly [UPDATED]

Simon Pham — Fri, 24 Jul 2020 07:50:44 +0000

Hi folks 👋
I have release a new package easy_hive, which is a better and simpler approach for storing key-value data instead of using shared_preferences. Please have a look.
Thank you so much!

We all know that SharedPreferences is a key/value store where you can read and store data very easily. It’s being used in most apps nowadays.

In Flutter, there’s a package named [shared_preferences] https://pub.dev/packages/shared_preferences) that helps us
deal with key/value data. Its documentation gives us something like this:

_incrementCounter() async {
  SharedPreferences prefs = await SharedPreferences.getInstance();
  int counter = (prefs.getInt('counter') ?? 0) + 1;
  print('Pressed $counter times.');
  await prefs.setInt('counter', counter);
}

It is really inconvenient to get the SharedPreferences instance asynchronously every time we need it. To increase reusability and reduce boilerplate code, I have an approach to save the instance of SharedPreferences and create getters/setters for the preference keys to use them anywhere in the app.

“Talk is cheap**. **Show me the code.” ~ Linus Torvalds

I will assume that you have already [added the shared_preferences] https://pub.dev/packages/shared_preferences#-installing-tab-) package.

First, we need to define a class to store the SharedPreferences instance. Let’s name it SharedPrefs.

// utils/shared_prefs.dart
class SharedPrefs {
  static SharedPreferences _sharedPrefs;
}

final sharedPrefs = SharedPrefs();

Easy, right?

Then, we will define an init() method to get the SharedPreference instance and store it to the _sharedPrefs variable in the SharedPrefs class.

// utils/shared_prefs.dart
class SharedPrefs {
  static SharedPreferences _sharedPrefs;
  init() async {
    if (_sharedPrefs == null) {
      _sharedPrefs = await SharedPreferences.getInstance();
    }
  }
}

final sharedPrefs = SharedPrefs();

And call it in main() function.

// main.dart
Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await sharedPrefs.init();
  runApp(
    MyApp(),
  );
}

Why called SharedPrefs.init() in the main() function? Because before runApp() is called, the app will show the splash screen. It’s a perfect moment for us to do some essential initialization for the app.

The next step is to define getters & setters for your preference keys. For example, I defined a getter and setter for getting & updating username in SharedPreferences.

// utils/shared_prefs.dart
class SharedPrefs {
  static SharedPreferences _sharedPrefs;

  init() async {
    if (_sharedPrefs == null) {
      _sharedPrefs = await SharedPreferences.getInstance();
    }
  }

  String get username => _sharedPrefs.getString(keyUsername) ?? "";

  set username(String value) {
    _sharedPrefs.setString(keyUsername, value);
  }
}

final sharedPrefs = SharedPrefs();
// constants/strings.dart
const String keyUsername = "key_username";

I also create a keyUsername *constant for consistency. You will not want to use a String directly like *_sharedPrefs.getString(“key_username”) and in another place use _sharedPrefs.setString(“key_user_name”**, value) by mistake.

That’s it. Now you can access username ANYWHERE in the app.

class MyApp extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: Text("Hi ${sharedPrefs.username}"),
      ),
    );
  }
}

Updated: Use `factory`

Factory constructors
Use the factory keyword when implementing a constructor that doesn’t always create a new instance of its class. For example, a factory constructor might return an instance from a cache, or it might return an instance of a subtype. Another use case for factory constructors is initializing a final variable using logic that can’t be handled in the initializer list.

class SharedPrefs {
  late final SharedPreferences _sharedPrefs;

  static final SharedPrefs _instance = SharedPrefs._internal();

  factory SharedPrefs() => _instance;

  SharedPrefs._internal();

  Future<void> init() async {
    _sharedPrefs ??= await SharedPreferences.getInstance();
  }

  // ...
}

// Remove this below line:
// final sharedPrefs = SharedPrefs();

Now change sharedPrefs to SharedPrefs() and you're good to go!

// main.dart
Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await SharedPrefs().init();
  runApp(
    MyApp(),
  );
}

class MyApp extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: Text("Hi ${SharedPrefs().username}"),
      ),
    );
  }
}

Thank you for reading my blog. You can check out this
gist for the full code.

Have questions? Find me at https://blog.simonit.dev