Forem: Ahmad Darwish

Comprehensive Guide to Using GetX in Flutter

Ahmad Darwish — Sat, 20 Jul 2024 21:14:19 +0000

GetX is a powerful and lightweight solution for Flutter that provides state management, route management, and dependency injection. This article will guide you through the essential features of GetX, including state management, route management, navigation, localization, and dialogs/bottom sheets.

Introduction to GetX
State Management
Route Management
Navigation
Localization
Dialogs and Bottom Sheets

1. Introduction to GetX

GetX is an all-in-one Flutter package that simplifies the development process by providing a robust and easy-to-use API for managing states, routes, dependencies, and more. Its simplicity and performance make it an excellent choice for Flutter developers.

Installation

To start using GetX, add it to your pubspec.yaml file:

dependencies:
  get: ^4.6.6

Then, run flutter pub get to install the package.

2. State Management

GetX offers a reactive state management solution that is both simple and efficient. Let's start with a basic example.

Example

Create a controller class to manage the state:

import 'package:get/get.dart';

class CounterController extends GetxController {
  var count = 0.obs;

  void increment() {
    count++;
  }
}

In your widget, use the Obx widget to reactively display the state:

import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'counter_controller.dart';

class CounterApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final CounterController controller = Get.put(CounterController());

    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('GetX Counter')),
        body: Center(
          child: Obx(() => Text('Count: ${controller.count}')),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: controller.increment,
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}

In this example, the Obx widget automatically updates the count whenever it changes.
Note: to impelement more advance state management for http call response and firebase integration search about:
RxStatus with StateMixin<T> and controller.obx widget in Getx

3. Route Management

GetX simplifies route management by allowing you to define routes in a single place and navigate without context.

Example

Define your routes:

import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'home_page.dart';
import 'details_page.dart';

void main() {
  runApp(GetMaterialApp(
    initialRoute: '/',
    getPages: [
      GetPage(name: '/', page: () => HomePage()),
      GetPage(name: '/details', page: () => DetailsPage()),
    ],
  ));
}

Navigate between pages:

import 'package:flutter/material.dart';
import 'package:get/get.dart';

class HomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Home')),
      body: Center(
        child: ElevatedButton(
          onPressed: () => Get.toNamed('/details'),
          child: Text('Go to Details'),
        ),
      ),
    );
  }
}

class DetailsPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Details')),
      body: Center(
        child: ElevatedButton(
          onPressed: () => Get.back(),
          child: Text('Back to Home'),
        ),
      ),
    );
  }
}

4. Navigation

GetX provides a simple way to navigate without requiring a BuildContext.

Example

Navigate to a new page:

Get.to(NextPage());

Navigate back to the previous page:

Get.back();

Navigate and remove all previous routes:

Get.offAll(NextPage());

5. Localization

GetX makes it easy to handle localization in your app.

Example

Define your translations:

import 'package:get/get.dart';

class Messages extends Translations {
  @override
  Map<String, Map<String, String>> get keys => {
        'en_US': {
          'hello': 'Hello',
        },
        'es_ES': {
          'hello': 'Hola',
        },
      };
}

Initialize localization in main.dart:

void main() {
  runApp(GetMaterialApp(
    translations: Messages(),
    locale: Locale('en', 'US'),
    fallbackLocale: Locale('en', 'US'),
    home: HomePage(),
  ));
}

Use translations in your widgets:

import 'package:flutter/material.dart';
import 'package:get/get.dart';

class HomePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Localization Example')),
      body: Center(
        child: Text('hello'.tr),
      ),
    );
  }
}

6. Dialogs and Bottom Sheets

GetX provides easy methods to show dialogs and bottom sheets.

Example

Show a dialog:

Get.defaultDialog(
  title: 'Dialog Title',
  middleText: 'Dialog content goes here',
  textConfirm: 'Confirm',
  textCancel: 'Cancel',
  onConfirm: () => print('Confirmed'),
  onCancel: () => print('Canceled'),
);

Show a bottom sheet:

Get.bottomSheet(
  Container(
    color: Colors.white,
    child: Wrap(
      children: <Widget>[
        ListTile(
          leading: Icon(Icons.music_note),
          title: Text('Music'),
          onTap: () => {},
        ),
        ListTile(
          leading: Icon(Icons.videocam),
          title: Text('Video'),
          onTap: () => {},
        ),
      ],
    ),
  ),
);

