graph TD
    A[User] -->|User interacting with View| B[View]
    B -->|Request Process| C[Controller]
    C -->|Asking Model to provide Data| D[Model]
    D -->|Asking Data from DB| E[(Database)]
    E -->|Response from DB| D
    D -->|Returning the Data| C
    C -->|Rendering the content| B
    B -.-> A

    %% Color and style enhancements
    style A fill:#f9c1c1,stroke:#333,stroke-width:2px
    style B fill:#ffff99,stroke:#333,stroke-width:2px
    style C fill:#d9f9a1,stroke:#333,stroke-width:2px
    style D fill:#a1c1f9,stroke:#333,stroke-width:2px
    style E fill:#ff9999,stroke:#333,stroke-width:2px

    %% Separating User and Database
    subgraph User Interaction
        A
        B
    end

    subgraph Backend
        C
        D
        E
    end

• App Module: The main module containing your app’s source code, resources, and app-level settings like the AndroidManifest.xml and build.gradle files. When you create a new project, the default app module is named “app”
• Library Module: (Project View Mode): External Libraries Contains reusable code that can be used as a dependency in other app modules or projects. It generates an Android Archive (AAR) file

• Project Files:

  • build.gradle: The root build file containing plugin declarations and common configurations for all subprojects.
  • settings.gradle: Contains global build information, including project names and subprojects to include.
  • local.properties: Contains properties related to the local machine, such as the Android SDK location (excluded from source control), you may also add your api keys here.

• Directory Structure:

  • src/main/AndroidManifest.xml: Declares essential information about your app, including components and permissions.
  • src/main/java: Contains the Java or Kotlin source code for your app.
  • src/main/res: Contains resource files like layouts, drawables, and strings.

[FR] \\

• Module App : Le module principal contenant le code source, les ressources et les paramètres de l'application (AndroidManifest.xml, build.gradle).
• Module Bibliothèque : (Mode Vue Projet) Contient du code réutilisable sous forme de fichier AAR.

• Fichiers du Projet :

  • build.gradle, settings.gradle, local.properties.

• Structure des Dossiers :

  • src/main/AndroidManifest.xml
  • src/main/java
  • src/main/res

For more detailed information, please refer to the original documentation.

• Activities: Activities represent a single screen with a user interface. They are the entry point for interacting with the user. Fragments have their own lifecycle, which is closely tied to the lifecycle of the host activity. This allows for better control over the UI components and their state management.

[FR] \\

• Activités : Les activités représentent une seule interface utilisateur et sont le point d'entrée pour interagir avec l'utilisateur. Les fragments ont leur propre cycle de vie, étroitement lié à celui de l'activité hôte, ce qui permet un meilleur contrôle des composants UI et de leur gestion d'état.

For more details, you can refer to the original documentation or a guide on Android architecture.

public class MainActivity extends AppCompatActivity {
  // Code for the activity
}
Fragments: Fragments introduce modularity into your app’s UI by letting you divide the UI into discrete chunks. This makes it easier to manage and reuse components across different parts of your app.

• Fragments: Fragments introduce modularity into your app’s UI by letting you divide the UI into discrete chunks. This makes it easier to manage and reuse components across different parts of your app.

[FR] \\

• Fragments: : Les fragments introduisent la modularité dans l'interface utilisateur de votre application en vous permettant de diviser l'interface en blocs distincts. Cela facilite la gestion et la réutilisation des composants dans différentes parties de l'application.

FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
transaction.replace(R.id.fragment_container, new ExampleFragment());
transaction.addToBackStack(null);
transaction.commit();

• Services: Services run in the background to perform long-running operations or to perform work for remote processes. Example: A music player app might use a service to play music in the background while the user is in a different app

[FR] \\

• Services : Les services s'exécutent en arrière-plan pour effectuer des opérations de longue durée ou des tâches pour des processus distants. Exemple : Une application de lecteur de musique peut utiliser un service pour jouer de la musique en arrière-plan pendant que l'utilisateur utilise une autre application.

public class MusicService extends Service {
  // Code for the service
}

• Content Providers: Content providers manage access to a structured set of data. They encapsulate the data and provide mechanisms for defining data security. In short, a Content Provider is Andoid's way of allowing apps to share their data with other apps Example: An app that stores user contacts might use a content provider to manage contact data.

[FR] \\

• Content Providers : Les content providers gèrent l'accès à un ensemble structuré de données. Ils encapsulent les données et fournissent des mécanismes pour définir la sécurité des données. En résumé, un Content Provider permet aux applications Android de partager leurs données avec d'autres applications. Exemple : Une application qui stocke les contacts d'un utilisateur peut utiliser un content provider pour gérer ces données de contact.

public class ContactsProvider extends ContentProvider {
  // Code for the provider
}

