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

• ऐप मॉड्यूल: मुख्य मॉड्यूल जिसमें आपके ऐप का सोर्स कोड, संसाधन और ऐप-स्तरीय सेटिंग्स जैसे AndroidManifest.xml और build.gradle फाइलें होती हैं। जब आप एक नया प्रोजेक्ट बनाते हैं, तो डिफ़ॉल्ट ऐप मॉड्यूल का नाम "app" होता है।
• लाइब्रेरी मॉड्यूल: (प्रोजेक्ट व्यू मोड): बाहरी लाइब्रेरीज़ में पुन: प्रयोज्य कोड होता है जिसे अन्य ऐप मॉड्यूल या प्रोजेक्ट्स में निर्भरता (dependency) के रूप में उपयोग किया जा सकता है। यह एक एंड्रॉइड आर्काइव (AAR) फाइल उत्पन्न करता है।

• प्रोजेक्ट फाइलें:

  • build.gradle: रूट बिल्ड फाइल जिसमें प्लगइन घोषणाएं और सभी सब-प्रोजेक्ट्स के लिए सामान्य कॉन्फ़िगरेशन होते हैं।
  • settings.gradle: वैश्विक बिल्ड जानकारी शामिल है, जिसमें प्रोजेक्ट के नाम और शामिल किए जाने वाले सब-प्रोजेक्ट्स शामिल हैं।
  • local.properties: स्थानीय मशीन से संबंधित गुण शामिल हैं, जैसे एंड्रॉइड SDK स्थान (सोर्स कंट्रोल से बाहर रखा गया है), आप यहां अपनी API कुंजियाँ भी जोड़ सकते हैं।

• निर्देशिका संरचना:

  • src/main/AndroidManifest.xml: आपके ऐप के बारे में आवश्यक जानकारी घोषित करता है, जिसमें घटक और अनुमतियाँ शामिल हैं।
  • src/main/java: आपके ऐप के लिए जावा या कोटलिन सोर्स कोड शामिल है।
  • src/main/res: लेआउट, ड्रॉएबल्स और स्ट्रिंग्स जैसी संसाधन फाइलें शामिल हैं।

