How to save to local storage using Flutter?

In Flutter, saving data to local storage can be achieved through several methods. Depending on the application context and data types, select the appropriate method. Below are some commonly used local storage approaches:

1. SharedPreferences

SharedPreferences is a key-value storage mechanism designed for saving simple data such as settings, configurations, and small datasets. For instance, it can store user preferences and login status. Here is a simple example:

Example Code

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

class UserData {
  Future<void> saveUserLoggedIn(bool isLoggedIn) async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    await prefs.setBool('isLoggedIn', isLoggedIn);
  }

  Future<bool> getUserLoggedIn() async {
    final SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs.getBool('isLoggedIn') ?? false;
  }
}

In this example, we define a class UserData that uses SharedPreferences to save the user's login status and provides methods for reading and writing this status.

2. File Storage

For storing text files or binary files, file storage is appropriate. For instance, it can save user diaries or downloaded images. In Flutter, the path_provider plugin helps locate the correct file path, and Dart's File class handles reading and writing operations. Here is an example:

Example Code

dart
import 'dart:io';
import 'package:path_provider/path_provider.dart';

class FileManager {
  Future<String> get _localPath async {
    final directory = await getApplicationDocumentsDirectory();
    return directory.path;
  }

  Future<File> get _localFile async {
    final path = await _localPath;
    return File('$path/data.txt');
  }

  Future<File> writeFile(String data) async {
    final file = await _localFile;
    return file.writeAsString(data);
  }

  Future<String> readFile() async {
    try {
      final file = await _localFile;
      return await file.readAsString();
    } catch (e) {
      return 'Error: $e';
    }
  }
}

3. SQLite

For more complex data storage needs, such as querying, updating, and relationship mapping, SQLite database is suitable. In Flutter, the sqflite plugin enables database operations. Here is an example:

Example Code

dart
import 'package:sqflite/sqflite.dart';

class DatabaseHelper {
  static Database _database;
  static final _databaseName = "MyDatabase.db";
  static final _databaseVersion = 1;

  Future<Database> get database async {
    if (_database != null) return _database;

    _database = await _initDatabase();
    return _database;
  }

  _initDatabase() async {
    String path = join(await getDatabasesPath(), _databaseName);
    return await openDatabase(path,
        version: _databaseVersion,
        onCreate: _onCreate);
  }

  Future _onCreate(Database db, int version) async {
    await db.execute('''
          CREATE TABLE my_table (
            id INTEGER PRIMARY KEY,
            info TEXT
          )
          ''');
  }
}

In this example, we define a class DatabaseHelper to manage database initialization, table creation, and version control.

Summary

Selecting the appropriate local storage method depends on the data type and application context. SharedPreferences is ideal for small, simple data; file storage is suitable for larger or specific-format files; and SQLite is best for scenarios involving complex queries and data relationship mapping.