Persistence and Data Storage

Back: Networking and APIs

Persistence and data storage are essential aspects of many Flutter applications. They allow you to store and retrieve data locally on the device, enabling features like caching, offline functionality, and user preferences. In this article, we'll explore different methods of persistence and data storage in Flutter and how to use them effectively in your applications.

CRUD Application with SQLite Database in Flutter

Building a CRUD (Create, Read, Update, Delete) application with a SQLite database is a common use case in Flutter development. It allows you to perform basic database operations and manage data effectively. In this article, we'll explore how to create a CRUD application using a SQLite database in Flutter and implement the necessary functionality for each operation.

Setting Up the Project

Before we start building the CRUD application, let's set up the Flutter project and add the necessary dependencies. Open your terminal or command prompt and navigate to the desired directory. Run the following commands:

flutter create crud_app cd crud_app

Next, open the project in your favorite code editor. In the `pubspec.yaml` file, add the following dependencies:

dependencies: flutter: sdk: flutter sqflite: ^2.0.0 path: ^2.1.0

Save the file, and run the command `flutter pub get` in the terminal to fetch the dependencies.

Creating the Database Helper

To interact with the SQLite database, we'll create a database helper class that encapsulates the database operations. Create a new Dart file, such as `database_helper.dart`, and define the helper class. Here's an example of a basic database helper class with CRUD operations:

import 'dart:async'; import 'package:path/path.dart'; import 'package:sqflite/sqflite.dart'; class DatabaseHelper { static final DatabaseHelper _instance = DatabaseHelper.internal(); factory DatabaseHelper() => _instance; static late Database _database; Future get database async { if (_database != null) return _database; _database = await initDatabase(); return _database; } DatabaseHelper.internal(); Future initDatabase() async { final databasePath = await getDatabasesPath(); final path = join(databasePath, 'crud_app.db'); return await openDatabase( path, version: 1, onCreate: (db, version) async { await db.execute('CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT)'); }, ); } Future>> getItems() async { final db = await database; return await db.query('items'); } Future addItem(String name) async { final db = await database; return await db.insert('items', {'name': name}); } Future updateItem(int id, String name) async { final db = await database; return await db.update('items', {'name': name}, where: 'id = ?', whereArgs: [id]); } Future deleteItem(int id) async { final db = await database; return await db.delete('items', where: 'id = ?', whereArgs: [id]); } }

In this example, we define a `DatabaseHelper` class that follows the Singleton pattern to ensure a single instance of the database is used throughout the application. The `initDatabase()` method initializes the database and creates a table if it doesn't exist. The `getItems()` method retrieves all items from the database. The `addItem()`, `updateItem()`, and `deleteItem()` methods perform the respective CRUD operations on the `items` table.

Implementing the User Interface

Now that we have the database helper class, let's implement the user interface for our CRUD application. Create a new Dart file, such as `main.dart`, and define the application's main entry point. Here's an example of a basic user interface with a ListView of items:

import 'package:flutter/material.dart'; import 'database_helper.dart'; void main() { runApp(CRUDApp()); } class CRUDApp extends StatelessWidget { final dbHelper = DatabaseHelper(); @override Widget build(BuildContext context) { return MaterialApp( title: 'CRUD App', home: Scaffold( appBar: AppBar( title: Text('CRUD App'), ), body: FutureBuilder>>( future: dbHelper.getItems(), builder: (context, snapshot) { if (snapshot.hasData) { final items = snapshot.data; return ListView.builder( itemCount: items!.length, itemBuilder: (context, index) { final item = items[index]; return ListTile( title: Text(item['name']), ); }, ); } else if (snapshot.hasError) { return Center( child: Text('Error: ${snapshot.error}'), ); } return Center( child: CircularProgressIndicator(), ); }, ), ), ); } }

In this example, we define a stateless widget `CRUDApp` as the root of the application. The `build()` method displays a `ListView.builder` widget that shows the list of items retrieved from the database using the `getItems()` method. The user interface can be further enhanced with input fields, buttons, and additional screens to enable the complete CRUD functionality.

Shared Preferences

Shared Preferences is a simple key-value store that allows you to store primitive data types locally on the device. It's commonly used for storing user preferences, such as settings or authentication tokens. Here's an example of using Shared Preferences to store and retrieve data:

  import 'package:shared_preferences/shared_preferences.dart';
  void saveData() async {    final prefs = await SharedPreferences.getInstance();    prefs.setString('username', 'JohnDoe');  }
  void loadData() async {    final prefs = await SharedPreferences.getInstance();    final username = prefs.getString('username');    print(username); // Output: JohnDoe  }

File Storage

Flutter also provides APIs for reading and writing files on the device. This can be useful for storing complex data structures or large files. You can use the `dart:io` library to interact with the file system. Here's an example of reading and writing data to a file:

  import 'dart:io';
  void writeToFile() {    final file = File('data.txt');    file.writeAsStringSync('Hello, world!');  }
  void readFromFile() {    final file = File('data.txt');    final contents = file.readAsStringSync();    print(contents); // Output: Hello, world!  }

Conclusion

Persistence and data storage are crucial for many Flutter applications. Whether you need to store user preferences, cache data, or work with a structured database, Flutter provides various options to meet your needs. By leveraging methods like Shared Preferences, SQLite databases, and file storage, you can create powerful and efficient applications that can store and retrieve data locally on the device. Consider the requirements of your application and choose the appropriate storage method to ensure optimal performance and user experience.