Need for Managing the Session in Flutter Apps 🤔

Managing user sessions is crucial for providing a seamless user experience in mobile applications. In this blog, you will learn how to store and save the login session using shared_preferences in a Flutter application. This includes implementing the login functionality, a "Remember Me" option, and logout functionality.
Let's get Started!🚀

Setting Up Shared Preferences:

First, ensure you have the shared_preferences package added to your pubspec.yaml:

dependencies:
  shared_preferences: ^latest

Then, import the package in your Dart file:

import 'package:shared_preferences/shared_preferences.dart';

Saving isLoggedIn Status:

When a user logs in, you can save their login status using shared preferences. Here’s a function to save the user’s login status:

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

Retrieving isLoggedIn Status:

When the app starts, you need to check if the user is already logged in. This function retrieves the stored login status:

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

Using the isLoggedIn Status:

You can use the retrieved login status to determine the initial screen of your app. Here’s how you can modify your main function to check the login status:

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final bool loggedIn = await isLoggedIn();
  runApp(MyApp(isLoggedIn: loggedIn));
}

class MyApp extends StatelessWidget {
  final bool isLoggedIn;
  const MyApp({required this.isLoggedIn});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: isLoggedIn ? DashboardScreen() : LoginScreen(),
    );
  }
}

Logging Out:

Finally, implement a logout function to clear the stored login session:

Future<void> logout() async {
  final SharedPreferences prefs = await SharedPreferences.getInstance();
  await prefs.clear();
}

To trigger the logout, you can use the onTap / onPressed widget:

IconButton(
            icon: const Icon(Icons.logout),
            onPressed: () {
              logout(context);
            },
          ),

Conclusion:

Using shared preferences to manage login sessions is a simple yet effective way to enhance the user experience in your Flutter applications. By storing user login status securely, you can keep users logged in and provide seamless navigation throughout your app.
For a complete example, refer to the sample code from this GitHub repository.

Introduction:

In today's rapidly evolving tech landscape, developers often find themselves working across various platforms and architectures. With the rise of ARM-based Macs like the M1, ensuring compatibility and smooth deployment to cloud services such as Azure Container Registry (ACR) becomes essential. In this blog post, we'll explore how to build and push Docker images from a Mac M1 to ACR seamlessly.

Understanding the Architecture Difference:

Mac M1 systems utilize the ARM64 architecture, while most cloud-based infrastructure runs on x86 architecture. This disparity can lead to compatibility issues when deploying Docker images from Mac M1 to ACR.

Solution:
Leveraging Docker Buildx for Multi-Platform Support. Docker Buildx, a powerful CLI plugin, comes to the rescue by enabling developers to build Docker images for multiple platforms simultaneously. Let's dive into the steps involved:

Step 1: Set Up Docker Buildx Builder Instance

Create a Docker Buildx builder instance using the following command:

docker buildx create --name mybuilder --use

This command initializes a builder instance named "mybuilder" for multi-platform builds.

Step 2: IDE Authentication to Azure Container Registry

Before pushing your image, establish a connection between your ACR and local IDE. Login to ACR using:

az acr login -n <your-acr-name>

Make sure you have enabled the admin user in the Azure Portal under Access keys settings as shown in the image below.

**

Step 3: Building and Pushing Docker Image to ACR:**

Now, let's build and push our Docker image to Azure Container Registry. Execute the following command:

docker buildx build --platform linux/amd64,linux/arm64 -t <acr-name>.azurecr.io/my-image:latest --push .

Explanation of the above command:

• docker buildx build: Initiates the build process using Docker Buildx.

• --platform linux/amd64,linux/arm64: Specifies the target platforms for the build.

• -t <acr-name>.azurecr.io/mac:latest: Tags the resulting image with the specified name and tag.

• --push . : Pushes the built image to the specified container registry.

Replace <acr-name> with the name of your Azure Container Registry. This command builds a multi-platform image for both x86 and ARM architectures and pushes it to ACR.

How to load the Docker image in Docker Desktop?

After pushing the image to the ACR, the image is stored in the build cache while building it if you want to load the docker image on the docker desktop you can use the following command:

docker buildx build --load -t <your-image-name>:<tag> .

In case of encountering an error shown below.

[+] Building 0.0s (0/0)                               docker:desktop-linux                                                    
ERROR: Multi-platform build is not supported for the docker driver.
Switch to a different driver, or turn on the containerd image store, and try again.
Learn more at https://docs.docker.com/go/build-multi-platform/

Then, try the following commands:

docker buildx rm mybuilder

The above command removes the previously created builder.
Then recreate a builder using:

docker buildx create --name mybuilder --use --driver docker-container

Now, continue from Step 2 onwards.

Conclusion:

Using Docker Buildx makes it easy for developers to create and send Docker images from Mac M1 computers to Azure Container Registry. This method guarantees that your software works smoothly on different types of computer systems, making it easier to deploy without running into compatibility issues. Embracing this multi-platform approach is crucial for managing the complexities of today's software development and deployment.