• Broadcast Receivers: Broadcast receivers respond to system-wide broadcast announcements. They enable the app to listen for specific broadcast messages from the system or other apps. Example: An app might use a broadcast receiver to detect when the device low battery.

[FR] \\

• Broadcast Receivers : Les broadcast receivers réagissent aux annonces système globales. Ils permettent à l'application d'écouter des messages spécifiques du système ou d'autres applications. Exemple : Une application peut utiliser un broadcast receiver pour détecter lorsque la batterie de l'appareil est faible.

batteryLevel = new BatteryLevel();
mContext.registerReceiver(batteryLevel, new IntentFilter(Intent.ACTION_BATTERY_LOW));

• Intents: Intents are messaging objects used to request an action from another app component. They facilitate communication between different components. Example: An intent can be used to start a new activity or to send a broadcast.

[FR] \\

• Intents : Les intents sont des objets de messagerie utilisés pour demander une action à un autre composant de l'application. Ils facilitent la communication entre différents composants. Exemple : Un intent peut être utilisé pour démarrer une nouvelle activité ou envoyer une diffusion (broadcast).

Intent intent = new Intent(this, NewActivity.class);
startActivity(intent);

• Layouts: Layouts are containers that hold and arrange views in a specific manner. They define the structure and positioning of the UI components Common Layouts:

  • LinearLayout: Arranges views in a single row or column.
  • RelativeLayout: Positions views relative to each other or the parent container.
  • ConstraintLayout: A flexible layout that allows you to create complex layouts with a flat view hierarchy.
  • FrameLayout: A simple layout that stacks views on top of each other.
  • GridLayout: Arranges views in a grid format.
  • Layout Editor: Use the Layout Editor in Android Studio to visually design your UI. Drag and drop UI components from the palette, and configure their properties using the attributes panel

• Views: Views are the basic building blocks of an Android user interface. They represent the UI components that users interact with, such as buttons, text fields, images, and more1. Common Views:

  • TextView: Displays text to the user.
  • Button: A clickable button.
  • ImageView: Displays an image.
  • EditText: A text field for user input.
  • ListViews
  • RecyclerView: A flexible view for displaying large data sets in a scrollable list.
  • ListViews and Adapters: ListViews are android elements used to display items in a list. Adapters are used to bind an array of data to a ListView. It is a simple adapter that can handle a single list of items.

[FR] \\

• Layouts : Les layouts sont des conteneurs qui organisent et disposent les vues dans une interface utilisateur.

  • LinearLayout : Dispose les vues en une seule ligne ou colonne.
  • RelativeLayout : Positionne les vues les unes par rapport aux autres ou au conteneur parent.
  • ConstraintLayout : Permet des mises en page complexes.
  • FrameLayout : Empile les vues les unes sur les autres.
  • GridLayout : Organise les vues en grille.
• Views : Composants de base de l'interface utilisateur, comme
• TextView : Affiche du texte à l'utilisateur.
• Button : Un bouton cliquable.
• ImageView : Affiche une image.
• EditText : Un champ de texte pour la saisie de l'utilisateur.
• ListView : Affiche une liste d'éléments.
• RecyclerView : Vue flexible pour afficher de grandes séries de données dans une liste défilante.
• ListViews et Adapters : ListViews sont utilisés pour afficher des listes, et les Adapters lient les données à cette liste.

ArrayAdapter<String> adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, dataArray);
listView.setAdapter(adapter);

public class CustomAdapter extends BaseAdapter {
  // Implementation of custom adapter
}

• XML Layouts: Designing with XML.

  
  xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical">
  
  
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello, World!" />
  
  
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Click Me" />
  

• Introduction to Material Design principles: Material Design is a design system developed by Google to create high-quality digital experiences across various platforms, including Android, iOS, Flutter, and the web. It is inspired by the physical world and its textures, incorporating principles from print design to create a cohesive and immersive user experience12. Using Material design

  • Add Material Components to your project: Open your build.gradle file and add the following dependency:

[FR]
Introduction aux principes du Material Design : Material Design est un système de conception développé par Google pour créer des expériences numériques de haute qualité sur Android, iOS, Flutter et le web. Inspiré du monde physique et des textures, il incorpore des principes du design imprimé pour offrir une expérience utilisateur immersive.

• Ajouter des composants Material à votre projet : Ouvrez votre fichier `build.gradle` et ajoutez la dépendance suivante :

implementation 'com.google.android.material:material:1.4.0'

Update your app theme:

 name="AppTheme" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
    
     name="colorPrimary">@color/primary
     name="colorPrimaryVariant">@color/primaryVariant
     name="colorOnPrimary">@color/onPrimary
     name="colorSecondary">@color/secondary

Use Material Components in your layouts. Example material button

    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Material Button" />

Handling User inputs: Example Button.

XML

    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Material Button" />

JAVA