Conclusion

GetX is a versatile and efficient solution for Flutter applications. It streamlines state management, route management, navigation, localization, and dialogs/bottom sheets, allowing developers to focus on building high-quality apps with less boilerplate code. By following the examples provided, you can quickly integrate GetX into your Flutter projects and take advantage of its powerful features.

Flutter Getx Clean Architecture

Ahmad Darwish — Sat, 16 Sep 2023 12:53:25 +0000

Flutter has established itself as a premier framework for developing cross-platform mobile applications. However, as applications grow in complexity, managing code becomes a significant challenge. Clean architecture is a software design pattern that addresses this challenge by promoting code separation into distinct layers, facilitating maintainability and scalability. In this article, we'll delve into the practical implementation of clean architecture in Flutter using the GetX library, a potent state management and dependency injection tool.

Understanding Clean Architecture

Clean architecture revolves around separating code into layers, each with a distinct responsibility. The primary layers include:

Presentation Layer: This layer concerns itself with the user interface and interactions. It includes widgets, views, and controllers responsible for user input and data display.
Application Layer: The application layer contains the application's core business logic. It serves as an intermediary between the presentation and domain layers, coordinating data flow and enforcing business rules.
Domain Layer: The domain layer defines the fundamental business logic and domain models of the application. It remains independent of specific UI frameworks or databases, ensuring high reusability and testability.
Data Layer: This layer manages data storage, retrieval, and interactions with external APIs. It encompasses repositories, data sources, and API clients.

Implementing Clean Architecture with GetX

Let's break down how to structure your Flutter app using GetX and clean architecture principles, supported by real-world examples:

Presentation Layer:

Utilize GetX's GetView and GetController to construct UI components and controllers. For instance, to create a simple counter application:
```
 class CounterController extends GetxController {
   var count = 0.obs;
   void increment() => count++;
 }
```
Navigation is simplified using GetX's Get.to() and Get.off() methods, which offer intuitive routing capabilities:
```
 Get.to(AnotherScreen());
```
Achieve responsive UI updates using GetX's reactive state management:
```
 Obx(() => Text('Count: ${controller.count}'));
```

.
.

Application Layer:

Develop controllers for each feature or screen, housing the business logic. These controllers manage interactions between the presentation and domain layers. For example, in a to-do list application:
```
 class TodoListController extends GetxController {
   final _todos = <Todo>[].obs;

   void addTodo(String title) {
     _todos.add(Todo(title));
   }
 }
```

Leverage GetX's dependency injection to supply controllers with necessary dependencies, like repositories or data sources:

 class TodoListBinding implements Bindings {
   @override
   void dependencies() {
     Get.lazyPut(() => TodoListController());
   }
 }

Implement use cases in the application layer to execute business operations, such as fetching data, processing it, and updating the UI:

 class FetchTodosUseCase {
   final TodoRepository _repository;

   FetchTodosUseCase(this._repository);

   Future<List<Todo>> execute() async {
     return await _repository.fetchTodos();
   }
 }

.
.

Domain Layer:

Define domain models to represent the core data structures. These models should remain independent of the presentation and data layers. In our to-do list example:
```
 class Todo {
   final String title;
   final bool completed;

   Todo(this.title, {this.completed = false});
 }
```

Create interfaces or abstract classes for repositories, specifying methods for data retrieval and manipulation:

 abstract class TodoRepository {
   Future<List<Todo>> fetchTodos();
   Future<void> addTodo(Todo todo);
 }

.
.

Data Layer:

Implement data sources that interact with external APIs, databases, or local storage. For instance, fetching todos from an API:

 class ApiTodoDataSource {
   Future<List<Todo>> fetchTodos() async {
     // Fetch data from API
   }
 }

Develop repositories that encapsulate data retrieval and caching logic, implementing the interfaces defined in the domain layer:

 class TodoRepositoryImpl implements TodoRepository {
   final ApiTodoDataSource _dataSource;

   TodoRepositoryImpl(this._dataSource);

   @override
   Future<List<Todo>> fetchTodos() async {
     return await _dataSource.fetchTodos();
   }
   // ...
 }