[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

अधिक विस्तृत जानकारी के लिए, कृपया मूल दस्तावेज़ देखें।

• एक्टिविटीज़ (Activities): एक्टिविटीज़ एक यूजर इंटरफेस के साथ एक एकल स्क्रीन का प्रतिनिधित्व करती हैं। वे उपयोगकर्ता के साथ बातचीत करने के लिए प्रवेश बिंदु हैं। फ्रैगमेंट का अपना जीवनचक्र (lifecycle) होता है, जो होस्ट एक्टिविटी के जीवनचक्र से निकटता से जुड़ा होता है। यह UI घटकों और उनकी स्थिति प्रबंधन पर बेहतर नियंत्रण की अनुमति देता है।

[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.

अधिक विवरण के लिए, आप मूल दस्तावेज़ या एंड्रॉइड आर्किटेक्चर पर एक गाइड देख सकते हैं।

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): फ्रैगमेंट आपके ऐप के UI में मॉड्यूलरिटी लाते हैं, जिससे आप UI को अलग-अलग हिस्सों में विभाजित कर सकते हैं। इससे आपके ऐप के विभिन्न हिस्सों में घटकों को प्रबंधित करना और उनका पुन: उपयोग करना आसान हो जाता है।

[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): सर्विसेज लंबे समय तक चलने वाले ऑपरेशन करने या रिमोट प्रक्रियाओं के लिए काम करने के लिए बैकग्राउंड में चलती हैं। उदाहरण: एक म्यूजिक प्लेयर ऐप बैकग्राउंड में संगीत चलाने के लिए एक सर्विस का उपयोग कर सकता है जबकि उपयोगकर्ता किसी अन्य ऐप में है।

[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): कंटेंट प्रोवाइडर्स डेटा के एक संरचित सेट तक पहुंच का प्रबंधन करते हैं। वे डेटा को एनकैप्सुलेट करते हैं और डेटा सुरक्षा को परिभाषित करने के लिए तंत्र प्रदान करते हैं। संक्षेप में, एक कंटेंट प्रोवाइडर एंड्रॉइड का तरीका है जिससे ऐप्स अपना डेटा अन्य ऐप्स के साथ साझा कर सकते हैं। उदाहरण: एक ऐप जो उपयोगकर्ता के संपर्क संग्रहीत करता है, संपर्क डेटा को प्रबंधित करने के लिए एक कंटेंट प्रोवाइडर का उपयोग कर सकता है।

[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): ब्रॉडकास्ट रिसीवर्स सिस्टम-व्यापी प्रसारण घोषणाओं का जवाब देते हैं। वे ऐप को सिस्टम या अन्य ऐप्स से विशिष्ट प्रसारण संदेशों को सुनने में सक्षम बनाते हैं। उदाहरण: एक ऐप डिवाइस की बैटरी कम होने पर पता लगाने के लिए ब्रॉडकास्ट रिसीवर का उपयोग कर सकता है।

[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): इंटेंट्स मैसेजिंग ऑब्जेक्ट्स हैं जिनका उपयोग किसी अन्य ऐप घटक से कार्रवाई का अनुरोध करने के लिए किया जाता है। वे विभिन्न घटकों के बीच संचार की सुविधा प्रदान करते हैं। उदाहरण: एक इंटेंट का उपयोग एक नई एक्टिविटी शुरू करने या प्रसारण भेजने के लिए किया जा सकता है।

[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): लेआउट्स ऐसे कंटेनर हैं जो व्यूज़ को एक विशिष्ट तरीके से रखते और व्यवस्थित करते हैं। वे UI घटकों की संरचना और स्थिति को परिभाषित करते हैं। सामान्य लेआउट्स:

  • LinearLayout: व्यूज़ को एक पंक्ति या कॉलम में व्यवस्थित करता है।
  • RelativeLayout: व्यूज़ को एक-दूसरे या पैरेंट कंटेनर के सापेक्ष स्थित करता है।
  • ConstraintLayout: एक लचीला लेआउट जो आपको एक फ्लैट व्यू पदानुक्रम के साथ जटिल लेआउट बनाने की अनुमति देता है।
  • FrameLayout: एक सरल लेआउट जो व्यूज़ को एक-दूसरे के ऊपर रखता है।
  • GridLayout: व्यूज़ को ग्रिड प्रारूप में व्यवस्थित करता है।
  • लेआउट एडिटर: अपने UI को नेत्रहीन रूप से डिजाइन करने के लिए एंड्रॉइड स्टूडियो में लेआउट एडिटर का उपयोग करें। पैलेट से UI घटकों को ड्रैग और ड्रॉप करें, और एट्रिब्यूट्स पैनल का उपयोग करके उनके गुणों को कॉन्फ़िगर करें।

• व्यूज़ (Views): व्यूज़ एंड्रॉइड यूजर इंटरफेस के बुनियादी निर्माण खंड हैं। वे उन UI घटकों का प्रतिनिधित्व करते हैं जिनके साथ उपयोगकर्ता इंटरैक्ट करते हैं, जैसे बटन, टेक्स्ट फील्ड, चित्र, और बहुत कुछ। सामान्य व्यूज़:

  • TextView: उपयोगकर्ता को टेक्स्ट प्रदर्शित करता है।
  • Button: एक क्लिक करने योग्य बटन।
  • ImageView: एक छवि प्रदर्शित करता है।
  • EditText: उपयोगकर्ता इनपुट के लिए एक टेक्स्ट फील्ड।
  • ListViews
  • RecyclerView: स्क्रॉल करने योग्य सूची में बड़े डेटा सेट प्रदर्शित करने के लिए एक लचीला व्यू।
  • ListViews और Adapters: ListViews एंड्रॉइड तत्व हैं जिनका उपयोग सूची में आइटम प्रदर्शित करने के लिए किया जाता है। एडेप्टर का उपयोग डेटा की एक सरणी को ListView से बांधने के लिए किया जाता है। यह एक सरल एडेप्टर है जो आइटम की एक एकल सूची को संभाल सकता है।

[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 लेआउट्स: 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" />
  

• मटेरियल डिजाइन सिद्धांतों का परिचय: मटेरियल डिजाइन गूगल द्वारा विकसित एक डिजाइन प्रणाली है जिसका उपयोग एंड्रॉइड, आईओएस, फ्लटर और वेब सहित विभिन्न प्लेटफार्मों पर उच्च-गुणवत्ता वाले डिजिटल अनुभव बनाने के लिए किया जाता है। यह भौतिक दुनिया और इसकी बनावट से प्रेरित है, जो एक सुसंगत और इमर्सिव उपयोगकर्ता अनुभव बनाने के लिए प्रिंट डिजाइन के सिद्धांतों को शामिल करता है। मटेरियल डिजाइन का उपयोग करना

  • अपने प्रोजेक्ट में मटेरियल घटक जोड़ें: अपनी build.gradle फाइल खोलें और निम्नलिखित निर्भरता जोड़ें:

[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'

अपने ऐप थीम को अपडेट करें:

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

अपने लेआउट में मटेरियल घटकों का उपयोग करें। उदाहरण मटेरियल बटन

    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Material 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
    }
});

