Persistence in mobile applications refers to the ability to save data locally on the device so that it can be retrieved and used later, even after the app has been closed and reopened. This is crucial for providing a seamless user experience, as it allows the app to remember user preferences, store data for offline use, and maintain state across sessions.

1. Types of Persistence:

   • In-Memory Storage: Data is stored in the device's RAM and is lost when the app is closed.
   • Local Storage: Data is stored on the device's storage and persists across app sessions.
   • Remote Storage: Data is stored on a remote server and accessed via network calls.

2. Common Local Storage Solutions:

   • Shared Preferences: Used for storing simple key-value pairs.
   • File Storage: Used for storing files such as text, images, and other media.
   • SQLite Database: Used for storing structured data in a relational database.
   • Hive: A lightweight and fast key-value database for Flutter.

3. Choosing the Right Storage Solution:

   • Shared Preferences: Best for small amounts of simple data, such as user settings.
   • File Storage: Best for large files or binary data.
   • SQLite Database: Best for complex data structures and relationships.
   • Hive: Best for high-performance needs and when using Dart objects directly.

Shared Preferences is a simple way to store key-value pairs persistently. Let's look at a practical example of how to use Shared Preferences in a Flutter app.

1. Add Dependency: Add the shared_preferences package to your pubspec.yaml file.

   dependencies:
     flutter:
       sdk: flutter
     shared_preferences: ^2.0.6
   

2. Import the Package:

   import 'package:shared_preferences/shared_preferences.dart';
   

3. Save Data:

   Future<void> saveData(String key, String value) async {
     final prefs = await SharedPreferences.getInstance();
     await prefs.setString(key, value);
   }
   

4. Retrieve Data:

   Future<String?> getData(String key) async {
     final prefs = await SharedPreferences.getInstance();
     return prefs.getString(key);
   }
   

5. Example Usage:

   void main() async {
     WidgetsFlutterBinding.ensureInitialized();
     await saveData('username', 'JohnDoe');
     String? username = await getData('username');
     print('Saved username: $username');
   }
   

• Adding Dependency: The shared_preferences package is added to the project to enable the use of Shared Preferences.
• Importing the Package: The package is imported into the Dart file where it will be used.
• Saving Data: The saveData function saves a string value with a specified key.
• Retrieving Data: The getData function retrieves the string value associated with a specified key.
• Example Usage: The main function demonstrates how to save and retrieve data using Shared Preferences.

Create a simple Flutter app that allows users to enter their name and save it using Shared Preferences. When the app is reopened, it should display the saved name.

1. Create a New Flutter Project:

   flutter create persistence_example
   cd persistence_example
   

2. Update pubspec.yaml:

   dependencies:
     flutter:
       sdk: flutter
     shared_preferences: ^2.0.6
   

3. Update main.dart:

   import 'package:flutter/material.dart';
   import 'package:shared_preferences/shared_preferences.dart';
   
   void main() {
     runApp(MyApp());
   }
   
   class MyApp extends StatelessWidget {
     @override
     Widget build(BuildContext context) {
       return MaterialApp(
         home: HomeScreen(),
       );
     }
   }
   
   class HomeScreen extends StatefulWidget {
     @override
     _HomeScreenState createState() => _HomeScreenState();
   }
   
   class _HomeScreenState extends State<HomeScreen> {
     TextEditingController _controller = TextEditingController();
     String _savedName = '';
   
     @override
     void initState() {
       super.initState();
       _loadSavedName();
     }
   
     Future<void> _loadSavedName() async {
       final prefs = await SharedPreferences.getInstance();
       setState(() {
         _savedName = prefs.getString('name') ?? '';
       });
     }
   
     Future<void> _saveName() async {
       final prefs = await SharedPreferences.getInstance();
       await prefs.setString('name', _controller.text);
       _loadSavedName();
     }
   
     @override
     Widget build(BuildContext context) {
       return Scaffold(
         appBar: AppBar(
           title: Text('Persistence Example'),
         ),
         body: Padding(
           padding: const EdgeInsets.all(16.0),
           child: Column(
             children: [
               TextField(
                 controller: _controller,
                 decoration: InputDecoration(labelText: 'Enter your name'),
               ),
               SizedBox(height: 20),
               ElevatedButton(
                 onPressed: _saveName,
                 child: Text('Save Name'),
               ),
               SizedBox(height: 20),
               Text('Saved Name: $_savedName'),
             ],
           ),
         ),
       );
     }
   }
   

• HomeScreen: A stateful widget that contains a text field for entering a name and a button to save the name.
• _loadSavedName: A function that loads the saved name from Shared Preferences and updates the state.
• _saveName: A function that saves the entered name to Shared Preferences and reloads the saved name.

In this section, we introduced the concept of persistence in Flutter applications. We discussed different types of persistence and common local storage solutions. We provided a practical example of using Shared Preferences to save and retrieve data. Finally, we included a practical exercise to reinforce the learned concepts. In the next section, we will dive deeper into other local storage solutions such as file storage and SQLite databases.