.
.

Benefits of Using GetX Clean Architecture

Modularity: Clean architecture with GetX enables your codebase to be organized into discrete modules, promoting code clarity and maintainability.
Testability: The separation of concerns inherent to clean architecture facilitates unit testing. GetX's reactive state management simplifies testing UI components.
Scalability: As your app grows, clean architecture allows you to add new features and modules without tightly coupling them to existing code, promoting scalability.
Reusability: The separation of concerns also enhances code reusability, enabling you to reuse domain models and use cases across different parts of your app or in future projects.

Conclusion

Combining Flutter, GetX, and clean architecture principles provides a robust foundation for building maintainable and efficient mobile applications. By segmenting your code into distinct layers and utilizing GetX's state management, navigation, and dependency injection features, you can develop Flutter apps that are visually appealing and easy to maintain, scale, and test. Embracing clean architecture and GetX will result in more structured and sustainable Flutter projects, saving you time and effort as your app evolves and expands.

Setting Up Dynamic Links in Flutter: A Quick Detailed Guide

Ahmad Darwish — Sat, 22 Apr 2023 08:20:13 +0000

Dynamic links are a powerful tool for mobile app developers to drive user engagement and retention. With dynamic links, you can create links that deep-link directly to specific content within your app, even if the user doesn't have the app installed yet. In this article, we'll show you how to set up dynamic links in Flutter.

Step 1: Set up Firebase

The first step in setting up dynamic links in Flutter is to set up Firebase. Firebase is a mobile and web application development platform that provides a variety of tools and services to help you build high-quality apps. To set up Firebase, follow these steps:

Go to the Firebase Console and sign in with your Google account.
Click on "Add project" and enter a name for your project.
Follow the prompts to set up your project.

Once you've set up your Firebase project, you'll need to add the Firebase SDK to your Flutter project.

Step 2: Add the Firebase SDK to your Flutter project

To add the Firebase SDK to your Flutter project, follow these steps:

Open your Flutter project in Android Studio or Visual Studio Code.
Open the pubspec.yaml file and add the following dependencies:

dependencies:
  firebase_core: ^1.0.0
  firebase_dynamic_links: ^2.0.0

Run flutter pub get to install the dependencies.

Step 3: Create a dynamic link

To create a dynamic link, follow these steps:

Open the Firebase Console and select your project.
Click on "Dynamic Links" in the left-hand menu.
Click on "Get Started" and follow the prompts to create a new dynamic link.

When creating a dynamic link, you'll need to specify the following:

The link URL: This is the URL that the user will be directed to when they click on the dynamic link.
The iOS and Android package names: These are the package names for your app on iOS and Android.
The link behavior: This determines what happens when the user clicks on the dynamic link. You can choose to open the link in your app, on the web, or in another app.

Step 4: Handle the dynamic link in your Flutter app

To handle the dynamic link in your Flutter app, follow these steps:

Add the following code to your main.dart file:

import 'package:firebase_dynamic_links/firebase_dynamic_links.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await Firebase.initializeApp();
  handleDynamicLinks();
  runApp(MyApp());
}

void handleDynamicLinks() async {
  FirebaseDynamicLinks.instance.onLink(
    onSuccess: (PendingDynamicLinkData dynamicLink) async {
      final Uri deepLink = dynamicLink?.link;
      // Handle the deep link here.
    },
    onError: (OnLinkErrorException e) async {
      print('onLinkError');
      print(e.message);
    }
  );
  final PendingDynamicLinkData data = await FirebaseDynamicLinks.instance.getInitialLink();
  final Uri deepLink = data?.link;
  // Handle the deep link here.
}

In the onSuccess callback, you can handle the deep link by extracting the relevant data from the Uri object.
In the onError callback, you can handle any errors that occur when processing the dynamic link.
In the getInitialLink method, you can retrieve the initial dynamic link that launched the app.

And that's it! With these steps, you can set up dynamic links in your Flutter app and drive user engagement and retention.

Comparing GoLang and Python, Which is the Best Choice for Your Project

Ahmad Darwish — Fri, 21 Apr 2023 21:14:27 +0000

Comparing programming languages can be a difficult task as each language has its own unique strengths and weaknesses. In this article, we'll compare two popular programming languages, Go and Python, and explore their similarities and differences to help you choose the best language for your project.