डेटा के साथ काम करना

• SharedPreferences का उपयोग करके डेटा प्रबंधित करना: SharedPreferences डेटा की छोटी मात्रा को की-वैल्यू पेयर के रूप में संग्रहीत करने का एक सरल तरीका है। [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.

  SharedPreferences इंस्टेंस प्राप्त करें:

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

  SharedPreferences में डेटा सहेजें:

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

  SharedPreferences से डेटा पुनर्प्राप्त करें:

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

• एंड्रॉइड में नेटवर्किंग की मूल बातें (REST API का उपयोग करना)

• एंड्रॉइड अनुमति परिचय

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

• रेट्रोफिट (Retrofit)
• OkHttp3 OkHttp3 का उपयोग करना: अपनी build.gradle फाइल में OkHttp3 निर्भरता जोड़ें:

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

नेटवर्क अनुरोध करें आप OkHttp3 का उपयोग करके सिंक्रोनस और एसिंक्रोनस दोनों नेटवर्क अनुरोध कर सकते हैं। GET अनुरोध करने का तरीका यहां दिया गया है:

सिंक्रोनस GET अनुरोध

  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();
  }

एसिंक्रोनस GET अनुरोध

  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()

कब कॉल किया जाता है: जब एक्टिविटी पहली बार बनाई जाती है। उद्देश्य: एक्टिविटी को इनिशियलाइज़ करना। यह वह जगह है जहां आपको एक बार की सेटअप प्रक्रियाएं करनी चाहिए, जैसे UI बनाना, वेरिएबल इनिशियलाइज़ करना, और सूचियों में डेटा बाइंड करना। उदाहरण:

[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()

कब कॉल किया जाता है: जब एक्टिविटी उपयोगकर्ता को दिखाई देने लगती है। उद्देश्य: एक्टिविटी को फोरग्राउंड में प्रवेश करने और इंटरैक्टिव बनने के लिए तैयार करना। उदाहरण:

[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()

कब कॉल किया जाता है: जब एक्टिविटी उपयोगकर्ता के साथ इंटरैक्ट करना शुरू करती है। उद्देश्य: किसी भी रुके हुए UI अपडेट, एनिमेशन या अन्य चल रहे कार्यों को फिर से शुरू करना।

[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()

कब कॉल किया जाता है: जब एक्टिविटी नष्ट होने वाली होती है। उद्देश्य: किसी भी संसाधन, जैसे थ्रेड्स या डेटाबेस कनेक्शन, को साफ करना जिन्हें जारी करने की आवश्यकता है।

[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
        }
    }