How to Optimize App Development Using Flutter SharedPreferences

Flutter SharedPreferences allows you to save and retrieve small data such as login states, counters, and theme choices without the need for a database. This blog explains setup, usage, examples, and best practices to optimize your Flutter projects with reliable storage.

Ever wondered how apps remember your login state or theme choice even after you close them? In Flutter, that smooth experience often comes from SharedPreferences.

Instead of setting up a full database for simple data like a string value, a boolean value, or an int value, you can persist key-value pairs quickly with Flutter . It’s lightweight, reliable, and ideal for user preferences and small value storage across app sessions.

Introduction to Shared Preferences in Flutter

Shared preferences in Flutter provide a simple data storage option for persisting information that doesn’t require a full database. Developers often use it to store user preferences, login states, or app settings. The SharedPreferences class manages persistent storage through key-value pair mappings, helping you save data like string values, boolean values, int values, or double values efficiently.

Shared preference data is best suited for handling lightweight tasks such as keeping initial values, counter value updates, or saving boolean flags. Unlike complex relational data models, shared preferences only store key-value data.

What is the Use of SharedPreferences in Flutter?

SharedPreferences is a lightweight key–value storage solution in Flutter that allows developers to store small amounts of data locally on the device. It’s perfect for saving user preferences, settings, login states, or simple app data without the need for a full-fledged database. — Check out the full post here

Shared preferences are used when you want to persist data across sessions without the complexity of a database. For example, you can save data such as a string key containing a user’s theme choice, an integer value for login attempts, or a boolean value that toggles dark mode.

Where are Shared Preferences Stored in Flutter?

On Android, shared preference data is stored as an XML file, while on iOS, it resides in . Both platforms provide persistent storage automatically, so the developer only needs to focus on how to write data and read data through the SharedPreferences API.

Initializing SharedPreferences in a Flutter Project

Before using in Flutter, you need to add it as a dependency in your Dart project. Open your YAML file and add the following line:

Run the following command to update your Flutter SDK dependencies:

Copy
1
flutter pub get

After this step, you can use SharedPreferences in your Flutter projects by initializing an instance.

How to Initialize SharedPreferences in Flutter

The sharedpreferences instance is obtained asynchronously. You need to call SharedPreferences prefs = await SharedPreferences.getInstance();. In practice, many developers shorthand this as prefs await sharedpreferences.getinstance.

Example: Setting Up SharedPreferences

Copy
1
2
3
4
5
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  SharedPreferences prefs = await SharedPreferences.getInstance();
  runApp(MyApp(prefs: prefs));
}

This setup ensures that your Flutter app can read data and write data from the very beginning when a user launches it.

Working with Data in SharedPreferences

Shared preferences can handle multiple data types, including string value, integer value, double value, and boolean value. Let’s explore how to write and read data using the setter and getter methods provided by the API.

Saving and Reading String Values

Developers often need to store key-value data like usernames or tokens.

Copy
1
2
prefs.setString('username', 'Vishal');
String? name = prefs.getString('username');

This approach uses a string key and safely returns a null value if the data doesn’t exist.

Saving and Reading Integer Values

Saving int values can help track user score, login count, or counter value.

Copy
1
2
prefs.setInt('loginCount', 5);
int? loginCount = prefs.getInt('loginCount');

The API reads an integer value directly or returns a null value if the key doesn’t exist.

Saving and Reading Double Values

When working with small value calculations, such as ratings or pricing, you can save a double value.

Copy
1
2
prefs.setDouble('rating', 4.5);
double? rating = prefs.getDouble('rating');

Saving double values is simple and avoids the overhead of handling databases for lightweight cases.

Saving and Reading Boolean Values

Boolean value storage is common for user preferences like dark mode toggles.

Copy
1
2
prefs.setBool('darkMode', true);
bool? isDark = prefs.getBool('darkMode');

Saving boolean flags helps maintain a consistent user experience across multiple app launches.

Take your Flutter projects further with Rocket.new’s instant app generation. Go from idea to production-ready code with a single prompt.

Build and Launch Your Flutter App Now!

Removing and Deleting Shared Preference Data

Sometimes you need to remove data when a user logs out or resets their settings. SharedPreferences provides both remove data and delete data options.

Copy
1
2
prefs.remove('username');
prefs.clear(); // Deletes all stored keys

The remove method helps target a given key, while clear removes all shared preference data at once.

Handling Null Values and Initial Values

When retrieving data from SharedPreferences, a null value might be returned if the key is missing. You should handle these cases gracefully by setting initial values. For example, while reading data for a counter, always provide a fallback.

Copy
1
int counter = prefs.getInt('counter') ?? 0;

This guarantees predictable results during user launches.

Using SharedPreferences in a Flutter App Example

Below is a practical Flutter app showing how to integrate SharedPreferences in Flutter.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class MyApp extends StatelessWidget {
  final SharedPreferences prefs;
  const MyApp({Key? key, required this.prefs}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int counter = 0;

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

  void _loadCounter() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    setState(() {
      counter = prefs.getInt('counter') ?? 0;
    });
  }

  void _incrementCounter() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    setState(() {
      counter++;
      prefs.setInt('counter', counter);
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("SharedPreferences Demo")),
      body: Center(child: Text("Counter Value: $counter")),
      floatingActionButton: FloatingActionButton(
        onPressed: _incrementCounter,
        child: Icon(Icons.add),
      ),
    );
  }
}

This sample demonstrates class Myapp extends StatelessWidget, class Myhomepage extends StatefulWidget, and buildContext context usage along with build methods.

SharedPreferences vs Other Storage Options

Shared preference is not designed for critical data or complex relational data. If you need structured storage or advanced queries, consider databases like Sqflite or Hive. SharedPreferences is best for small value settings, flags, or app preferences.

Best Practices for SharedPreferences in Flutter

• Persist key value data only for lightweight use cases.
• Avoid writing critical data such as passwords.
• Handle null values gracefully when retrieving data.
• Use containsKey method to verify a given key exists before reading data.
• Keep supporting classes minimal for testing and use mock implementation where needed.

Top Flutter App Development Tools with Secure Workflow Support

Modern app development often involves multiple platforms. While Flutter SDK is a strong choice, developers sometimes compare it with other tools. Below are the top 10 app development platforms offering enterprise-grade security and workflow support:

1. Rocket.new
2. Flutter SDK
3. React Native
4. Xamarin
5. Swift (iOS)
6. Kotlin (Android)
7. Ionic
8. NativeScript
9. Sencha
10. PhoneGap

These platforms complement workflows where persistent storage, like a SharedPreferences instance, may be required for handling user preferences and local data.

Final Thoughts on Flutter SharedPreferences

Using SharedPreferences in Flutter makes it straightforward to persist key-value data across sessions. It supports storing string, double, integer, and boolean values with minimal overhead. Whether you want to read, write, or remove data, the API provides simple setter and getter methods.

While it should not be used for complex relational data, it is ideal for small value storage, user preferences, and lightweight app settings. By applying best practices, you can optimize your Flutter projects and make your apps more reliable for every user launch.