How to create a single instance of shared preferences which can be used in full project in flutter

To create Singleton class of SharedPreference:

Put this class in project

       import 'dart:async' show Future;
       import 'package:shared_preferences/shared_preferences.dart';
    
       class PreferenceUtils {
         static Future<SharedPreferences> get _instance async => _prefsInstance ??= await SharedPreferences.getInstance();
         static SharedPreferences _prefsInstance;
        
         // call this method from iniState() function of mainApp().
         static Future<SharedPreferences> init() async {
           _prefsInstance = await _instance;
           return _prefsInstance;
         }
       
         static String getString(String key, [String defValue]) {
           return _prefsInstance.getString(key) ?? defValue ?? "";
         }
       
         static Future<bool> setString(String key, String value) async {
           var prefs = await _instance;
           return prefs?.setString(key, value) ?? Future.value(false);
         }
       }

Initialize this class in initState() main class

 void main() async {
  // Required for async calls in `main`
  WidgetsFlutterBinding.ensureInitialized();

  // Initialize SharedPrefs instance.
  await SharedPrefs.init();

  runApp(MyApp());
}

Access in methods

PreferenceUtils.setString(AppConstants.USER_ID, "");
String userId = PreferenceUtils.getString(AppConstants.USER_ID);

more: https://dev.to/lucianojung/flutter-singelton-pattern-1a38

SharedPreferences.getInstance() returns already a Singleton. It reads once from disk and subsequent calls just return the resolved future. This way, just store the object returned by the await SharedPreferences.getInstance(); somewhere accessible globally.

Check out its source code below. It creates the static _completer once for the lifetime of the app.

  /// Loads and parses the [SharedPreferences] for this app from disk.
  ///
  /// Because this is reading from disk, it shouldn't be awaited in
  /// performance-sensitive blocks.
  static Future<SharedPreferences> getInstance() async {
    if (_completer == null) {
      final Completer<SharedPreferences> completer = Completer<SharedPreferences>();
      try {
        final Map<String, Object> preferencesMap = await _getSharedPreferencesMap();
        completer.complete(SharedPreferences._(preferencesMap));
      } on Exception catch (e) {
        // If there's an error, explicitly return the future with an error.
        // then set the completer to null so we can retry.
        completer.completeError(e);
        final Future<SharedPreferences> sharedPrefsFuture = completer.future;
        _completer = null;
        return sharedPrefsFuture;
      }
      _completer = completer;
    }
    return _completer!.future;
  }

Apart from creating a singleton separately you can also do this.. You can create a dart file with methods defined globally. By globally i mean outside the class.

late SharedPreferences prefs;
void initiateSharedPreferences()
{
   prefs = await SharedPreferences.getInstance();
}

From main.dart call this method to initiate prefs. Now the var pref is globally available. Now wherever you use prefs you only have to import this dart file and you can use prefs normally.

Use a simple Service Locator for Dart get_it. You will have many such cases when you have to have a global object to work with other than SharedPreferences too. The first step is to add dependencies for get_it. Just go to a link, and flollow steps below to set shared preferences below up.

Your SharedPreferences will be

import 'package:flutter/cupertino.dart';
import 'package:shared_preferences/shared_preferences.dart';

class SharedPrefs extends ChangeNotifier {
  SharedPreferences? _prefsInstance;

  SharedPrefs() {
    _init();
  }

  Future<void> _init() async {
    _prefsInstance = await SharedPreferences.getInstance();
    getIt.signalReady(this);
  }

  bool getBool(String key, [bool elseValue = false]) {
    return _prefsInstance?.getBool(key) ?? elseValue;
  }

  Future<bool> setBool(String key, bool value) async {
    return _prefsInstance?.setBool(key, value) ?? Future.value(false);
  }
}

In main.dart

import 'package:flutter/material.dart';
import 'package:get_it/get_it.dart';
import 'package:yourpackage/shared_prefs.dart';

import 'app.dart';

GetIt getIt = GetIt.instance;

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  getIt.registerSingleton(SharedPrefs(), signalsReady: true);
  runApp(const App());
}

Anywhere you need shared preferences you call it

final authenticated = getIt<SharedPrefs>().getBool('key_auth');