Overview

Go is a statically-typed, compiled language developed by Google in 2009. It was designed to be fast, efficient, and easy to read and write, with a focus on concurrency and simplicity. Go is commonly used for building network and system tools, web servers, and other high-performance applications.

Python, on the other hand, is an interpreted language first released in 1991. It is dynamically-typed, meaning that data types are inferred at runtime, and is known for its readability and ease of use. Python is widely used for web development, scientific computing, machine learning, and other applications.

Syntax

Go: C-like syntax with curly braces and semicolons; requires explicit variable declarations and type annotations.
Python: Uses whitespace indentation to delimit code blocks; does not require variable declarations or type annotations.

Here's an example of a "Hello, World!" program in Go:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

And here's the same program in Python:

print("Hello, World!")

As you can see, Python code is generally more concise and easier to read, while Go code may be more verbose but also more explicit and easier to maintain.

Performance

Go: Compiled language optimized for speed and efficiency; ideal for building high-performance applications.
Python: Interpreted language executed at runtime; may have slower performance; has a large ecosystem of libraries and frameworks to improve performance.

Concurrency

Go: Supports concurrency with "goroutines" that allow for efficient and scalable concurrent applications.
Python: Supports concurrency through libraries such as asyncio and multiprocessing, but may require more effort to write efficient concurrent code.

Community

Go: Young community growing quickly; strong focus on performance, reliability, and simplicity.
Python: Large and mature community with a vast ecosystem of libraries and tools; emphasis on code readability and maintainability.

Choosing between Go and Python ultimately depends on your project's specific requirements and goals. Go is an excellent choice for building high-performance, concurrent applications, while Python is well-suited for scientific computing, web development, and other applications that require ease of use and readability.

Both languages have their own unique strengths and weaknesses, and both have active and supportive communities of developers. Ultimately, the best language for your project is the one that meets your specific needs and helps you achieve your goals.

Detect Root And Jailbreak In Flutter App

Ahmad Darwish — Fri, 21 Apr 2023 21:05:03 +0000

You can detect root access on Android devices by checking for the presence of certain files or binaries that are typically only accessible with root privileges, while detecting jailbreak on iOS devices involves checking for the presence of certain files or system configurations that are typically modified during the jailbreaking process. One way to perform these checks is by using the flutter_device_info package.

1- Add the flutter_device_info package to your project by adding it to your pubspec.yaml file and running flutter pub get.

2- Import the package in your code:

import 'package:flutter_device_info/flutter_device_info.dart';

3- Create an instance of the FlutterDeviceInfo class:

FlutterDeviceInfo flutterDeviceInfo = FlutterDeviceInfo();

To determine whether a device is rooted, you can use the isRooted method:

bool isDeviceRooted = await flutterDeviceInfo.isRooted;

The isRooted method returns a boolean value indicating whether the device is rooted. If the device is rooted, the method will return true; otherwise, it will return false.

For iOS devices, you can check if it's jailbroken by calling the isJailBroken method:

bool isDeviceJailbroken = await flutterDeviceInfo.isJailBroken;

The isJailBroken method returns a boolean value indicating whether the device is jailbroken. If the device is jailbroken, the method will return true; otherwise, it will return false.

It's important to note that detecting jailbreak on iOS devices or root access on other devices is not a foolproof method of determining whether a device has been modified, as there are ways to hide these modifications from detection. Furthermore, detecting such modifications may not be necessary or appropriate for all apps, and may potentially violate platform policies or user privacy. Therefore, before attempting to detect jailbreak or root access, it's important to carefully consider the potential risks and benefits.

Bito the AI plugin and How to add it to JetBrains IDEs

Ahmad Darwish — Sun, 26 Mar 2023 13:15:08 +0000

Bito is a powerful AI plugin that helps developers write code, explain code, create tests, and more using ChatGPT. Bito integrates with JetBrains IDEs such as IntelliJ IDEA, Android Studio, PyCharm, and others, and allows you to access ChatGPT’s models without having an OpenAI key. Bito can save you an hour a day by accelerating your coding tasks and providing you with helpful insights.

In this article, we will show you how to install Bito on your JetBrains IDE and how to use its features to boost your productivity and creativity.

