**Course Title:** Flutter Development: Build Beautiful Mobile Apps **Section Title:** Working with APIs and Data Persistence **Topic:** Introduction to local storage: Shared Preferences and SQLite **Introduction** In the previous topics, we have covered how to make HTTP requests and consume RESTful APIs in Flutter applications. However, there are situations where we need to store data locally on the device, such as when the network connection is lost or when we want to reduce the amount of data transferred over the network. In this topic, we will explore two popular local storage solutions for Flutter applications: Shared Preferences and SQLite. **Shared Preferences** Shared Preferences is a simple key-value store that allows us to store small amounts of data, such as strings, integers, and booleans, on the device. It is a lightweight and easy-to-use solution that is suitable for small to medium-sized applications. ### How to use Shared Preferences in Flutter To use Shared Preferences in Flutter, we need to add the `shared_preferences` package to our project. We can do this by adding the following line to our `pubspec.yaml` file: ```yaml dependencies: flutter: sdk: flutter shared_preferences: ^2.0.6 ``` Then, we can import the package in our Dart file and use the `SharedPreferences` class to store and retrieve data: ```dart import 'package:flutter/material.dart'; import 'package:shared_preferences/shared_preferences.dart'; class SharedPreferencesExample extends StatefulWidget { @override _SharedPreferencesExampleState createState() => _SharedPreferencesExampleState(); } class _SharedPreferencesExampleState extends State<SharedPreferencesExample> { final _key = Key('my_key'); Future<void> _storeData() async { final prefs = await SharedPreferences.getInstance(); await prefs.setBool(_key, true); } Future<bool> _retrieveData() async { final prefs = await SharedPreferences.getInstance(); return prefs.getBool(_key) ?? false; } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text('Shared Preferences Example'), ), body: Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: [ ElevatedButton( onPressed: _storeData, child: Text('Store Data'), ), SizedBox(height: 20), ElevatedButton( onPressed: _retrieveData, child: Text('Retrieve Data'), ), ], ), ), ); } } ``` In this example, we store a boolean value using the `setBool` method and retrieve it using the `getBool` method. ### Key Concepts * **Key**: A unique identifier for a key-value pair. * **Value**: The data stored in the key-value pair. * **String**: A string value can be stored using the `setString` and `getString` methods. * **Int**: An integer value can be stored using the `setInt64` and `getInt64` methods. * **Bool**: A boolean value can be stored using the `setBool` and `getBool` methods. **SQLite** SQLite is a self-contained, file-based database that allows us to store structured data on the device. It is a more powerful solution than Shared Preferences, but it requires more setup and configuration. ### How to use SQLite in Flutter To use SQLite in Flutter, we need to add the `sqlite3` package to our project. We can do this by adding the following line to our `pubspec.yaml` file: ```yaml dependencies: flutter: sdk: flutter sqlite3: ^1.3.0 ``` Then, we can import the package in our Dart file and use the `SQLite` class to create and interact with a database: ```dart import 'package:flutter/material.dart'; import 'package:sqflite/sqflite.dart'; class SQLiteExample extends StatefulWidget { @override _SQLiteExampleState createState() => _SQLiteExampleState(); } class _SQLiteExampleState extends State<SQLiteExample> { final _databaseName = 'example.db'; final _table = 'users'; Future<void> _createDatabase() async { await DatabaseHelper().createDatabase(_databaseName); } Future<void> _insertData() async { await DatabaseHelper().insertData(_table, { 'id': 1, 'name': 'John Doe', 'email': 'john.doe@example.com', }); } Future<List<Map<String, dynamic>>> _retrieveData() async { return await DatabaseHelper().retrieveData(_table); } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: Text('SQLite Example'), ), body: Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: [ ElevatedButton( onPressed: _createDatabase, child: Text('Create Database'), ), SizedBox(height: 20), ElevatedButton( onPressed: _insertData, child: Text('Insert Data'), ), SizedBox(height: 20), ElevatedButton( onPressed: _retrieveData, child: Text('Retrieve Data'), ), ], ), ), ); } } class DatabaseHelper { static final _databaseName = 'example.db'; static final _table = 'users'; static Database _database; static Future<Database> createDatabase(String databaseName) async { return await openDatabase(databaseName, version: 1, onCreate: (db, version) { db.execute(''' CREATE TABLE $ _table ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, email TEXT NOT NULL ); '''); }); } static Future<void> insertData(String tableName, Map<String, dynamic> data) async { final db = await _database; await db.insert(tableName, data); } static Future<List<Map<String, dynamic>>> retrieveData(String tableName) async { final db = await _database; return await db.query(tableName); } } ``` In this example, we create a database, insert a row into the table, and retrieve all rows from the table. ### Key Concepts * **Database**: A self-contained, file-based database that allows us to store structured data on the device. * **Table**: A collection of related data in the database. * **Row**: A single entry in the table. * **Column**: A single field in the row. **Conclusion** In this topic, we have explored two popular local storage solutions for Flutter applications: Shared Preferences and SQLite. We have learned how to use these solutions to store and retrieve data on the device, and we have seen examples of how to use them in real-world scenarios. **Practical Takeaways** * Use Shared Preferences for small to medium-sized applications that require simple key-value storage. * Use SQLite for larger applications that require more structured data storage. * Consider using a third-party package, such as `flutter_sqlite_plus`, to simplify the process of working with SQLite in Flutter. **Leave a comment or ask for help if you have any questions or need further clarification on any of the concepts covered in this topic.**