MaterialButton button = findViewById(R.id.materialButton);
button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        // Handle button click
    }
});

Working with Data

• Managing data using SharedPreferences: SharedPreferences is a simple way to store small amounts of data as key-value pairs. [FR] \\

• Gérer les données avec SharedPreferences : SharedPreferences est un moyen simple de stocker de petites quantités de données sous forme de paires clé-valeur. Cela permet de sauvegarder des préférences d'utilisateur ou des paramètres de l'application de manière persistante.

  Get a SharedPreferences instance: - Obtenir une instance de SharedPreferences

  SharedPreferences sharedPreferences = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE);

  Save data to SharedPreferences: - Enregistrer des données dans SharedPreferences

  SharedPreferences.Editor editor = sharedPreferences.edit();
  editor.putString("key", "value");
  editor.apply();

  Retrieve data from SharedPreferences: - Récupérer des données depuis SharedPreferences :

  String value = sharedPreferences.getString("key", "default_value");

• Basics of Networking in Android (Using REST APIs) - Principes de base du réseau sous Android (utilisation des API REST)

• Android permission Intro

  <uses-permission android:name="android.permission.INTERNET" />

• Retrofit
• OkHttp3 Using OkHttp3: add the OkHttp3 dependency to your build.gradle file:

  implementation 'com.squareup.okhttp3:okhttp:4.9.1'

Make Network Requests You can make both synchronous and asynchronous network requests using OkHttp3. Here’s an example of how to perform a GET request:

synchronous Get Request

  OkHttpClient client = new OkHttpClient();
  Request request = new Request.Builder()
      .url("https://api.example.com/data")
      .build();

  try (Response response = client.newCall(request).execute()) {
      if (response.isSuccessful()) {
          String responseData = response.body().string();
          // Handle the response
      }
  } catch (IOException e) {
      e.printStackTrace();
  }

asynchronous Get Request

  OkHttpClient client = new OkHttpClient();
  Request request = new Request.Builder()
      .url("https://api.example.com/data")
      .build();

  client.newCall(request).enqueue(new Callback() {
      @Override
      public void onFailure(Call call, IOException e) {
          e.printStackTrace();
      }

      @Override
      public void onResponse(Call call, Response response) throws IOException {
          if (response.isSuccessful()) {
              String responseData = response.body().string();
              // Handle the response
          }
      }
  });

• onCreate()

Called when: The activity is first created. Purpose: Initialize the activity. This is where you should perform one-time setup procedures, such as creating the UI, initializing variables, and binding data to lists. Example:

[FR]
Appelée lorsque : L'activité est créée pour la première fois. But : Initialiser l'activité. C'est ici que vous devez effectuer les procédures de configuration uniques, telles que la création de l'interface utilisateur, l'initialisation des variables, et le binding des données aux listes. Exemple :

@Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     // Initialize components here
 }

• onStart()

Called when: The activity becomes visible to the user. Purpose: Prepare the activity to enter the foreground and become interactive. Example:

[FR]
Appelée lorsque : L'activité devient visible pour l'utilisateur. But : Préparer l'activité à entrer au premier plan et à devenir interactive. Exemple :

 @Override
 protected void onStart() {
     super.onStart();
     // Perform tasks to make the activity visible
 }

• onResume()

Called when: The activity starts interacting with the user. Purpose: Resume any paused UI updates, animations, or other ongoing actions.

[FR]
Appelée lorsque : L'activité commence à interagir avec l'utilisateur. But : Reprendre les mises à jour de l'interface utilisateur en pause, les animations ou d'autres actions en cours.

@Override
protected void onResume() {
        super.onResume();
        // Resume interactions with the user
}

• onDestroy()

Called when: The activity is about to be destroyed. Purpose: Clean up any resources, such as threads or database connections, that need to be released.

[FR]
Appelée lorsque : L'activité est sur le point d'être détruite. But : Nettoyer toutes les ressources, telles que les threads ou les connexions à la base de données, qui doivent être libérées.

@Override
protected void onDestroy() {
        super.onDestroy();
        // Clean up resources
}

public class Car {
        // Fields
        private String color;
        private String model;

        // Constructor
        public Car(String color, String model) {
            this.color = color;
            this.model = model;
        }

        // Methods
        public void displayInfo() {
            System.out.println("Car model: " + model + ", Color: " + color);
        }
    }

    Car myCar = new Car("Red", "Toyota");
    myCar.displayInfo(); // Output: Car model: Toyota, Color: Red

      public class Calculator {
          // Method to add two numbers
          public int add(int a, int b) {
              return a + b;
          }

          // Method to subtract two numbers
          public int subtract(int a, int b) {
              return a - b;
          }
      }

public interface MyInterface {
        void myMethod();
    }

public class MyClass implements MyInterface {
        @Override
        public void myMethod() {
            // Implementation of myMethod
        }
    }