How to install Bito on Jetbrains IDEs
Installing Bito on your JetBrains IDE is very easy and takes less than two minutes. Here are the steps:

Open your JetBrains IDE and go to Settings > Plugins.
Search for Bito in the Marketplace tab and click Install.
Restart your IDE to activate the plugin.
You will see a Bito icon on the right side of your editor. Click on it to open the Bito panel.
If you are the first user for your organization, Bito will ask you to create a workspace. You can set it so that everyone with the same domain can automatically join or you can add teammates to your workspace to collaborate. Bito works best when you have a few teammates to collaborate with.
Alternatively, you can access the Bito extension directly from the
JetBrains marketplace at: https://plugins.jetbrains.com/plugin/18289-bito--chatgpt-to-write-code-explain-code-create-tests

How to use Bito on Jetbrains IDEs
Once you have installed Bito on your JetBrains IDE, you can start using its features to enhance your coding experience. Here are some of the things you can do with Bito:

Ask any technical question: You can type any question related to programming languages, frameworks, libraries, algorithms, data structures, etc. and Bito will try to answer it using ChatGPT. For example, you can ask “how to implement a binary search tree in Python” or “what is the difference between abstract classes and interfaces in Java”.

Generate code: You can ask Bito to generate code for you based on your specifications. For example, you can ask “code in Java to convert a number from one base to another” or “code to implement a simple REST API in Go”. Bito will show you the generated code in a diff view against your existing code, and you can choose which lines or sections you want to integrate.

Explain code: You can ask Bito to explain code that you are unfamiliar with or want to learn more about. For example, you can ask “explain this code < insert code >” or “explain how this function works”. Bito will give you a detailed summary of the code’s logic, purpose, inputs, outputs, and potential errors.

Comment code: You can ask Bito to comment code for you based on best practices and standards. For example, you can ask “comment this method < insert method >” or “comment this class < insert class >”. Bito will generate comments for the method or class and its parameters, return values, exceptions, etc.

Create tests: You can ask Bito to create test cases for your code based on different scenarios and edge cases. For example, you can ask “generate test cases for this code < insert code >” or “generate test cases for this function < insert function >”. Bito will generate test cases in the same language as your code and show them in a diff view against your existing tests.

Bito also provides one-click shortcuts for some of these features so that you don’t have to type anything. For example, you can select some code and click on the Explain Code button in the Bito panel to get an explanation of that code.

Bito also allows you to share your results with your colleagues via Slack or email. You can also access your history of queries and results in the Bito panel.

Conclusion
Bito is an innovative AI plugin that brings ChatGPT to your Jetbrains IDEs and helps you write code faster, better, and easier. It can answer your technical questions, generate code for you, explain code for you, comment code for you, create tests for you, and more. It also lets you collaborate with your teammates and share your results with them.

Handling HTTP Requests with DIO and Refresh Tokens in Flutter

Ahmad Darwish — Sun, 26 Mar 2023 13:00:12 +0000

In this article, we'll demonstrate how to use the DIO package to make GET and POST requests in a Flutter application, while leveraging refresh tokens to maintain a persistent user session. We'll cover the following topics:

Setting up DIO
Creating a DIO instance with interceptors
Making GET and POST requests
Implementing automatic token refresh with DIO interceptors

1. Setting up DIO
First, add the DIO package to your pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  dio: ^4.0.0

Then, run flutter packages get to install the package.

2. Creating a DIO instance with interceptors
To create a DIO instance with interceptors, first import the DIO package:
import 'package:dio/dio.dart';

Then, create a DIO instance with a default configuration:

Dio dio = Dio(
  BaseOptions(
    baseUrl: 'https://your-api-url.com',
    connectTimeout: 5000,
    receiveTimeout: 3000,
  ),
);

3. Making GET and POST requests
Now that we have a DIO instance, we can use it to make GET and POST requests. Here's an example of making a GET request:

Future<void> fetchData() async {
  try {
    Response response = await dio.get('/path/to/your/endpoint');
    print(response.data);
  } on DioError catch (e) {
    print(e.message);
  }
}

To make a POST request, we can use the post method as shown below:

Future<void> postData() async {
  try {
    Response response = await dio.post(
      '/path/to/your/endpoint',
      data: {'key': 'value'},
    );
    print(response.data);
  } on DioError catch (e) {
    print(e.message);
  }
}

4. Implementing automatic token refresh with DIO interceptors
To implement automatic token refresh, we'll add an interceptor to the DIO instance. This interceptor will handle token refresh logic whenever it detects a 401 (Unauthorized) response from the server.

First, create a function to refresh the access token:

Future<String> refreshToken() async {
  // Perform a request to the refresh token endpoint and return the new access token.
  // You can replace this with your own implementation.
  return 'your_new_access_token';
}

Next, add an interceptor to the DIO instance:

dio.interceptors.add(
  InterceptorsWrapper(
    onRequest: (options, handler) {
      // Add the access token to the request header
      options.headers['Authorization'] = 'Bearer your_access_token';
      return handler.next(options);
    },
    onError: (DioError e, handler) async {
      if (e.response?.statusCode == 401) {
        // If a 401 response is received, refresh the access token
        String newAccessToken = await refreshToken();

        // Update the request header with the new access token
        e.requestOptions.headers['Authorization'] = 'Bearer $newAccessToken';

        // Repeat the request with the updated header
        return handler.resolve(await dio.fetch(e.requestOptions));
      }
      return handler.next(e);
    },
  ),
);

With this interceptor in place, your application will automatically refresh the access token and retry requests whenever a 401 response is received.

That's it! You've now implemented a DIO instance with interceptors for handling GET and POST requests, as well as automatic token refresh. This will help you maintain a persistent user session and improve the user experience in your Flutter application.

Flutter - securing http requests

Ahmad Darwish — Tue, 20 Apr 2021 04:43:12 +0000

In today's digital era, web security is of utmost importance. One of the most common attacks on web applications is the Cross-Site Request Forgery (CSRF) attack. This attack occurs when an attacker tricks the user's browser into sending a request to a web application without their knowledge or consent. To prevent CSRF attacks, it is essential to secure HTTP requests.

Flutter is a popular mobile app development framework that allows developers to build high-performance, cross-platform apps. It provides a rich set of tools and features to secure HTTP requests, including CSRF protection.

To secure HTTP requests in Flutter, developers can use the csrf package, which provides middleware to prevent CSRF attacks. The package generates a unique token for each user session and adds it to the HTTP request header. The server then verifies the token before processing the request.

To use the csrf package in Flutter, follow these steps:

Add the csrf package to your project dependencies in the pubspec.yaml file:

dependencies:
  csrf: ^1.0.0

Import the package in your code:

import 'package:csrf/csrf.dart';

Add the middleware to your HTTP requests:

final csrfToken = await getCsrfToken(); // Get the CSRF token
final response = await http.post(
  url,
  headers: {'X-CSRF-Token': csrfToken}, // Add the token to the HTTP request header
   body: {...},
);

On the server side, verify the token before processing the request:

function verifyCsrfToken(req, res, next) {
  const csrfToken = req.headers['x-csrf-token'];
  if (!csrfToken || csrfToken !== req.session.csrfToken) {
    return res.sendStatus(403);
  }
  next();
}

In the example above, the server verifies the token by comparing it to the token stored in the user's session. The server sends a 403 Forbidden response if the tokens do not match.

In conclusion, securing HTTP requests with CSRF protection is essential to prevent attacks on web applications. Flutter provides robust tools and features to secure HTTP requests, including the csrf package. By implementing these security measures, developers can ensure that their mobile apps are protected from CSRF attacks and provide a secure user experience.

Forem: Ahmad Darwish

Comprehensive Guide to Using GetX in Flutter

Table of Contents

1. Introduction to GetX

Installation

2. State Management

Example

3. Route Management

Example

4. Navigation

Example

5. Localization

Example

6. Dialogs and Bottom Sheets

Example

Conclusion

Flutter Getx Clean Architecture

Setting Up Dynamic Links in Flutter: A Quick Detailed Guide

Comparing GoLang and Python, Which is the Best Choice for Your Project

Overview

Syntax

Performance

Concurrency

Community

Detect Root And Jailbreak In Flutter App

Bito the AI plugin and How to add it to JetBrains IDEs

Handling HTTP Requests with DIO and Refresh Tokens in Flutter

Flutter - securing http requests