diff --git a/Android_Development_With_Java/02.16 Migrate from ViewPager to ViewPager2.md b/Android_Development_With_Java/02.16 Migrate from ViewPager to ViewPager2.md
new file mode 100644
index 0000000000..1cd7bd23c1
--- /dev/null
+++ b/Android_Development_With_Java/02.16 Migrate from ViewPager to ViewPager2.md
@@ -0,0 +1,449 @@
+# Migrate from ViewPager to ViewPager2
+
+## What is ViewPager?
+
+ViewPager is a Layout manager that allows the user to flip left and right through pages of data.
+Basically, In simpler words, if you want to change the app screen without making an Activity then you can use ViewPager.
+You can also add some more screens during runtime. You supply an implementation of a PagerAdapter to generate the pages that the view shows.
+
+## What is ViewPager2?
+
+ViewPager-2 comes with a variety of new features, enhanced functionality and addresses common difficulties with using ViewPager.
+ViewPager-2 is an updated version of ViewPager library. A significant difference from the old library is the use of a RecyclerView adapter.
+And also ViewPager-2 improves user experience as compare to ViewPager, Because of smooth transitions and it also use less memory usage.
+It uses RecyclerView to display contents on screen, Because of using RecyclerView data can be changed dynamically.
+
+## Advantages of migrating to ViewPager2
+
+- ViewPager2 now based on a RecyclerView, so we should get better efficiency. We an add some items dynamically.
+- We can use both horizontal swipe as well as Vertical swipe by setting its android:orientation attribute.
+
+```xml
+
+```
+
+- Supports right-to-left (RTL) paging. RTL paging is enabled automatically where appropriate based on locale, but we can set it manually too using android:layoutDirection attribute.
+
+```xml
+
+```
+
+- We can dynamically modify the fragment collection at runtime, and ViewPager2 will correctly display the modified collection.
+- ViewPager-2 also provides data-set change animations, Because ViewPager-2 is built on RecyclerView therefore it has access to the DiffUtil utility class.
+- There is only one type of adapter now called FragmentStateAdapter, which corresponds to FragmentStatePagerAdapter from old ViewPager.
+- With LinearSnapHelper and custom PageTransformer it is much easier to create a carousel view with next and previous items partially visible.
+- ItemDecoration from RecyclerView is also available.
+
+
+## Migrate your app to ViewPager-2
+
+Follow these steps to update ViewPager objects in your app to ViewPager2:
+
+### Step 1: First step is to add a new dependency
+
+```
+implementation "androidx.viewpager2:viewpager2:1.0.0"
+```
+### Step 2: Update XML layout files
+
+First, replace the ViewPager elements in your XML layout files with ViewPager2 elements:
+
+```xml
+
+
+
+
+
+```
+
+### Step 3: Update adapter classes
+
+- Change the superclass to RecyclerView.Adapter for paging through views, or FragmentStateAdapter for paging through fragments.
+- Change the constructor parameters in fragment-based adapter classes.
+- Override getItemCount() instead of getCount().
+- Override createFragment() instead of getItem() in fragment-based adapter classes.
+
+
+```java
+// A simple ViewPager adapter class for paging through fragments
+public class ScreenSlidePagerAdapter extends FragmentStatePagerAdapter {
+ public ScreenSlidePagerAdapter(FragmentManager fm) {
+ super(fm);
+ }
+
+ @Override
+ public Fragment getItem(int position) {
+ return new ScreenSlidePageFragment();
+ }
+
+ @Override
+ public int getCount() {
+ return NUM_PAGES;
+ }
+}
+
+// An equivalent ViewPager2 adapter class
+private class ScreenSlidePagerAdapter extends FragmentStateAdapter {
+ public ScreenSlidePagerAdapter(FragmentActivity fa) {
+ super(fa);
+ }
+
+ @Override
+ public Fragment createFragment(int position) {
+ return new ScreenSlidePageFragment();
+ }
+
+ @Override
+ public int getItemCount() {
+ return NUM_PAGES;
+ }
+}
+```
+
+### Step 4: Refactor TabLayout interfaces
+
+- ViewPager2 introduces changes to TabLayout integration.
+If you currently use a ViewPager with a TabLayout object to display horizontal tabs for navigation, you need to refactor
+the TabLayout object for integration with ViewPager2.
+- You also need to change the TabLayout element's location in the hierarchy of your XML layout file. With ViewPager,
+the TabLayout element is declared as a child of the ViewPager element;
+but with ViewPager2, the TabLayout element is declared directly above the ViewPager2 element, on the same level:
+
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+- Finally, you must update the code that attaches the TabLayout object to the ViewPager object. While TabLayout uses its own setupWithViewPager() method to integrate
+with ViewPager, it requires a TabLayoutMediator instance to integrate with ViewPager2.
+
+- The TabLayoutMediator object also handles the task of generating page titles for the TabLayout object, which means that the adapter class does not need to
+override getPageTitle():
+
+
+```java
+// Integrating TabLayout with ViewPager
+public class CollectionDemoFragment extends Fragment {
+ ...
+ @Override
+ public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+ TabLayout tabLayout = view.findViewById(R.id.tab_layout);
+ tabLayout.setupWithViewPager(viewPager);
+ }
+ ...
+}
+
+public class DemoCollectionPagerAdapter extends FragmentStatePagerAdapter {
+ ...
+ @Override
+ public int getCount() {
+ return 4;
+ }
+
+ @Override
+ public CharSequence getPageTitle(int position) {
+ return "OBJECT " + (position + 1);
+ }
+ ...
+}
+
+// Integrating TabLayout with ViewPager2
+public class CollectionDemoFragment : Fragment() {
+ ...
+ @Override
+ public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+ TabLayout tabLayout = view.findViewById(R.id.tab_layout);
+ new TabLayoutMediator(tabLayout, viewPager,
+ (tab, position) -> tab.setText("OBJECT " + (position + 1))
+ ).attach();
+ }
+ ...
+}
+```
+
+### Step 5: Support nested scrollable elements
+
+- To support a scroll view inside a ViewPager2 object with the same orientation, you must call requestDisallowInterceptTouchEvent() on the ViewPager2 object
+when you expect to scroll the nested element instead. The "ViewPager2 nested scrolling" sample demonstrates one way of solving this problem with
+a versatile "custom wrapper layout".
+
+
+## Example on Implementing ViewPager2
+
+### Step 1: Adding Views in activity_main.xml Layout
+
+
+```xml
+
+
+
+
+
+
+
+```
+
+### Step 2: Add this dependency in gradle for circleimageview
+
+```
+ implementation 'de.hdodenhof:circleimageview:3.1.0'
+```
+
+### Adding Views in slider_item.xml Layout
+
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+### Step 3: Make Adapter Class
+
+
+```java
+package com.example.instagramviewpager2app;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import de.hdodenhof.circleimageview.CircleImageView;
+
+public class AdapterClass extends RecyclerView.Adapter {
+
+ int a[]; // array to store images
+
+ public AdapterClass(int[] a) { // constructor of array
+ this.a = a;
+ }
+
+ @NonNull
+ @Override
+ public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ return new MyViewHolder(LayoutInflater.from(parent.getContext()).inflate(R.layout.slider_item, parent, false)); // inflate slider_item xml layout here
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
+ holder.imageView.setImageResource(a[position]); // add image to imageview
+
+ }
+
+ @Override
+ public int getItemCount() {
+ return a.length; // return item count
+ }
+
+ public class MyViewHolder extends RecyclerView.ViewHolder{
+ CircleImageView imageView; // initialise views
+ public MyViewHolder(@NonNull View itemView) {
+ super(itemView);
+ imageView = itemView.findViewById(R.id.image);
+ }
+ }
+}
+
+```
+
+### Step 4: MainActivity.java Code
+
+
+```java
+package com.example.instagramviewpager2app;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.viewpager2.widget.CompositePageTransformer;
+import androidx.viewpager2.widget.ViewPager2;
+
+import android.os.Bundle;
+import android.view.View;
+
+public class MainActivity extends AppCompatActivity {
+
+ AdapterClass adapterClass;
+ ViewPager2 pager2;
+ int list[];
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ pager2 = findViewById(R.id.view_pager2);
+
+ list = new int[5];
+
+ // add data to arraylist
+ list[0] = R.drawable.image2;
+ list[1] = R.drawable.image3;
+ list[2] = R.drawable.image2;
+ list[3] = R.drawable.image3;
+ list[4] = R.drawable.image2;
+
+ // create adapterClass object and set adapter to viewpager2
+ adapterClass = new AdapterClass(list);
+ pager2.setAdapter(adapterClass);
+
+ pager2.setClipToPadding(false);
+ pager2.setClipChildren(false);
+ pager2.setOffscreenPageLimit(3);
+
+ CompositePageTransformer transformer = new CompositePageTransformer();
+ transformer.addTransformer(new ViewPager2.PageTransformer() {
+ @Override
+ public void transformPage(@NonNull View page, float position) {
+ float a = 1 - Math.abs(position); // decide y scale of page
+ page.setScaleY(0.85f + a * 0.15f);
+ }
+ });
+
+ pager2.setPageTransformer(transformer); // add transformer to viewpager2
+
+ }
+}
+
+```
+
+### Result:
+
+> **Image Source: Google **
+
+
+
+
+
+## Additional resource
+
+To learn more about ViewPager2, see the following additional resource.
+
+https://github.com/android/views-widgets-samples/tree/master/ViewPager2
+
+## References
+
+- https://developer.android.com/training/animation/vp2-migration?authuser=3#java
+- https://proandroiddev.com/migrating-to-viewpager2-89354b9b068d
+- Youtube
diff --git a/Android_Development_With_Java/1 Introduction/1.12 Dalvik-Virtual-Machine.md b/Android_Development_With_Java/1 Introduction/1.12 Dalvik-Virtual-Machine.md
new file mode 100644
index 0000000000..3fd41c2263
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.12 Dalvik-Virtual-Machine.md
@@ -0,0 +1,53 @@
+# Android-Java: 1.12 Dalvik-Virtual-Machine
+
+
+|
As you all know the JVM is high performance and provides excellent memory management. But it needs to be optimized for low-powered handheld devices as well. This is the reason why Dalvik Virtual Machine (DVM) was introduced.
| |
+|:-|:-|
+
+### Introduction to DVM:
+Dalvik Virtual Machine is a Register-Based virtual machine for executing Android apps.
+DVM is an android virtual machine optimized for mobile devices.
+It optimizes the virtual machine for memory, battery life and performance.
+The **_DVM design principle_** aims to optimize itself so that it can `load fastly` and `run smoothly` even on low memory/powered devices.
+
+### Working of DVM:
+> Steps -
+ 1. The Java Compiler`(javac)` converts the Java Source Code`(.java)` into Java Byte-Code`(.class)`.
+ 2. Then DEX Compiler`(dx tool)` converts all this `(.class)` file of the application into a single Dalvik Byte Code i.e. `"dex"` file.
+ 3. The Android Assets Packaging Tool `(aapt)` handles the packaging process and later it forms a `".apk"` file.
+
+> Look over the diagram to understand the process-
+
+
+
+
+
+
+
+
+
+### Advantages:
+- DVM supports the Android operating system only.
+- Execution is faster because it treats the variable and object of the same name as one.
+- From Android 2.2 SDK Dalvik has it’s own JIT (Just In Time) compiler.
+- In DVM, the executable is an APK file.
+- DVM has been designed so that a device can run multiple instances of the Virtual Machine effectively.
+- Every application is given their own instance.
+
+> Though it has these merits,but it still has some drawbacks. Here, few disadvantages are listed.
+### Disadvantages:
+- DVM supports only Android Operating System.
+- For DVM very few Re-Tools are available.
+- Requires more instructions than register machines to implement the same high-level code.
+- App Installation takes more time due to dex.
+- More internal storage is required.
+
+### Application:
+For Android, a new Virtual machine was developed by Google as stated above.
+It uses registers of the CPU to store the operands. So no requirement of any pushing and popping of instructions. Hence making execution faster.
+The instructions operate on virtual registers, being those virtual registers memory positions in the host device. Register-based models are good at optimizing and running on low memory. They can store common sub-expression results which can be used again in the future. This is not possible in a Stack-based model at all.
+Dalvik Virtual Machine uses its own byte-code and runs “.dex”(Dalvik Executable File) file.
+
+### References:
+- [origin of DVM](https://www.javatpoint.com/dalvik-virtual-machine)
+- [Difference between DVM and JVM](https://www.geeksforgeeks.org/difference-between-jvm-and-dvm/)
diff --git a/Android_Development_With_Java/1 Introduction/1.3 Installing Android studio.ipynb b/Android_Development_With_Java/1 Introduction/1.3 Installing Android studio.ipynb
new file mode 100644
index 0000000000..2f83552e06
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.3 Installing Android studio.ipynb
@@ -0,0 +1,142 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 2,
+ "metadata": {
+ "colab": {
+ "name": "java_INSTALLATION.ipynb",
+ "provenance": [],
+ "collapsed_sections": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "#Installing Android Studio\r\n",
+ "\r\n",
+ "Download Android studio to here: https://developer.android.com/studio#downloads\r\n",
+ "as per your operating system.\r\n",
+ "here .exe and .zip both are available. \r\n",
+ "If you download .zip then unzip it (using write click on those file and select option \"extrect here\").\r\n",
+ "open android-studio > bin folder here 2 .exe file presant. studio64.exe (for 64-bit machine) and studio.exe (for 32-bit machine).\r\n",
+ "\r\n",
+ "#Installation Android studio in system. \r\n",
+ "\r\n",
+ "1. For windows user:- \r\n",
+ "\r\n",
+ " 1. launch Android studio --> click on .exe file. then you find this interface.\r\n",
+ " \r\n",
+ "\r\n",
+ " 2. continue with next.\r\n",
+ "\r\n",
+ " \r\n",
+ " \r\n",
+ " 3. Click next\r\n",
+ " \r\n",
+ " \r\n",
+ " \r\n",
+ " 4. choose path and click next.\r\n",
+ " \r\n",
+ " \r\n",
+ "\r\n",
+ " 5. Click Install\r\n",
+ " \r\n",
+ " \r\n",
+ " \r\n",
+ " 6. Installing start\r\n",
+ " \r\n",
+ " \r\n",
+ " \r\n",
+ " 7. Click next\r\n",
+ " \r\n",
+ " \r\n",
+ " \r\n",
+ " 8. Click finish\r\n",
+ " \r\n",
+ " \r\n",
+ "\r\n"
+ ],
+ "metadata": {
+ "id": "zX-h1IcZU6-J"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "2. For MAC user :- \n",
+ " \n",
+ " 1. Launch the Android Studio DMG file.(double click on DMG file)\n",
+ "\n",
+ " \n",
+ "\n",
+ " 2. Drag and drop Android Studio into the Applications folder, then launch Android Studio.\n",
+ "\n",
+ " \n",
+ "\n",
+ " 3. click OK.\n",
+ "\n",
+ " \n",
+ "\n",
+ " 4. click next.\n",
+ "\n",
+ " \n",
+ "\n",
+ " 5. click next.\n",
+ "\n",
+ " .\n",
+ "\n",
+ " \n",
+ ". \n",
+ " \n",
+ " .\n",
+ " \n",
+ ".\n",
+ " \n"
+ ],
+ "metadata": {
+ "id": "Pn7BbBURI8kM"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "3.For Linux user: \n",
+ "\n",
+ " 1. unzip file using this command\n",
+ " \"tar –xvzf android-studio-2020.3.1.24-linux.tar.gz\"\n",
+ " 2. Go in (/Downloads/android-studio/bin) this directory\n",
+ " 3. Run \"./android.sh\" then start android-studio ..\n",
+ "  \n",
+ " \n",
+ "  \n",
+ " \n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n",
+ "  \n",
+ "\n"
+ ],
+ "metadata": {
+ "id": "4dQZpz2_J3dG"
+ }
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/1 Introduction/1.3.1 Customize Android Studio UI.md b/Android_Development_With_Java/1 Introduction/1.3.1 Customize Android Studio UI.md
new file mode 100644
index 0000000000..ebb1db9cad
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.3.1 Customize Android Studio UI.md
@@ -0,0 +1,63 @@
+## Customize Android Studio UI
+
+**So if you have installed the latest version of `Android Studio Arctic Fox` (at the time of writing) you should have a UI that looks something like this.**
+
+
+
+> ## First - we will look at default options to customize Android Studio.
+
+Go into `Files-> Settings` or use shortcut `Ctrl+Alt+s`. After that, a pop-up box will open with the setting tab.
+
+
+
+* ### We can use Custom `Font` and `Size`, according to our preference.
+
+
+
+**Preview:**
+
+
+
+* ### We can also customize the theme.
+
+
+
+**Preview:**
+
+> Intellij Light
+
+
+
+> High Contrast
+
+
+
+* ### We can also add our custom background.
+
+
+
+**Preview:**
+
+
+
+> ## Second - By installing the Plugin
+
+Go to `File -> Settings -> Plugins` and install **Material Theme UI Plugin**.
+
+
+
+### After installation, Restart your Android Studio. After Restart your Environment will look like this.
+
+
+
+### Material Theme consists, lots of Theme, Accent, and Pannel color.
+
+**For that you need `Tools -> Material Theme`**
+
+
+
+### We can also customize icons.
+
+
+
+
diff --git a/Android_Development_With_Java/1 Introduction/1.4 Creating First Project.md b/Android_Development_With_Java/1 Introduction/1.4 Creating First Project.md
new file mode 100644
index 0000000000..68fbbf88cb
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.4 Creating First Project.md
@@ -0,0 +1,68 @@
+# 1.4 Creating First Project
+
+In this tutorial, we'll see creating the first project in Android studio. This tutorial is for absolute beginners in Android development.
+
++ First of all click on the "Create New Project".
+
+ 
+
+
++ Now select the desired predefined Activity Templates based on your requirements, because we are simply creating an app so select "Empty Activity" and click "Next". If you want to work on Maps then select Google Map Activity.
+
+ 
+
+
++ You can also select Activity Templates based on devices like for Phones, Tabs, Wear OS, Android TV, Automotive and any other Android things.
++ Activity Templates for Wear OS
+
+ 
+
++ Activity Templates for Android TV
+
+ 
+
+
++ Activity Templates for Automotive
+
+ 
+
++ Activity Templates for other Android Things
+
+ 
+
+
+
+
++
Configure the Project
+ After selecting the activity, now next step is to configure the some settings as described below.
+
+ 
+
+
+ 1. Specify the "Name" of the project.
+ 2. Specify the "Package name". By default, this package name also becomes your application ID, which you can change later.
+ 3. Specify the "Save location" where you want to locally store your project.
+ 4. Select the Language you want Android Studio to use when creating sample code for your new project. As we are creating Java Application select "Java". Keep in mind, you are not limited to using only that language creating the project.
+ 5. Select the "Minimum API level" you want your app to support. When you select a lower API level, your app can rely on fewer modern Android APIs. However, a larger percentage of Android devices are able to run your app. The opposite is true when selecting a higher API level. If you want to see more data to help you decide, click "Help me choose".
+ 6. If you want your project to use "AndroidX libraries" by default, which are improved replacements of the Android Support libraries, check the box next to Use AndroidX artifacts.
+ When you're finish all the configuration settings to create your project, click "Finish".
+
+
+ Android Studio creates your new project with some basic code and resources to get you started. If you later decide to add support for a different device form factor, you can add a module to your project later. And if you want to share code and resources between modules, you can do so by creating an Android library.
+
+
++
Import an existing project
+ To import an existing, local project into Android Studio, proceed as follows:
+ 1. Click "File > New > Import Project".
+ 2. In the window that appears, navigate to the root directory of the project you want to import.
+ 3. Click "OK".
+ Android Studio then opens the project in a new IDE window and indexes its contents.
+
+
+For more Detail information about Creating the Project, see the Android Developer documentation on https://developer.android.com/studio/projects/create-project .
+
+
+Was this Documentation helpful? If, yes give a star to this Repository.
+
+### Authors
+- [Sai Kumar](https://github.com/saigoud25)
diff --git a/Android_Development_With_Java/1 Introduction/1.5 Running your app using virtual device.md b/Android_Development_With_Java/1 Introduction/1.5 Running your app using virtual device.md
new file mode 100644
index 0000000000..807645be6a
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.5 Running your app using virtual device.md
@@ -0,0 +1,51 @@
+# Run your app on Real Device
+
++ Go to Mobile settings and open Developer Options Window. If you can’t see the developer option then go step no 2. Else step no 3.
++ Open **About Phone** Window then go Software Information after open, tap 7 times on **Build Number**. (You can go according to your device's setting may be **About Phone** in a different window.)
+
+
+
+
+
+
+
++ After Enable Developer options you can see one option that is **USB debugging** you need to enable this option. (Take care by mistake of any other option not enable or disable.)
+
+
+
+
+
+
+
++ Mobile set up is completed now, Connect your device to your development machine with a **USB cable**.
++ Open Android Studio IDE you can see at the top your device model name.
++ Now Just Click on the Run button. (Android Studio automatically install an app into your Mobile and you can see the output.)
+
+
+# Run apps on the Android Emulator
+
++ Before Creating Android Emulator first check your device requirements [here](https://developer.android.com/studio/run/emulator?authuser=2#requirements).
++ Click on **Tools** and go to **AVD Manager** then Create Virtual Device…
++ Then Select Virtual Device according to your choice, then go next and Download the android version which you want.
++ You can create a **custom virtual device** based on your requirements.
+
+
+
+
+
+
+
++ After Download Completed select your virtual device for Run.
++ Now Just Click on the Run button. (Android Studio automatically install an app into your Virtual device and you can see the output.)
diff --git a/Android_Development_With_Java/1 Introduction/1.6.1 Uploading Project on GitHub from Android Studio.md b/Android_Development_With_Java/1 Introduction/1.6.1 Uploading Project on GitHub from Android Studio.md
new file mode 100644
index 0000000000..4bbd20a6a7
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.6.1 Uploading Project on GitHub from Android Studio.md
@@ -0,0 +1,55 @@
+## Uploading Project on GitHub from Android Studio
+
+
+### Prerequisite
+* GitHub Account
+* Android Studio linked with Github. If you have any difficulty in that please refer [this](https://stackoverflow.com/questions/64869735/cant-log-in-to-github-on-android-studio)
+* Git Installed, if not, get It from [here](https://git-scm.com/).
+
+> **Step 1: Go to the VCS panel which is present on the top of Android Studio and click on it. After clicking select the “Enable Version Control Integration.**
+
+
+
+> **Step 2: After clicking on the Enable Version Control Integration a pop-up will arise. Then select Git from the drop-down menu and click OK. This will initialize the project for GitHub.**
+
+
+
+
+
+
By doing this,you will notice that all your files will turn red.
+
+
+
+>**Step 3: Now `Add` the file you want to push into the `Github`, by doing this we can stage them and ready for the commit. It's always better to stage/Add the whole project folder, as shown in the screenshot.**
+
+
+
+
After Adding the files, the color of files with turn green, that means only these files can now be commited.
+
+
+
+>**Step 4: The next step is to `Commit` (it will collect all unversioned files and make them ready to update in `GitHub`). By click on the green tick ✔, we can easily commit without writing any command.**
+
+
+
+>**Step 5: After that, a pop box will open, simply add a meaningful message and add or remove files from being committed.**
+
+
+
+>**Step 6: After `Commit` we need to push the file to `Github`.By clicking on the `Push` button, we can easily `Push` without writing any command.**
+
+
+
+>**Step 7: After Clicking the `Push` button ↗, a pop-menu will open, in that we have to define /add a remote and click on Okay button.**
+
+
+
+> **URL Eg:**
+>
+
+
+>**Step 8: Select remote and Push it.**
+
+
+
+**Now All of your file get pushed and added in Github Repo.**
diff --git a/Android_Development_With_Java/1 Introduction/1.6.2 Clone Android Project from GitHub in Android Studio.md b/Android_Development_With_Java/1 Introduction/1.6.2 Clone Android Project from GitHub in Android Studio.md
new file mode 100644
index 0000000000..4aea437c12
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.6.2 Clone Android Project from GitHub in Android Studio.md
@@ -0,0 +1,34 @@
+## Clone Android Project from GitHub in Android Studio.
+
+### Prerequisite
+* GitHub Account
+* Git Installed, if not, get It from [here](https://git-scm.com/).
+
+> **Step 1: `Clone` the project repo `HTTPS` link from GitHub.**
+
+
+
+> **Step 2: There are two ways to do 2nd Step.**
+
+**Open `Android Studio` then go to the `File > New > Project from Version Control` as shown in the below image**.
+
+
+
+**Open `Android Studio` and close pre-existing projects.**
+
+
+
+> **Step 3: Now the pop-up screen will arise like below. In the Version, control choose `Git` from the drop-down menu**
+
+
+
+> **Step 4: Paste the link in the `URL` and choose your Directory.**
+
+
+
+> **Step 5: Finally Click on `Clone`**
+
+
+
+**Done, Your Project is Cloned**
+
\ No newline at end of file
diff --git a/Android_Development_With_Java/1 Introduction/1.6_Setup_Git_Github_On_Android_Studio.md b/Android_Development_With_Java/1 Introduction/1.6_Setup_Git_Github_On_Android_Studio.md
new file mode 100644
index 0000000000..84e2fff514
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.6_Setup_Git_Github_On_Android_Studio.md
@@ -0,0 +1,59 @@
+
+
+ # How to Setup Git And Connect Your Github Account to Android Studio.
+
+
+
+ > To begin with you should have installed git in your system, if not already then here's the download link -
+ > [Download git](https://git-scm.com/downloads)
+
+ > Check if it is successfully installed, open command promt and write the command
+
+ ```bash
+ git --version
+ ```
+ this will show the version of git installed in your system.
+
+
+
+ ## Setup git in Android Studio
+
+ Navigate to file and click on settings *file > settings*
+
+ Shortcut keys to open *settings* =>
+ **windows/linux**(Ctrl + Alt + S) | **mac**(Cmd + ,)
+
+
+ Head towards *Git > Version Control* in the right menu, here you can see **Path to Git executable** Android Studio will automatically detect your git.exe path, if it doesn't then select provide the path manually. git.exe resides in *Git -> cmd* directory.
+
+ Once you're done setting up the path click on **Test**
+ and git version installed in your system will be displayed.
+
+
+
+ Click OK
+ You've successfully connected git in your Android Studio !
+
+ ## Connecting Github account
+ Go to setting and navigate to Github from right menu. Here tap on the + button, you will see three ways to connect your github account click **log in with token** with this you can simply provide a token generated in your github account for authorization.
+
+
+
+ A tab will pop-up here click on **Generate**
+
+
+
+
+ It will redirect to Github page scroll down and tap **Generate Token**
+
+
+
+
+
+
+
+
+ A token will be generated copy that and paste it in **Token** section then click **Add Account**
+
+ Done !
+
diff --git a/Android_Development_With_Java/1 Introduction/1.8 Introduction to android manifest file.ipynb b/Android_Development_With_Java/1 Introduction/1.8 Introduction to android manifest file.ipynb
new file mode 100644
index 0000000000..4ef6783601
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.8 Introduction to android manifest file.ipynb
@@ -0,0 +1,1167 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Android-Java: number(1.0) 1.8 Introduction to android manifest file.ipynb",
+ "provenance": [],
+ "collapsed_sections": [],
+ "authorship_tag": "ABX9TyPzUZLO60o1UumhmEy6DwcP",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XIeqVFFJXzxK"
+ },
+ "source": [
+ "# Introduction to **AndroidManifest.xml**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "t-0miPvNYcXJ"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KJxRjeKrYkWF"
+ },
+ "source": [
+ "\n",
+ "Think about the feeling when you first time opens a project on android studio.\n",
+ "You are shocked up to see so many folders and files are piled up on one side. Let's try to find out where the manifest file is."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "4-AaClipY0x2"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "L73xswuKY334"
+ },
+ "source": [
+ "## **Where is the manifest.xml file present inside Android studio? **"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9ptHkPjelh1U"
+ },
+ "source": [
+ "Create a new project in android studio or you can go through your existing project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "LSEcLTMnag5Y"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MBAb92gHaiCe"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "RANsdK9Zaqpr"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GTucmLPNawM9"
+ },
+ "source": [
+ "Then, move on to the app folder. As soon as you click on this, you will see another folder named manifest.Inside the manifest folder, you will found our desired file AndroidManifest.xml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gkEqZekWd7KD"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hKS80ZWMb4zJ"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DgYWqM1seVRY"
+ },
+ "source": [
+ "We solved our first problem.\n",
+ "Let us clear another confusion, why do we need this file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hg16pRksdM65"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Jsx1z2IQgedo"
+ },
+ "source": [
+ "# Role of AndroidManifest.xml file in our development:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qb0qDk6xFdh8"
+ },
+ "source": [
+ "Before saying anything about the role of manifest.xml, I would like to ask a question. Let us assumed you have created an application.\n",
+ "Suppose you have more than one activity in your application. One of which is your launcher activity, this means you want as soon as a user opens your app, \n",
+ "this activity will come in front of him."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Bx8ioCE2F-by"
+ },
+ "source": [
+ "### How can you specify this?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ouvpcip3GOZv"
+ },
+ "source": [
+ "Now, android does not mention it anywhere that you just named your activity as MainActivity, Then it became a launcher activity.\n",
+ "Manifest.xml helps us in this task. This manifest file categorizes all the activities which we will create when we go to develop an application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "k5InmdZaGmpc"
+ },
+ "source": [
+ "**AndroidManifest.xml** helps us in this task. This manifest file categorizes all the activities which we will create when we go to develop an application.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KO8fzYyxG87s"
+ },
+ "source": [
+ "*Let us consider another scenario*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kELt8UkWIkPG"
+ },
+ "source": [
+ "Suppose one user has installed your application on his device.\n",
+ "Now, your application will ask the user for permission to access some of the system apps (For example, camera, gallery, phone contact, audio recorder, video recorder, internet, wifi) present in the device as per its requirement.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Rr3sDFnvJYzO"
+ },
+ "source": [
+ "\n",
+ "The **manifest file** helps us in this task. Here we ask permission from the user as per our application's requirement. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YbWN0JTMJv_X"
+ },
+ "source": [
+ "## **Summary:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6xM4mRLiKD0R"
+ },
+ "source": [
+ "AndroidManifest.xml describes the fundamental characteristics of the app and defines each of its components.\n",
+ "Here we define all the components of android which system must have before it runs any code of the application.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e0qqTwMvKb6e"
+ },
+ "source": [
+ "It is important to note that every application has its own manifest file. This manifest file is storing in the package manager of the android phone, in which we installed the application.\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2TXTVGxTT_Se"
+ },
+ "source": [
+ "## Some important point about XML:\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xtC9W3fjUU9_"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "* XML stands for eXtensible Markup Language much like HTML.\n",
+ "* It is a software- and hardware-independent tool for storing and transporting data.\n",
+ "\n",
+ "\n",
+ "* XML was designed to carry data - with a focus on what data is.\n",
+ "*XML elements can have attributes, just like HTML. Attributes are designed to contain data related to a specific element.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "h5_jxRQVWfMM"
+ },
+ "source": [
+ "# Manifest file structure:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jv3TaFBDXSpu"
+ },
+ "source": [
+ "Manifest is an XML file and We have discussed its role before. Here we will see how it does this. We will learn about the common elements we are using to develop our application."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "axIeIxv4T9cV"
+ },
+ "source": [
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "s4KNSZkNgUsF"
+ },
+ "source": [
+ "\n",
+ "Let us discuss some elements of manifest.xml, which we use most of the time for our application development. Here I have made a chart of them according to the order of root elements."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QMsnY9C2RQT4"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dzatryRxohCM"
+ },
+ "source": [
+ "\n",
+ "## ``\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-uS3Z5z7pdiD"
+ },
+ "source": [
+ "The root element of AndroidManifest.xml file. It must contain an `` element and specify `xmlns:android` and `package` attributes.\n",
+ "\n",
+ "**`xmlns:android`** Defines the android namespace and as a java programmer you should all know about package."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "RVzoBi_lrf2w"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0uTEGtFfsqNa"
+ },
+ "source": [
+ "## ``\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MQ_QyMyUtKAz"
+ },
+ "source": [
+ "\n",
+ "The declaration of the application.\n",
+ "This element contains subelements that declare each of the application's components and has attributes that can affect all the components. Many of these attributes (such as icon, label, permission, process) set default values for corresponding attributes of the component elements. Others (such as debuggable, enabled, description, and allowClearUserData) set values for the application as a whole and cannot be overridden by the components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "fAUByGO-skKB"
+ },
+ "source": [
+ "\n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eFjuD2Ukut7J"
+ },
+ "source": [
+ "### Child elements of ``:\n",
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "y-JUDB4-vSUb"
+ },
+ "source": [
+ "## `1.`\n",
+ " **Root element:** *``*\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UKXdq2cYw-rm"
+ },
+ "source": [
+ "Declares an Activity subclass that implements part of the application's visual user interface. All activities must be represented by activity elements in the manifest file. Any that are not declared there will not be seen by the system and will never be run."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GQb7CPAcxFmz"
+ },
+ "source": [
+ "**Child elements of` `:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KTKJiE5XxWTK"
+ },
+ "source": [
+ "### `A. `"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DJJoUg6XyL-L"
+ },
+ "source": [
+ "Specifies the types of intents that an activity, service, or broadcast receiver can respond to. An intent filter declares the capabilities of its parent component — what an activity or service can do and what types of broadcasts a receiver can handle. It opens the component to receiving intents of the advertised type, while filtering out those that are not meant for the component."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "h0TEfhoMyPwR"
+ },
+ "source": [
+ "Most of the contents of the filter are described by its ``, ``, and `` subelements.\n",
+ "It is important to note that intent-filter must contain subelement ``."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zcjxt1Y00mkH"
+ },
+ "source": [
+ "**Child elements of` `:**\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JwsbIhQx0-lL"
+ },
+ "source": [
+ "### ` i) :`\n",
+ " **Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "aKUcCRJD1yHL"
+ },
+ "source": [
+ "Adds an action to an intent filter. It is introduced in API level 1.\n",
+ "\n",
+ "**Some example of action:**\n",
+ "\n",
+ "* android.intent.action.MAIN (ACTION_MAIN is considered an entry point for the application.)\n",
+ "* android.intent.action.VIEW (Display information)\n",
+ "* android.intent.action.EDIT (Edit information)\n",
+ "* android.intent.action.PICK (allow a user to select an image from any of the installed apps which registered for such an action)\n",
+ "* android.intent.action.GET_CONTENT (Allow the user to select a particular kind of data and return it.)\n",
+ "you can find more information here. \n",
+ "https://developer.android.com/reference/android/content/Intent\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "1b0oPNEcunNj"
+ },
+ "source": [
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UcaxJVsOGHd8"
+ },
+ "source": [
+ "### ` ii) :`\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1HqujigKGnKl"
+ },
+ "source": [
+ " Gives additional information about the` ` to execute. The categories alone are useless, they are used to describe a possible target for an \"implicit intent\" in an ``. \n",
+ "\n",
+ "**Some example of category:**\n",
+ "* android.intent.category.LAUNCHER(Should be displayed in the top-level launcher.)\n",
+ "* android.intent.category.ALTERNATIVE \n",
+ "* android.intent.category.DEFAULT (Set if the activity should be an option for the default action (center press) to perform on a piece of data.)\n",
+ "* android.intent.category.HOME\n",
+ "* android.intent.category.OPENABLE\n",
+ "\n",
+ "For further information: https://developer.android.com/reference/android/content/Intent#CATEGORY_HOME\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "psPVxnulLgoP"
+ },
+ "source": [
+ " \n",
+ " \n",
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9ppYSLSvLuSI"
+ },
+ "source": [
+ "### `iii) :`\n",
+ "**Root element:**` `"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dSp0z7SNMSEP"
+ },
+ "source": [
+ "Adds a data specification to an intent filter. The specification can be just a data type (the mimeType attribute), just a URI, or both a data type and a URI. A URI is specified by separate attributes for each of its parts.\n",
+ "\n",
+ "`://:[||]`\n",
+ "\n",
+ "These attributes that specify the URL format are optional, but also mutually dependent:\n",
+ "\n",
+ "\n",
+ "* If a scheme is not specified for the intent filter, all the other URI attributes are ignored.\n",
+ "* If a host is not specified for the filter, the port attribute and all the path attributes are ignored."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hzh0xC0tNBCw"
+ },
+ "source": [
+ "\n",
+ " \n",
+ " . . .\n",
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_SoPHXn9NYBw"
+ },
+ "source": [
+ "### ` 2.`\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "P1QmzWF3Odwp"
+ },
+ "source": [
+ "An alias for an activity, named by the targetActivity attribute. The target must be in the same application as the alias and it must be declared before the alias in the manifest."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "lE88ZXZIF3SX"
+ },
+ "source": [
+ " \n",
+ " \n",
+ "\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "\n",
+ " \n",
+ "\n",
+ " \n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "D0u0g5sdP_b3"
+ },
+ "source": [
+ "### ` 3. ` :\n",
+ "**Root element:**\n",
+ "* ``\n",
+ "* ``\n",
+ "* ``\n",
+ "* ``\n",
+ "* ``\n",
+ "* ``\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "U9_lt_tQNMtf"
+ },
+ "source": [
+ "Metadata is data that describes other data to inform other applications how to use the data itself.\n",
+ "It is basically an additional option to store information that can be accessed through the entire project. \n",
+ "\n",
+ "Using ``, a developer who wants to use your API/LIB can share the KEY with you. This way, you leave your API configured to read that KEY and raise an exception if the user did not define."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "m2CaZyUCRiMW"
+ },
+ "source": [
+ "\n",
+ " \n",
+ " \n",
+ "\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "\n",
+ " \n",
+ "\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vl_iNvGgvQsT"
+ },
+ "source": [
+ "### `4.`:\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Aqs-HfCRSuZP"
+ },
+ "source": [
+ "All services must be represented by `` elements in the manifest file. Any that are not declared there will not be seen by the system and will never be run."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "WvyXNkgDTSLz"
+ },
+ "source": [
+ " \n",
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "whJigctmvDEs"
+ },
+ "source": [
+ "### `5.`\n",
+ "**Root element:**` `"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6pa_MoeBT7j2"
+ },
+ "source": [
+ "Declares a broadcast receiver as one of the application's components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "IgCanHjaubdO"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XqWhY6JesoDO"
+ },
+ "source": [
+ "### `6.`:\n",
+ "**Root element**: ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ucus5OL00qN7"
+ },
+ "source": [
+ "Declares a content provider component. A content provider is a subclass of ContentProvider that supplies structured access to data managed by the application. All content providers in your application must be defined in a `` element in the manifest file; otherwise, the system is unaware of them and doesn't run them.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "y7U94ne4VyfQ"
+ },
+ "source": [
+ "\n",
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AeV3UIiYWm9O"
+ },
+ "source": [
+ "### `7. `\n",
+ "**Root element**:` `"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8I47UXq4W5tU"
+ },
+ "source": [
+ "Specifies a shared library that the application must be linked against. This element tells the system to include the library's code in the class loader for the package.\n",
+ "\n",
+ "It is used to restrict app availability in Google Play based on the availability of a library already on the device like maps."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "4GPAKPRIW8GJ"
+ },
+ "source": [
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4nTves4FXfWr"
+ },
+ "source": [
+ "### `8. `\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gMt4ErlpYmHF"
+ },
+ "source": [
+ "This element tells the system to make the native library accessible for the package. NDK libraries are by default accessible and therefore don't require the ` `tag."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8C7cA49LZ9bC"
+ },
+ "source": [
+ "# ``\n",
+ "**Root element:** ``\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QIVGpWJpbSeI"
+ },
+ "source": [
+ "Declares an Instrumentation class that enables you to monitor an application's interaction with the system. The Instrumentation object is instantiated before any of the application's components."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "XRD1-BfQbZ0I"
+ },
+ "source": [
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "11U2hHU4bxYM"
+ },
+ "source": [
+ "# ``\n",
+ "\n",
+ "Root element:``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kXLdG_BGc2jg"
+ },
+ "source": [
+ "Indicates what hardware and software features the application requires."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "yS0rFnAOdRkG"
+ },
+ "source": [
+ "\n",
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kg_aJ6zVdWQ0"
+ },
+ "source": [
+ "## ``\n",
+ "**Root element:**``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uwmD3rw2bxOe"
+ },
+ "source": [
+ "Declares a single hardware or software feature that is used by the application.\n",
+ "\n",
+ "Google Play uses the `` elements declared in your app manifest to filter your app from devices that do not meet its hardware and software feature requirements."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "2Fs_8P0BWc1O"
+ },
+ "source": [
+ "\n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Wx4qIpbsio7j"
+ },
+ "source": [
+ "# ``\n",
+ "**Root element:**` `"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "t33NpZYljL2Y"
+ },
+ "source": [
+ "Android apps must request permission to access sensitive user data (such as contacts and SMS) or certain system features (such as the camera and internet access). Each permission is identified by a unique label. For example, an app that needs to send SMS messages must have the following line in the manifest.\n",
+ "\n",
+ "Declares a security permission that can be used to limit access to specific components or features of this or other applications. \n",
+ "\n",
+ "For further information:\n",
+ "\n",
+ " https://developer.android.com/guide/topics/manifest/manifest-intro#perms"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "cQHOmbhfi_Bd"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XpjguhpaWcgO"
+ },
+ "source": [
+ "# ``\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fLMid1c0VyN0"
+ },
+ "source": [
+ "Specifies a system permission that the user must grant in order for the app to operate correctly. Permissions are granted by the user when the application is installed (on devices running Android 5.1 and lower) or while the app is running (on devices running Android 6.0 and higher)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hP8rVYIdfoqf"
+ },
+ "source": [
+ " \n",
+ " \n",
+ " \n",
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EsmHyIP0hUTD"
+ },
+ "source": [
+ "# ``\n",
+ "**Root element:** ``"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CNxNsR_GhiUO"
+ },
+ "source": [
+ "\n",
+ " applies to all SDKs and will apply the permission only to SDK 23+.\n",
+ "For Android SDK 23 and above, you have the option to request the permission at runtime but the permissions will be in their default state upon installation and the user will not be prompted at installation. (Essentially this can be used to prompt the user to grant the permission on a need-to-use basis and you have the opportunity to provide an explanation of why it's needed.)\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "8YHO50jFhPpH"
+ },
+ "source": [
+ "\n",
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "nTpYVSMxiF2w"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7TxmWOcH3kWl"
+ },
+ "source": [
+ "# ``\n",
+ "**Root element:** ``\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "szj1uaftLAZp"
+ },
+ "source": [
+ "Despite its name, this element is used to specify the API Level, not the version number of the SDK (software development kit) or Android platform. The API Level is always a single integer. You cannot derive the API Level from its associated Android version number (for example, it is not the same as the major version or the sum of the major and minor versions)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "LX6XEIGOgqqe"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/Android_Development_With_Java/1 Introduction/1.9 Updating_IDE_and_Essential_SDK_Tools.ipynb b/Android_Development_With_Java/1 Introduction/1.9 Updating_IDE_and_Essential_SDK_Tools.ipynb
new file mode 100644
index 0000000000..d7e8de68f0
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.9 Updating_IDE_and_Essential_SDK_Tools.ipynb
@@ -0,0 +1,151 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "1.9 Updating IDE and Essential SDK Tools.ipynb",
+ "provenance": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nQi6CCnFtQMN"
+ },
+ "source": [
+ "
Updating IDE and Essential SDK Tools
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-KCIUhagtfgz"
+ },
+ "source": [
+ "Today we will be seeing how we can update our Android Studio IDE and SDK tools within android. Keeping your IDE and different SDK tools updated has become very easy with automatic updates and Android SDK Manager."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "LyQLotJJT2BC"
+ },
+ "source": [
+ "Android Studio handles different release channels for rolling over updates to its users. There a four different channels for Android Studio :\n",
+ "\n",
+ "\n",
+ "* Canary\n",
+ "* Dev\n",
+ "\n",
+ "* Beta\n",
+ "* Stable\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "48RT_5NWVbdx"
+ },
+ "source": [
+ "Out of these four channels Stable Channel is being more preferred for production and development of applications.\n",
+ "The official stable releases are available only on this channel. Also we can download the stable release from [developer.android.com/studio](https://developer.android.com/studio)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DsKmLBCxXFaN"
+ },
+ "source": [
+ "To update your android studio from within android studio follow these steps :\n",
+ "\n",
+ "* Files -> Settings\n",
+ "* From Settings go to Appearance & Behaviour -> System Settings\n",
+ "* Go to Updates Section.\n",
+ "* Select suitable channel whichever you want.\n",
+ "* Check for updates, if available click on Apply."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_Wa56LaRrNAr"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jWjtt-g3tWPY"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-hehK-XNkii1"
+ },
+ "source": [
+ "
Updating Tools with SDK Manager
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fZ4mjtkulp89"
+ },
+ "source": [
+ "The Android SDK Manager provides a greater help to download the SDK tools, platforms, and other components which we need to develop our applications. Once downloaded, we can find each package in the directory indicated as the Android SDK Location in the Android SDK Section."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ARh3AgnCm6VP"
+ },
+ "source": [
+ "Follow these steps to update your tools using SDK Manager :\n",
+ "\n",
+ "* Files -> Settings\n",
+ "* From Settings go to Appearance & Behaviour -> System Settings\n",
+ "* Click on Android SDK.\n",
+ "* Select SDK Tools Section.\n",
+ "* Click on checkboxes whichever tools you want to dowload/update.\n",
+ "* Click on Apply button to start downloading. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bNTIedkRtgez"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "88hxFMyWokGX"
+ },
+ "source": [
+ "You can also change your Android SDK Location where your packages will be getting downloaded. You can just edit the path from there itself."
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/1 Introduction/1.91 Memory Profile.md b/Android_Development_With_Java/1 Introduction/1.91 Memory Profile.md
new file mode 100644
index 0000000000..268bc95d20
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/1.91 Memory Profile.md
@@ -0,0 +1,40 @@
+## Android Studio Memory Profiler
+
+**The Android Profiler tools give you real-time information on how your app consumes CPU, memory, network, and battery resources.**
+
+
+
+ **To Open Memory Profiler `Select View > Tool Windows > Profiler from the menu bar.`**
+
+
+
+**OR From the Toolbar.**
+
+
+
+**Choose the device on which to profile your program if prompted by the Select Deployment Target window. If a device isn’t shown after you’ve connected it through USB, make sure USB debugging is turned on.**
+
+
+
+**The Android Profiler lists all running processes, even if they aren’t debuggable.**
+
+https://user-images.githubusercontent.com/90956475/140618981-b73c2d01-f9f2-4abf-be1f-346d146a0f86.mp4
+
+
+**Now, click Anywhere on the Memory section:**
+
+
+
+**It now shows the DetailActivity is the current activity and a small pink dot. The profiler shows these dots each time you touch the screen. Below that, you can see the memory count of your app, segmented into several categories.**
+
+https://user-images.githubusercontent.com/90956475/140619852-7ba19c06-d693-4ee9-b38a-4d7102f51f67.mp4
+
+* **`Java`** : Memory from objects that Java/Kotlin has allocated.
+* **`Native`**: Allocated memory from C/C++ code objects.
+* **`Graphics`**: Memory to display pixels to the screen.
+* **`Stack`**: Memory used by both native and Java stacks in your app. When your app invokes a method, a block is created in the stack memory to hold local primitive values and * references to other objects in this method.
+* **`Code`**: Memory used for code and resources such as dex bytecode, .so libraries and fonts.
+* **`Others`**: Memory that the system doesn’t know how to categorize.
+* **`Allocated`**: The number of Java/Kotlin objects your app has allocated.
+
+For more help visit [Android Official Documenation](https://developer.android.com/studio/profile/memory-profiler)
diff --git a/Android_Development_With_Java/1 Introduction/ANDROID_ARCHITECTURE_OVERVIEW.md b/Android_Development_With_Java/1 Introduction/ANDROID_ARCHITECTURE_OVERVIEW.md
new file mode 100644
index 0000000000..caf71ea224
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/ANDROID_ARCHITECTURE_OVERVIEW.md
@@ -0,0 +1,163 @@
+
+
+ # Android Architecture Overview
+
+
+Android is a mobile operating system that has an open-source framework
+and is based on Linux which helps us to develop advanced and user-friendly applications, having
+collection of number of C/C++ libraries.
+
+Android Architecture is divided into five components, **Applications,
+Application Framework, Android Runtime, Platform Libraries, Linux
+Kernel.**
+
+
+
+
+**APPLICATIONS:**
+
+It is the top-most layer of Android architecture. All the third-party
+applications downloaded from play store like games, messenger, etc, and
+pre- installed applications like home, contacts, camera, etc, will be
+installed on this layer. It runs within the Android runtime with the
+help of the classes and services provided by the application framework.
+
+**APPLICATION FRAMEWORK:**
+
+The application framework built on top of the native library layer!
+
+provides us with Application programming interface and higher-level
+services. It provides the services with the help of which we can create
+a particular class and, Android developers use these high-level services
+to build applications.
+
+It also consists of an Android **Hardware Abstraction Layer (HAL)** that
+allows the Android Application framework to communicate with
+hardware-specific device drivers. It acts as an interface for hardware
+vendors to implement. An android application uses HAL APIs to get
+commands from different hardware devices.
+
+>The application framework consists of following key services:
+
+- **Activity Manager:** The method in this class uses testing and
+ debugging methods.
+
+- **Content provider:** It provides data from application to other
+ layers.
+
+- **Resource Manager:** It provides access to non-code resources as
+ such string, colour setting and user interface layouts.
+
+- **Notification Manager:** The users get notification about all the
+ actions happening in the background.
+
+- **View System:** It acts as a base class for widgets and is
+ responsible for event handling.
+
+**ANDROID RUNTIME:**
+
+This is the third section of the architecture and available on the
+second layer from the bottom. It comprises of DVM (Dalvik Virtual
+Machine). Just like Java Virtual Machine, Android uses DVM to optimize
+battery life, memory and performance. It depends on the Linux kernel
+layer for threading and low-level memory management. The core libraries
+enable us to implement android applications using the standard JAVA or
+Kotlin programming languages.
+
+**LIBRARIES:**
+
+This layer consists of a set of Libraries and Android Runtime. The
+Android component is built using **native codes** and require **native
+libraries**, which are written in C/C++ and most of the libraries are
+open-source libraries. Also, this layer handles data that is specific to
+the hardware.
+
+> A summary of some key core Android libraries available to the Android
+> developer is as follows −
+
+- **android.app** − Provides access to the application model and is
+ the cornerstone of all Android applications.
+
+- **android.content** − Facilitates content access, publishing and
+ messaging between applications and application components.
+
+- **android.database** − Used to access data published by content
+ providers and includes SQLite database management classes.
+
+- **android.opengl** − A Java interface to the OpenGL ES 3D graphics
+ rendering API.
+
+- **android.os** − Provides applications with access to standard
+ operating system services including messages, system services and
+ inter-process communication.
+
+- **android.text** − Used to render and manipulate text on a device
+ display.
+
+- **android.view** − The fundamental building blocks of application
+ user interfaces.
+
+- **android.widget** − A rich collection of pre-built user interface
+ components such as buttons, labels, list views, layout managers,
+ radio buttons etc.
+
+- **android.webkit** − A set of classes intended to allow web-browsing
+ capabilities to be built into applications.
+
+>A summary of some key core Java based libraries to provide a support for
+>android development as follows --
+
+- **Media** - Library provides support to play and record an audio and
+ video formats.
+
+- **Surface manager** - Responsible for managing access to the display
+ subsystem.
+
+- **SGL** and **OpenGL** - Both cross-language, cross-platform
+ application program interface (API) is used for 2D and 3D computer
+ graphics.
+
+- **SQLite** - Provides database support.
+
+- **FreeType** - Provides font support.
+
+- **Web-Kit** - This open-source web browser engine provides all the
+ functionality to display web content and to simplify page loading.
+
+- **SSL (Secure Sockets Layer)** -- It is security technology to
+ establish an encrypted link between a web server and a web
+ browser.
+
+**LINUX:**
+
+At the bottom of the layers is Linux. Among all the components linux
+kernel provides main functionality of operating system functions. It
+also provides a level of abstraction between the device hardware and it
+contains all the essential hardware drivers like camera, keypad, display
+etc.
+
+>It provides features such as:
+
+- **Security:** It provides the security between the application and
+ the system.
+
+- **Memory Management:** It manages the memory efficiently ans thus
+ provide the freedom to develop our apps.
+
+- **Process Management:** It allocates resources to processes whenever
+ they need them and manages the process well.
+
+- **Network Stack:** It effectively handles the network communication.
+
+- **Driver Model:** It ensures that the application works properly on
+ the device and hardware manufacturers responsible for building
+ their drivers into the Linux build.
+
+
diff --git a/Android_Development_With_Java/1 Introduction/Android_Java_1_0_Introduction_to_Android_Studio.ipynb b/Android_Development_With_Java/1 Introduction/Android_Java_1_0_Introduction_to_Android_Studio.ipynb
new file mode 100644
index 0000000000..5e895b8365
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/Android_Java_1_0_Introduction_to_Android_Studio.ipynb
@@ -0,0 +1,699 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Android_Java_1_0_Introduction_to_Android_Studio.ipynb",
+ "provenance": [],
+ "collapsed_sections": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FSYsR_1E0wjR"
+ },
+ "source": [
+ "# Introduction:\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7oVtowtX0-QA"
+ },
+ "source": [
+ "The most common activities of writing software are editing source code, building executables, and debugging. An IDE is an application suite where you can do all of those activities in one place. You can do the whole software development life cycle in an IDE.\n",
+ "As a result, many different Integrated Development Environments (IDEs) have been created for mobile app development. Many new ones are emerging, and the old ones are evolving."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BEi8V_c61H92"
+ },
+ "source": [
+ " Talking about IDEs, nowadays people prefer using **Android Studio** and **IntelliJ** to develop any android application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jdVODSqe4EsG"
+ },
+ "source": [
+ "## Agenda:\n",
+ "\n",
+ "---\n",
+ "* What is **Android Studio**?\n",
+ "* **Features** and **Disadvantages**.\n",
+ "* Demonstrate **setting up** an android studio project.\n",
+ "* Introduction to **files and folder** in android studio.\n",
+ "* Demonstrate **how Android studio can be used** to make a single app.\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "50mFJ6Nm6HEx"
+ },
+ "source": [
+ "## Prerequisites:\n",
+ "\n",
+ "\n",
+ "---\n",
+ "* Java\n",
+ "* A PC or Mac with Java installed\n",
+ "* A PC or Mac with Java SDK installed.\n",
+ "* A PC or Mac with Android Studio installed.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xYwKx45A10YD"
+ },
+ "source": [
+ "### **What is Android Studio?**\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "It5BrV452WlZ"
+ },
+ "source": [
+ "Android studio is one such platform that gives you all the advantages that make developing an android app much easier."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nSjnjFdK3SWs"
+ },
+ "source": [
+ "Android Studio is an **Integrated Development Environment**, that contains a text editor, debugging tools, and tools for running your app.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7lHO6WKe8-pC"
+ },
+ "source": [
+ "### **Features of Android Studio:**\n",
+ "---\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VRaB-VCXUZtN"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UTv3cysm5gyR"
+ },
+ "source": [
+ "### **Disadvantages of Android Studio:**\n",
+ "\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ktqZmCVX5tdj"
+ },
+ "source": [
+ "* Android Studio is not light weighted. It cannot be used on low configuration machines.\n",
+ "\n",
+ "* Emulator is very slow.\n",
+ "* Takes too long to build and run.\n",
+ "\n",
+ "\n",
+ "\n",
+ "To know more details about Android Studio, click here."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zb24-L-IRkcG"
+ },
+ "source": [
+ "### **Android Studio set up:**\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "v3g_XK2tAMLu"
+ },
+ "source": [
+ "When we are going to launch Android studio for the first time,When we are going to launch Android studio for the first time, At the final stage, it would extract SDK packages into our local machine, it would take a while time to finish the task and would take 2626MB of Hard disk space."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Q4-BK0mITrgQ"
+ },
+ "source": [
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1obMY7M1T7QW"
+ },
+ "source": [
+ "After completing the downloading process, we get the finish button then it will be open the Android Studio project with a Welcome to android studio message as shown below."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hoZ8ux1rXPom"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "
\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bNWpWVPHkgy0"
+ },
+ "source": [
+ "If you are interested in exploring more about it, click here "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wO8NfD2EZXTh"
+ },
+ "source": [
+ "**Android Application File Structure:**\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jy0T7ijqZftG"
+ },
+ "source": [
+ "It is very important to know about the basics of Android Studio’s file structure. Here we will discuss some important files and folders and their significance for the easy understanding of the Android studio work environment.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "50BeKIisnPep"
+ },
+ "source": [
+ "In the below image, several important files are marked:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vRLwMGaBnlJQ"
+ },
+ "source": [
+ " See the Explanation: "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rSrsfhvmnb5F"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jIO5UNh8pBgQ"
+ },
+ "source": [
+ "### **How can we use Android Studio to develop an application?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SzH5qK1QpQyT"
+ },
+ "source": [
+ "Let's create an application that will take two Integer inputs from the user. Then with the click of a button, we see the output, which is the sum of those two integers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rIB9p3bV-y0Z"
+ },
+ "source": [
+ "For this, we will first create a project, as we did a while ago. I have named my project here **Add-on**, you are independent in this regard.\n",
+ "An application usually consists of two parts. One is the user interface, which is visible in front of the user. Another is its internal coding part, which enlivens our user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rMTky01A5owN"
+ },
+ "source": [
+ "\n",
+ "As soon as your project opens, you will see two files. One is MainActivity.java, where we will do internal coding, Another is activity_main.xml, where we will design the user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KYWLOov1CU4o"
+ },
+ "source": [
+ "Let us first create the user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "21PlnZkzCgcC"
+ },
+ "source": [
+ "**Required view :**\n",
+ "* Two EditText (For user input.)\n",
+ "\n",
+ "* One Button (To determine the result.)\n",
+ "\n",
+ "* One TextView (To show the result.)\n",
+ "\n",
+ "Here I have used ConstraintLayout as the parent layout.\n",
+ "\n",
+ " See an example of the use of ConstraintLayout.\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "v1k7R8FlY9vb"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ "\n",
+ " \n",
+ "\n",
+ " \n",
+ "\n",
+ " \n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QsyYYwCbX4o5"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UkzAFbUtYDia"
+ },
+ "source": [
+ "Now let's look at the coding part, Here we will clarify our concept step by step.\n",
+ "\n",
+ "First, let's see which views we want to set the action. In this case, except for the parent layout, we will perform some action on each View.\n",
+ "\n",
+ "The second step is that we will give a unique id to each identified View.\n",
+ "\n",
+ "Now we are ready for the coding part."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZC031cv7aIAg"
+ },
+ "source": [
+ "In the next step, At MainActivity class, we will declare each required view, and find their id inside the onCreate method."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Q06z2TVmbXy-"
+ },
+ "source": [
+ "We have already discussed which actions we want to perform in which views.\n",
+ "\n",
+ "Now it's time to look at the coding part."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "Ly42h0jVZTH3"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "package com.application.addon;\n",
+ "\n",
+ "import androidx.appcompat.app.AppCompatActivity;\n",
+ "\n",
+ "import android.os.Bundle;\n",
+ "import android.view.View;\n",
+ "import android.widget.Button;\n",
+ "import android.widget.EditText;\n",
+ "import android.widget.TextView;\n",
+ "import android.widget.Toast;\n",
+ "\n",
+ "public class MainActivity extends AppCompatActivity {\n",
+ "\n",
+ " // declare the required view\n",
+ " private EditText firstInteger, secondInteger;\n",
+ " private Button button;\n",
+ " private TextView result;\n",
+ "\n",
+ " @Override\n",
+ " protected void onCreate(Bundle savedInstanceState) {\n",
+ " super.onCreate(savedInstanceState);\n",
+ " setContentView(R.layout.activity_main);\n",
+ "\n",
+ " // find the view\n",
+ " firstInteger= findViewById(R.id.first_integer);\n",
+ " secondInteger= findViewById(R.id.second_integer);\n",
+ " button= findViewById(R.id.button);\n",
+ " result= findViewById(R.id.result);\n",
+ "\n",
+ " // set action on the button\n",
+ " button.setOnClickListener(new View.OnClickListener() {\n",
+ " @Override\n",
+ " public void onClick(View v) {\n",
+ "\n",
+ " // check whether the edit text field are empty or not.\n",
+ " if (firstInteger.getText().toString().isEmpty() || secondInteger.getText().toString().isEmpty()) {\n",
+ "\n",
+ " // show a toast\n",
+ " Toast.makeText(MainActivity.this, \"Input field cannot be empty\", Toast.LENGTH_SHORT).show();\n",
+ " } else {\n",
+ "\n",
+ "\n",
+ " // get the user input from EditText\n",
+ " int first = Integer.parseInt(firstInteger.getText().toString());\n",
+ " int second = Integer.parseInt(secondInteger.getText().toString());\n",
+ "\n",
+ " int sum = first + second;\n",
+ " result.setText(String.valueOf(sum));\n",
+ " }\n",
+ "\n",
+ " }\n",
+ " });\n",
+ " }\n",
+ "}\n",
+ "\n",
+ "\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "TrQ59LRdvh9f"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "prfTLw8iWtx1"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "EMRA0UsgW8Kv"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "QsITh93J5oBs"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/1 Introduction/Components of Android.md b/Android_Development_With_Java/1 Introduction/Components of Android.md
new file mode 100644
index 0000000000..4fb5799b22
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/Components of Android.md
@@ -0,0 +1,73 @@
+# **Components of Android Application**
+ Android Application components are essential building blocks necessary to make Android Apps. These provide gateway to the system and the user to interact with your app. Some of these components depend on each other.
+These are the following main components of an Android Application:
+
+
+* Activities
+* Services
+* Broadcast Receivers
+* Content Providers
+
+ Each type has its own distinct purpose and its own unique life cycle on how the component is created and destroyed. The following section describes each of these app components.
+
+
+
+
+
+
+## **Activities**
+
+Activity is the UI which interacts with the user for the app. It is through activities that user can communicate with the app. In more simple words it is a single screen with user interface. For example, an Instagram have one activity where it shows all the posts and profile of someone would be another activity. Although all the activities work together to form a smooth and cohesive user experience, but these activities are independent of each other. As, any different app can start any of the above activities if Instagram allows to do so. For example, a camera app can open up the acitvity in Instagram that open user's chat feed and allow the user to share the photo with anyone.
+An activity is implemented as subclass of class Activity.
+
+
+
+
+
+>As you can see these are two different pages on the Instagram application. These are actually two **Activities**.
+First activity shows the profile of someone whereas Second activty shows latest posts around the world.
+
+
+
+
+## **Services**
+ Service is used to keep the app running in the background. This component keeps running in the background to perform both long-running operations and work for remote processes. A service does no provide a user inteeface. For example, a service might play music in the background, or it can fetch data over the network without interrupting the user interaction with an activity. There are two kind of services to manage an app:
+
+* **Started Services**: These services tell the system to keep them running until the work is done. For example, this could be syncing data in the background or playing music even after the user leaves the app.
+
+* **Bound Service**: This service runs because some app had said it want to make use of the srevice. Basically this service provides an API to a process.
+
+Live wallpapers, notifications, screen savers, playing music in the background, these are few of the many features that services have blessed us with.
+A service can be implemented as subclass of class **Service**.
+
+ 
+
+>These are some Services that takes place in background without disturbing the interaction of the user with the current activity.
+
+
+
+
+## **Broadcast Receiver**
+ Broadcast is like making announcements for system-wide events. For example, when a message is received, an incoming call or low battery. These are some of the few system-wide events that happens in an Android.
+And Broadcast Receiver is a component that allows the app to respond to these system-wide events which is outside the regular user flow of the app. This is another way of entry to an app and even to those apps that are not currently running. For example, an app can schedule an alarm to post a notification about an upcoming event. And by delivering that alarm to the BroadcastReceiver of the app there is no need for the app to keep running until the alarm gets off. Most of the common broadcasts originate from the system itself as the phrase itself states ***system-wide events***. For example, battery low, phone is turning off and many more. These are some of the many broadcasts system generates. Even though broadcast receiver don't display user interface, but they could aware user by creating notification regarding the events.
+A broadcast receiver is implemented as a sub class of **BroadcastReceiver** class.
+
+
+> These are some of the events that Broadcast Receiver delivers.
+
+
+
+## **Content Providers**
+ Content Provider is very important component from both perspective securing and storing your data. The task of the content provider in android is like of a central database in which data of the applications are stored, and it allows other applications to access and moidfy the app data based on the user requirements, if content provider allows it. This app data could be images, videos, audios or personal information. Content provider has the liberty to store this app data in file system, in a SQLite database, on the network or anywhere where the app can access it. It has the permission to grant or rescrit access of data to the apps.These are also useful for reading and writing data that is private to your app.
+A content provider is implemented as a subclass of class **ContentProvider**.
+
+
+>The role of the ContentProvider is to collect and store data.
+
+
+
+## **Referrences**
+
+* https://www.geeksforgeeks.org/components-android-application/
+
+* https://developer.android.com/guide/components/fundamentals?authuser=2
diff --git a/Android_Development_With_Java/1 Introduction/Drawable Resource Overview.md b/Android_Development_With_Java/1 Introduction/Drawable Resource Overview.md
new file mode 100644
index 0000000000..a7b642b050
--- /dev/null
+++ b/Android_Development_With_Java/1 Introduction/Drawable Resource Overview.md
@@ -0,0 +1,778 @@
+# Android-Java: Drawable Resource Overview
+
+
+
+
+A drawable resource is a concept for a graphic that is to be displayed on the screen and which can be retrieved by applying to another XML resource with attributes such as android:drawable and android:icon or with APIs such as `getDrawable(int)`.
+- **Drawable resource file can be refered as:**
+ > _In Java:_ R.drawable.filename
+ >
+ > _In XML:_ @drawable/filename
+
+There are several different types of drawables:
+
+1. Inflate/paste an image resource (bitmap Image or file) in your project.
+2. Create an XML resource file that defines the drawable properties.
+
+ 2.1. Create Custom Resource files.
+
+ 2.1.1 Layer List
+ 2.1.2 State List (Selector)
+ 2.1.3 Level List
+ 2.1.4 Shape Drawable
+ 2.1.5 Scale Drawable
+ 2.1.6 Clip Drawable
+ 2.1.7 Transition Drawable
+ 2.1.8 Animation list Drawable
+ 2.2. Create Image Assets.
+
+ 2.3. Create Vector Assets.
+
+
+
+
+## 1. Inflate Image Resource file (Bitmap files):
+- Android supports bitmap files in three formats: .png (preferred), .jpg (acceptable), .gif (discouraged).
+- This is why, a bitmap file must be in .png, .jpg, or .gif extension.
+- You can reference a bitmap file directly, using the filename as the resource ID, or create an alias resource ID in XML.
+- Android creates a Drawable resource for any of these files when you save them in the res/drawable/ directory.
+- **file location:**
+ > res/drawable/filename.png (.png, .jpg, or .gif)
+- **syntax:**
+ > With an image saved at res/drawable/myimage.png, this layout XML applies the image to a View as:
+ ```bash
+
+ ```
+- **Example:**
+ 1. Copy from system-
+
+
+
+ 2. Right click and paste in drawable folder-
+
+ 3. Add image to drawable folder-
+
+ 4. Give any name to the image-
+ here it is android_image.png
+
+ 5. Inside the xml activity page add ImageView widget-
+
+ ```bash
+
+
+
+
+
+
+ ```
+ > here, src is an attribute used to set a source file or you can say image in your imageview
+
+ 6. Drawable Image on Android Screen-
+
+
+
+
+
+## 2. Create an XML resource file that defines the drawable properties:
+
+### 2.1. Create Custom Resource files.
+- **file location:**
+ > res/drawable/filename.xml
+
+
+
+#### 2.1.1 Layer List
+> A Layer list is a drawable object that manages an array of other drawables. These are drawn in array order, so the element of the larger index will be drawn first i.e. the last drawable in the list is drawn on top.
+- Elements `` must be the root element. Contains one or more `` elements.
+- Each drawable is represented by an `` element inside a single `` element.
+- **syntax:**
+ ```bash
+
+
+
+
+ ```
+- **Example:**
+ 1. Right click on drawable folder and create resource xml file-
+
+
+
+ 2. Select the root element of xml and name the file-
+
+
+
+
+
+
+----------------------------------------------------------------------------------------------------------------------------------------
+` #NOTE `
+ - All drawable items are scaled to fit the size of the containing View, by default. Thus, placing images in a layer list at different positions might increase the size of the View and some images scale as appropriate.
+ > Example, scales fit its container View using item element:
+ ```bash
+
+ ```
+
+- To avoid scaling items in the list, use a `` element inside the `` element to specify the drawable and define the gravity.
+ > For example:
+ ```bash
+
+
+
+ ```
+----------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+#### 2.1.2 State List (Selector)
+> A StateList is a drawable object defined in XML that uses several different images to represent the bitmap graphic, depending on the state of the drawable.
+ - For example, a Button widget can exist in one of several different states (pressed, focused, or neither) and, using a state list drawable, you can provide a different background for each state.
+ - Another example is, to use a different image when a button is pressed.
+
+ > Elements `` must be the root element. Contains one or more `` elements. Each graphic is represented by an `` element inside a single `` element. `` uses various attributes to describe the state to used as the graphic for the drawable.
+
+ > During each state change, the state list is traversed top to bottom and the first item that matches the current state is used—the selection is not based on the "best match," but simply the first item that meets the minimum criteria of the state.
+
+- **syntax:**
+ ```bash
+
+
+
+
+ ```
+- **Example:**
+ 1. Create drawable resource xml file by selecting root element and name the file
+
+
+
+1. BottomSheetDialogFragment A fragment can be displayed as a Bottom Sheet dialog. Go ahead and create a new fragment, call it `BottomSheetFragment`. You can opt to start a new project.
+
+Creating a new fragment will generate an XML file associated with it. Go ahead and include your layout design in it. Use the same layout as specified in `bottom_sheet_dialog_layout.xml`. Inflate the layout for this fragment, as shown below.
+
+```java
+public class BottomSheetFragment extends Fragment {
+ public BlankFragment() {
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {
+
+ View view = inflater.inflate(R.layout.bottom_sheet_dialog, container, false);
+ return view;
+ }
+}
+```
+Add a button in the activity_main.xml, declare it, and set OnClick Listener as dicussed in the previous steps.
+
+We want to open the fragment when the button is clicked.
+
+Indicate the following code block inside the button’s OnClick Listener.
+
+```java
+Button bottton = findViewById(R.id.button);
+bottton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ BlankFragment blankFragment = new BlankFragment();
+ blankFragment.show(getSupportFragmentManager(),blankFragment.getTag());
+ }
+});
+```
+
+We need to convert the fragment to a Bottom Sheet. We do so by extending BottomSheetDialogFragment rather than Fragment.
+
+```java
+public class BottomSheetFragment extends BottomSheetDialogFragment {
+
+}
+```
+
+When you run the application, it should show the dialog shown below.
+
+
+
+### Implementing a Persistent Bottom Sheet dialog
+
+#### Laying out the Bottom Sheet design
+
+We will use an example of a simple login screen. Instead of showing it within the regular activity layout, we will use a Persistent dialog to slide it into the main screen.
+
+I have created a `bottom_sheet_dialog_layout.xml`file and included the following simple login layout.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+This is not a Bottom Sheet yet. It's just a regular layout. To transform the layout to a Bottom Sheet dialog, a few declarations should be added to the root layout.
+
+These statements will control the Bottom Sheet's behaviors. You can learn more about these attributes from [here](https://material.io/components/sheets-bottom/android#handling-insets).
+
+```xml
+
+```
+
+The Bottom Sheet behavioral flags include;
+
+- `app:layout_behavior` - applies the `BottomSheetBehavior` into the XML file. This is assigned to `com.google.android.material.bottomsheet`. It is the most important `BottomSheetBehavior` attribute since it defines a given layout as a Bottom Sheet dialog.
+
+- `app:behavior_hideable` - takes a Boolean value. If `true`, a user can drag and hide the dialog by sliding it down. If false, the dialog will float on the screen and will not be hideable.
+
+- `app:behavior_peekHeight` - it defines the height of the Bottom Sheet visible to the user.
+
+*Remember to add an id to be used to access the layout.*
+
+For a Bottom Sheet to be implemented effectively, it must be a child of `CoordinatorLayout`. To do that, go to your main XML file. This could be an Activity or Fragment. In our case, it will be the `activity_main.xml`.
+
+Here is the code to do that.
+
+```xml
+
+
+
+
+
+
+
+
+```
+
+*Remember to include the Bottom Sheet we designed. Wrap it with `CoordinatorLayout`.*
+
+#### Expanding and collapsing the sheet dialog
+
+To control the sliding and collapsing of the dialog, we use states. The Bottom Sheet has several states which you need to understand. They include:
+
+- `STATE_EXPANDED` - the dialog is visible to its maximum defined height.
+- `STATE_COLLAPSED` - the dialog is visible depending on the set `peekHeight`.
+- `STATE_DRAGGING` - the user is dragging the dialog up and down.
+- `STATE_SETTLING` - show that the dialog is settling at a specific height. This can be the `peekHeight`, expanded height, or zero if the dialog is hidden.
+- `STATE_HIDDEN` - the dialog is not visible.
+
+The last thing we will do is listen to the state of the dialog. We use `BottomSheetCallback` to detect any state changes.
+
+Declare the following parameters:
+
+```java
+private LinearLayout mBottomSheetLayout;
+private BottomSheetBehavior sheetBehavior;
+private ImageView header_Arrow_Image;
+```
+
+Initialize the behavior Bottom Sheet layout and the arrow image:
+
+```java
+mBottomSheetLayout = findViewById(R.id.bottom_sheet_layout);
+sheetBehavior = BottomSheetBehavior.from(mBottomSheetLayout);
+header_Arrow_Image = findViewById(R.id.bottom_sheet_arrow);
+```
+We will assign OnClick Listener to the arrow vector image. When clicked, we want to expand or collapse the dialog.
+
+```java
+header_Arrow_Image.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+
+ if(sheetBehavior.getState() != BottomSheetBehavior.STATE_EXPANDED){
+ sheetBehavior.setState(BottomSheetBehavior.STATE_EXPANDED);
+ } else {
+ sheetBehavior.setState(BottomSheetBehavior.STATE_COLLAPSED);
+ }
+
+ }
+});
+```
+
+Implement a `BottomSheetCallback` to listen to the `BottomSheetBehavior` state.
+
+```java
+sheetBehavior.addBottomSheetCallback(new BottomSheetBehavior.BottomSheetCallback() {
+ @Override
+ public void onStateChanged(@NonNull View bottomSheet, int newState) {
+ }
+ @Override
+ public void onSlide(@NonNull View bottomSheet, float slideOffset) {
+
+ header_Arrow_Image.setRotation(slideOffset * 180);
+ }
+});
+
+```
+
+`onStateChanged` tells the application what's happening on the dialog depending on the state. `onSlide` will rotate the arrow image (while sliding bottom to top) until the `STATE_EXPANDED` has reached its maximum height.
+
+On the other side, the image will rotate to its original state when `STATE_COLLAPSED` is at `peekHeight`.
+
+#### Run the application
+
+
+
+### Conclusion
+
+The Bottom Sheet dialog is a unique way to display menus and dialogs. It provides more room to include content. Bottom Sheet dialogs can accomodate different components.
+
+So that is all that you need to get started with the Bottom Sheet Dialog in Android (java) , if you have any doubts you can definetly visit the official documentation of [Java](https://docs.oracle.com/en/java/).
+
+## HAPPY LEARNING 😎🙌
+
+
+### References-:
+
+- For preparing these documents official documentation of [Java](https://docs.oracle.com/en/java/). was referred for maintaining the authenticity of the code and also for making the topics more informative some external sources like [blogs](https://www.section.io/engineering-education/bottom-sheet-dialogs-using-android-studio/) were referred.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.14 TabLayout in Android.md b/Android_Development_With_Java/2 Android UI Widgets/2.14 TabLayout in Android.md
new file mode 100644
index 0000000000..a5fc20ad6a
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.14 TabLayout in Android.md
@@ -0,0 +1,236 @@
+# TabLayout
+
+**TabLayout** is an element in Design Support Library. It is used to implement horizontal tabs. We can display more than one screen using tabs and the user can swipe between different tabs. We can create sliding as well as non-sliding tabs. TabLayout is basically view class required to be added in .xml file for creating tabs.
+
+TabLayout is released by Android after the deprecation of ActionBar.TabListener (API level 21). There are different methods used to create, add and manage the tabs.
+
+Let's look at some of the important methods of TabLayout :
+
+#### Important Methods of TabLayout (used in .java file)
+
+1. newTab() -
+ - Tabs are created using *newTab()* method of TabLayout class.
+ - This is the method that is used to return a new TabLayout.Tab.
+ - To set the title of Tabs, *setText(int)* method of TabListener interface is used.
+ - To set the icon of Tabs, *setIcon(int)* method of TabListener interface is used.
+2. addTab(Tab tab) -
+ - To add a tab in the TabLayout, *addTab(Tab tab)* method is used.
+ - Using this method, new tab created using *newTab()* method can be added in the TabLayout. The tab will be added at the end of the list; and if it is the first tab to be added, then it will become the selected tab.
+3. addTab(Tab tab, boolean setSelected) -
+ - To add a tab in the TabLayout and set it's state, *addTab(Tab tab, boolean setSelected)* method is used.
+ - Using this method, new tab created using *newTab()* method can be added in the TabLayout. Also, in this method, we set the state of the tab, whether it is selected or not.
+4. addTab(Tab tab, int position) -
+ - To add a tab in the TabLayout at a particular position and set it's state, *addTab(Tab tab, int position)* method is used.
+ - Using this method, new tab created using *newTab()* method can be added in the TabLayout and it's state can be set, whether it is selected or not. Also, the tab created can be inserted at the given position; and if it is the first tab to be added, then it will become the selected tab.
+5. addTab(Tab tab, int position, boolean setSelected) -
+ - To add a tab at a specific position and set the state of the tab, *addTab(Tab tab, int position, boolean setSelected)* method is used.
+ - We add the tab created using *newTab()* method in the TabLayout using this method.
+ - The tab will be inserted at the defined position. Defined position is passed as second parameter to the method.
+ - Third parameter represents a boolean value that is used to set the state of the tab. True value is used to make the tab selectable.
+6. getSelectedTabPosition() -
+ - To get the position of the currently selected tab, *getSelectedTabPosition()* method is used.
+ - An Integer (int) value is returned, for the position of the selected tab.
+ - This method returns -1, if no tab is selected.
+7. getTabAt(int index) -
+ - To get the tab at a specific index, *getTabAt(int index)* method is used.
+ - This method returns TabLayout.Tab.
+8. getTabCount() -
+ - To get the number of tabs that are currently registered with the action bar, *getTabCount()* method is used.
+ - This method returns an integer (int) value for the number of total tabs.
+9. setTabGravity(int gravity) -
+ - To set the gravity, to use when laying out the tabs, *setTabGravity(int gravity)* method is used.
+ - After setting the gravity, if we want to know the gravity, *getTabGravity()* method is used.
+10. getTabGravity() -
+ - To get the current gravity used for laying out the tabs, *getTabGravity()* method is used.
+ - The gravity, which we set using *setTabGravity(int gravity)* method, is returned.
+11. setTabMode(int mode) -
+ - To set the behaviour mode for the Tabs in the TabLayout, *setTabMode(int mode)* method is used.
+ - Two valid modes (inputs) that can be set are :
+ 1. MODE_FIXED :-
+ - Tabs whose mode is set MODE_FIXED display all the tabs concurrently.
+ - This mode is best used with content that benefits from quick pivots between tabs.
+ 2. MODE_SCROLLABLE :-
+ - Tabs whose mode is set MODE_SCROLLABLE display a subset of tabs at any given moment and those tabs can contain longer tab labels and a large number of tabs.
+ - This mode is best used for browsing contexts in touch interfaces, when users don't need to directly compare the tab labels.
+ - This mode is commonly used with a ViewPager.
+12. getTabMode() -
+ - To get current mode of TabLayout, *getTabMode()* method is used.
+ - An integer (int) value is returned, which we set using *setTabMode(int mode)* method.
+13. setTabTextColors(int normalColor, int selectedColor) -
+ - To set the text colors for different states (normal, selected) of the tabs, *setTabTextColors(int normalColor, int selectedColor)* method is used.
+ - Text colors for both the states of the tab is set using this method.
+ - First parameter represents the color that is to be set for the normal state of the tab.
+ - Second parameter represents the color that is to be set for the selected state of the tab.
+14. getTabTextColors() -
+ - To get the text colors for different states (normal, selected) of the tabs, *getTabTextColors()* method is used.
+ - Text color, which we set using *setTabTextColors(int normalColor, int selectedColor)* method, is returned.
+15. removeAllTabs() -
+ - To deselect the current tab and remove all the tabs from the action bar, *removeAllTabs()* method is used.
+16. setOnTabSelectedListener(OnTabSelectedListener listener) -
+ - To add a listener that will be invoked when tab selection changes, *setOnTabSelectedListener(OnTabSelectedListener listener)* method is used.
+17. removeTab(Tab tab) -
+ - To remove a tab from the TabLayout, *removeTab(Tab tab)* method is used.
+ - We pass the TabLayout.Tab object as parameter to the method to remove that tab from the layout.
+ - If the removed tab was selected, then it will be automatically deselected and another tab will be selected, if present in the TabLayout.
+18. removeTabAt(int position) -
+ - To remove a tab, from a particular position, from the TabLayout, *removeTabAt(int position)* method is used.
+ - We pass the position of the tab that we want to remove from the TabLayout as parameter to the method.
+ - If the removed tab was selected, then it will be automatically deselected and another tab will be selected, if present in the TabLayout.
+19. setSelectedTabIndicatorColor(int color) -
+ - To set the tab indicator's color for the currently selected tab, *setSelectedTabIndicatorColor(int color)* method is used.
+20. setSelectedTabIndicatorHeight(int height) -
+ - To set the tab indicator's height for the currently selected tab, *setSelectedTabIndicatorHeight(int height)* method is used.
+21. setupWithViewPager(ViewPager viewPager) -
+ - For setting up the TabLayout with ViewPager, *setupWithViewPager(ViewPager viewPager)* method is used.
+ - ViewPager is mainly used for creating sliding tabs.
+
+#### Attributes of TabLayout (used in .xml file)
+
+1. id :
+ - Attribute that uniquely identifies a TabLayout.
+2. support.design:tabBackground :
+ - Attribute used to set the background of the tabs.
+ - We can set a color or drawable in the background of tabs.
+3. support.design:tabGravity :
+ - Attribute used to set the gravity, that will be used when laying out the tabs.
+ - *setTabGravity(int gravity)* method can also be used to set the gravity programmatically (in java class).
+4. support.design:tabIndicatorColor :
+ - Attribute used to set the color of the indicator, that is used to show the currently selected tab.
+ - *setSelectedTabIndicatorColor(int color)* method can also be used to set the color programmatically (in java class).
+5. support.design:tabIndicatorHeight :
+ - Attribute used to set the height of the indicator, that is used to show the currently selected tab.
+ - *setSelectedTabIndicatorHeight(int height)* method can also be used to set the height programmatically (in java class).
+6. support.design:tabMaxWidth :
+ - Attribute used to set the maximum width for the tabs.
+7. support.design:tabMinWidth :
+ - Attribute used to set the minimum width for the tabs.
+8. support.design:tabMode :
+ - Attribute used to set the behaviour mode for the tabs in the TabLayout.
+ - *setTabMode(int mode)* method can also be used to set the mode programmatically (in java class).
+9. support.design:tabPadding :
+ - Attribute used to set the padding along all edges of tabs.
+ 1. android.support.design:tabPaddingBottom :- used to set padding along the bottom edge of the tabs.
+ 2. android.support.design:tabPaddingTop :- used to set padding along the top edge of the tabs.
+ 3. android.support.design:tabPaddingEnd :- used to set padding along the end edge of the tabs.
+ 4. android.support.design:tabPaddingStart :- used to set padding along the start edge of the tabs.
+10. support.design:tabSelectedTextColor :
+ - Attribute used to set the text color to be applied to the currently selected tab.
+ - *setTabTextColors(int normalColor, int selectedColor)* method can also be used to set default text color programmatically (in java class).
+11. support.design:tabTextColor :
+
+ - Attribute used to set the default text color to be applied to tabs.
+ - *setTabTextColors(int normalColor, int selectedColor)* method can also be used to set default text color programmatically (in java class).
+
+
+### Steps to be followed to design a TabLayout (three non-sliding tabs)
+
+Step 1 :- Create a new project in Android Studio, go to File -> New Project; and fill all the required details to create new project.
+
+Step 2 :- Open project level build.gradle and add android design support library - implementation `com.android.support:design:23.0.1`
+
+
+
+Step 3 :- Open res directory; then layout; then activity_main.xml file, add tablayout and framelayout.
+
+#### res -> layout-> activity_main.xml
+
+
+
+Step 4 :- Open src folder; then package; then MainActivity.java, to add functionalities of various tabs.
+
+#### src -> package-> MainActivity.java
+
+
+
+In MainActivity.java, add the code for TabLayout and FrameLayout; followed by adding 3 tabs (for example) in the TabLayout. Finally, we implement `setOnTabSelectorListener` event and replace the FrameLayout with fragments according to the selected tab.
+
+Step 5 :- After successfully completing step 4, we now need 3 fragments and 3 xml layouts for three tabs. Hence, create three fragments by right clicking on package folder and creating classes and name them as FirstFragment, SecondFragment and ThirdFragment.
+
+#### FirstFragment.class
+
+
+
+#### SecondFragment.class
+
+
+
+#### ThirdFragment.class
+
+
+
+And now, create three xml layouts by right clicking on layout folder (in res directory); click on New -> Layout Resource File and name them as fragment_first, fragment_second and fragment_third.
+
+#### fragment_first.xml
+
+
+
+#### fragment_second.xml
+
+
+
+#### fragment_third.xml
+
+
+
+Step 7 :- Check AndroidManifest.xml file once, whether LAUNCHER activity is properly mentioned or not.
+
+
+
+### Steps to be followed to design a TabLayout Using ViewPager (three non-sliding tabs)
+
+Step 1 :- Create a new project in Android Studio, go to File -> New Project; and fill all the required details to create new project.
+
+Step 2 :- Open project level build.gradle and add android design support library - implementation `com.android.support:design:23.0.1`
+
+
+Step 3 :- Open res directory; then layout; then activity_main.xml file, add tablayout and viewpager.
+
+#### res -> layout-> activity_main.xml
+
+
+
+Step 4 :- Open src folder; then package; then MainActivity.java, to add functionalities of various tabs.
+
+#### src -> package-> MainActivity.java
+
+
+
+In MainActivity.java, add the code for TabLayout and ViewPager; followed by adding 3 tabs (for example) in the TabLayout. Finally, we set an Adapter named `PagerAdapter` to set up the TabLayout with ViewPager.
+
+Step 5 :- In this step, we create a new class named `PagerAdapter` and extend `FragmentStatePagerAdapter` in the class for setting up the TabLayout with the ViewPager.
+
+
+
+Step 6 :- After successfully completing step 4 and 5, we now need 3 fragments and 3 xml layouts for three tabs. Hence, create three fragments by right clicking on package folder and creating classes and name them as FirstFragment, SecondFragment and ThirdFragment.
+
+#### FirstFragment.class
+
+
+
+#### SecondFragment.class
+
+
+
+#### ThirdFragment.class
+
+
+
+And now, create three xml layouts by right clicking on layout folder (in res directory); click on New -> Layout Resource File and name them as fragment_first, fragment_second and fragment_third.
+
+#### fragment_first.xml
+
+
+
+#### fragment_second.xml
+
+
+
+#### fragment_third.xml
+
+
+
+Step 7 :- Check AndroidManifest.xml file once, whether LAUNCHER activity is properly mentioned or not.
+
+
+
+For more information about sensors, please visit [this](https://abhiandroid.com/materialdesign/tablayout-example-android-studio.html).
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.17 Nested RecyclerView in Android.md b/Android_Development_With_Java/2 Android UI Widgets/2.17 Nested RecyclerView in Android.md
new file mode 100644
index 0000000000..af8a27fac5
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.17 Nested RecyclerView in Android.md
@@ -0,0 +1,396 @@
+# Nested RecyclerView in Android
+Nested Recycler View means adding a recycler View within a recycler View. In other words, it means that there will be a recycler view whose each layout will contain recycler views in themselves.
+
+The steps to make a Single RecyclerView are as follows :
+ 1) Create the Model Class.
+ 2) Create an item layout xml.
+ 3) Create the RecyclerView Adapter and the ViewHolder classes.
+ 4) Attach the recycler view adapter to the recycler view.
+
+We will be following the same steps as mentioned. The only difference in the Nested Recycler View is that the item layout (in Step 2) will contain a recycler view.
+
+## Let's start making a Nested RecyclerView :
+
+### 1) Model Class of the RecyclerView within the main RecyclerView (Child RecyclerView):
+
+```java
+public class NestedModelClass {
+ private String name;
+ private String unique_id;
+
+ //Constructor
+ public NestedModelClass(String name, String unique_id) {
+ this.name = name;
+ this.unique_id = unique_id;
+ }
+
+ public NestedModelClass() {
+ }
+
+ // Getters and Setters
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getUnique_id() {
+ return unique_id;
+ }
+
+ public void setUnique_id(String unique_id) {
+ this.unique_id = unique_id;
+ }
+}
+```
+
+### 2) Model Class of the Parent RecyclerView :
+
+```java
+import java.util.List;
+
+public class ModelClass {
+
+ private String date;
+ private List list;
+
+ // Constructor
+ public ModelClass(String date, List list) {
+ this.date = date;
+ this.list = list;
+ }
+
+ public ModelClass() {
+ }
+
+ //Getters and Setters
+ public String getDate() {
+ return date;
+ }
+
+ public void setDate(String date) {
+ this.date = date;
+ }
+
+ public List getList() {
+ return list;
+ }
+
+ public void setList(List list) {
+ this.list = list;
+ }
+}
+
+```
+
+#### With this we have completed the first step, i.e., making the Model Classes. Next we will make the item layouts, one for the Parent RecyclerView and the other for the nested Child RecyclerView.
+
+### child_item_layout.xml
+
+```xml
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+Next we will create the item_layout of the Parent Recycler View. This layout will contain a recycler View.
+
+### item_layout.xml
+
+```xml
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+#### The second step is complete,i.e., creating the item_layouts. Next we will create the Adapter Classes. First we will make the Adapter of the Child recyclerView. This adapter will be attached within the onBindViewHolder() method of the main RecyclerView.
+
+### RecyclerView Adapter and ViewHolder of the Child RecyclerView.
+This will inflate the `child_item_layout.xml` layout.
+
+```java
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.List;
+
+public class ChildAdapter extends RecyclerView.Adapter {
+ Context context;
+ List list;
+
+ //Constructor
+ public ChildAdapter(Context context, List list) {
+ this.context = context;
+ this.list = list;
+ }
+
+ //Override Methods
+
+ @NonNull
+ @Override
+ public ChildViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ //Inflate the child_item_layout
+ View view = LayoutInflater.from(context).inflate(R.layout.child_item_layout, parent, false);
+ return new ChildViewHolder(view);
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull ChildViewHolder holder, int position) {
+ NestedModelClass modelClass = list.get(position);
+ holder.name.setText(modelClass.getName());
+ holder.uniqueid.setText(modelClass.getUnique_id());
+
+ }
+
+ @Override
+ public int getItemCount() {
+ return list.size();
+ }
+
+ //View Holder Class
+ public class ChildViewHolder extends RecyclerView.ViewHolder {
+ TextView name, uniqueid;
+
+ public ChildViewHolder(@NonNull View itemView) {
+ super(itemView);
+ name = itemView.findViewById(R.id.name);
+ uniqueid = itemView.findViewById(R.id.unique_id);
+ }
+ }
+}
+```
+ This Adapter Class will be used in the RecyclerView inside each item of the main RecyclerView. We will now create the Adapter Class of the Main Recycler View.
+
+### RecyclerView Adapter and ViewHolder of the Parent RecyclerView.
+This will inflate the `item_layout.xml` layout.
+
+```java
+ import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DataAdapter extends RecyclerView.Adapter {
+ Context context;
+ List list;
+
+ //Constructor
+ public DataAdapter(Context context, List list) {
+ this.context = context;
+ this.list = list;
+ }
+
+ //Override Methods
+
+ @NonNull
+ @Override
+ public DataViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ View view = LayoutInflater.from(context).inflate(R.layout.item_layout, parent, false);
+ return new DataViewHolder(view);
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull DataViewHolder holder, int position) {
+ ModelClass modelClass = list.get(position);
+ holder.date.setText(modelClass.getDate());
+ List modelClassList=new ArrayList<>();
+ modelClassList=modelClass.getList(); //get list
+ ChildAdapter adapter=new ChildAdapter(context,modelClassList);
+ LinearLayoutManager layoutManager=new LinearLayoutManager(context);
+ holder.recyclerView.setLayoutManager(layoutManager); //Set Layout Manager
+ holder.recyclerView.setAdapter(adapter); //Set Adapter
+ }
+
+ @Override
+ public int getItemCount() {
+ return list.size();
+ }
+
+
+ //View Holder Class
+ public class DataViewHolder extends RecyclerView.ViewHolder {
+ TextView date;
+ RecyclerView recyclerView;
+
+ public DataViewHolder(@NonNull View itemView) {
+ super(itemView);
+ date = itemView.findViewById(R.id.date);
+ recyclerView = itemView.findViewById(R.id.recycler_view);
+ }
+ }
+}
+```
+Finally, we will complete the app by making the MainActivity.java and activity_main.xml.
+
+### activity_main.xml
+
+```xml
+
+
+
+
+
+
+```
+
+### MainActivity.java
+
+// We have added random data to the lists for demo purposes
+
+```java
+package com.example.nestedrecyclerview;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import android.os.Bundle;
+import android.view.View;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainActivity extends AppCompatActivity {
+ List list;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ RecyclerView recyclerView = findViewById(R.id.rv_main);
+ list = new ArrayList<>();
+
+ // add items to the list as per your app
+ getList();
+ DataAdapter adapter = new DataAdapter(this, list);
+ recyclerView.setLayoutManager(new LinearLayoutManager(this));
+ recyclerView.setAdapter(adapter);
+
+ }
+
+ private void getList() {
+
+ //Adding Random Data to the lists.
+ List list1 = new ArrayList<>();
+ List list2 = new ArrayList<>();
+ List list3 = new ArrayList<>();
+ List list4 = new ArrayList<>();
+ List list5 = new ArrayList<>();
+
+ list1.add(new NestedModelClass("Alice", "1"));
+ list1.add(new NestedModelClass("Alexa", "2"));
+ list1.add(new NestedModelClass("Bob", "3"));
+ list2.add(new NestedModelClass("Charlie", "4"));
+ list2.add(new NestedModelClass("Dean", "5"));
+ list3.add(new NestedModelClass("Emily", "6"));
+ list3.add(new NestedModelClass("George", "7"));
+ list4.add(new NestedModelClass("Henry", "8"));
+ list4.add(new NestedModelClass("Harry", "9"));
+ list4.add(new NestedModelClass("Hermione", "10"));
+ list4.add(new NestedModelClass("John", "11"));
+ list5.add(new NestedModelClass("Ron", "12"));
+
+ list.add(new ModelClass("26-Jan-2021", list1));
+ list.add(new ModelClass("15-Aug-2021", list2));
+ list.add(new ModelClass("05-Sep-2021", list3));
+ list.add(new ModelClass("14-Nov-2021", list4));
+ list.add(new ModelClass("25-Dec-2021", list5));
+ }
+
+
+}
+```
+
+We have finally attached the DataAdapter to our main RecyclerView. The final `output` of the above code is as follows:
+
+
+# _______________________________________________________________________________________________________________________
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.18 NESTED_SCROLL_VIEW_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.18 NESTED_SCROLL_VIEW_IN_ANDROID.md
new file mode 100644
index 0000000000..3d73bbadbb
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.18 NESTED_SCROLL_VIEW_IN_ANDROID.md
@@ -0,0 +1,127 @@
+# **Nested Scroll View**
+
+Scroll View is while reading a pdf or a going through the feed in Instagram we scroll to move further pages and to see more posts respectively.
+Similarly, NestedScrollView is just like ScrollView, but it supports acting as both a nested scrolling parent and child. It is enabled by default. As the Name suggests, NestedScrollView is a widget that is used when we want to implement scrollable view inside another scrollable view.
+You have seen this in many apps for example when we open a pdf file and when we reached the end of the PDF there is an Ad below the pdf file. This would be difficult for the system as it have to decide which view to Scroll. So, this is where NestedScrollView comes in.
+
+Lets undestand this with an example:
+
+
+### **Step 1: Create a New Project**
+
+Follow steps below to create new project. Please ignore the steps if you have already created a new application.
+
+
+|Step|Description|
+|----|-----------|
+|1.|Open Android Studio|
+|2.|Go to **File** => **New** => **New Project**. Write application name as **Nested App**. Then click **next**.|
+|3.|Select minimum SDK you need. However, we have selected 17 as minimum SDK. Then, click **next** button.|
+|4.|Then, select **Empty Activity** => click **next** => click **finish**.|
+
+
+
+Now, we will modify xml and java file to use nestedScrollView widget in the application.
+
+
+
+### **Step 2: Modifying XML file**
+
+Go to the **app** -> **res** -> **values** -> **strings.xml** and add two random text strings inside the strings.xml file to display those strings in the activity_main.xml file.
+
+~~~
+
+ Nested App
+
+ assassin_s_creed_is_an_open_world_action_adventure_stealth_video_game_franchise_published_by_ubisoft_and_developed_mainly_by_its_studio_ubisoft_montreal_using_the_game_engine_anvil_and_its_more_advanced_derivatives_created_by_patrice_d_silets_jade_raymond_and_corey_may_the_assassin_s_creed_series_depicts_a_fictional_millennia_old_struggle_between_the_assassins_who_fight_for_peace_and_free_will_and_the_templars_who_desire_peace_through_order_and_control_the_series_features_historical_fiction_science_fiction_and_fictional_characters_intertwined_with_real_world_historical_events_and_figures_in_the_majority_of_the_games_players_control_a_historical_assassin_while_also_playing_as_an_assassin_initiate_or_someone_caught_in_the_assassin_templar_conflict_in_the_present_day_framing_story_the_series_took_inspiration_from_the_novel_alamut_by_the_slovenian_writer_vladimir_bartol_based_on_the_historical_hashashin_sect_of_the_medieval_middle_east_1_while_building_upon_concepts_from_the_prince_of_persia_series_2_the_series_s_eponymous_first_title_was_released_in_2007_and_it_has_featured_twelve_main_games_in_total_the_most_recent_being_2020_s_valhalla_main_games_of_assassin_s_creed_are_set_in_an_open_world_and_presented_from_the_third_person_perspective_where_the_protagonists_take_down_targets_using_their_combat_and_stealth_skills_with_the_exploitation_of_the_environment_players_have_freedom_to_explore_the_historical_settings_as_they_finish_main_and_side_quests_apart_from_single_player_missions_some_games_also_provide_competitive_and_cooperative_multiplayer_gameplay_a_new_story_and_occasional_new_time_period_are_introduced_in_each_entry_and_gameplay_elements_evolve_from_the_previous_one_there_are_three_overarching_story_arcs_in_the_series_the_first_five_main_games_follow_desmond_miles_a_descendant_of_several_important_assassins_throughout_history_who_uses_a_machine_called_the_animus_to_relive_his_ancestors_memories_and_find_powerful_artifacts_called_quot_pieces_of_eden_quot_while_also_attempting_to_prevent_a_catastrophic_event_said_to_wipe_out_humanity_by_the_end_of_2012_from_assassin_s_creed_iv_black_flag_and_until_assassin_s_creed_syndicate_assassin_initiates_and_employees_of_abstergo_a_company_used_as_a_cover_by_the_modern_day_templars_record_genetic_memories_using_the_helix_software_helping_the_templars_and_assassins_find_new_pieces_of_eden_in_the_modern_world_the_latest_three_games_assassin_s_creed_origins_assassin_s_creed_odyssey_and_assassin_s_creed_valhalla_follow_ex_abstergo_employee_layla_hassan_and_her_own_quest_to_save_humanity_from_another_disaster">Assassin\'s Creed is an open-world action-adventure stealth video game franchise published by Ubisoft and developed mainly by its studio Ubisoft Montreal using the game engine Anvil and its more advanced derivatives. Created by Patrice Désilets, Jade Raymond, and Corey May, the Assassin\'s Creed series depicts a fictional millennia-old struggle between the Assassins, who fight for peace and free will, and the Templars, who desire peace through order and control. The series features historical fiction, science fiction and fictional characters intertwined with real-world historical events and figures. In the majority of the games, players control a historical Assassin, while also playing as an Assassin Initiate or someone caught in the Assassin-Templar conflict in the present-day framing story. The series took inspiration from the novel Alamut by the Slovenian writer Vladimir Bartol, based on the historical Hashashin sect of the medieval Middle East,[1] while building upon concepts from the Prince of Persia series.[2] The series\'s eponymous first title was released in 2007, and it has featured twelve main games in total, the most recent being 2020\'s Valhalla. Main games of Assassin\'s Creed are set in an open world and presented from the third-person perspective where the protagonists take down targets using their combat and stealth skills with the exploitation of the environment. Players have freedom to explore the historical settings as they finish main and side quests. Apart from single-player missions, some games also provide competitive and cooperative multiplayer gameplay. A new story and occasional new time period are introduced in each entry, and gameplay elements evolve from the previous one. There are three overarching story arcs in the series. The first five main games follow Desmond Miles, a descendant of several important Assassins throughout history, who uses a machine called the Animus to relive his ancestors\' memories and find powerful artifacts called \"Pieces of Eden\", while also attempting to prevent a catastrophic event said to wipe out humanity by the end of 2012. From Assassin\'s Creed IV: Black Flag and until Assassin\'s Creed Syndicate, Assassin initiates and employees of Abstergo (a company used as a cover by the modern-day Templars) record genetic memories using the Helix software, helping the Templars and Assassins find new Pieces of Eden in the modern world. The latest three games, Assassin\'s Creed Origins, Assassin\'s Creed Odyssey, and Assassin\'s Creed Valhalla, follow ex-Abstergo employee Layla Hassan and her own quest to save humanity from another disaster.
+
+ Nested Scroll View
+ TODO
+
+
+~~~
+
+
+### **Step 3: Designing UI**
+
+In the activity_main.xml file add the NestedScrollView and inside NestedScrollView add a LinearLayout and inside LinearLayout add two TextView to display the strings which are created inside the strings.xml file and one Button between the TextView. Here is the code for the activity_main.xml file. One can add as many views inside the NestedScrollView’s Linear Layout.
+
+~~~
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+~~~
+
+
+### **Step 4: Working with main Java file**
+
+
+There is no need of changing the **MainActivity.java**, so keep it as it is.
+
+And for the referrence below is the code of the **MainActivity.java** file:
+
+~~~
+import androidx.appcompat.app.AppCompatActivity;
+import android.os.Bundle;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ }
+}
+~~~
+
+## **Output**
+Below is how your output should look like.
+
+[](https://drive.google.com/uc?id=1ygGca-38G_vKE4UTvFJXDTSSLdEHdCrU)
+
+## **Referrences**
+
+* https://www.geeksforgeeks.org/nestedscrollview-in-android-with-example/
\ No newline at end of file
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.19 Expandable RecyclerView in Android.md b/Android_Development_With_Java/2 Android UI Widgets/2.19 Expandable RecyclerView in Android.md
new file mode 100644
index 0000000000..ed9ef844af
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.19 Expandable RecyclerView in Android.md
@@ -0,0 +1,332 @@
+# Expandable RecyclerView in Android
+Expandable RecyclerView is one of the most important feature in Android which can be easily created for our application.
+
+It contains two views one is parent view and other is child view.
+Parent is visible by default but the child view has to be expanded and collapsed.
+It will expand when we click on parent view.
+
+## Expandable RecyclerView View Holders
+We have to create two view holders to hold the view of parent and child
+- ParentViewHolder
+- ChildViewHolder
+
+So, by using these we shall create it in our application to make it better.
+
+## Example for Expandable RecyclerView
+
+### Step 1: Build.Gradle (Module)
+Add this dependency in your build.gradle file.
+
+ ```xml
+implementation 'androidx.cardview:cardview:1.0.0'
+implementation 'androidx.recyclerview:recyclerview:1.2.1'
+```
+
+### Step 2: Adding RecyclerView
+Now come back to the layout of your MainActivity which is usually activity_main.xml and add a RecyclerView here.
+
+```xml
+
+
+
+
+
+
+
+```
+
+### Step 3: Designing List Layout
+Now lets design the xml layout for the List/Row.
+So first create a new layout resource file named row.xml (or you can give it any name), and write the following xml code.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Step 4: Creating Data Model
+Now to store data, we need to create a model class. So create a new class named Versions.java and write the following code.
+
+```java
+package com.example.recyclerviewapp;
+
+public class Versions {
+
+ private String codeName, version, apiLevel, description;
+ private boolean expandable;
+ // create parameterize constructors, getters and setter by pressing alt+insert.
+
+ public String getCodeName() {
+ return codeName;
+ }
+
+ public void setCodeName(String codeName) {
+ this.codeName = codeName;
+ }
+
+ public String getVersion() {
+ return version;
+ }
+
+ public void setVersion(String version) {
+ this.version = version;
+ }
+
+ public String getApiLevel() {
+ return apiLevel;
+ }
+
+ public void setApiLevel(String apiLevel) {
+ this.apiLevel = apiLevel;
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public boolean isExpandable() {
+ return expandable;
+ }
+
+ public void setExpandable(boolean expandable) {
+ this.expandable = expandable;
+ }
+
+ public Versions(String codeName, String version, String apiLevel, String description) {
+ this.codeName = codeName;
+ this.version = version;
+ this.apiLevel = apiLevel;
+ this.description = description;
+ this.expandable = false;
+ }
+ // toString method
+
+ @Override
+ public String toString() {
+ return "Versions{" +
+ "codeName='" + codeName + '\'' +
+ ", version='" + version + '\'' +
+ ", apiLevel='" + apiLevel + '\'' +
+ ", description='" + description + '\'' +
+ '}';
+ }
+}
+
+```
+
+### Step 5: Creating RecyclerView Adapter
+Create a new class named VersionsAdapter.java and write the following code.
+
+```java
+package com.example.recyclerviewapp;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.List;
+
+public class VersionsAdapter extends RecyclerView.Adapter {
+ // VersionVH is viewHolder Class
+ List versionsList;
+
+ public VersionsAdapter(List versionsList) {
+ this.versionsList = versionsList;
+ }
+
+ @NonNull
+ @Override
+ public VersionVH onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.row, parent, false);
+ return new VersionVH(view);
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull VersionVH holder, int position) {
+
+ Versions versions = versionsList.get(position);
+ holder.codeNametext.setText(versions.getCodeName());
+ holder.versiontext.setText(versions.getVersion());
+ holder.apiLeveltext.setText(versions.getApiLevel());
+ holder.descriptiontext.setText(versions.getDescription());
+ boolean isExpandable = versionsList.get(position).isExpandable();
+ holder.expandableLayout.setVisibility(isExpandable ? View.VISIBLE : View.GONE);
+
+ }
+
+ @Override
+ public int getItemCount() {
+ return versionsList.size();
+ }
+
+ public class VersionVH extends RecyclerView.ViewHolder {
+
+ // get layouts and textView
+ TextView codeNametext, versiontext, apiLeveltext, descriptiontext;
+ LinearLayout linearLayout;
+ RelativeLayout expandableLayout;
+
+ public VersionVH(@NonNull View itemView) {
+ super(itemView);
+ codeNametext = itemView.findViewById(R.id.code_name);
+ versiontext = itemView.findViewById(R.id.version);
+ apiLeveltext = itemView.findViewById(R.id.api_level);
+ descriptiontext = itemView.findViewById(R.id.description);
+
+ linearLayout = itemView.findViewById(R.id.linear_layout);
+ expandableLayout = itemView.findViewById(R.id.expandable_layout);
+
+ // set onclickListener on linearLayout
+ linearLayout.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+
+ Versions versions = versionsList.get(getAdapterPosition());
+ versions.setExpandable(!versions.isExpandable());
+ notifyItemChanged(getAdapterPosition());
+ }
+ });
+ }
+ }
+}
+
+```
+
+### Step 6: Now come back to MainActivity.java and write the following code.
+
+```java
+package com.example.recyclerviewapp;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.recyclerview.widget.RecyclerView;
+
+import android.os.Bundle;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainActivity extends AppCompatActivity {
+
+ RecyclerView recyclerView;
+ List versionsList;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ recyclerView = findViewById(R.id.recyclerView);
+
+ initData();
+ setRecyclerview();
+ }
+
+ private void setRecyclerview() {
+ VersionsAdapter versionsAdapter = new VersionsAdapter(versionsList);
+ recyclerView.setAdapter(versionsAdapter);
+ recyclerView.setHasFixedSize(true);
+ }
+
+ private void initData() {
+ // add required information
+ versionsList = new ArrayList<>();
+ versionsList.add(new Versions("Android 10", "Version 10", "Api Level 29", "Description"));
+ versionsList.add(new Versions("Pie", "Version 9", "Api Level 28", "Description"));
+ versionsList.add(new Versions("Oreo", "Version 8.1.0", "Api Level 27", "Description"));
+ versionsList.add(new Versions("Nougat", "Version 7.1", "Api Level 25", "Description"));
+ versionsList.add(new Versions("Marshmallow", "Version 6.0", "Api Level 23", "Description"));
+ versionsList.add(new Versions("Lollipop", "Version 5.1", "Api Level 22", "Description"));
+ versionsList.add(new Versions("Kit Kat", "Version 4.4", "Api Level 19", "Description"));
+
+ }
+}
+
+```
+### Result
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.2 onClickListener.md b/Android_Development_With_Java/2 Android UI Widgets/2.2 onClickListener.md
new file mode 100644
index 0000000000..b19f6e7e24
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.2 onClickListener.md
@@ -0,0 +1,40 @@
+# OnClickListeners
+
+In simple words, **`OnClickListener`** is an Interface definition for a callback to be invoked when a view (button in your case) is clicked.
+
+## So what actually a Listener is?
+Listeners are used to capture events. When, for instance, the user interacts with the Android system by clicking on a button or tapping a part of the screen
+
+* **`SetOnClickListeners`** - SetOnClickListener method which helps us to link a listener with certain attributes.
+
+----
+
+
+----
+
+
+> **Code**
+```Java
+public class MyActivity extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.content_layout_id);
+
+ // With the help of findViewById() method,we will get the reference to the view in XML.
+ Button mButton = findViewById(R.id.button_send);
+
+ //setting listener on the mButton
+ mButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view)
+ {
+ TextView mTextView = findViewById(R.id.textView);
+ mTextView.setText("Click Captured");
+ }
+ });
+ }
+ }
+```
+
+For more help visit [Android Official Documenation.](https://developer.android.com/reference/android/widget/Button) & [Stack Overflow](https://stackoverflow.com/questions/29479647/android-setonclicklistener-vs-onclicklistener-vs-view-onclicklistener)
\ No newline at end of file
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.21 Chips in android.md b/Android_Development_With_Java/2 Android UI Widgets/2.21 Chips in android.md
new file mode 100644
index 0000000000..b912185ba5
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.21 Chips in android.md
@@ -0,0 +1,291 @@
+# Chips in android
+Chips are material design elements that allow users to enter information, make selections, filter content, or trigger actions. They appear dynamically as a group of multiple interactive elements.
+
+#### Chips are mainly of 4 types :
+ * Input Chips
+ * Choice Chips
+ * Filter Chips
+ * Action Chips
+
+## Getting Started with Chips
+To create chips, we can add the layout using the below code:
+```xml
+
+```
+
+Changes to a chip can be observed using the following functions:
+
+* `chip.setOnClickListener()` - Responds to chip click
+* `chip.setOnCloseIconClickListener()` - Responds to chip's close icon click (if present)
+* `chip.setOnCheckedChangeListener()` - Responds to chip checked/unchecked
+
+#### Chips are grouped together using `ChipGroup`. A ChipGroup rearranges chips across multiple rows by default.
+
+```xml
+
+
+
+
+
+```
+
+## Input Chips
+Input Chips (also called Entry Chips) are used to take input from the user and convert the text in the form of a chip. It can show entity or provide suggestions for input.
+
+### To design Input Chips :
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+## Choice Chips
+Choice Chips are used to select from a set of options. They are a good alternative to toggle buttons, radio buttons, and single select menus.
+
+### To design Choice Chips :
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+## Filter Chips
+Filter Chips are used to select multiple items from a set of options. They are a good alternative to toggle buttons and checkboxes.
+
+### To design Filter Chips :
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+## Action Chips
+Action Chips are used to perform a particular task when clicked.
+
+### To design Action Chips :
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+To perform a task we use the `chip.setOnClickListener()` method.
+
+
+
+
+
+ #### Chips are widely used in our Apps to make the App UI look more professional. There are many other attributes by which one can design and execute these chips as per their choice. To know more about these attributes, [click here](https://material.io/components/chips/android).
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.22 Top App Bar.md b/Android_Development_With_Java/2 Android UI Widgets/2.22 Top App Bar.md
new file mode 100644
index 0000000000..e73a064c51
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.22 Top App Bar.md
@@ -0,0 +1,86 @@
+## Top App Bar
+**The top app bar provides content and actions related to the current screen. It’s used for branding, screen titles, navigation, and actions.**
+
+
+
+## Types
+**There are four types of top app bars: 1. `Center aligned`, 2. `Small`, 3. `Medium`, 4. `Large`.**
+
+
+## Small top app bar example
+Before you can use Material top app bars, you need to add a dependency to the Material Components for Android library.
+
+The following example shows a Small top app bar with a page title, a navigation
+icon, two actions, and an overflow menu.
+
+
+
+In the layout:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+In `@menu/top_app_bar.xml`:
+
+```xml
+
+```
+
+In menu/navigation icon drawables:
+
+```xml
+
+ ...
+
+```
+**Note:** In order for it to work, you need to use a `Theme.Material3.*` theme containing the `NoActionBar`
+segment, such as the `Theme.Material3.Light.NoActionBar`.
+
+**For three other types `Small`, `Medium`, `Large` please vist [Official Doc](https://github.com/material-components/material-components-android/blob/master/docs/components/TopAppBar.md#types)**
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.23 Toolbar - Custom Action Bar.md b/Android_Development_With_Java/2 Android UI Widgets/2.23 Toolbar - Custom Action Bar.md
new file mode 100644
index 0000000000..c7527b5eea
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.23 Toolbar - Custom Action Bar.md
@@ -0,0 +1,112 @@
+## Toolbar - Custom Action Bar
+
+**In Android applications, Toolbar is a kind of ViewGroup that can be placed in the XML layouts of an activity.**
+
+
+
+* **Use as an ActionBar:** In an app, the toolbar can be used as an ActionBar in order to provide more customization and a better appearance. All the features of ActionBar such as menu inflation, ActionBarDrawerToogle, etc. are also supported in Toolbar.
+
+### Features supported by the Toolbar.
+
+* Navigation button
+* Brand logo/App icon
+* Title and Subtitle
+* ActionMenuView
+* Multiple Custom Views
+
+## Process
+
+### Step 1 - Removing ActionBar.
+
+Go to `theme.xml` file.and chnage theme of the base application to `Theme.AppCompat.Light.NoActionBar.`
+
+```XML
+
+
+
+
+```
+Output:
+
+
+
+### Step 2 - Adding a Tooolbar XML Layout.
+
+Here we define our own custom Toolbar Attributes.
+
+```XML
+
+
+
+```
+
+### Step 3 - Including the Toolbar in activity_main Layout..
+
+
+we have use `` attribute to add our `toolbar.xml` to the `activity_main.xml.`
+
+```XMl
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Step 4 - Setting up Toolbar as ActionBar.
+
+To make the desired change, the ID of the Toolbar must be passed as an argument in the `setSupportActionBar()` method written inside the MainActivity file.
+
+```JAVA
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // finding toolbar by id
+ Toolbar toolbar = findViewById(R.id.toolbar);
+ // setting toolbar
+ setSupportActionBar(toolbar);
+ }
+
+}
+```
+For more help please visit [Android Official Documentation](https://developer.android.com/reference/android/widget/Toolbar)
\ No newline at end of file
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.3 Toast.md b/Android_Development_With_Java/2 Android UI Widgets/2.3 Toast.md
new file mode 100644
index 0000000000..b76de613a1
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.3 Toast.md
@@ -0,0 +1,47 @@
+# Toast
+
+`Toast` can be used to display information for the short period of time. A `Toast` contains message to be displayed quickly and disappears after sometime.
+
+
+
+> **Toast Syntax**
+
+```java
+// We use makeText() method, which takes the following parameters: Context, text, duration
+Toast toast = Toast.makeText(context, text, duration);
+
+// To display the toast, call the show() method,
+toast.show();
+```
+* Generally `duration` can be `LENGTH_LONG` or `LENGTH_SHORT`
+* Context arguments can `getApplicationContext()` or `Class.this` depending on the uses.
+
+---
+### Toast Example
+
+
+**Source Code**
+
+```java
+
+public class MainActivity extends AppCompatActivity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ Button mButton = findViewById(R.id.button);
+
+ mButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view)
+ {
+ // Setting up the Toast
+ Toast toast = Toast.makeText(MainActivity.this, "Hello I'm A Toast" , Toast.LENGTH_SHORT);
+ toast.show();
+
+ }
+ });
+ }
+}
+```
+For more help visit [Android Official Documenation](https://developer.android.com/guide/topics/ui/notifiers/toasts) & [Stack Overflow](https://stackoverflow.com/questions/3500197/how-to-display-toast-in-android)
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.36 RatingBar in Android.md b/Android_Development_With_Java/2 Android UI Widgets/2.36 RatingBar in Android.md
new file mode 100644
index 0000000000..b4264be829
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.36 RatingBar in Android.md
@@ -0,0 +1,151 @@
+# RatingBar in Android
+
+Rating Bar, available in the widget package, is an extension of SeekBar and ProgressBar, which shows the rating as stars.
+The **RatingBar** class extends from the AbsSeekBar class in the widget package.
+
+
+
+```java
+
+public class RatingBar extends android.widget.AbsSeekBar {
+ ...
+}
+
+```
+
+
+
+## How to use?
+
+The user can either touch or drag the stars or shall use arrow keys to set the rating.
+
+
+
+## Attributes
+
+- ``` android:isIndicator``` To set whether this rating bar is an indicator
+- ``` android:numStars``` To set the number of stars to show
+- ``` android:rating``` To set the default rating
+- ``` android:stepSize``` To set the step size of the rating
+
+
+
+## Public Methods
+
+> *isIndicator()* - Returns whether the ratings bar is an indicator or not
+>
+> *setIsIndicator(boolean isIndicator)* - Sets the rating bar to only be an indicator
+
+> *getNumStars()* - Returns the number of stars
+>
+> *setNumStars(int numStars)* - Sets the number of stars
+
+> *getRating()* - Returns the rating
+>
+> *setRating(float rating)* - Sets the rating
+
+> *getStepSize()* - Returns the step size
+>
+> *setStepSize(float stepSize)* - Sets the tep size
+
+> *setMax(int max)* - Set the upper range of the progress bar max
+>
+> *setOnRatingBarChangeListener(RatingBar.OnRatingBarChangeListener listener)* - Sets the listener to be called when the rating changes
+
+> *getAccessibilityClassName()* - Returns the class name of this object to be used for accessibility purposes
+>
+> *getOnRatingBarChangeListener()* - Returns the RatingBar.OnRatingBarChangeListener
+
+
+
+
+### XML
+```xml
+
+```
+
+
+
+### Java
+
+```java
+ RatingBar ratingBar = findViewById(R.id.ratingBar);
+
+ ratingBar.setOnRatingBarChangeListener(new RatingBar.OnRatingBarChangeListener() {
+ @Override
+ public void onRatingChanged(RatingBar ratingBar, float v, boolean b) {
+ //Code here
+ }
+ });
+```
+
+```java
+ RatingBar ratingBar = findViewById(R.id.ratingBar);
+
+ ratingBar.setOnRatingBarChangeListener(new RatingBar.OnRatingBarChangeListener() {
+ @Override
+ public void onRatingChanged(RatingBar ratingBar, float v, boolean b) {
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getRating() returns : " + ratingBar.getRating(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getNumStars() returns : " + ratingBar.getNumStars(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getStepSize() returns : " + ratingBar.getStepSize(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.isIndicator() returns : " + ratingBar.isIndicator(),
+ Toast.LENGTH_SHORT).show();
+
+ }
+ });
+```
+
+
+
+### Lambda Expression
+
+```java
+ ratingBar.setOnRatingBarChangeListener((ratingBar, v, b) -> {
+
+ //Example using methods
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getRating() returns : " + ratingBar.getRating(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getNumStars() returns : " + ratingBar.getNumStars(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.getStepSize() returns : " + ratingBar.getStepSize(),
+ Toast.LENGTH_SHORT).show();
+
+ Toast.makeText(getApplicationContext(),
+ "ratingBar.isIndicator() returns : " + ratingBar.isIndicator(),
+ Toast.LENGTH_SHORT).show();
+
+ });
+```
+
+
+
+## Screenshots
+
+
+
+About:
+
+In Android, the layout is used to describe the user interface that
+contains the UI controls or widgets that would display on an android
+device or operation screen. Layout specifies the various widgets to be
+used in the UI and the relationships between such widgets and their
+containers.
+
+Layout files are stored in \"res-\> layout\" in the Android application.
+When we open the resource of the application, we find the layout files
+of the Android application.
+
+The layout must contain only one root, View or ViewGroup object. Once we
+define the root element, then we can add additional layout objects or
+widgets as child elements to build the View hierarchy that defines our
+layout. These layouts can have various widgets like buttons, labels,
+textboxes, and many others.
+
+In android, we can define a layout in two ways, those are
+
+- Declare UI elements in XML
+
+- Instantiate layout elements at runtime
+
+The Android framework will allow us to use either or both of these
+methods to define our application's UI.
+
+**Quick Glance**: A **View** is a simple building block of a user
+interface. It is a small rectangular box that can be TextView, EditText,
+or even a button. The view is a superclass of all the graphical user
+interface components. A **View Group** is a subclass of the ViewClass
+and can be considered as a superclass of Layouts. It provides an
+invisible container to hold the views or layouts. ViewGroup instances
+and views work together as a container for Layouts.
+
+Android Layout Attributes:
+
+ -----------------------------------------------------------------------
+ **Attributes of Layout**
+ ----------------------------- -----------------------------------------
+ **android:id** - It uniquely defines the identity of View
+ and ViewGroups in a layout.
+
+ **android:layout_width** - It defines the width of View and
+ ViewGroup elements in a layout.
+
+ **android:layout_height** - It defines the height of View and
+ ViewGroup elements in a layout.
+
+ **android:layout_marginLeft** - It defines the extra space in the left
+ side of View and ViewGroup elements in a
+ layout.
+
+ **android:layout_marginRight** - It defines the extra space on the right
+ side of View and ViewGroup elements in a
+ layout.
+
+ **android:layout_marginTop** - It defines the extra space on the top of
+ View and ViewGroup elements in a layout.
+
+ **android:layout_marginBottom** - It defines the extra space on the bottom
+ of View and ViewGroup elements in a
+ layout.
+
+ **android:paddingLeft** - It defines the left-side padding for View
+ and ViewGroup elements in the layout
+ files.
+
+ **android:paddingRight** - It defines the right-side padding for
+ View and ViewGroup elements in the layout
+ files.
+
+ **android:paddingTop** - It defines the top-side padding for View
+ and ViewGroup elements in the layout
+ files.
+
+ **android:paddingBottom** - It defines the bottom-side of the padding
+ for View and ViewGroup elements in the
+ layout files.
+
+ **android:layout_gravity** - It defines the position of child View.
+
+ **android:layout_x** - It defines the x-coordinate of a layout.
+
+ **android:layout_y** - It defines the y-coordinate of a layout.
+
+ -----------------------------------------------------------------------
+
+Look at the below code to understand width and height attributes.
+
+> \\
+> \ xmlns:android=\"http://schemas.android.com/apk/res/android" \
+> xmlns:app=\"http://schemas.android.com/apk/res-auto" \
+> xmlns:tools=\"http://schemas.android.com/tools] \
+> android:layout_width=\"match_parent"\
+> android:layout_height=\"wrap_content"\
+> tools:context=\".MainActivity">\
+> \
+
+If you observe the above example, we used different values to set
+**layout_width** and **layout_height**, those are
+
+- match_parent
+
+- Wrap_content
+
+If we set the value **match_parent**, then the View or ViewGroup will
+try to match with parent width or height.
+
+If we set the value **wrap_content**, then the View or ViewGroup will
+try to adjust its width or height based on the content.
+
+View and ViewGroup hierarchy can be understood as :
+
+
+
+All the Layouts are built as per the hierarchy and the root of the
+layout.
+
+
+
+
+Android Layout Types:
+
+Different types of layouts in android are as follows:
+
+- Linear layout
+
+- Relative layout
+
+- Constraint layout
+
+- Table layout
+
+- Absolute layout
+
+- Frame layout
+
+- Grid Layout
+
+- ListView
+
+- ScrollView
+
+- WebView
+
+Every layout is discussed briefly in subsequent parts.
+
+Below pictorial representation will further help you to visualize these
+layouts.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.1 LINEAR_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.1 LINEAR_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..30567cda7a
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.1 LINEAR_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,158 @@
+
+
+ # LINEAR LAYOUT IN ANDROID
+
+
+We use this layout to place the elements in a linear manner. This layout
+creates various kinds of forms on Android. In this, the arrangement of
+the elements is in a top to bottom manner.
+
+This can have two orientations:
+
+a\. **Vertical Orientation** -- It is shown above where the widgets such
+as TextViews, and all in a vertical manner.
+
+b\. **Horizontal Orientation** -- It is shown above where the widgets
+such as TextViews, and all in a horizontal manner.
+
+This pictorial representation will further allow you to visualize efficiently:
+
+
+
+
+The complete code example of LinearLayout is listed below:
+
+> **\**\
+> **\**android:id=\"@+id/relative_layout\"** \
+>**android:layout_width=\"match_parent\"**\
+>**android:layout_height=\"match_parent\"**\
+>**android:orientation=\"vertical\"\>**\
+>**\**android:id=\"@+id/text_view\"**\
+>**android:layout_width=\"match_parent\"**\
+>**android:layout_height=\"wrap_content\"**\
+>**android:background=\"\@color/teal_700\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:layout_marginTop=\"30dp\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Linear Layouts\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/design_default_color_primary_dark\"**\
+>**android:textSize=\"30sp\"**\
+>**android:textStyle=\"bold\" />**\
+>**\**android:id=\"@+id/text_view1\"**\
+>**android:layout_width=\"match_parent\"**\
+>**android:layout_height=\"wrap_content\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:background=\"\@color/pink\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Vertical Orientation\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/black\"**\
+>**android:textSize=\"30sp\"**\
+>**android:textStyle=\"italic\" />**\
+>**\**android:id=\"@+id/text_view2\"**\
+>**android:layout_width=\"match_parent\"**\
+>**android:layout_height=\"wrap_content\"**\
+>**android:background=\"\@color/teal_200\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:layout_marginTop=\"30dp\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Example\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/design_default_color_primary_variant\"**\
+>**android:textSize=\"30sp\"**\
+>**android:textStyle=\"bold\" />**\
+>**\**android:layout_width=\"match_parent\"**\
+>**android:layout_height=\"98dp\"**\
+>**android:orientation=\"horizontal\"\>**\
+>****android:id=\"@+id/text_view0\"**\
+>**android:layout_width=\"120dp\"**\
+>**android:layout_height=\"wrap_content\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:layout_marginTop=\"30dp\"**\
+>**android:background=\"\@color/teal_700\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Linear Layouts\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/design_default_color_primary_dark\"**\
+>**android:textSize=\"15sp\"**\
+>**android:textStyle=\"bold\" />**\
+>**\**android:id=\"@+id/text_view11\"**\
+>**android:layout_width=\"120dp\"**\
+>**android:layout_height=\"wrap_content\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:background=\"\@color/pink\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Horizontal Orientation\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/black\"**\
+>**android:textSize=\"15sp\"**\
+>**android:textStyle=\"italic\" />**\
+>**\**android:id=\"@+id/text_view22\"**\
+>**android:layout_width=\"120dp\"**\
+>**android:layout_height=\"78dp\"**\
+>**android:background=\"\@color/teal_200\"**\
+>**android:layout_margin=\"10dp\"**\
+>**android:layout_marginTop=\"30dp\"**\
+>**android:padding=\"20dp\"**\
+>**android:text=\"Example\"**\
+>**android:textAlignment=\"center\"**\
+>**android:textColor=\"\@color/design_default_color_primary_variant\"**\
+>**android:textSize=\"15sp\"**\
+>**android:textStyle=\"bold\" />**\
+>**\**\
+>**\**
+
+
+
+**EXPLANATION**
+
+In the above code example, we use LinearLayout as the parent layout and
+as the child views, we use three TextView and arrange them vertically.
+Then having first LinearLayout as root we made another LinearLayout
+having horizontal orientation and used three TextView as its child
+views.
+
+Component tree will be like:
+
+
+
+
+If we will run our application, the UI of the project will
+be:
+
+
+
+Another helpful feature of Linear Layout is **android:weightSum.** It
+defines the maximum weight sum and is calculated as the sum of the
+**layout_weight** of all the children if not specified explicitly.
+
+Let\'s consider an example with a LinearLayout with horizontal
+orientation and **3** ImageViews inside it. Now we want these
+ImageViewsalways to take equal space. To acheive this, you can set the
+layout_weight of each ImageView to **1** and the weightSum will be
+calculated to be equal to **3** as shown below.
+
+>\android:layout_width=\"wrap_content\" \
+>android:layout_height=\"wrap_content\"\
+> android:weightSum=\"3\" >\
+>android:orientation=\"horizontal\"\
+>android:layout_gravity=\"center\"\>\
+>\android:layout_height=\"wrap_content\"\
+>android:layout_weight=\"1\"\
+>android:layout_width=\"0dp\"/>\
+>\...
+
+WeightSum is useful for having the layout rendered correctly for any
+device, which will not happen if you set width and height directly.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.10 WEB_VIEW_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.10 WEB_VIEW_IN_ANDROID.md
new file mode 100644
index 0000000000..88b1357323
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.10 WEB_VIEW_IN_ANDROID.md
@@ -0,0 +1,70 @@
+
+
+ # WEB VIEW IN ANDROID
+
+
+
+If you want to deliver a web application (or just a web page) as a part of a client application, you can do it using [WebView](https://developer.android.com/reference/android/webkit/WebView).The WebView class is an extension of Android\'s [View](https://developer.android.com/reference/android/view/View) class that allows you to display web pages as a part of your activity layout. It does *not* include any features of a fully developed web browser, such as navigation controls or an address bar. All that WebViewdoes, by default, is show a web page.
+
+To add a WebView to your app, you can either include the \ element in your activity layout or set the entire Activity window as a WebView in
+[onCreate()](https://developer.android.com/reference/android/app/Activity#onCreate(android.os.Bundle,%20android.os.PersistableBundle)).
+
+Below is a sample code for you to understand the application of Webview in your project. In this code, we tried to make a web browser using Google's Url.
+
+**activity_main.xml:**
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>xmlns:app=\"http://schemas.android.com/apk/res-auto\" \
+>xmlns:tools=\"http://schemas.android.com/tools\" \
+>android:layout_width=\"match_parent\" \
+>android:layout_height=\"match_parent\" \
+>tools:context=\".MainActivity\"\> \
+>\android:id=\"@+id/webView\" \
+>android:layout_width=\"match_parent\" \
+>android:layout_height=\"match_parent\" \
+>tools:layout_editor_absoluteX=\"171dp\" \
+>tools:layout_editor_absoluteY=\"499dp\" />\
+>\ \
+
+**MainActivity.java:**
+
+>public class MainActivity extends AppCompatActivity { \
+>private WebView webView; \
+>
+> \@Override \
+>
+>protected void onCreate(Bundle savedInstanceState) {\
+>super.onCreate(savedInstanceState);\
+>setContentView(R.layout.*activity_main*); \
+>webView=findViewById(R.id.*webView*);\
+>webView.loadUrl(\"https://www.google.co.in\"); \
+>}\
+>}\
+
+**Android manifest:**
+
+Add permission to access the Internet.
+
+
+> \
+>
+
+
+Our App will look like this:
+
+
+
+
+
+
+
+
+**Additionally, you can customize your WebView by modifying the following:**
+
+- Enabling fullscreen support with [WebChromeClient](https://developer.android.com/reference/android/webkit/WebChromeClient).This class is also called when a WebView needs permission to alter the host app\'s UI, such as creating or closing windows and sending JavaScript dialogs to the user. To learn more about debugging in this context, read [Debugging Web Apps](https://developer.android.com/guide/webapps/debugging).
+- Handling events that impact content rendering, such as errors on form submissions or navigation with [WebChromeClient](https://developer.android.com/reference/android/webkit/WebChromeClient). You can also use this subclass to intercept URL loading.
+- Enabling JavaScript by modifying [WebSettings](https://developer.android.com/reference/android/webkit/WebSettings).
+- Using JavaScript to access Android framework objects that you have injected into a WebView.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.2 RELATIVE_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.2 RELATIVE_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..aa9dcbc16f
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.2 RELATIVE_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,123 @@
+
+
+ # RELATIVE LAYOUT IN ANDROID
+
+
+
+Relative Layout arranges the views relative to other views. The views
+can be relative to its parent or other child views. Child views specify
+layout attributes to get aligned
+
+To get the element aligned on the top left of the parent container we
+can write the following:
+
+- android:layout_alignParentTop= "true"
+
+- android:layout_alignParentLeft= "true"
+
+If we want to align it with some other element in the same container, it
+can be defined is as follows:
+
+- android:layout_alignLeft= "@+id/element_name"
+
+- android:layout_below= "@+id/element_name"
+
+This will align the element below the other element to its left.
+
+Below pictorial representation will further help you to visualize this layout:
+
+
+
+
+
+The complete code example of the RelativeLayout is listed below:
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\"\
+>android:id=\"@+id/relative_layout\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"match_parent\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:layout_marginTop=\"10dp\"\
+>android:layout_marginRight=\"10dp\"\
+>android:layout_marginBottom=\"10dp\"\
+>android:layout_weight=\"1\"\>\
+>\android:id=\"@+id/text_view\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_centerHorizontal=\"true\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:layout_marginTop=\"50dp\"\
+>android:layout_marginRight=\"10dp\"\
+>android:padding=\"20dp\"\
+>android:background=\"\@color/teal_700\"\
+>android:text=\"Android Relative Layouts\"\
+>android:textAlignment=\"center\"\
+>android:textColor=\"\@color/design_default_color_primary_dark\"\
+>android:textSize=\"35sp\"\
+>android:textStyle=\"bold\" />\
+>\android:id=\"@+id/text_view1\"\
+>android:layout_width=\"180dp\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_below=\"\@id/text_view\"\
+>android:layout_alignParentStart=\"true\"\
+>android:layout_marginStart=\"15dp\"\
+>android:layout_marginLeft=\"30dp\"\
+>android:layout_marginTop=\"50dp\"\
+>android:layout_marginRight=\"10dp\"\
+>android:background=\"\@color/purple_200\"\
+>android:padding=\"20dp\"\
+>android:text=\"Relative\"\
+>android:textAlignment=\"center\"\
+>android:textColor=\"\@color/design_default_color_primary_variant\"\
+>android:textSize=\"30sp\"\
+>android:textStyle=\"italic\" />\
+>\android:id=\"@+id/text_view2\"\
+>android:layout_width=\"180dp\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_below=\"\@id/text_view\"\
+>android:layout_marginLeft=\"5dp\"\
+>android:layout_marginTop=\"50dp\"\
+>android:layout_toRightOf=\"\@id/text_view1\"\
+>android:padding=\"20dp\"\
+>android:background=\"\@color/purple_200\"\
+>android:text=\"Layout\"\
+>android:textAlignment=\"center\"\
+>android:textColor=\"\@color/design_default_color_primary_variant\"\
+>android:textSize=\"30sp\"\
+>android:textStyle=\"italic\" />\
+>\android:id=\"@+id/text_view3\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_below=\"\@id/text_view1\"\
+>android:layout_centerInParent=\"true\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:layout_marginTop=\"50dp\"\
+>android:background=\"\@color/cardview_dark_background\"\
+>android:layout_marginRight=\"10dp\"\
+>android:padding=\"20dp\"\
+>android:text=\"Relative Layout Example\"\
+>android:textAlignment=\"center\"\
+>android:textColor=\"\@color/white\"\
+>android:textSize=\"35sp\"\
+>android:textStyle=\"bold\" />\
+>\\
+
+**Explanation:** In this layout example, We use RelativeLayout as the
+parent layout. In this layout example, we create four TextView and
+arrange them according to the required design. We use different
+attributes of the text views for arranging the text views.
+
+Component tree will be like:
+
+
+
+
+If we will run our application, the UI of the project will be:
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.3 CONSTRAINT_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.3 CONSTRAINT_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..998a07ec10
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.3 CONSTRAINT_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,78 @@
+
+
+ # CONSTRAINT LAYOUT IN ANDROID
+
+ConstantLayout is a view group that is used to arrange the views in an
+adaptable and flexible way. ConstantLayout is the default Layout that is
+used by the Android Studio. It also supports animation. ConstraintLayout
+allows you to create large and complex layouts with a flat view hierarchy.
+ (no nested view groups)
+
+It\'s similar to RelativeLayout in that all views are laid out according
+to relationships between sibling views and the parent layout, but it\'s
+more flexible than RelativeLayout and easier to use with Android
+Studio\'s Layout Editor. You can build your layout with ConstraintLayout
+entirely by drag-and-dropping instead of editing the XML.
+
+To define a view\'s position in ConstraintLayout, **you must add at
+least one horizontal and one vertical constraint for the view**. Each
+constraint represents a connection or alignment to another view, the
+parent layout, or an invisible guideline. Each constraint defines the
+view\'s position along either the vertical or horizontal axis; so **each
+view must have a minimum of one constraint for each axis** but often
+more are necessary.
+
+Below pictorial representation will further help you to visualize this layout:
+
+
+
+
+
+The complete code example of ConstraintLayout is as below:
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\"\
+>xmlns:app=\"http://schemas.android.com/apk/res-auto\"\
+>xmlns:tools=\"http://schemas.android.com/tools\"\
+>android:id=\"@+id/webView\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"match_parent\"\
+>tools:context=\".MainActivity\"\>\
+>\android:id=\"@+id/textView\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\"\
+>android:text=\"Constraint Layout\"\
+>android:textAlignment=\"center\"\
+>android:textColor=\"\@color/pink\"\
+>android:textSize=\"60dp\"\
+>app:layout_constraintBottom_toBottomOf=\"parent\"\
+>app:layout_constraintHorizontal_bias=\"0.501\"\
+>app:layout_constraintLeft_toLeftOf=\"parent\"\
+>app:layout_constraintRight_toRightOf=\"parent\"\
+>app:layout_constraintTop_toTopOf=\"parent\"\
+>app:layout_constraintVertical_bias=\"0.345\" />\
+>\android:id=\"@+id/button\"\
+>android:layout_width=\"120dp\"\
+>android:layout_height=\"50dp\"\
+>android:background=\"\@color/teal_700\"\
+>android:text=\"Click\"\
+>android:textColor=\"\@color/white\"\
+>android:textSize=\"18dp\"\
+>app:layout_constraintBottom_toBottomOf=\"parent\"\
+>app:layout_constraintEnd_toEndOf=\"parent\"\
+>app:layout_constraintHorizontal_bias=\"0.514\"\
+>app:layout_constraintStart_toStartOf=\"parent\"\
+>app:layout_constraintTop_toBottomOf=\"@+id/textView\"\
+>app:layout_constraintVertical_bias=\"0.231\" />\
+>\\
+
+The constraint on the design will look like this:
+
+
+
+
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.4 TABLE_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.4 TABLE_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..34cecc80c4
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.4 TABLE_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,118 @@
+
+
+ # Table Layout in Android
+
+
+A layout that arranges its children into rows and columns. A TableLayout
+consists of a number of TableRow objects, each defining a row (actually,
+you can have other children, which will be explained below). TableLayout
+containers do not display border lines for their rows, columns, or
+cells. Each row has zero or more cells; each cell can hold one View
+object. The table has as many columns as the row with the most cells. A
+table can leave cells empty.
+
+The width of a column is defined by the row with the widest cell in that
+column. However, a TableLayout can specify certain columns as shrinkable
+or stretchable by calling **setColumnShrinkable()** or
+**setColumnStretchable()**. If marked as shrinkable, the column width
+can be shrunk to fit the table into its parent object. If marked as
+stretchable, it can expand in width to fit any extra space. The total
+width of the table is defined by its parent container. It is important
+to remember that a column can be both shrinkable and stretchable. In
+such a situation, the column will change its size to always use up the
+available space, but never more. Finally, you can hide a column by
+calling **setColumnCollapsed().**
+
+The children of a TableLayout **cannot** specify the layout_width
+attribute. Width is always **MATCH_PARENT**. However, the layout_height
+attribute can be defined by a child; the default value is
+**ViewGroup.LayoutParams.WRAP_CONTENT.** If the child is a TableRow,
+then the height is always **ViewGroup.LayoutParams.WRAP_CONTENT**.
+
+**Note**: In the table layout, the indexing of the columns started with
+0. For example 0, 1,2,3\...\....etc.
+
+The below pictorial representation will further help you to visualize this layout:
+
+
+
+The complete code example of TableLayout is as below:
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"match_parent\"\
+>android:background=\"\@color/black\"\
+>android:orientation=\"vertical\"\
+>android:stretchColumns=\"1\"\>\
+>\\
+>\android:layout_height=\"wrap_content\"\
+>android:layout_marginBottom=\"20dp\"\
+>android:layout_span=\"2\"\
+>android:gravity=\"center_horizontal\"\
+>android:text=\"Credentials\"\
+>android:textColor=\"\@color/pink\"\
+>android:textSize=\"25sp\"\
+>android:textStyle=\"bold\" />\
+>\\
+>\\
+>\android:id=\"@+id/userName\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_column=\"1\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:background=\"\@color/white\"\
+>android:hint=\"userName\"\
+>android:padding=\"5dp\"\
+>android:textColor=\"\@color/black\" />\
+>\android:layout_height=\"wrap_content\"\
+>android:layout_column=\"0\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:text=\"User Name\"\
+>android:textColor=\"\@color/white\"\
+>android:textSize=\"16sp\" />\
+>\\
+>\\
+>\android:id=\"@+id/password\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_column=\"1\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:layout_marginTop=\"20dp\"\
+>android:background=\"\@color/white\"\
+>android:hint=\"password\"\
+>android:padding=\"5dp\"\
+>android:textColor=\"\@color/black\" />\
+>\android:layout_height=\"wrap_content\"\
+>android:layout_column=\"0\"\
+>android:layout_marginLeft=\"10dp\"\
+>android:layout_marginTop=\"20dp\"\
+>android:text=\"Password\"\
+>android:textColor=\"\@color/white\"\
+>android:textSize=\"16sp\" />\
+>\\
+>\\
+>\android:id=\"@+id/loginBtn\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_gravity=\"center\"\
+>android:layout_span=\"2\"\
+>android:background=\"\@color/design_default_color_primary\"\
+>android:text=\"Login\"\
+>android:textColor=\"#000\"\
+>android:textSize=\"20sp\"\
+>android:textStyle=\"bold\" />\
+>\\
+>\\
+
+Component tree of the layout will look like this:
+
+
+
+UI of the application will look like this:
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.5 ABSOLUTE_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.5 ABSOLUTE_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..29a53fecce
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.5 ABSOLUTE_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,104 @@
+
+
+ # Absolute Layouts in Android
+
+
+A layout that lets you specify the exact locations (x/y coordinates) of
+its children. Absolute layouts are less flexible and harder to maintain
+than other types of layouts without absolute positioning.
+
+the absolute layout is harder to maintain for different mobile screen
+sizes than other types of layouts because we set the exact location of a
+child view or called component. The positioning is based on x(top) and
+y(left) coordinates and that positioning is not as useful in the world
+of various screen resolutions(sizes) and aspect ratios.
+
+The absolute layout is depreciated in Android because of the same reason
+as discussed in the above note.
+
+
+
+
+Some of the important Absolute Layout attributes are the following:
+
+1. **android:id**: It uniquely specifies the absolute layout
+
+2. **android:layout_x:** It specifies X-Coordinate of the Views
+ (Possible values of this is in dp or px)
+
+3. **android:layout_y:** It specifies Y-Coordinate of the Views
+ (Possible values of this is in dp or px)
+
+## **Public Constructors:**
+
+- AbsoluteLayout(Context context)
+
+- AbsoluteLayout(Context context, AttributeSet attrs)
+
+- AbsoluteLayout(Context context, AttributeSet attrs, int defStyleAttr)
+
+- AbsoluteLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes)
+
+
+
+
+Below is the example code where we design a Registration screen with two
+fields First name and Last name and one button for navigating to the next
+page. We set all views using x and y coordinates of the screen and set
+the values in px(pixels).
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>xmlns:tools=\"http://schemas.android.com/tools\" \
+>android:layout_width=\"fill_parent\"\
+>android:layout_height=\"fill_parent\"\
+>tools:ignore=\"Deprecated\"\>\
+>\android:layout_x=\"19dp\"\
+>android:layout_y=\"74dp\"\
+>android:text=\"First Name\"\
+>android:textSize=\"18sp\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:layout_x=\"140dp\"\
+>android:layout_y=\"54dp\"\
+>android:width=\"300px\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:layout_x=\"22dp\"\
+>android:layout_y=\"137dp\"\
+>android:text=\"Last Name\"\
+>android:textSize=\"18sp\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:layout_x=\"143dp\"\
+>android:layout_y=\"117dp\"\
+>android:width=\"300px\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:id=\"@+id/next\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_x=\"281dp\"\
+>android:layout_y=\"211dp\"\
+>android:text=\"Next\" />\
+>\
+
+The component tree of the layout will be like this:
+
+
+
+
+The design of our UI will be:
+
+
+
+
+**Note**: Try opening the same layout in different size Emulators and
+you will see it doesn't fit in different size devices. That's why
+Android has depreciated the use of Absolute Layout.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.6 FRAME_LAYOUT_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.6 FRAME_LAYOUT_ANDROID.md
new file mode 100644
index 0000000000..421cc28b46
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.6 FRAME_LAYOUT_ANDROID.md
@@ -0,0 +1,189 @@
+
+
+ # FRAME LAYOUT ANDROID
+
+
+FrameLayout is designed to block out an area on the screen to display a
+single item. Generally, FrameLayout should be used to hold a single
+child view, because it can be difficult to organize child views in a way
+that\'s scalable to different screen sizes without the children
+overlapping each other. You can, however, add multiple children to a
+FrameLayout and control their position within the FrameLayout by
+assigning gravity to each child, using the **android:layout_gravity** attribute.
+
+The size of the FrameLayout is the size of its largest child (plus
+padding), visible or not (if the FrameLayout\'s parent permits). Views
+that are **View.GONE** are used for sizing only if **setConsiderGoneChildrenWhenMeasuring()** is set to true.
+
+
+## **XML attributes**
+
+**android:foregroundGravity**: Defines the gravity to apply to the foreground drawable.
+
+**android:measureAllChildren**: Determines whether to measure all children or just those in the VISIBLE or INVISIBLE state when measuring.
+
+
+## **Public Methods**
+
+**1) generateLayoutParams :**
+
+*public **FrameLayout.LayoutParams** generateLayoutParams **AttributeSet** (attrs)*
+
+Returns a new set of layout parameters based on the supplied attributes
+set.
+
+**2) getAccessibilityClassName:**
+
+*public **CharSequence** getAccessibilityClassName ()*
+
+
+Return the class name of this object to be used for accessibility purposes. Subclasses should only override this if they are implementing something that should be seen as a completely new class of view when used by accessibility, unrelated to the class it is deriving from. This is used to fill in **AccessibilityNodeInfo.setClassName**.
+
+**3) getConsiderGoneChildrenWhenMeasuring:**
+
+*public **boolean** getConsiderGoneChildrenWhenMeasuring ()*
+
+This method is deprecated in favor of **getMeasureAllChildren()**, which was renamed for consistency with **setMeasureAllChildren()**.Determines
+whether all children or just those in the VISIBLE or INVISIBLE state,
+are considered when measuring.
+
+**4) getMeasureAllChildren:**
+
+*public boolean getMeasureAllChildren ()*
+
+Determines whether all children or just those in the VISIBLE or
+INVISIBLE state, are considered when measuring
+
+**5) setForegroundGravity**
+
+*public void setForegroundGravity (int foregroundGravity)*
+
+Describes how the foreground is positioned. Defaults to START and TOP.
+
+**6) setMeasureAllChildren:**
+
+*public void setMeasureAllChildren (boolean measureAll)*
+
+Sets whether to consider all children or just those in the VISIBLE or
+INVISIBLE state, when measuring. Defaults to false.
+
+**7) shouldDelayChildPressedState:**
+
+*Public boolean shouldDelatChildPressedState ()*
+
+Return true if the pressed state should be delayed for children or
+descendants of this ViewGroup. Generally, this should be done for
+containers that can scroll, such as a List. This prevents the pressed
+state from appearing when the user is actually trying to scroll the
+content. The default implementation returns true for compatibility
+reasons. Subclasses that do not scroll should generally override this
+method and return false.
+
+
+
+
+
+
+
+Here we are designing ImageView and TextView inside Frame Layout. Here we will put textview at a different position in Frame Layout using layout gravity. Below is the code and final output.
+
+**Important Note:** Make sure you have an image saved in the drawable
+folder name img_name. If you have saved other images with a different
+name then please change it in the code.
+
+>\/
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>android:layout_height=\"match_parent\"\
+>android:layout_width=\"match_parent\" >\
+>
+>\\
+>\android:layout_width=\"134dp\"\
+>android:layout_height=\"180dp\"\
+>android:layout_gravity=\"top\|right\"\
+>android:src=\"\@drawable/daniel_lincoln_ie2z11zksso_unsplash\" />\
+>\android:layout_width=\"wrap_content\"\
+>android:text=\"RightTop\"\
+>android:textSize=\"30dp\"\
+>android:textColor=\"\@color/white\" \
+>android:layout_gravity=\"top\|right\" /> \
+>android:layout_width=\"138dp\" \
+>android:layout_height=\"180dp\"\
+>android:layout_gravity=\"left\"\
+>android:src=\"\@drawable/karsten_winegeart_cre553zfmtg_unsplash\" />\
+>\android:textSize=\"30dp\"\
+>android:textColor=\"\@color/black\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:layout_width=\"wrap_content\"\
+>android:text=\"CentreTop\"\
+>android:textSize=\"30dp\"\
+>android:layout_gravity=\"top\|center_horizontal\" />\
+>\android:layout_width=\"149dp\"\
+>android:layout_height=\"180dp\"\
+>android:layout_gravity=\"top\|center_horizontal\"\
+>android:src=\"\@drawable/\_90954\" />\
+>\android:layout_width=\"400dp\"\
+>android:layout_height=\"300dp\"\
+>android:layout_gravity=\"center\"\
+>android:src=\"\@drawable/\_81289\" />\
+>\android:layout_width=\"wrap_content\"\
+>android:text=\"Centre\"\
+>android:textSize=\"40dp\"\
+>android:textColor=\"\@color/white\"\
+>android:layout_gravity=\"center\" />\
+>\android:layout_gravity=\"left\|bottom\"\
+>android:textSize=\"20dp\"\
+>android:textColor=\"\@color/black\"\
+>android:layout_width=\"wrap_content\"\
+>android:layout_height=\"wrap_content\" />\
+>\android:layout_width=\"150dp\"\
+>android:layout_height=\"180dp\"\
+>android:layout_gravity=\"left\|bottom\"\
+>android:src=\"\@drawable/karsten_winegeart_tucvnmovxfq_unsplash\" />\
+>\android:layout_width=\"137dp\"\
+>android:layout_height=\"180dp\"\
+>android:layout_gravity=\"right\|bottom\" \
+>android:src=\"\@drawable/karsten_winegeart_qb7d1xw28co_unsplash\" />\
+>\android:layout_width=\"wrap_content\" \
+>android:layout_height=\"wrap_content\" \
+>android:layout_gravity=\"right\|bottom\" \
+>android:text=\"RightBottom\" \
+>android:textColor=\"\@color/black\" \
+>android:textSize=\"20dp\" /> \
+>\android:layout_width=\"wrap_content\" \
+>android:text=\"CenterBottom\" \
+>android:textSize=\"20dp\" \
+>android:textColor=\"\@color/black\" \
+>android:layout_gravity=\"center\|bottom\" /> \
+>\android:layout_width=\"150dp\" \
+>android:layout_height=\"180dp\" \
+>android:layout_gravity=\"center\|bottom\"\ android:src=\"\@drawable/sq_lim_k4vhuuhv08o_unsplash\" />\
+>\
+
+
+Component tree of the layout will be:
+
+
+
+The design of our code will look like this:
+
+
+
+
+
+ ---------------------- ------------------------------------------------
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.7 GRID_LAYOUT_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.7 GRID_LAYOUT_IN_ANDROID.md
new file mode 100644
index 0000000000..fe6304cacc
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.7 GRID_LAYOUT_IN_ANDROID.md
@@ -0,0 +1,104 @@
+
+
+ # GRID LAYOUT IN ANDROID
+
+
+A layout that places its children in a rectangular grid.
+The grid is composed of a set of infinitely thin lines that separate the viewing area into cells. A grid with N columns has N + 1 grid indices that run from 0 through N inclusive.
+Children occupy one or more contiguous cells, as defined by their **rowSpec** and **columnSpec** layout parameters. Each spec defines the set of rows or columns that are to be occupied; and how children should be aligned within the resulting group of cells.
+
+If a child does not specify the row and column indices of the cell it wishes to occupy, GridLayout assigns cell locations automatically using its: **orientation, rowCount** and **columnCount properties.**
+Space between children may be specified either by using instances of the dedicated Space view or by setting the **leftMargin, topMargin, rightMargin, and bottomMargin** layout parameters. When the **useDefaultMargins** property is set, default margins around children are automatically allocated based on the prevailing UI style guide for the platform.
+The flexibility of a view is therefore influenced by its alignment which is, in turn, typically defined by setting the **gravity property** of the child's layout parameters.
+For layout purposes, GridLayout treats views whose visibility status is **GONE**, as having zero width and height.
+
+
+Below pictorial representation will further help you to visualize these layouts.
+
+
+
+
+Below is the example code of GridLayout for designing a simple
+calculator:
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\"\
+>xmlns:tools=\"http://schemas.android.com/tools\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_gravity=\"center\"\
+>android:columnCount=\"4\"\
+>android:orientation=\"horizontal\"\
+>android:background=\"\@color/black\"\>\
+>\android:layout_width=\"180dp\"\
+>android:layout_height=\"wrap_content\"\
+>android:layout_row=\"0\"\
+>android:layout_column=\"1\"\
+>android:layout_columnSpan=\"2\"\
+>android:text=\"CALCULATOR\"\
+>android:textColor=\"\@color/white\"\
+>android:textSize=\"25dp\" />\
+>\android:layout_columnSpan=\"3\"\
+>android:text=\"/\" />\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\\
+>\android:layout_gravity=\"fill\"\
+>android:layout_rowSpan=\"3\"\
+>android:text=\"+\" />\
+>\android:layout_columnSpan=\"2\"\
+>android:layout_gravity=\"fill\"\
+>android:text=\"0\" />\
+>\\
+>\android:layout_columnSpan=\"3\"\
+>android:layout_rowSpan=\"1\"\
+>android:layout_gravity=\"fill\"\
+>android:text=\"=\" />\
+>\
+
+Component Tree will look like this:
+
+
+
+
+
+
+UI design will look like this:
+
+
+
+
+
+
+ ## XML attributes Summary
+
+
+
+ - **android:alignmentMode** - When set to alignMargins, causes alignment to take place between the outer boundary of a view, as defined by its margins.
+ - **android:columnCount** - The maximum number of columns to create when automatically positioning children.
+ - **android:columnOrderPreserved** - When set to true, forces column boundaries to appear in the same order as column indices
+ - **android:orientation** - The orientation property is not used during layout.
+ - **android:rowCount** -The maximum number of rows to create when automatically positioning children.
+ - **android:rowOrderPreserved** - When set to true, forces row boundaries to appear in the same order as row indices.
+ - **android:useDefaultMargins** - When set to true, tells GridLayout to use default margins when none are specified in a view's layout parameters.
+
+
+
+
+In order to distribute the space between the child views equally
+GridLayout also supports grid **android:layout_columnWeight=\"1\"** and
+**android:grid:layout_rowWeight=\"1\"**
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.8 LIST_VIEW_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.8 LIST_VIEW_IN_ANDROID.md
new file mode 100644
index 0000000000..2c508a0315
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.8 LIST_VIEW_IN_ANDROID.md
@@ -0,0 +1,260 @@
+
+
+ # LIST VIEW IN ANDROID
+
+
+
+Displays a vertically scrollable collection of views, where each view is positioned immediately below the previous view in the list. For a more modern, flexible, and performant approach to displaying lists, use **RecyclerView** .
+
+A list view is an **adapter view** as needed, such as to display new views as the user scrolls up or down. In order to display items in the list, call **setAdapter(android.widget.ListAdapter)** to associate an adapter with the list. For a simple example, see the discussion of Filling an adapter view with text in the Layouts guide.
+
+Below Visual will help you to understand ListView.
+
+
+
+
+## **XML attributes**
+
+- **android:divider** - Drawable or color to draw between list items.
+- **android:dividerHeight** - Height of the divider.
+- **android:entries** - Reference to an array resource that will
+- **android:footerDividersEnabled** - When set to false, the ListView will not draw the divider before each footer view.
+- **android:headerDividersEnabled** - When set to false, the ListView will not draw the divider after each header view.
+
+
+## **Public constructors**
+
+- public ListView (**Context** context)
+- public ListView (**Context** context, **AttributeSet** attrs)
+- public ListView (**Context** context, **AttributeSet** attrs, **int** defStyleAttr)
+- public ListView (**Context** context, **AttributeSet** attrs, **int** defStyleAttr, **int** defStyleRes)
+
+
+# **Adapters use in ListView**
+
+An adapter is a bridge between the UI component and data source that
+helps us to fill data in the UI component. It holds the data and sends
+the data to the adapter view then the view can take the data from the
+adapter view and shows the data on different views like list view, grid
+view, spinner, etc.
+
+ListView is a subclass of AdapterView and it can be populated by binding
+to an Adapter, which retrieves the data from an external source and
+creates a View that represents each data entry.
+
+**In android commonly used adapters are:**
+
+1. Array Adapter
+
+2. Base Adapter
+
+Now we explain these two adapters in detail:
+
+**Array adapter:**
+
+Whenever you have a list of single items which is backed by an array,
+you can use ArrayAdapter. For instance, a list of phone contacts,
+countries, or names.
+
+> >**Important Note:** By default, ArrayAdapter expects a Layout with a
+>>single TextView, If you want to use more complex views means more
+>>customization in list items, please avoid ArrayAdapter and use custom
+>>adapters.
+
+Below is Array Adapter code:
+
+> ArrayAdapter adapter = new ArrayAdapter\(this,R.layout.ListView,R.textView,StringArray);
+
+Below is the simple implementation of array adapter:
+
+- In the **main activity** create a list view withing linear layout to store
+data of the list.
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>xmlns:tools=\"http://schemas.android.com/tools\" \
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"match_parent\"\
+>android:orientation=\"vertical\"\
+>tools:context=\".MainActivity\" \>\
+>\android:id=\"@+id/mobile_list\"\
+>android:layout_width=\"match_parent\"\
+>android:layout_height=\"wrap_content\" \>\
+>\
+>
+
+- Create a **new XML file** for defining the layout of a single item in the
+list.
+
+>\\
+>\android:id=\"@+id/label\"\
+>android:layout_width=\"fill_parent\"\
+>android:layout_height=\"fill_parent\"\
+>android:padding=\"10dip\"\
+>android:textSize=\"16dip\"\
+>android:textStyle=\"bold\" \>\
+>\
+
+- In the **Main java class** use an array adapter to display the content of
+array in form of a list.
+
+>public class MainActivity extends AppCompatActivity {\
+>String\[\] Array = {\"A\",\"I\",\"W\",\"B\",\"W\",\"U\",\"Y\",\"M\"};\
+>
+>\@Override\
+>
+>protected void onCreate(Bundle savedInstanceState) {\
+>super.onCreate(savedInstanceState);\
+>setContentView(R.layout.*activity_main*);\
+>ArrayAdapter adapter = new ArrayAdapter\(this,R.layout.*activity_list*, Array);\
+>ListView listView = (ListView) findViewById(R.id.*mobile_list*);\
+>listView.setAdapter(adapter);\
+>}\
+>}
+
+Output of the above code will look like:
+
+
+
+
+**2. Base Adapter:**
+
+BaseAdapter is a common base class of a general implementation of an
+Adapter that can be used in ListView. Whenever you need a customized
+list you create your own adapter and extend the base adapter in that.
+Base Adapter can be extended to create a custom Adapter for displaying a
+custom list item. ArrayAdapter is also an implementation of BaseAdapter.
+
+Below is the simple List view application using the base adapter.
+
+- In the **activity_main.xml** create a list view withing linear layout to store
+data of the list.
+
+>\\
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>android:layout_width=\"match_parent\" \
+>android:layout_height=\"match_parent\" \
+>android:orientation=\"vertical\"\> \
+>\android:id=\"@+id/simpleListView\" \
+>android:layout_width=\"fill_parent\" \
+>android:layout_height=\"wrap_content\" \
+>android:divider=\"\@color/material_blue_grey_800\" \
+>android:dividerHeight=\"1dp\" \
+>android:footerDividersEnabled=\"false\" /> \
+>\
+
+- Create a **new XML file** for defining the layout of a single item in the
+list.
+
+>\ \
+>\xmlns:android=\"http://schemas.android.com/apk/res/android\" \
+>android:layout_width=\"match_parent\" \
+>android:layout_height=\"match_parent\" \
+>android:orientation=\"horizontal\"\> \
+>\android:id=\"@+id/icon\" \
+>android:layout_width=\"50dp\" \
+>android:layout_height=\"50dp\" \
+>android:src=\"\@drawable/ic_launcher_foreground\" /> \
+>\android:id=\"@+id/textView\" \
+>android:layout_width=\"fill_parent\" \
+>android:layout_height=\"wrap_content\" \
+>android:paddingTop=\"15dp\" \
+>android:textColor=\"\@color/black\" /> \
+>\
+
+- Now create another java class Custom Adapter which will extend **BaseAdapter**.
+Below is the code of CustomAdapter.java
+
+>package com.example.a3rdclass;\
+>import android.content.Context;\
+>import android.view.LayoutInflater;\
+>import android.view.View;\
+>import android.view.ViewGroup;\
+>import android.widget.BaseAdapter;\
+>import android.widget.ImageView;\
+>import android.widget.TextView;\
+>public class CustomAdapter extends BaseAdapter { \
+>Context context;\
+>String names\[\]; \
+>int dogs\[\];\
+>LayoutInflater inflter; \
+>public CustomAdapter(Context context, String\[\] names, int\[\] dogs) { \
+>this.context = context;\
+>this.names = names;\
+>this.dogs = dogs;\
+>inflter = (LayoutInflater.*from*(context));; \
+>}\
+>
+>\@Override \
+>
+>public int getCount() { \
+>return names.length; \
+>}\
+>
+>\@Override \
+>
+>public Object getItem(int i) { \
+>return null;\
+>}\
+>
+>\@Override \
+>
+>public long getItemId(int i) {\
+> return 0; \
+>}\
+>
+> \@Override \
+>
+>public View getView(int i, View view, ViewGroup viewGroup) { \
+>view = inflter.inflate(R.layout.*activity_list*, null); \
+>TextView name = (TextView) view.findViewById(R.id.*textView*); \
+>ImageView icon = (ImageView) view.findViewById(R.id.*icon*); \
+>name.setText(names\[i\]); \
+>icon.setImageResource(dogs\[i\]);\
+>return view; \
+>}\
+>}
+
+- In the third step, we will use a custom adapter to display the pet dog names in UI by coding **MainActivity.java**. Below is the code of MainActivity.java
+
+>> **Important Note:** Make sure the images are stored in a drawable folder
+>> present inside the res folder with correct naming.
+
+>package com.example.a3rdclass;\
+>import androidx.appcompat.app.AppCompatActivity;\
+>import android.app.Activity;\
+>import android.os.Bundle;\
+>import android.webkit.WebView;\
+>import android.widget.ArrayAdapter;\
+>import android.widget.ListAdapter;\
+>import android.widget.ListView;\
+>public class MainActivity extends Activity {\
+>ListView simpleList;\
+
+>String names\[\] = {\"tommy\", \"jerry\", \"kuel\", \"ruby\",\"barry\",\"mimo\"};\
+
+>int dogs\[\] ={R.drawable.*daniel_lincoln_ie2z11zksso_unsplash*, R.drawable.*karsten_winegeart_cre553zfmtg_unsplash*, R.drawable.*sq_lim_k4vhuuhv08o_unsplash*, >R.drawable.*\_90954*, R.drawable.*k>arsten_winegeart_qb7d1xw28co_unsplash*, R.drawable.*karsten_winegeart_tucvnmovxfq_unsplash*};\
+>
+>\@Override\
+>
+>protected void onCreate(Bundle savedInstanceState) {\
+>super.onCreate(savedInstanceState);\
+>setContentView(R.layout.*activity_main*);\
+>simpleList = (ListView) findViewById(R.id.*simpleListView*);\
+>CustomAdapter customAdapter = new CustomAdapter(getApplicationContext(),names, dogs);\
+>simpleList.setAdapter((ListAdapter) customAdapter);\
+>}\
+>}
+
+Output of the above code will look like this :
+
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.4.9 SCROLL_VIEW_IN_ANDROID.md b/Android_Development_With_Java/2 Android UI Widgets/2.4.9 SCROLL_VIEW_IN_ANDROID.md
new file mode 100644
index 0000000000..cf90ea9e44
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.4.9 SCROLL_VIEW_IN_ANDROID.md
@@ -0,0 +1,89 @@
+
+
+ # SCROLL VIEW IN ANDROID
+
+
+It is a view group that allows the view hierarchy placed within it to be scrolled. Scroll view may have only one direct child placed within it.To add multiple views within the scroll view, make the direct child you add a view group, for example, LinearLayout, and place additional views within that LinearLayout.
+When an app has layout content that might be longer than the height or wider than the width of the device and that content should be vertically or horizontally scrollable, then we need to use a ScrollView.
+
+
+
+
+ Below visual will be help you to understand scroll view better.
+
+
+
+
+
+### **Vertically Scrolling:**
+
+To make any content vertically scrollable, simply wrap that content in a ScrollView:
+
+>\\
+>\android:layout_width=\"match_parent\"\
+>android:layout_height=\"match_parent\" \
+>xmlns:android=\"http://schemas.android.com/apk/res/android\"\> \
+>\android:layout_width=\"match_parent\" \
+>android:layout_height=\"wrap_content\" \
+>android:orientation=\"vertical\" \>\
+>\android:id=\"@+id/tv_long\" \
+>android:layout_width=\"wrap_content\" \
+>android:layout_height=\"match_parent\"\
+>android:text=\"\@string/really_long_string\" \>\
+>\\
+>\\
+>\ \
+>\ \
+
+Output of the above code will look like this :
+
+
+
+
+In certain situations, you want to position content beneath the end of the scrollable content area. For example for a \"terms of service\" where you can only accept once you\'ve scrolled through all the content.In this case, you might need to apply the **android:fillViewport** property to \"true\". Read this post by [Romain Guy](http://www.curious-creature.org/2010/08/15/scrollviews-handy-trick/) for a detailed look at this use case.
+
+
+### **Scrollable TextView**
+
+Note that a TextView doesn\'t require a ScrollView and if you just need a scrolling TextView simply set the scrollbars property and apply the correct MovementMethod.
+In the **activity_main.xml** :
+
+>\android:id=\"@+id/tv_long\" \
+>android:layout_width=\"wrap_content\" \
+>android:layout_height=\"match_parent\" \
+>android:scrollbars = \"vertical\" \
+>android:text=\"\@string/really_long_string\" \> \
+\ \
+
+and then in the **MainActivity.java**:
+
+>TextView tv = (TextView) findViewById(R.id.tv_long);\
+>tv.setMovementMethod(new ScrollingMovementMethod());\
+
+Now the TextView will automatically scroll vertically.
+
+### **Horizontally Scrolling**
+
+In other cases, we want content to horizontally scroll in which case we need to use the HorizontalScrollView instead like this:
+
+>\android:layout_width=\"match_parent\" \
+>android:layout_height=\"match_parent\"\> \
+>\android:layout_width=\"match_parent\" \
+>android:layout_height=\"wrap_content\" \
+>android:orientation=\"horizontal\" \> \
+>*\ * \
+>\ \
+>\ \
+
+and now you have a horizontally scrolling view.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.5 CheckBox in Android.md b/Android_Development_With_Java/2 Android UI Widgets/2.5 CheckBox in Android.md
new file mode 100644
index 0000000000..3eae5fd761
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.5 CheckBox in Android.md
@@ -0,0 +1,141 @@
+# CheckBox in Android Java
+
+CheckBox is a type of two state button either checked or unchecked. Checkboxes allow the user to select one or more options from a set. CheckBox belongs to android.widget.CheckBox class. Android CheckBox class is the subclass of CompoundButton class.
+
+## Methods of CheckBox class
+1) public boolean isChecked(): If CheckBox is in checked state then return true otherwise false.
+2) public void setChecked(boolean status): It changes the state of the CheckBox.
+
+
+## Implementation-
+To create each checkbox option, create a CheckBox in your layout. Because a set of checkbox options allows the user to select multiple items, each checkbox is managed separately and you must register a click listener.
+
+ We create *View.OnClickListener* object and assign it to the button by calling *setOnClickListener(View.OnClickListener)* as shown below.
+
+## Example of checkbox
+- [x] MainActivity.java
+```
+package com.example.checkboxs;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.TextView;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+ CheckBox c1,c2,c3,c4;
+ Button button;
+ TextView tv;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ c1=(CheckBox)findViewById(R.id.checkBox);
+ c2=(CheckBox)findViewById(R.id.checkBox2);
+ c3=(CheckBox)findViewById(R.id.checkBox3);
+ c4=(CheckBox)findViewById(R.id.checkBox4);
+ button=(Button)findViewById(R.id.button);
+ tv=(TextView)findViewById(R.id.textView2);
+ button.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ String s=" ";
+ if(c1.isChecked())
+ {
+ s+=c1.getText().toString()+" ";
+ }
+ if(c2.isChecked())
+ {
+ s+=c2.getText().toString()+" ";
+ }
+ if(c3.isChecked())
+ {
+ s+=c3.getText().toString()+" ";
+ }
+ if(c4.isChecked())
+ {
+ s+=c4.getText().toString()+" ";
+ }
+ Toast.makeText(getApplicationContext(),s,Toast.LENGTH_LONG).show();
+ tv.setText("Ans-"+ s);
+ }
+
+
+ });
+ }
+}
+```
+- [x] Activity.xml
+ ```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+## Output
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.6 Radio-Buttons.md b/Android_Development_With_Java/2 Android UI Widgets/2.6 Radio-Buttons.md
new file mode 100644
index 0000000000..0b4b10e9c6
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.6 Radio-Buttons.md
@@ -0,0 +1,87 @@
+# Radio Buttons
+`Radio buttons` allow the user to select one option from a set. You should use radio buttons for optional sets that are mutually exclusive if you think that the user needs to see all available options side-by-side.
+
+
+
+## Radio Group
+
+To create each radio button option, create a `RadioButton` in your layout. However, because radio buttons are mutually exclusive, you must group them together inside a `RadioGroup`. By grouping them together, the system ensures that only one radio button can be selected at a time.
+
+
+
+
+
+> ### Xml Code
+```xml
+
+
+
+
+
+
+
+
+```
+
+
+> ### Java Code
+
+```java
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ //finding RadioGroup with help of findViewById() method
+ RadioGroup radioColorGroup = findViewById(R.id.radioGroup);
+ //finding Button with help of findViewById() method
+ Button selectButton =findViewById(R.id.button);
+
+ selectButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // Getting the id which radio is button is checked and storing in the int variable
+ int selectedId=radioColorGroup.getCheckedRadioButtonId();
+
+ // finding Radio Button with help of findViewById() method
+ RadioButton radioButton = findViewById(selectedId);
+
+ // Showing toast of particular Radio Button
+ Toast.makeText(MainActivity.this,radioButton.getText(),Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
+```
+
+For more help visit [Android Official Documenation](https://developer.android.com/guide/topics/ui/controls/radiobutton)
diff --git a/Android_Development_With_Java/2 Android UI Widgets/2.7 Image View.md b/Android_Development_With_Java/2 Android UI Widgets/2.7 Image View.md
new file mode 100644
index 0000000000..849663f701
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/2.7 Image View.md
@@ -0,0 +1,35 @@
+# Image View
+Image View is used to display Images in our App. To add an Image, the following steps should be followed :
+ 1) Add the image in drawable folder
+ 2) Use android:src attribute to use that image in Image View.
+
+
+
+
+
+ ```XML
+
+
+ ```
+
+
+ Sometimes we need to change the image during run time. For that, we can use the following Java Code to change the image programmatically.
+
+ ```JAVA
+ ImageView imageView=findViewById(R.id.imageView);
+ imageView.setImageResource(R.drawable.image_name);
+ ```
+
+ Images can be scaled using android:scaleType attribute.
+ 1) center - It centers the image in the ImageView without any scaling.
+ 2) centerCrop - It scales image uniformly in the center. Both dimensions will be equal to or larger than than the View's dimensions.
+ 3) centerInside - It scales image uniformly in the center. Both dimensions will be equal to or smaller than than the View's dimensions.
+ 4) fitStart - It scales the image to the start of the View
+ 5) fitEnd - It scales the image to the end of the View.
+
+
+If we use vector images, we can change the color of the image by using android:tint attribute.
diff --git a/Android_Development_With_Java/2 Android UI Widgets/Alert Dialog Box.md b/Android_Development_With_Java/2 Android UI Widgets/Alert Dialog Box.md
new file mode 100644
index 0000000000..a313cffd43
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/Alert Dialog Box.md
@@ -0,0 +1,172 @@
+# **Alert Dialog Box**
+
+## Introduction
+
+ Sometimes in your application, if you wanted to ask the user about taking a decision between yes or no in response of any particular action taken by the user, by remaining in the same activity and without changing the screen, you can use __Alert Dialog__.
+
+
+ Android AlertDialog is composed of three regions: __title, content area and action buttons__. Android AlertDialog is the subclass of Dialog class.
+
+
+
+
+
+
+ In order to make an alert dialog, you need to make an object of __AlertDialogBuilder__ which an inner class of __AlertDialog__.
+ Its syntax is given below:
+``` java
+AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
+
+```
+
+ Now you have to set the positive (yes) or negative (no) button using the object of the AlertDialogBuilder class. Its syntax is-
+``` java
+alertDialogBuilder.setPositiveButton(CharSequence text,
+DialogInterface.OnClickListener listener)
+
+alertDialogBuilder.setNegativeButton(CharSequence text,
+DialogInterface.OnClickListener listener)
+```
+
+# __Functions provided by the builder class__
+
+Apart from this, you can use other functions provided by the builder class to customize the alert dialog. These are listed below:
+
+
+
+| Sr no. | Method type & description |
+| ------ | ------------- |
+| 1 | setIcon(Drawable icon)This method set the icon of the alert dialog box.|
+| 2 | setCancelable(boolean cancelable)This method sets the property that the dialog can be cancelled or not. |
+| 3 | setMessage(CharSequence message)This method sets the message to be displayed in the alert dialog.|
+|4 |setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems,DialogInterface.OnMultiChoiceClickListenerlistener)This method sets list of items to be displayed in the dialog as the content. The selected option will be notified by the listener.|
+| 5 | setOnCancelListener(DialogInterface.OnCancelListener onCancelListener)This method Sets the callback that will be called if the dialog is canceled.|
+| 6 | setTitle(CharSequence title)This method sets the title that will appear in the dialog.|
+
+
+
+
+
+ After creating and setting the dialog builder, you will create an alert dialog by calling the create() method of the builder class. Its syntax is:
+``` java
+AlertDialog alertDialog = alertDialogBuilder.create();
+alertDialog.show();
+```
+ This will create the alert dialog and will show it on the screen.
+
+
+# __Example__
+
+ Let's see a simple example of android alert dialog.
+
+
+__activity_main.xml__
+
+ You can have multiple components, here we are having only a textview.
+
+```
+
+
+
+
+
+
+
+```
+
+### __strings.xml__
+
+ Optionally, you can store the dialog message and title in the strings.xml file.
+
+``` java
+
+ AlertDialog
+ Welcome to Alert Dialog
+ Javatpoint Alert Dialog
+
+```
+
+### __Activity class__
+
+### Let's write the code to create and show the AlertDialog.
+
+File: MainActivity.java
+
+``` java
+package example.javatpoint.com.alertdialog;
+
+import android.content.DialogInterface;
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.app.AlertDialog;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+ Button closeButton;
+ AlertDialog.Builder builder;
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ closeButton = (Button) findViewById(R.id.button);
+ builder = new AlertDialog.Builder(this);
+ closeButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+
+ //Uncomment the below code to Set the message and title from the strings.xml file
+ builder.setMessage(R.string.dialog_message) .setTitle(R.string.dialog_title);
+
+ //Setting message manually and performing action on button click
+ builder.setMessage("Do you want to close this application ?")
+ .setCancelable(false)
+ .setPositiveButton("Yes", new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int id) {
+ finish();
+ Toast.makeText(getApplicationContext(),"you choose yes action for alertbox",
+ Toast.LENGTH_SHORT).show();
+ }
+ })
+ .setNegativeButton("No", new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int id) {
+ // Action for 'NO' Button
+ dialog.cancel();
+ Toast.makeText(getApplicationContext(),"you choose no action for alertbox",
+ Toast.LENGTH_SHORT).show();
+ }
+ });
+ //Creating dialog box
+ AlertDialog alert = builder.create();
+ //Setting the title manually
+ alert.setTitle("AlertDialogExample");
+ alert.show();
+ }
+ });
+ }
+}
+```
+
+# __Output__
+
+
+
+
+
+
+
diff --git a/Android_Development_With_Java/2 Android UI Widgets/Overview of JVM-DVM-ART-JIT-AOT.md b/Android_Development_With_Java/2 Android UI Widgets/Overview of JVM-DVM-ART-JIT-AOT.md
new file mode 100644
index 0000000000..015c34af16
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/Overview of JVM-DVM-ART-JIT-AOT.md
@@ -0,0 +1,136 @@
+# Overview of JVM,DVM, ART, JIT, AOT
+# GIRLSCRIPT WINTER OF CONTRIBUTING’21
+# OVERVIEW
+### 1. What is Virtual Machine?
+A virtual machine, commonly shortened to just VM, is no different than any other physical computer like a laptop, smart phone or server. It has a CPU, memory, disks to store your files and can connect to the internet if needed. While the parts that make up your computer (called hardware) are physical and tangible, VMs are often thought of as virtual computers or software-defined computers within physical servers, existing only as code.
+There are 2 main types of Virtual Machine (VM):
+· System virtual machines (full virtualization VMs) provide a substitute for a real machine.
+· Process virtual machines are designed to execute computer programs in a platform-independent environment.
+
+
+
+
+
+
+### 2. Give some overview of JVM, DVM, ART, JIT,AOT
+
+##### a.) JVM:
+JVM is the virtual machine that runs java code on different platforms. It acts as an abstract layer between the program and the platform on which the java code is running. The portability of Java code is possible only because of the JVM. The javac compiler converts the source code file(.java file) into an intermediate java bytecode format which is machine/platform independent. This intermediate file is then provided to the target machine/platform where it gets translated into machine code. JVM supports multiple host architecture and it is the reason why Java applications are called WORA(Write Once Run Anywhere).
+
+
+
+
+
+
+##### b.) DVM:
+DVM stands for “Dalvik Virtual Machine”. It is a Register-Based virtual machine. It was designed and written by Dan Bornstein with contributions of other Google engineers as part of the Android mobile phone platform. The Dalvik virtual machine was named after Bornstein after the fishing village “Dalvík” in Iceland, where some of his ancestors used to live.
+
+
+
+
+
+
+
+##### c.) ART:
+ART or Android Runtime is an Android runtime that uses Ahead Of Time (AOT). By using AOT, what is does is it converts or compiles the whole High-level language code into Machine level code and at the time of installation of the app and not dynamically as the application runs(like in case of Dalvik). By compiling the whole code during installation results in no lag that we see when we run our app on our device. By doing so, the compilation becomes very faster.
+
+
+
+
+
+
+
+##### d.) JIT:
+JIT stands for "Just In Time," and we use it to describe a Dalvik JIT compiler, which was added to Android with the 2.2 release. It compiles bytecode into native machine code at runtime. Essentially it takes the code for an app, analyzes it and converts it into something that runs faster. It does all this while the application is running, and that's where the "just in time" tag comes from. The JIT compiler designed for Android also can do this with a very short "warm up" time, meaning it doesn't take very long to analyze the code before it starts working. It stores information in a cache in your phone's RAM, which means it's not an ideal solution for devices with low memory.
+
+
+
+
+
+
+
+##### e.) AOT:
+AOT stands for Ahead of Time compilation, and compiles your code, to the native platform, dependent upon the architecture. The reason you would use AOT, is because it has a drastically reduces startup time, and app performance.
+
+
+
+
+
+### 3. JVM V/s DVM
+
+##### Difference Table
+
+
+
+
+### 4. Why Android OS used DVM instead of JVM ?
+One of the main reasons of using DVM in android is because it follows the register based model and it is much faster than stack based model while JVM follows the stack based model which takes a lot of memory and also slower than DVM.
+
+There are couple of reasons why Google not choose JVM over DVM, so let’s understand each one of them one by one.
+· Though JVM is free, it was under GPL license, which is not good for Android as most the Android is under Apache license.
+· JVM was designed for desktops and it is too heavy for embedded devices.
+· DVM takes less memory, runs and loads faster compared to JVM.
+
+
+
+### 5. Why Android deprecated DVM & started to use ART?
+In Android Lollipop, DVM has been replaced by ART. Because DVM converts bytecode every time you launch a specific app. But ART converts it just once at the time of app installation.
+ART is extremely fast and smooth. Apps are very snappy and responsive. Any comparison between Dalvik and ART, will surely make the ART device win by a significant margin.
+Dalvik used Just-In-Time (JIT) approach in which the compilation was done on demand. All the dex files were converted into their respective native representations only when it was needed.
+But ART uses the Ahead-Of-Time (AOT) approach, in which the dex files were compiled before they were demanded. This itself massively improves the performance and battery life of any Android device.
+
+
+
+
+
+
+### 6. DVM V/s ART
+ Difference Between DVM and ART
+
+DALVIK VIRTUAL MACHINE ANDROID RUN TIME
+Faster Booting time Rebooting is significantly longer
+Cache builds up overtime The cache is built during the first boot
+Occupies less space due to JIT Consumes a lot of storage space internally due to AOT
+Works best for small storage devices Works best for Large storage devices
+Stable and tested virtual machine Experimental and new – not much app support comparatively
+Longer app loading time Extremely Faster and smoother Faster and app loading time and lower processor usage
+Uses JIT compiler(JIT: Just-In-Time)
+Thereby resulting in lower storage space consumption Uses AOT compiler(Ahead-Of-Time) thereby compiling apps when installed
+Application lagging due to garbage collector pauses and JIT Reduced application lagging and better user experience
+App installation time is comparatively lower as the compilation is performed later App installation time is longer as compilation is done during installation
+
+
+
+
+##### What’s Better?
+It depends on the device and one’s own device and preferences: in the long run, ART is better, but the apps do get bigger, requiring large storage space over time, unlike flappy bird which was just 1MB and required less space. Therefore, the devices in the future need to expand storage if ART is going to dominate the market in the next few years.
+
+
+
+### 7. Why Android is reintroducing JIT with ART?
+This is done in order to tackle problems such as initial installation time and memory. Using the Hybrid Runtime, there won't be any compilation during install, and applications can be started right away, the bytecode is interpreted. Now with ART and the new JIT the application installation is faster.
+
+
+
+
+### 8. JIT V/s AOT
+JIT compilers have way more information at their disposal than AOT compilers. Static analysis is impossible in the general case (nearly everything interesting you would want to know about a program can be reduced to either the Halting Problem or Rice's Theorem), and hard even in the special case. JIT compilers don't have this problem: they don't have to statically analyze the program; they can observe it dynamically at runtime.
+Plus, a JIT compiler has techniques at its disposal that AOT compilers don't, the most important one being de-optimization. Now, you might think, we is de-optimization important for performance? Well, if you can de-optimize, then you can be over-aggressive in making optimizations that are actually invalid (like inlining a method call that may or may not be polymorphic), and if it turns out that you are wrong, you can then de-optimize back to the un-inlined case (for example).
+However, there's the problem of resources: an AOT compiler can take as much time as it wants, and use as much memory as it wants. A JIT compiler has to steal its resources away from the very program that the user wants to use right now.
+
+
+
+
+
+
+###### References:
+1. https://azure.microsoft.com/en-in/overview/what-is-a-virtual-machine/#overview
+2. https://medium.com/programming-lite/android-core-jvm-dvm-art-jit-aot-855039a9a8fa
+3. https://medium.com/android-news/virtual-machine-in-android-everything-you-need-to-know-9ec695f7313b
+4. https://www.geeksforgeeks.org/what-is-dvmdalvik-virtual-machine/
+5. https://www.geeksforgeeks.org/difference-between-jvm-and-dvm/
+6. https://blog.mindorks.com/what-are-the-differences-between-dalvik-and-art
+7. https://www.journaldev.com/23464/android-runtime-dvm-vs-art-aot-vs-jit
+8. https://towardsdatascience.com/jvm-vs-dvm-b257229d18a2
+9. https://stackoverflow.com/questions/31957568/what-is-difference-between-dvm-and-art-why-dvm-has-been-officially-replaced-wi
+10. https://stackoverflow.com/questions/40336455/difference-between-aot-and-jit-compiler-in-the-art
diff --git a/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md b/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md
new file mode 100644
index 0000000000..6fe8d59315
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md
@@ -0,0 +1,98 @@
+# Progress Bar
+Progress Bar is used to determine how much an event has progressed or is in progress. It can be done in two modes: Indeterminant and Determinant.
+
+An Indeterminate Progress Bar is used when we do not know how long an event will take place. It is commonly seen in Apps when some page is being loaded or some action is to be starting soon.
+
+
+
+
+
+
+
+
+
+We usually set the visibility of this widget to INVISIBLE. When an action starts we set its mode to VISIBLE and again set it to INVISIBLE when an action ends.
+
+
+
+ Within Java:
+
+ // When activity starts
+ progressBar.setVisibility(View.VISIBLE);
+
+ // When activity ends
+ progressBar.setVisibility(View.INVISIBLE);
+
+
+
+ Determinate Progress Bars show how much an event has progressed.
+
+
+
+
+
+
+
+
+
+ Progress Bars can be of different styles:
+
+ 1)
+
+
+
+
+
+
+
+
+
+ 2)
+
+
+
+
+
+
+
+
+ 3)
+
+
+
+
+
+
+
+
+
diff --git a/Android_Development_With_Java/2.2 Button_in_Android.md b/Android_Development_With_Java/2.2 Button_in_Android.md
new file mode 100644
index 0000000000..1efa4649e9
--- /dev/null
+++ b/Android_Development_With_Java/2.2 Button_in_Android.md
@@ -0,0 +1,584 @@
+# BUTTONS IN ANDROID
+
+## What is a button in android studio?
+
+In Android Studio, Button allows users to perform actions and make choices, when they are
+clicked, tapped or pressed. Button represents a push button.
+A button can consist of text or an icon or both text and an icon, which when clicked let us
+know what actions are going to be performed. It is a very common widget in Android and
+developers often use it.
+
+Types of buttons in android studio are button, imagebutton, checkbox, switch, chip, radio
+button etc
+
+
+
+
+
+##
Xml Code of button
+
+```xml
+
+
+
+
+```
+
+##
Xml Attributes
+
+Here are some important attributes to configure a Button in xml layout.\
+
+
1. id : id is an attribute which uniquely identifies a text Button.
+Below is the example code in which we set the id of a Button.
+
+```xml
+
+```
+
+
+
+
2. gravity : The gravity attribute specifies the alignment of the text in the button like left,
+right, center, top, bottom, center_vertical, center_horizontal, bottom_start etc.
+Here we have used bottom_start gravity.
+
+```xml
+
+```
+
+
+
+
+
3. text : text attribute displays the text of a Button.
+We can display text in XML and Java class both.
+
+
+```xml
+
+```
+
+
+
+
+
+#### Set Text Using Java Class:
+
+In the code below, we have set the text on Button in java class
+
+```xml
+Button button = (Button) findViewById(R.id.button);
+button.setText("Android Development");//set the text on button
+```
+
+
+
4. textColor : textColor attribute displays the color of the text.
+
+
+```xml
+
+```
+
+
+
+
+
+#### Set Text Color On Button In Java class:
+
+In the code below, we have set the text color on Button in java class
+
+```xml
+Button button=(Button) findViewById(R.id.button);
+button.setTextColor(Color.BLUE);//set the blue color for the text
+```
+
+
+
5. textSize : textSize attribute displays the size of the text on Button. We can display text
+in sp (scale independent pixel) and dp (density independent pixel) units.
+
+
+
+```xml
+
+```
+
+
+
+
+
+#### Set textSize In Java class:
+
+
In the code below, we have set the text size of buttons in java class.
+
+```xml
+Button button=(Button)findViewById(R.id.button);
+button.setTextSize(24);//set the text size of button
+```
+
+
+
6. textStyle : textStyle attribute displays the style of a text. Some text styles are bold, italic
+and normal. To use more than one text style for a Button us "|" operator.
+
+
+```xml
+
+```
+
+
+
+
+
+
7. background : background attribute displays the background of a Button. We can
+display a color or a drawable in the background of a Button.
+
+
+```xml
+
+```
+
+
+
+
+
+#### Set background in Button In Java class:
+
+
In the code below, we have set the background color of buttons in java class.
+
+```xml
+Button button=(Button)findViewById(R.id.button);
+button.setBackgroundColor(Color.PINK);//set the pink color of
+button background
+```
+
+
+
8. padding : padding attribute is used to set the padding from left, right, top or bottom.
+
+
In the below example code we have set paddings from all the sides.
+
+
+```xml
+
+```
+
+
+
+
+
+## Making buttons attractive
+
+## Round button
+
+In XML Layout
+
+```xml
+
+```
+
+
+
+
+## Gradient button
+
+Making gradient colors is fun. Because they look just like magic when one color changes to another.
+
+First make a drawable file. Name it gradientbutton.xml.
+
+
+
+
+In drawable file: \
+
+We need gradient, shape and corners. For gradient we have used two color values, startColor and endColor. Set the corner radius.
+
+```xml
+
+
+
+
+
+```
+
+In XML Layout
+
+```xml
+
+```
+
+
+
+
+
+## Outlined buttons:
+
+ Make a drawable file. Name it borderbutton.xml.
+ We need a selector, item, shape for this.
+ Set shape to rectangle, solid with color, stroke with width and color.
+
+
+
+
+
+## Contained button
+
+Note The contained button is the default style in android studio
+
+
+
+
+In xml Layout
+
+```xml
+
+```
+
+## Buttons with icon and text:
+
+Lots of designs for buttons in Android use icons and text for buttons.
+To create these types of buttons we use some attributes. The attribute drawableBottom is the drawable to be drawn below the text.
+Similarly drawableRight for right of the text.
+Let’s see how to add an icon to a button at the start of the text, at bottom, at end and at top
+of the text.
+We have taken the default Android icon from the drawable resource manager
+
+
+
+
+
XML Code for icon below the text.
+
+```xml
+
+```
+
+
+
+
+#### For icon at top of the text
+
+```xml
+android:drawableTop="@drawable/ic_launcher_foreground"
+```
+
+
+
+#### For icon at top of the text
+
+```xml
+android:drawableTop="@drawable/ic_launcher_foreground"
+```
+
+
+
+#### For icon at the start of text
+
+```xml
+android:drawableLeft="@drawable/ic_launcher_foreground"
+```
+
+
+
+
+
+### ANATOMY FOR OUTLINED BUTTON WITH TEXT AND ICON
+
+It has a text label, a stroked container and an optional icon.
+
+
+
+
+ 1. Text label
+ 2. Container
+ 3. icon
+
+### ANATOMY FOR CONTAINED BUTTON WITH TEXT AND ICON
+
+
+
+
+
+
+ 1. Text label
+ 2. Container
+ 3. icon
+
+## Circle button
+
+To make a circle button, we need a new drawable. Name it circle.xml.
+We need a selector, item and shape. Use an oval for shape. Take the width and height size
+the same to make the button circular. Set the size with the size tag. Also set color with solid
+to any color code. Now you can use your drawable for the background attribute of your
+button.
+
+
+In xml Layout
+
+```xml
+
+```
+
+In drawable file
+
+```xml
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+## Responding to Click Events
+
+When a user clicks a button, the button receives an on click event.
+We add the android:onClick attribute to the button element in XML layout. The value of the
+attribute is the name of the method we call in response to a click event. Then the Activity
+hosting the layout, implements the method.
+Here is an example for this:
+
+### In xml layout setting onclick
+
+
+```xml
+
+```
+
+### In java code making a toast
+
+Here using the openButton() method on the button and using Toast we will display which button is clicked by the user.
+
+```xml
+public class MainActivity extends AppCompatActivity {
+Button button;
+@Override
+protected void onCreate(Bundle savedInstanceState) {
+super.onCreate(savedInstanceState);
+setContentView(R.layout.activity_main);
+button = findViewById(R.id.button); //get id of button
+}
+public void openButton(View v){
+Toast.makeText(this, "Learn Android Development",
+Toast.LENGTH_SHORT).show();
+}
+}
+```
+
+ ### Result:
+
+ Now start the AVD in Emulator and run the app. There is a button. Click on it and you will see a message on screen when the button is clicked.
+
+
+
+
+
+## References:
+
+https://developer.android.com/reference/android/widget/Button
+
+https://developer.android.com/guide/topics/ui/controls/button
+
+https://material.io/components/buttons/android
diff --git a/Android_Development_With_Java/3 Activity and Intents/3.07 Intent Filter in android.md b/Android_Development_With_Java/3 Activity and Intents/3.07 Intent Filter in android.md
new file mode 100644
index 0000000000..5e36a94716
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3.07 Intent Filter in android.md
@@ -0,0 +1,208 @@
+# Intent Filter in android
+Intent Filter tells andriod which activities can handle which actions. This process is also known as `Intent Resolution`. Intents are of two types:
+* Explicit Intent
+* Implicit Intent
+
+When we use an `Explicit Intent`, intent resolution is straightforward. The intent explicitly tells android to which action the intent is pointing at.
+
+For Example:
+```java
+Intent intent=new Intent(MainActivity.this, SecondActivity.class);
+startActivity(intent);
+```
+In this the intent explicitly tells that the App must start the SecondActivity.
+
+When we use an `Implicit Intent`, the intent information is used to figure out which action is used to be performed. This is done by checking the `intent filters` in the Android Manifest file.
+The `intent filter` specifies what types of intent each component can receive.
+
+Most of the intent filters are describe by its
+ 1) action
+ 2) category
+ 3) data
+
+### Action
+The `` tells the Application what kind of activity the intent has to perform.
+
+Example:
+```xml
+
+```
+
+Other common actions that can be used are `ACTION_VIEW` and `ACTION_SEND`.
+
+### Category
+The `` adds a category name to an intent filter. It contains additional information about the kind of component that should handle the intent.
+
+Example:
+```xml
+
+```
+
+### Data
+The `` adds specifications to the intent.
+
+Example:
+```xml
+
+```
+
+## Integrate Intent Filters in a demo application
+ We will first create a demo UI for our App consisting of two buttons, one for sending the data and the other for viewing the data.
+
+```xml
+
+
+
+
+
+
+
+
+
+```
+The layout :
+
+
+
+
+
+
+#### Next we move on to the AndroiManifest.xml file. We will make our MainActivity as the launcher activity,i.e., the first activity on our App.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+#### We have created two Intent Filters in the Manifest file, one for sending and the other for viewing the data.
+
+Now we will create our main Activity where we will see how the data can be shared and viewed on respective button clicks.
+For sample string we have already created the string within strings.xml
+
+### MainActivity.java
+```java
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ }
+
+ public void shareData(View view) {
+ Intent intent = new Intent(Intent.ACTION_SEND); //type of action to be performed
+ intent.setType("text/plain"); //mime type
+
+ //To add extra Info, use intent.putExtra()
+ intent.putExtra(Intent.EXTRA_EMAIL, "gwoc@gmail.com"); //Email Id to which mssg will be send
+ intent.putExtra(Intent.EXTRA_SUBJECT, "Email Subject"); //Title of the mail
+ intent.putExtra(Intent.EXTRA_TEXT, R.string.sample); //sample string has been created within strings.xml
+
+ //start the action
+ startActivity(intent);
+ }
+
+ public void viewData(View view) {
+ Intent intent = new Intent(Intent.ACTION_VIEW);
+ intent.putExtra(Intent.EXTRA_TEXT, R.string.sample);
+ startActivity(intent);
+ }
+}
+```
+## After running the App
+### On clicking on the Share Button:
+
+
+
+
+### On clicking on the View Button:
+
+
+
diff --git a/Android_Development_With_Java/3 Activity and Intents/3.2 Spinners.md b/Android_Development_With_Java/3 Activity and Intents/3.2 Spinners.md
new file mode 100644
index 0000000000..b59516f70b
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3.2 Spinners.md
@@ -0,0 +1,112 @@
+## Spinner
+
+**Android Spinner is a view similar to the dropdown list which is used to select one option from the list of options. It provides an easy way to select one item from the list of items and it shows a dropdown list of all values when we click on it.**
+
+
+
+### Sample Project
+
+Here we will create a simple spinner having some numbers as items.
+
+
+
+## Process
+
+### Step 1 - Add `Spinner` widget to `activity_main.xml` layout.
+
+> XML Code:
+
+```XML
+
+
+
+
+
+
+
+
+
+
+```
+### Step 2 - Add `Spinner` list item in form of a `Array`.
+
+Here we will add the list of items in form of `string-array`. We will that in
+
+* `string.xml` file is by default present in the project.
+Path - `res -> Values -> string.xml`
+
+> XML Code:
+
+```xml
+
+
+
+ Spinners
+
+
+
+ One
+ Two
+ Three
+ Four
+ Five
+
+
+
+```
+### Step 3 - Adding functionality in `MainActivity.java`
+
+Android spinner is associated with AdapterView. So you need to use one of the adapter classes with spinner.
+
+> JAVA Code:
+
+```java
+package com.example.spinners;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Spinner;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity{
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ Spinner spinner =findViewById(R.id.spinner);
+ // Create an ArrayAdapter using the string array and a default spinner layout
+
+ ArrayAdapter adapter = ArrayAdapter.createFromResource(this,R.array.numbers, android.R.layout.simple_spinner_item);
+ // Specify the layout to use when the list of choices appears
+
+ adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ // Apply the adapter to the spinner
+
+ spinner.setAdapter(adapter);
+
+ }
+}
+```
+* Both `simple_spinner_item` and `simple_spinner_dropdown_item` is by default available in Android.
+
+For more details please visit [Andoid Official Documentation](https://developer.android.com/guide/topics/ui/controls/spinner).
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/3.4 Implicit Intents.md b/Android_Development_With_Java/3 Activity and Intents/3.4 Implicit Intents.md
new file mode 100644
index 0000000000..0c1345be39
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3.4 Implicit Intents.md
@@ -0,0 +1,77 @@
+# Implicit intents
+`Implicit intents` do not name a specific component, but instead declare a general action to perform, which allows a component from another app to handle it.
+
+For example, if you want to show the user a location on a map, you can use an implicit intent to request that another capable app show a specified location on a map.
+
+
+
+
+## Building an Intent
+**Here we Taking an example how to send a text message and break down each and every component.**
+
+```java
+// Create the text message with a string.
+Intent sendIntent = new Intent();
+sendIntent.setAction(Intent.ACTION_SEND);
+sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
+sendIntent.setType("text/plain");
+
+// Try to invoke the intent.
+try {
+ startActivity(sendIntent);
+} catch (ActivityNotFoundException e) {
+ // Define what your app should do if no activity can handle the intent.
+}
+```
+**Action**
+
+A string that specifies the generic action to perform (such as view or pick).
+
+- `ACTION_VIEW` - Use this action in an intent with startActivity() when you have some information that an activity can show to the user, such as a photo to view in a gallery app, or an address to view in a map app.
+
+- `ACTION_SEND` - Also known as the share intent, you should use this in an intent with startActivity() when you have some data that the user can share through another app, such as an email app or social sharing app.
+
+**Extra**
+
+Key-value pairs that carry additional information required to accomplish the requested action.
+
+- You can add extra data with various `putExtra()` methods, each accepting two parameters: the key name and the value.
+
+- you can specify the to recipient with the `EXTRA_EMAIL` key, and specify the subject with the `EXTRA_SUBJECT` key.
+
+**Data**
+
+The type of data supplied is generally dictated by the intent's action.
+
+- To set only the data URI, call `setData()`
+
+- To set only the MIME type, call `setType()`
+
+**In this example we will sending a Text message Intent**
+
+
+
+
+> **Java Source Code**
+```java
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // Finding button 1 with its id
+ Button b1 = findViewById(R.id.button1);
+
+ b1.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ Intent i = new Intent(Intent.ACTION_SEND);
+ i.setType("text/plain");
+ i.putExtra(i.EXTRA_TEXT,"Hello, I am Sharing this");
+ startActivity(i.createChooser(i,"share"));
+ }
+ });
+ }
+}
+```
+For more help please visit [Android official Documentation.](https://developer.android.com/guide/components/intents-filters)
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/3.5 Explicit Intent.md b/Android_Development_With_Java/3 Activity and Intents/3.5 Explicit Intent.md
new file mode 100644
index 0000000000..3194f6c0a8
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3.5 Explicit Intent.md
@@ -0,0 +1,115 @@
+# Android Explicit Intent
+`Android Explicit Intent` specifies the component to be invoked from activity. In other words, we can call another activity in android by explicit intent. We can also pass the information from one activity to another using explicit intent.
+
+
+
+
+> Explicit Intent Syntax
+```java
+// First parameter is for context and second is for the Activity which we want to open.
+Intent i = new Intent(this, ActivityView.class);
+startActivity(i);
+```
+---
+**In this example we will opening Second Activity from First Activity and vice versa.**
+
+
+
+---
+> First Activity Java And XML source code.
+
+**JAVA**
+
+```java
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // Finding button 1 with its id
+ Button b1 = findViewById(R.id.button1);
+ // Setting OnClickListener
+ b1.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // Setting up Intent
+ Intent i = new Intent(MainActivity.this, Activity2.class);
+ startActivity(i);
+ }
+ });
+ }
+}
+```
+**XML**
+```XML
+
+
+
+
+
+
+
+```
+
+
+> Second Activity Java And XML source code.
+
+**JAVA**
+```java
+public class Activity2 extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_2);
+ // Finding button 2 with its id
+ Button b2 = findViewById(R.id.button2);
+ // Setting OnClickListener
+ b2.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // Setting up Intent
+ Intent i = new Intent(Activity2.this, MainActivity.class);
+ startActivity(i);
+ }
+ });
+ }
+}
+```
+**XML**
+```XML
+
+
+
+
+
+
+
+```
+For more help please visit [Android official Documentation.](https://developer.android.com/guide/components/intents-filters)
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/3.8 Activity and Activity LifeCycle.md b/Android_Development_With_Java/3 Activity and Intents/3.8 Activity and Activity LifeCycle.md
new file mode 100644
index 0000000000..624f342e11
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3.8 Activity and Activity LifeCycle.md
@@ -0,0 +1,97 @@
+ # *Activity and Activity LifeCycle*
+
+
+
+
+
+## **What is activity in android?**
+
+ > An activity is a single, focused thing that the user can do. Almost all activities interact with the user. An Android app may contain one or more activities,
+ > meaning one or more screens. The Android app starts by showing the main activity, and from there the app may make it possible to open additional activities.
+
+## **What is activity life cycle in android?**
+
+> An activity has various stages in its lifecycle. To transit from one stage to the other stage of the activity lifecycle activity class has six methods which are
+> overided by the developers according to the need. These methods are termed as callbacks. The six callbacks are :
+## **Methods to handle activity life cycle :-**
+### 1. onCreate()
+
+### 2. onStart()
+
+### 3. onResume()
+
+### 4. onPause()
+
+### 5. onStop()
+
+### 6. onDestroy()
+
+ 
+
+### 1. *onCreate()*:
+ > It displays the UI given in the XML file when the activity starts . It calls the SetContentView() method.
+
+### 2. *onStart():*
+ > when our activity is in process to be displayed this callback method is called .And after this method onResume() callbackis called.
+
+### 3. *onResume()* :
+ > The core functionality of application is written within this callback method.When the activity is just about to bedisplayed this callback method
+ > is called .Suppose if you start a new activity that hides the already ongoing activity , onResume() is called when the activity that was hidden comes back to
+ > the view on the screen again.
+
+### *4. onPause()*:
+ > The code you want to be executed when app is being paused (minimised ) should be wriiten in this callback method and when the user resumes to the
+ > application onResume() callback method will be called again.
+
+### 5. *onStop():*
+ > when an activity is being minimised onPause() callback is immediately called and after a few miliseconds onStop will be called.onStop() will stop
+ > the API calls of the application.
+
+### 6. *onDestroy():*
+ > onDestroy callback is to be called when you need to shutdown all the operations .
+
+
+
+## **Starting Activities and Getting Results**
+
+ > The *startActivity(Intent)* method is used to start a new activity,which will be placed at the top of the activity stack. It takes a single argument,an
+ > [*Intent*](https://developer.android.com/reference/android/content/Intent),which describes the activity to be executed.
+
+ > Sometimes you want to get a result back from an activity when it ends. For example, you may start an activity that lets the user pick a person in a list of contacts;
+ > when it ends, it returns the person that was selected. To do this, you call the *startActivityForResult(Intent,int)* version with a second integer parameter identifying
+ > the call. The result will come back through your *onActivityResult(int, int,Intent)* method.
+
+ > When an activity exits, it can call *setResult(int)* to return data back to its parent. It must always supply a result code, which can be the standard results
+ > RESULT\_CANCELED, RESULT\_OK, or any custom values starting at RESULT\_FIRST\_USER. In addition, it can optionally return back an Intent containing any additional
+ > data it wants. All of this information appears back on the parent's Activity.onActivityResult(),along with the integer identifier it originally supplied.
+
+ > If a child activity fails for any reason (such as crashing), the parent activity will receive a result with the code RESULT_CANCELED.
+
+ ...
+ public class MyActivity extends Activity {
+
+ static final int PICK_CONTACT_REQUEST = 0;
+
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+ // When the user center presses, let them pick a contact.
+ startActivityForResult(
+ new Intent(Intent.ACTION_PICK,
+ new Uri("content://contacts")),
+ PICK_CONTACT_REQUEST);
+ return true;
+ }
+ return false;
+ }
+
+ protected void onActivityResult(int requestCode, int resultCode,
+ Intent data) {
+ if (requestCode == PICK_CONTACT_REQUEST) {
+ if (resultCode == RESULT_OK) {
+ // A contact was picked. Here we will just display it
+ // to the user.
+ startActivity(new Intent(Intent.ACTION_VIEW, data));
+ }
+ }
+ }
+ }
diff --git a/Android_Development_With_Java/3 Activity and Intents/3_7_Android_Webview.ipynb b/Android_Development_With_Java/3 Activity and Intents/3_7_Android_Webview.ipynb
new file mode 100644
index 0000000000..34e457e83f
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/3_7_Android_Webview.ipynb
@@ -0,0 +1,214 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "3.7 Android Webview.ipynb",
+ "provenance": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pXd1W0Kgv5uH"
+ },
+ "source": [
+ "
Introduction
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GS5NtgtHwEiP"
+ },
+ "source": [
+ "Hello everyone, toady we will be discussing about webview in android using java. So let's see what's this webview is, android webview is used to display webpages in your android applications.\n",
+ "The webview is basically like a framework which allows us to specify viewport and style properties that make your web pages appear at the proper size and scale on all screen configurations for all major web browsers. We can even define an interface between your Android app and our web pages that allows javaScript in the web pages to call upon APIs in your app for providing Android APIs to our web-based application.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VuzjcGIDzhrN"
+ },
+ "source": [
+ "In order to add WebView to your application, you have to add < WebView > element to your xml layout file. \n",
+ "\n",
+ "Syntax : \n",
+ "\n",
+ " < WebView xmlns:android=\"http://schemas.android.com/apk/res/android\" \n",
+ " android:id=\"@+id/webview\" \n",
+ " android:layout_width=\"fill_parent\" \n",
+ " android:layout_height=\"fill_parent\"\n",
+ " / >\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7kp7P9Z52REH"
+ },
+ "source": [
+ "After adding this in our xml file, in order to use we need to reference this view in our java file. We will be creating the object of this class - \n",
+ "Syntax : \n",
+ " \n",
+ " WebView webview = (WebView) findViewById(R.id.webview);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DMhat2EX3CVf"
+ },
+ "source": [
+ "**Note :** However, you shouldn't develop an Android app simply as a means to view your website. Rather, the web pages you embed in your app should be designed especially for that environment."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Z2SMUIye4K6y"
+ },
+ "source": [
+ "The web page can be loaded from same application or URL. Android WebView uses webkit engine to display web page.\n",
+ "\n",
+ "The android.webkit.WebView is the subclass of AbsoluteLayout class."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oWIkQZGP4-JC"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_fQ_a49I5ILA"
+ },
+ "source": [
+ "The loadUrl() and loadData() methods of Android WebView class are used to load and display web page."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wE6NyZ2d5nT8"
+ },
+ "source": [
+ "Lets see one example how the above two methods work : \n",
+ " \n",
+ "WebView webview = (WebView) findViewById(R.id.webView); \n",
+ "webview.loadUrl(\"https://gwoc.girlscript.tech/\"); \n",
+ "\n",
+ "String Data = \"< html > < body > < h1 >Hello GWOC!!!< /h1 >< /body >< /html >\"; \n",
+ "webview.loadData(Data, \"text/html\", \"UTF-8\"); "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5k-4knc16rWE"
+ },
+ "source": [
+ "
Diiferent methods provided by WebView
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qRJHZerm7zyI"
+ },
+ "source": [
+ "Apart from just loading url there are several other method's also which are provided by webview to have more control over webview by using webview class."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zMBElkmX8jQg"
+ },
+ "source": [
+ "1. canGoBack() - This method specifies the WebView has a back history item.\n",
+ "\n",
+ "1. canGoForward() - This method specifies the WebView has a forward history item.\n",
+ "\n",
+ "1. clearHistory() - This method will clear the WebView forward and backward history.\n",
+ "\n",
+ "1. destroy() - This method destroy the internal state of WebView.\n",
+ "\n",
+ "1. findAllAsync(String find) - This method find all instances of string and highlight them.\n",
+ "2. getProgress() - This method gets the progress of the current page.\n",
+ "\n",
+ "2. getTitle() - This method return the title of the current page.\n",
+ "\n",
+ "2. getUrl() - This method return the url of the current page.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oYYE9lrL9vJd"
+ },
+ "source": [
+ "
Alternatives to WebView
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZJQE-v6i-LOi"
+ },
+ "source": [
+ "Although WebView objects provide increased control over the UI, there are alternatives that may provide similar functionality with various advantages. They require less configuration, may load and perform faster, provide improved privacy protections, and can access the browser's cookies."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KbmiJibh-pPe"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "* If you want to send users to mobile site we can build a progressive web app.\n",
+ "* If we want to display third party web content we will send an intent to repective installed web browser.\n",
+ "\n",
+ "\n",
+ "* We can also use custom tabs if we don't want to allow app to open up the browser. Also we can customize the browser's UI using custom tabs.\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fCb5T2Cb_zOV"
+ },
+ "source": [
+ "**Image Credits and References :** \n",
+ " \n",
+ " \n",
+ "\n",
+ " * https://developer.android.com/guide/webapps\n",
+ " * https://www.tutorialspoint.com/android/android_webview_layout.htm\n",
+ " * https://www.javatpoint.com/android-webview-example\n",
+ "\n"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/4.3 Start Activity For Result.md b/Android_Development_With_Java/3 Activity and Intents/4.3 Start Activity For Result.md
new file mode 100644
index 0000000000..6bfe48cce9
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/4.3 Start Activity For Result.md
@@ -0,0 +1,44 @@
+# Start an Activity For Result
+This documentation contains how to get a result from an activity. Starting another activity and getting the result does not need to be a one-way operation. This can also be done by starting another activity and receiving the result from that activity in your current activity. Here I am showing an example where one can click on the button to upload an image from the internal storage of the phone and that image will be displayed in the imageview.
+
+
+**First make a new project in android.**
+
+
+
+
+**Give the name whatever you want and select the language java.**
+
+
+
+
+**Now in layout set an ImageView and a button**
+
+
+
+
+ In java class define the ImageView and button variables then follow the steps listed below.
+
+ Registering a callback for an Activity Result
+
+- `registerForActivityResult()` API is for registering the result callback while the image is selected. `registerForActivityResult()` takes an `ActivityResultContract` and an `ActivityResultCallback` where imageURI is set on the image, and returns an `ActivityResultLauncher` which will be used to launch the result .
+
+
+ - An `ActivityResultContract` defines the input type needed to produce a result along with the output type of the result. Here the contract used is default(default contracts) to take the picture, various contracts are there for different intent actions such as to take video to request multiple permissions and so on.
+
+
+
+## Launching an activity for result
+
+- While `registerForActivityResult()` registers the callback, but does not launch the activity and rejects the request for a result. When onActivityResult() from the ActivityResultCallback is executed, calling launch() starts the process of producing the result
+
+
+
+
+
+## After uploading the image, in the activity result URI is received and the corresponding image is launched and shows up.
+
+
+
+
+For more information please visit (https://developer.android.com/training/basics/intents/result)
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/Android-Java 3.3_EventListener in Android.ipynb b/Android_Development_With_Java/3 Activity and Intents/Android-Java 3.3_EventListener in Android.ipynb
new file mode 100644
index 0000000000..a0e363464c
--- /dev/null
+++ b/Android_Development_With_Java/3 Activity and Intents/Android-Java 3.3_EventListener in Android.ipynb
@@ -0,0 +1,819 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Android-Java 3.3: EventListener in Android.ipynb",
+ "provenance": [],
+ "collapsed_sections": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "SvqXtV2eDvoJ"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SfZ7Py7CEopt"
+ },
+ "source": [
+ "# **EventListener in Android**\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "z2VORbrHEy5S"
+ },
+ "source": [
+ "This discussion is going to be little bit interesting, because It will help us most of the time in our project to give life to our application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZwzyGIP-HjVt"
+ },
+ "source": [
+ "Suppose there is someone in your home whom you respect very much.\n",
+ "You always complete the task whenever you get a glimpse of that task from them.\n",
+ "This is how your application interacts with the user. It responds with the user's action and fulfills the user's requirement. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qQaJcYlnH-uk"
+ },
+ "source": [
+ "##**Agenda**\n",
+ "---\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bNPRgt49ggo_"
+ },
+ "source": [
+ "\n",
+ "* Purpose of Listener.\n",
+ "* Listeners in Java.\n",
+ "* Definition of event handling method and event class\n",
+ "* What is the use of listeners in android?\n",
+ "* Basic EventListeners in Android.\n",
+ "* Implementation of onClickListener in the android application.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "P9w1rm2MhKiL"
+ },
+ "source": [
+ "## **Why do we use listener?**\n",
+ "---\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WZZjekfKC-yZ"
+ },
+ "source": [
+ "Listening is an active process by which we make sense of, assess, and respond to what we hear.\n",
+ "\n",
+ "\n",
+ "An event listener is a procedure or function in a computer program that waits for an event to occur. Examples of an event are the user clicking or moving the mouse, pressing a key on the keyboard, disk I/O, network activity, or an internal timer or interrupt.\n",
+ "\n",
+ "The term event listener is often specific to `Java` and `JavaScript`. In other languages, a subroutine that performs a similar function is referred to as an **event handler.**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KJ8NhKyWEBSd"
+ },
+ "source": [
+ "## **Listeners in Java:**\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NucFZdtAEisk"
+ },
+ "source": [
+ "The Event listener represents the interfaces responsible to handle events. For every type of event class, there is a listener interface available in java. All these interfaces are available in java. awt. event package.\n",
+ "In Java, there are several event listener interfaces which are listed below:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PA1oHgbJK-uG"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FCq6hwYPOHZ4"
+ },
+ "source": [
+ "These are the most commonly used event listeners.\n",
+ "For further details click here.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sXoqldsCWN2K"
+ },
+ "source": [
+ "## **Event handling method:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DAVfrkNDW5sd"
+ },
+ "source": [
+ "An event handler is a method that is called in response to a particular type of event. Each event interface specifies one or more event-handling methods that must be defined in the class that implements the event-listener interface. REMEMBER that interfaces define abstract methods."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wFCU7-H9YuJG"
+ },
+ "source": [
+ "*Now it's time to end the annoyance with so much documentation and lecture. Let us practically implement the event listener interfaces through java.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fxGW-jpRxPnt"
+ },
+ "source": [
+ "## **Event class:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pJDArZ3hLbEy"
+ },
+ "source": [
+ "The classes that represent events are at the core of Java's event handling mechanism.\n",
+ "For further details click here\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "br5NwRsAY2AL"
+ },
+ "source": [
+ "Hopefully, through this, we have got an idea about event listeners. Let us move ahead and jump into android."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hirzmbuIOjQg"
+ },
+ "source": [
+ "## **What is the use of listener in android?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Olt2estXPskq"
+ },
+ "source": [
+ "Android Listeners are **used to capturing events**. When, for instance, the user interacts with the Android system by clicking on a button, the Listeners would prompt the underlying activity to do the task associated with the button click."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "HMVTaAZEP3xl"
+ },
+ "source": [
+ "## **Basic Event Listeners in android:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SZA0w-3xQPQn"
+ },
+ "source": [
+ "Event Listening in Android development is largely centered around the `View` object."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xQ0Cq9sTQ7vn"
+ },
+ "source": [
+ "Here, I have categorized the event listeners according to View.\n",
+ "* View Event Listeners.\n",
+ "* AdapterView Event Listeners\n",
+ "* EditText Common Listeners\n",
+ "* Input View Listeners."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ln7jL8lsR2wN"
+ },
+ "source": [
+ "### **View Event Listeners:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OZ78Bm0AS3uH"
+ },
+ "source": [
+ "Any View (Button, TextView, etc) has many event listeners that can be attached using the setOnEvent pattern which involves passing a class that implements a particular event interface. The listeners available to any View include:\n",
+ "\n",
+ "* setOnclickListener - Callback when the view is clicked\n",
+ "* setOnDragListener - Callback when the view is dragged\n",
+ "* setOnFocusChangeListener - Callback when the view changes focus\n",
+ "* setOnGenericMotionListener - Callback for arbitrary gestures\n",
+ "* setOnHoverListener - Callback for hovering over the view\n",
+ "* setOnKeyListener - Callback for pressing a hardware key when view has focus\n",
+ "* setOnLongClickListener - Callback for pressing and holding a view\n",
+ "* setOnTouchListener - Callback for touching down or up on a view"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gGaoO_EbRy-2"
+ },
+ "source": [
+ "### **AdapterView Event Listeners:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RQeHEB9zTlUS"
+ },
+ "source": [
+ "In addition to the standard View listeners, AdapterView descendants have a few more key event listeners having to do with their items:\n",
+ "\n",
+ "* setOnItemClickListener - Callback when an item contained is clicked\n",
+ "* setOnItemLongClickListener - Callback when an item contained is clicked and held\n",
+ "* setOnItemSelectedListener - Callback when an item is selected"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jzvzsoA_TyMu"
+ },
+ "source": [
+ "### **EditText Common Listeners:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7rRIRiVtUHoT"
+ },
+ "source": [
+ "In addition to the listeners described above, there are a few other common listeners for input fields in particular.\n",
+ "\n",
+ "* addTextChangedListener - Fires each time the text in the field is being changed\n",
+ "* setOnEditorActionListener - Fires when an \"action\" button on the soft keyboard is pressed"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DsdkMjNbUMp1"
+ },
+ "source": [
+ "### **Input View Listeners:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "peYfzfaSUfwE"
+ },
+ "source": [
+ "Similarly to EditText, many common input views have listeners of their own including NumberPicker has setOnValueChangedListener and SeekBar has setOnSeekBarChangeListener which allow us to listen for changes:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "LeUZS3kNXlf5"
+ },
+ "source": [
+ "We just got an overview of EventListeners present in Android.\n",
+ "This time we will look at the implementation of some of the most commonly used event listeners."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EVl1V0jhYjbt"
+ },
+ "source": [
+ "## **What are the most commonly used Listeners?**\n",
+ "The following basic Listeners are the most commonly used:\n",
+ "* OnClickListener\n",
+ "* OnTouchListener\n",
+ "* OnDateSetListener"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gE5JT8v7Y67S"
+ },
+ "source": [
+ "### **onClickListener:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3pg3_6fLZEhc"
+ },
+ "source": [
+ "OnClickListener is used when one wants to execute a task in the event of a click.\n",
+ "\n",
+ "For example, With the click of the button, a toast will display the number of clicks."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "55Tule3mtxOA"
+ },
+ "source": [
+ "Here I am going to discuss the implementation of onClickListener step by step."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Xud2c8GsviZ3"
+ },
+ "source": [
+ " **Step 1:** Create a new project, It will be better for our understanding."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hhWJMc-NwJDL"
+ },
+ "source": [
+ "Initial code of MainActivity.java and activity_main.xml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qTn0yvB-wKen"
+ },
+ "source": [
+ "**`MainActivity.java`**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "gQiAP7YRvp3K"
+ },
+ "source": [
+ "\n",
+ "import androidx.appcompat.app.AppCompatActivity;\n",
+ "\n",
+ "import android.os.Bundle;\n",
+ "\n",
+ "public class MainActivity extends AppCompatActivity {\n",
+ "\n",
+ " @Override\n",
+ " protected void onCreate(Bundle savedInstanceState) {\n",
+ " super.onCreate(savedInstanceState);\n",
+ " setContentView(R.layout.activity_main);\n",
+ " }\n",
+ "}"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "y7xbkkzPzcLB"
+ },
+ "source": [
+ " **`activity_main.xml`**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "eFmpr2mvVLbc"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ " \n",
+ "\n",
+ "\n",
+ "\n"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ilJ8PDM50YEe"
+ },
+ "source": [
+ "Initially, there is only a TextView in our XML file."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rA4bXENe07VJ"
+ },
+ "source": [
+ " **Step 2:** Add a button to your XML file and give it an id."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Bbm09dtg_7EL"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MDrVscDy1x51"
+ },
+ "source": [
+ " **Step 3**: In your MainActivity, declare a button type instance variable. \n",
+ " \n",
+ " **Step 4**: In the onCreate method find the button view present inside the XML file."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YHfDHT2b2c1U"
+ },
+ "source": [
+ "**Step 5**: Set onClickListener to our button."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "dsErklqcAGF6"
+ },
+ "source": [
+ "\n",
+ "import androidx.appcompat.app.AppCompatActivity;\n",
+ "import android.widget.Button;\n",
+ "import android.os.Bundle;\n",
+ "import android.widget.Toast;\n",
+ "import android.view.View.OnClickListener;\n",
+ "\n",
+ "public class MainActivity extends AppCompatActivity {\n",
+ " // step 3\n",
+ " private Button button;\n",
+ "\n",
+ " @Override\n",
+ " protected void onCreate(Bundle savedInstanceState) {\n",
+ " super.onCreate(savedInstanceState);\n",
+ " setContentView(R.layout.activity_main);\n",
+ " \n",
+ " //step 4\n",
+ " button= findViewById(R.id.button);\n",
+ "\n",
+ " // step 5\n",
+ " button.setOnClickListener(new View.OnClickListener() {\n",
+ " @Override\n",
+ " public void onClick(View v) {\n",
+ " Toast.makeText(MainActivity.this,\"Button is clicked\",Toast.LENGTH_LONG).show();\n",
+ " }\n",
+ " });\n",
+ " }\n",
+ "}"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cwWOe2b43N8U"
+ },
+ "source": [
+ "**Step 6**: Install your app on the emulator and click the button."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6Zxj42mPxBR8"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "z_4SnBJg4X5g"
+ },
+ "source": [
+ "### **onTouchListener:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iKpN4thoKjVx"
+ },
+ "source": [
+ "The user interacts with the application while touching the screen in a different location for his desired action. Android applications understand the touch and process this touch and take appropriate action. \n",
+ "We can customize this action as per our requirement, with the help of onTouchListener."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JY69opyWMkLG"
+ },
+ "source": [
+ "OnTouchListener is used *to capture a touch event and execute the task associated with it.*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "3sDjJp8K6bGh"
+ },
+ "source": [
+ "Here we are going to create an onTouchListener on our ConstraintLayout\n",
+ "and going to see how we can move our view around the screen on our application. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Uz5FUUth4mgy"
+ },
+ "source": [
+ "Steps 1 and 2 will remain the same."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "slST2Oe35SzW"
+ },
+ "source": [
+ " **Step 3:** Give an id to your ConstraintLayout"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "InxFq-rKMyEu"
+ },
+ "source": [
+ "\n",
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RLyT2Lok7PqF"
+ },
+ "source": [
+ " **Step 4**: Find the id into your onCreate method."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NVbcLdoM7mZT"
+ },
+ "source": [
+ "**Step 5**: Set onTouchListener on the layout."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "nyYajDH4JxuM"
+ },
+ "source": [
+ "package com.sb2318.myapplication;\n",
+ "\n",
+ "import androidx.appcompat.app.AppCompatActivity;\n",
+ "import androidx.constraintlayout.widget.ConstraintLayout;\n",
+ "\n",
+ "\n",
+ "import android.annotation.SuppressLint;\n",
+ "import android.os.Bundle;\n",
+ "import android.view.MotionEvent;\n",
+ "import android.view.View;\n",
+ "import android.widget.Button;\n",
+ "\n",
+ "\n",
+ "import android.widget.Toast;\n",
+ "\n",
+ "public class MainActivity extends AppCompatActivity {\n",
+ "\n",
+ " private Button button;\n",
+ " private ConstraintLayout myLayout ;\n",
+ " private float x;\n",
+ " private float y;\n",
+ " private int i=0;\n",
+ "\n",
+ " @SuppressLint(\"ClickableViewAccessibility\")\n",
+ " @Override\n",
+ " protected void onCreate(Bundle savedInstanceState) {\n",
+ " super.onCreate(savedInstanceState);\n",
+ " setContentView(R.layout.activity_main);\n",
+ "\n",
+ " button= findViewById(R.id.button);\n",
+ " // step 4\n",
+ " myLayout= findViewById(R.id.parent_layout);\n",
+ "\n",
+ "\n",
+ " button.setOnClickListener(new View.OnClickListener() {\n",
+ " @Override\n",
+ " public void onClick(View v) {\n",
+ " Toast.makeText(MainActivity.this,\"Button is clicked\",Toast.LENGTH_LONG).show();\n",
+ " }\n",
+ " });\n",
+ "\n",
+ " // step 5\n",
+ " myLayout.setOnTouchListener(new View.OnTouchListener() {\n",
+ "\n",
+ " @SuppressLint(\"ClickableViewAccessibility\")\n",
+ " @Override\n",
+ " public boolean onTouch(View v, MotionEvent event) {\n",
+ " x= event.getX();\n",
+ " y= event.getY();\n",
+ "\n",
+ "\n",
+ " button.setX(x);\n",
+ " button.setY(y);\n",
+ " button.setText(\"You bring me here\");\n",
+ "\n",
+ " if(++i<60)\n",
+ " return true;\n",
+ " else\n",
+ " return false;\n",
+ " }\n",
+ " });\n",
+ " }\n",
+ "}"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "o9x5661FUDVX"
+ },
+ "source": [
+ "If you want to see the explanation click here"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bEKVbwAh8VA4"
+ },
+ "source": [
+ "**Step 6**: Install your app on the emulator and click the button."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "z0maBaM0xZ_K"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NI628jxq8dgT"
+ },
+ "source": [
+ "### **onDataSetListener:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ktEPsAxj9A0l"
+ },
+ "source": [
+ "To see the implementation of onDataSetListener \n",
+ "click here\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "l1QsChHL4WQS"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/3 Activity and Intents/index.md b/Android_Development_With_Java/3 Activity and Intents/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/4 Android Menu/4.01 Android Menu.md b/Android_Development_With_Java/4 Android Menu/4.01 Android Menu.md
new file mode 100644
index 0000000000..78975c7a72
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/4.01 Android Menu.md
@@ -0,0 +1,58 @@
+## Android Menus
+
+**Menus are a common user interface component in many types of applications. To provide a familiar and consistent user experience.**
+
+We Inflate the menu by calling the `inflate()` method of MenuInflater class. To perform event handling on menu items, we need to override the `onOptionsItemSelected()` method of the Activity class.
+
+### Defining Menu in XML File?
+
+Android Studio provides a standard XML format for the type of menus to define menu items. We can simply define the `menu` and all its items in an XML menu resource instead of building the menu in the code and also load the menu resource as a menu object in the activity or fragment used in our android application.
+
+We should create a new folder menu inside of our project directory `(res/menu)` to define the menu and also add a new `XML` file to build the menu with the following elements.
+
+> XML
+
+```xml
+
+
+
+```
+
+## Android Different Types of Menus
+
+In android, we have three types of Menus available to define a set of options and actions in our android applications.
+
+* **Options Menu**
+* **Context Menu**
+* **Popup Menu**
+
+### Android Options Menu -
+
+**This menu is usually found at the top of your application and in it, you should place actions that affect the application as a whole. These could be the application’s settings or a search box.**
+
+
+
+### Android Context Menu -
+
+**This menu appears when a user performs a long click on one of your UI elements. The options found in this menu affect what UI element the user made the click on. It is common to use this type of menu in list or grid views, where the user’s interaction with each item can lead to a specific action.**
+
+
+
+### Android Popup Menu -
+
+**A popup menu is a type of menu that displays items in a vertical list. This list is attached to the view the user has clicked on to invoke this menu. It is important to keep in mind, that when choosing a popup menu, you do not want the user’s choice to affect the previous content the user pressed.**
+
+
+
+**For more help please visit [Android Official Documentation](https://developer.android.com/guide/topics/ui/menus)**
\ No newline at end of file
diff --git a/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md b/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md
new file mode 100644
index 0000000000..995a545308
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md
@@ -0,0 +1,151 @@
+# Popup Menu Android Studio
+
+We are going to discuss the Popup Menu.
+A Popup Menu displays a Menu in a popup window anchored to a View.
+The popup will be shown below the anchored View if there is room (space) otherwise above the View.
+If any IME (Input Method Editor) is visible the popup will not overlap it until the View (to which the popup is anchored) is touched.
+Touching outside the popup window will dismiss it.
+
+- Go to Android Studio and create Empty Project in Java Language.
+
+- In this step, we will add a button to the **activity_main.xml** layout file and give it an id as btn to it.
+
+``` xml
+
+
+
+
+
+
+
+
+```
+
+
+- First, we will create a menu directory which will contain the menu file. Go to **app > res > right-click > New > Android Resource Directory** and give Directory name and Resource type as menu.
+
+
+
+
+
+
+
+- Now, we will create a **popup_menu** file inside that menu resource directory. Go to **app > res > menu > right-click > New > Menu Resource File** and create a menu resource file and name it as **popup_menu**. In the **popup_menu.xml** file, we will add menu items.
+
+
+``` xml
+
+
+
+
+```
+
+- In the **MainActivity.java** file, we will get the reference of the Button and initialize it. Add onClick behaviour to the button and inflate the popup menu to it.
+
+
+``` java
+
+package com.example.gwocpopupmenu;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+
+ Button button;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ button = findViewById(R.id.btn);
+
+ button.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ PopupMenu popupMenu = new PopupMenu(MainActivity.this, button);
+
+ popupMenu.getMenuInflater().inflate(R.menu.popup_menu, popupMenu.getMenu());
+ popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
+ @Override
+ public boolean onMenuItemClick(MenuItem menuItem) {
+ Toast.makeText(MainActivity.this, "You Clicked on " + menuItem.getTitle(), Toast.LENGTH_SHORT).show();
+ return true;
+ }
+ });
+ popupMenu.show();
+ }
+ });
+ }
+}
+
+```
+
+
+
+- Output
+
+
+
+
+
+
diff --git a/Android_Development_With_Java/4 Android Menu/4.4 Android Context Menu.md b/Android_Development_With_Java/4 Android Menu/4.4 Android Context Menu.md
new file mode 100644
index 0000000000..c8177f5a99
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/4.4 Android Context Menu.md
@@ -0,0 +1,125 @@
+## Context Menu.
+**Android context menu appears when user press long click on the element. It is also known as floating menu. It affects the selected content while doing action on it.**
+
+
+
+### Step 1 - Add a `Button` to `activity_main.xml` layout.
+
+> XML
+
+```xml
+
+
+
+
+
+
+```
+### Step 2 - Adding a `menu` Resource Directory.
+
+Right click on `res` then `New` then `Android Resource Directory`.
+
+
+
+
+### Step 3 - Adding a menu layout in `menu` res folder and adding items to it.
+
+**Here we add 3 items to the Menu** with the Id's `cm1` `cm2` `cm3`.
+
+
+
+> XML
+
+```xml
+
+
+
+```
+
+### Step 4 - Infalting and Setting up the menu.
+
+Here we will use `onCreateContextMenu()` for setting up the Context Menu and `onContextItemSelected()` to handle the item cliked in Context Menu.
+
+> JAVA
+```java
+package com.example.myapplication;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // we are registering a button for Context menu
+ // when we hold for sometime it will pop up a Context Menu.
+
+ Button b1 = findViewById(R.id.button);
+ registerForContextMenu(b1);
+
+ }
+
+ // Here we are setting or Inflating a Layout(Custom Menu) as a Context Menu.
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
+ getMenuInflater().inflate(R.menu.cmenu,menu);
+ super.onCreateContextMenu(menu, v, menuInfo);
+ }
+
+ // It is use to handle what task need to perform whenever any item is clicked in the menu.
+ // Here we use a Toast Message.
+
+ @Override
+ public boolean onContextItemSelected(@NonNull MenuItem item) {
+ int itemid;
+
+ itemid = item.getItemId();
+
+ if(itemid == R.id.cm1){
+ Toast.makeText(this, "This is Home menu", Toast.LENGTH_SHORT).show();}
+
+ if(itemid == R.id.cm2){
+ Toast.makeText(this, "This is insert menu", Toast.LENGTH_SHORT).show();}
+
+ if(itemid == R.id.cm3){
+ Toast.makeText(this, "This is update menu", Toast.LENGTH_SHORT).show();}
+
+ return super.onContextItemSelected(item);
+ }
+}
+```
+For more help please visit [Android Official Documentation](https://developer.android.com/guide/topics/ui/menus)
\ No newline at end of file
diff --git a/Android_Development_With_Java/4 Android Menu/Context menu.md b/Android_Development_With_Java/4 Android Menu/Context menu.md
new file mode 100644
index 0000000000..29433500f8
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/Context menu.md
@@ -0,0 +1,143 @@
+# **Android Context Menu**
+
+In android, Context Menu is like a floating menu and that appears when the user performs a long press or click on an element and it
+is useful to implement actions that affect the selected content or context frame.
+
+ The android Context Menu is more like the menu which displayed on right-click in Windows or Linux.
+
+ Following is the pictorial representation of using Context Menu in our android applications.
+
+
+
+In android, the Context Menu offers actions that affect a specific item or context frame in the UI and we can provide a context menu
+for any view. The context menu won’t support any item shortcuts and item icons.
+
+
+
+## **Steps to create the application:-**
+
+1. Open Android Studio and create a new Android application and name it as “ContextMenu”
+2. Open an Empty Activity and name it as MainActivity.
+3. You will also need to create a menu directory and then create an context_menu.xml file in that directory. To achieve this first
+right click on res, goto new, goto android resource directory, in directory name write menu, select the resource type as menu and
+source set as main, click OK. Now you will have your menu directory created. Then to create the context_menu.xml file, right click
+on menu which you just created, click on new, you should get an option as menu resource file click on that, set filename as context_menu
+source set as main and your directory name as menu, click OK. Now you have successfully created your context_menu.xml file.
+4. Copy the contents of res/layout/activity_main.xml and res/menu/context_menu.xml file.
+5. Run the application to launch Android emulator or you can run it on your mobile also(which is way faster).
+
+
+ ### *XML File(res/layout/activity_main.xml):*
+
+
+
+
+
+
+
+
+### *XML File(res/menu/context_menu.xml):*
+
+
+
+
+
+### *MainActivity.java*
+
+package codedost.contextmenu;
+
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.view.ContextMenu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+
+ private Button cntxtbtn;
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ cntxtbtn =(Button) findViewById(R.id.btn);
+ //register the cntxtbtn from activity_main.xml file to context menu
+ registerForContextMenu(cntxtbtn);
+ }
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
+ super.onCreateContextMenu(menu, v, menuInfo);
+ menu.setHeaderTitle("Select the Action");
+ MenuInflater menuInflater = getMenuInflater();
+ menuInflater.inflate(R.menu.menu, menu);
+
+ }
+
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+
+
+ switch (item.getItemId()) {
+ case R.id.comp:
+ //select item computer with id comp from menu.xml file and toast
+ Toast.makeText(MainActivity.this, "Computer is Selected", Toast.LENGTH_SHORT).show();
+
+ return true;
+
+ case R.id.game:
+ //select item gamepad with id game from menu.xml file and toast
+ Toast.makeText(MainActivity.this, "Gamepad is Selected", Toast.LENGTH_SHORT).show();
+
+ return true;
+
+ case R.id.lap:
+ //select item laptop with id lap from menu.xml file and toast
+ Toast.makeText(MainActivity.this, "Laptop is Selected", Toast.LENGTH_SHORT).show();
+
+ return true;
+
+ default: return super.onContextItemSelected(item);
+ }
+ }
+}
+
+
+
+## *Output*
+
+
+
+
diff --git a/Android_Development_With_Java/4 Android Menu/Option Menu.md b/Android_Development_With_Java/4 Android Menu/Option Menu.md
new file mode 100644
index 0000000000..92d7c9d180
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/Option Menu.md
@@ -0,0 +1,147 @@
+# Option Menu
+
+Menus are a common UI component in various applications. By using Options Menu, we can combine multiple options that are relevant to our current activity.
+Menu Items are defined within Menu Resource Folder inside the Resource folder.
+
+
+
+In order to create a menu we need to override two functions :
+* @Override
+ public boolean onCreateOptionsMenu(Menu menu)
+* @Override
+ public boolean onOptionsItemSelected(@NonNull MenuItem item)
+
+ The onCreateOptionsMenu() is used to create a Menu in the given Activity. The onOptionsItemSelected() is used to handle item clicks.
+
+ To change the image on the toolbar, we can change the code in option_menu.xml as follows :
+
+
+
+
+
+
+
+
+
+ The showAsAction attribute decides how our menus will be displayed.
+
+
+ In order to add Options Menu to Fragments, the steps are almost similar to that with Activities. In both the cases the menus are displayed on the actionbar. However, if you want to display the fragment menus before Activity Menu, you can use the android:orderInCategory attribute as shown below. But when you detach the fragment, the fragment menu items will disappear from the action bar also.
+
+
+
+
+ Inside the onCreate() method in Fragments, you need to write the following code :
+
+ @Override
+ public void onCreate(@Nullable Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ // Confirm this fragment has menu items.
+ setHasOptionsMenu(true);
+ }
+
+ After this, override the onCreateOptionsMenu(Menu menu) and onOptionsItemSelected(@NonNull MenuItem item) methods, similar to that as done in Activities.
+
+
+
diff --git a/Android_Development_With_Java/4 Android Menu/Popup menu.md b/Android_Development_With_Java/4 Android Menu/Popup menu.md
new file mode 100644
index 0000000000..59487bdec6
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/Popup menu.md
@@ -0,0 +1,168 @@
+
+
+ # **PopUp Menu Android**
+
+ PopUp menu is a type of menu that contains a menu and displays that menu below the anchor text if space is available. If the space
+ is not available then it displays it above the Anchor text. It appears untill when you do not click on the pop-up menu text.
+
+# For this you need to create an `XML` file inside `"res/menu/popup"` like this:
+> XML Code:
+```XML
+
+```
+
+## Step 1
+
+## **Create an `XML` file with this:**
+
+> XML Code:
+```XML
+
+
+
+
+
+```
+
+
+
+## Step 2
+
+## **Create another `XML` file with this:**
+
+> XML Code:
+```XML
+
+ ```
+
+
+## Step 3
+
+## **Create a `Java` class file and with the following.**
+
+In this, you create the id of the button on which you pop up the menu. Now you will crate the instance of the PopUp menu, then
+you will populate.
+
+> JAVA Code:
+```java
+package com.popupmenu;
+
+import android.os.Bundle;
+import android.app.Activity;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.Toast;
+public class MainActivity extends Activity {
+ Button button;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ button = (Button) findViewById(R.id.button);
+ button.setOnClickListener(new OnClickListener() {
+
+ @Override
+ public void onClick(View v) {
+ //Creating the instance of PopupMenu
+ PopupMenu popupMenu = new PopupMenu(MainActivity.this, button);
+ //Inflating the Popup using xml file
+ popupMenu.getMenuInflater().inflate(R.menu.popup, popupMenu.getMenu());
+ //registering popup with OnMenuItemClickListener
+ popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
+ public boolean onMenuItemClick(MenuItem item) {
+ Toast.makeText(MainActivity.this,"Button Clicked : " + item.getTitle(),Toast.LENGTH_SHORT).show();
+ return true;
+ }
+ });
+ popupMenu.show();//showing popup menu
+ }
+ });//closing the setOnClickListener method
+ }
+}
+```
+
+
+
+
+
+## Step 4
+
+## **Android Manifest.xml file**
+
+> XML Code:
+``` xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ```
+
+
+## Step 5
+
+### *Popup menu*
+
+
+
diff --git a/Android_Development_With_Java/4 Android Menu/index.md b/Android_Development_With_Java/4 Android Menu/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/5 Android storage/5.01: Android-Internal-Storage-Example.md b/Android_Development_With_Java/5 Android storage/5.01: Android-Internal-Storage-Example.md
new file mode 100644
index 0000000000..30bff29c84
--- /dev/null
+++ b/Android_Development_With_Java/5 Android storage/5.01: Android-Internal-Storage-Example.md
@@ -0,0 +1,251 @@
+# Internal Storage in Android with Example
+
+Android provides many kinds of storage for applications to store their data. These storage places are shared preferences,
+internal and external storage, SQLite storage, and storage via network connection.
+
+Here, we are going to look at the internal storage. Internal storage is the storage of the private data on the device memory.
+
+By default these files are private and are accessed by only your application and get deleted , when user delete your application.
+
+We are able to save or read data from the device internal memory.
+
+To read and write in the android internal storage we have two methods
+
+#### Writing file
+
+- OpenFileOutput(): Used for creating and saving a file. This method returns a FileOutputStream instance.
+
+```
+Syntax: OpenFileOutput(String filename,int mode)
+
+Context.MODE_PRIVATE: If the file exists then it is overiddent else a new file is created.
+
+Context.MODE_APPEND: if the file exists then the data is appended at the end of the file.
+
+Returns:
+FileOutputStream object
+
+```
+
+#### Reading file
+
+- OpenFileInput(): Used to read data from a file, this returns an FileInputStream instance.
+
+```
+Syntax: OpenFileInput( String filename)
+
+Returns:
+FileInputStream object
+
+```
+
+**Apart from the the methods of write and close, there are other methods provided by the FileOutputStream class for better writing files.
+These methods are listed below −**
+
+| Method | Description |
+| :--- | :---: |
+| FileOutputStream(File file, boolean append) | This method constructs a new FileOutputStream that writes to file. |
+| getChannel() | This method returns a write-only FileChannel that shares its position with this stream |
+| getFD() | This method returns the underlying file descriptor |
+| write(byte[] buffer, int byteOffset, int byteCount) | IThis method Writes count bytes from the byte array buffer starting at position offset to this stream |
+
+
+
+**Apart from the the methods of read and close, there are other methods provided by the FileInputStream class for better reading files.
+These methods are listed below −**
+
+
+
+| Method | Description |
+| :--- | :---: |
+| available() | This method returns an estimated number of bytes that can be read or skipped without blocking for more input |
+| getChannel() | This method returns a read-only FileChannel that shares its position with this stream |
+| getFD() | This method returns the underlying file descriptor |
+| read(byte[] buffer, int byteOffset, int byteCount) | This method reads at most length bytes from this stream and stores them in the byte array b starting at offset |
+
+
+## Example
+
+In this example we will be creating an application that can write data to a file and store it in internal storage and read data from the file and
+display it on the main activity using TextView. Saving and loading data on the internal storage is private for an application that can not be
+accessed by other applications. When the app is uninstalled the data stored in the internal by that app is removed.
+
+## Step 1: Create activity_main.xml file
+
+The activity_main.xml file has the following widgets
+
+- One EditText for accepting user input
+- Two Buttons one for reading data and the other for writing
+- One TextView to display the content of the file
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+## Reference
+
+- https://www.javatpoint.com/android-internal-storage-example
+- https://www.geeksforgeeks.org/internal-storage-in-android-with-example/
+- YouTube
diff --git a/Android_Development_With_Java/5 Android storage/5.02 Android External Storage .md b/Android_Development_With_Java/5 Android storage/5.02 Android External Storage .md
new file mode 100644
index 0000000000..740de13534
--- /dev/null
+++ b/Android_Development_With_Java/5 Android storage/5.02 Android External Storage .md
@@ -0,0 +1,232 @@
+## Android External Storage
+
+**In android, we have different storage options such as shared preferences, internal storage, external storage, SQLite storage, etc.**
+
+In android, External Storage is useful to store the data files publically on the shared external storage using the `FileOutputStream` object. After storing the data files on external storage, we can read the data file from external storage media using a `FileInputStream` object.
+
+## Sample Project.
+
+Here we will be saving a `.txt.` file on the external SD card.
+
+
+
+### Process
+
+### Step 1 - Permission For writing in External Storage.
+
+Open `AndroidManifest.xml` and add `WRITE_EXTERNAL_STORAGE` permsiion
+
+```XML
+
+```
+After addition, your `AndroidManifest.xml` should look like this.
+
+```XML
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Step 2 - Prepraing the **activity_main.xml** layout.
+
+Here we will add two `EditText` and a `Button`.
+
+> XML Source Code.
+
+```XML
+
+
+
+
+
+
+
+
+
+
+```
+### Step 3 - Adding the functionality to the **MainActivity.java** file.
+
+This is full source code, every part of the code is explained below.
+
+> JAVA Source code
+
+```java
+
+public class MainActivity extends AppCompatActivity {
+ EditText filename;
+ EditText text;
+
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ filename = findViewById(R.id.fileName);
+ text = findViewById(R.id.text);
+ }
+
+ public boolean isExternalStorageIsAvailableRW() {
+ if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ public void writeFile(View v) {
+ if (isExternalStorageIsAvailableRW() && checkPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+ File textFile = new File(Environment.getExternalStorageDirectory(), filename.getText().toString());
+
+ try {
+ FileOutputStream fos = new FileOutputStream(textFile);
+ fos.write(text.getText().toString().getBytes());
+ fos.close();
+
+ Toast.makeText(this, "File Saved", Toast.LENGTH_SHORT).show();
+
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ } else {
+
+ Toast.makeText(this, "Cannot Write to External Storage", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ public boolean checkPermission(String permission) {
+ int check = ContextCompat.checkSelfPermission(this, permission);
+ return (check == PackageManager.PERMISSION_GRANTED);
+
+ }
+}
+
+```
+
+### Checking For the External Storage state.
+
+It checks whether the device has External Storage attached to it.
+
+```java
+
+ public boolean isExternalStorageIsAvailableRW() {
+ if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+```
+
+### Checking for user permission.
+
+It checks whether the user has been permitted to write in External Storage.
+
+```java
+
+ public boolean checkPermission(String permission) {
+ int check = ContextCompat.checkSelfPermission(this, permission);
+ return (check == PackageManager.PERMISSION_GRANTED);
+
+ }
+
+```
+
+### Handling Button clicks and Writing in External Storage.
+
+Herewith the help of `FileOutputStream` we will write to the external storage. We need to cover the whole code `Try & Catch` block majority due to `IOException`.
+
+* Here we wil take filename and text as a user input `filename.getText()` & `text.getText()`
+
+
+```java
+
+public void writeFile(View v) {
+ // Here we are checking the External Storage and permission
+
+ if (isExternalStorageIsAvailableRW() && checkPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+ // Getting the file name.
+ File textFile = new File(Environment.getExternalStorageDirectory(), filename.getText().toString());
+
+ try {
+ // trying to write in external storage
+ FileOutputStream fos = new FileOutputStream(textFile);
+ fos.write(text.getText().toString().getBytes());
+ fos.close();
+
+ Toast.makeText(this, "File Saved", Toast.LENGTH_SHORT).show();
+
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ } else {
+
+ Toast.makeText(this, "Cannot Write to External Storage", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+```
+For more help please visit [Android official Documentation.](https://developer.android.com/training/data-storage/)
+
+### Step 4 - Navigating to your saved `Test.txt` file.
+
+After you click on `SAVE FILE`, your `Text.txt` will save on Dir path.
+
+> SD card - `/Android/data/com.example.externalstorage/files/Test.txt`
+
+
+
+For more help please visit [Android official Documentation.](https://developer.android.com/training/data-storage/)
diff --git a/Android_Development_With_Java/5 Android storage/Room Database.md b/Android_Development_With_Java/5 Android storage/Room Database.md
new file mode 100644
index 0000000000..aac9e10031
--- /dev/null
+++ b/Android_Development_With_Java/5 Android storage/Room Database.md
@@ -0,0 +1,166 @@
+# Room Database
+ Room is a library which can be called an advanced version of SQL. It makes the use of SQLite easier by using **annotations**. With the help of Room Database, we can easily create the database and perform CRUD operations (Create, Read, Update, Delete).
+ To start with Room Database we need to add the following dependencies in app build.gradle :
+
+ ```XML
+ def room_version="2.2.4"
+ implementation "androidx.room:room-runtime:$room_version"
+ annotationProcessor "androidx.room:room-compiler:$room_version"
+```
+
+ ## Components
+ Room has three main components:
+ * Entity
+ * Dao
+ * Database
+
+ ### 1) Entity
+ Entity represents a table within the Database. Room creates a seperate table for all classes using ```@Entity``` annotation. They are usually small model classes without any logic. The columns of the table correspond to the fields in the Entity class.
+ It includes
+ * foreignKeys
+ * indices
+ * primaryKeys
+ * tableName
+
+ An example of Entity Class is as follows :
+
+ ```JAVA
+
+@Entity(tableName =Constants.TABLE_NAME_NOTE)
+public class Note implements Serializable {
+@PrimaryKey(autoGenerate = true)
+ private long id;
+
+@ColumnInfo(name="note_content")
+ private String content; //name of the column is note_content and not content
+ private String title;
+ //Constructor
+
+ public Note(String content, String title) {
+ this.content = content;
+ this.title = title;
+ }
+
+ @Ignore
+ public Note()
+ {}
+
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public String getContent() {
+ return content;
+ }
+
+ public void setContent(String content) {
+ this.content = content;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ @Override
+ public boolean equals(@Nullable Object obj) {
+ if(this==obj)
+ return true;
+ if(!(obj instanceof Note))
+ return false; // check if we have an instance of note
+ Note note=(Note) obj;
+ return title != null ? title.equals(note.title) : note.title==null;
+
+ }
+
+
+
+ @NonNull
+ @Override
+ public String toString() {
+ return "Note{"+"id=" +id + ", content='" +content + '\'' + ", title='" + title + '}';
+
+
+ }
+}
+
+```
+
+In the above code we can see that apart from ```@Entity``` there are some other annotations which has been used. So, let's study these annotations and their attributes:
+1) ```@PrimaryKey```: It refers to a unique value in the table. Two columns cannot have the same Primary Key.
+2) ```@PrimaryKey(autoGenerate = true)```: If autoGenerate is set as true, then values are automatically generated to the Primary Key in the Table.
+3) ```@ColumnInfo```: It allows specifying custom information about the columns in the table
+4) ```@Ignore```: This annotation means that the field will not be persisted by the Room
+5) ```@Embedded```: This annotation means that nested fields can be referenced directly in the SQL queries.
+
+
+### 2) Dao
+The function of Dao is similar to that of the function of a Cursor in SQLite.The queries in Room are defined using annotations in Dao.
+An example of Dao class is :
+
+```JAVA
+@Dao
+public interface NoteDao {
+ @Query("SELECT * FROM " +Constants.TABLE_NAME_NOTE)
+ List getNotes();
+
+ @Insert
+ void insertNote(Note note);
+
+ @Update
+ void updateNote (Note note);
+
+ @Delete
+ void deleteNote (Note note);
+
+}
+```
+
+### 3) Database
+This is the point which connects the App's data with the database. To create a Database we create an abstract class which extends RoomDatabase. It is annotated with ```@Database```. It contains all the Entities and the Daos.
+An example of this class is:
+
+```JAVA
+
+@Database(entities = {Note.class}, version = 1, exportSchema = false)// we are telling the database that Note class contains the entities
+public abstract class NoteDatabase extends RoomDatabase {
+
+ public abstract NoteDao getNoteDao();
+ private static NoteDatabase noteDB;
+ public static /*synchronised*/ NoteDatabase getInstance(Context context)
+ {
+ if(null==noteDB)
+ {
+ noteDB=buildDatabaseInstance(context);
+ }
+ return noteDB;
+ }
+
+ private static NoteDatabase buildDatabaseInstance(Context context)
+ {
+ return Room.databaseBuilder(context, NoteDatabase.class,Constants.DB_NAME).allowMainThreadQueries().build(); // acquires instance of database during runtime
+ }
+
+ public void cleanUp()
+ {
+ noteDB=null;
+ }
+}
+```
+
+
+## Summary of the Steps to create a Room Database:
+1) Add the Gradle Dependencies in build.gradle
+2) Create a Model Class with ```@Entity``` annotation
+3) Create Data Access Object (DAO) with ```@Dao``` annotation
+4) Create the Database with ```@Database``` annotation
+
+# _______________________________________________________________________________________________________________________
diff --git a/Android_Development_With_Java/5 Android storage/index.md b/Android_Development_With_Java/5 Android storage/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/6 Android SQLite/06.00 SQLite tutorial in android.md b/Android_Development_With_Java/6 Android SQLite/06.00 SQLite tutorial in android.md
new file mode 100644
index 0000000000..4a68354446
--- /dev/null
+++ b/Android_Development_With_Java/6 Android SQLite/06.00 SQLite tutorial in android.md
@@ -0,0 +1,315 @@
+# SQLite tutorial in android
+SQLite is a relational database which contains Tables,indexes,etc. We create tables to store the App data and this structure is known as Schema.
+
+To start with, let's first create a basic XML design.
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+## SQLiteOpenHelper
+In order to handle the SQLite Database Schemas, we create a helper class which extends SQLiteOpenHelper. It overrides two functions:
+
+* onCreate(SQLiteDatabase sqLiteDatabase) - This function is used to create a new database which can populate with tables and initial data.
+* onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) - This function is called when we need to upgrade our App version to a newer version.
+
+The given code is an example of DBHelper Class and how it can be used to perform `CRUD (Create, Read, Update, Delete)` functions.
+
+```java
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+
+import androidx.annotation.Nullable;
+
+public class DBHelper extends SQLiteOpenHelper {
+ SQLiteDatabase db;
+ private static final String DATABASE_NAME = "database.db"; //Name of the database
+ private static final int DATABASE_VERSION = 1; //Version
+ private static final String TABLE = "GWOC"; //Table in which our data will be saved
+ private static final String KEY_ID = "id"; //ID is the Primary Key,i.e., it will have an unique value
+ private static final String KEY_NAME = "name";
+ private static final String KEY_EMAIL = "email";
+ private static final String KEY_MOBILE = "mobile";
+
+ //Constructor
+ public DBHelper(Context context) {
+ super(context, DATABASE_NAME, null, DATABASE_VERSION);
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase sqLiteDatabase) {
+ //Create the SQLite Table
+ String Query_Table = " CREATE TABLE " + TABLE + "(" + KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + KEY_NAME + " TEXT, " + KEY_EMAIL + " TEXT, " + KEY_MOBILE + " TEXT);"; //Query to create table
+ sqLiteDatabase.execSQL(Query_Table); //The ID will be implemented automatically
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
+ sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + TABLE); // delete table if version is upgraded
+ onCreate(sqLiteDatabase);//Create a new Table
+ }
+
+ //to insert and save new data in the table
+ public long insertData(String name, String email, String mobile) {
+ db = this.getWritableDatabase();
+ ContentValues values = new ContentValues();
+ values.put(KEY_NAME, name);
+ values.put(KEY_EMAIL, email);
+ values.put(KEY_MOBILE, mobile);
+ return db.insert(TABLE, null, values); //the values are inserted in the table
+ }
+
+ //Read Data from the Table
+ public String getData() {
+ db = this.getReadableDatabase();
+ String[] columns = new String[]{KEY_ID, KEY_NAME, KEY_EMAIL, KEY_MOBILE}; //Table Columns
+ Cursor cursor = db.query(TABLE, columns, null, null, null, null, null);
+
+ int columnId = cursor.getColumnIndex(KEY_ID);
+ int columnName = cursor.getColumnIndex(KEY_NAME);
+ int columnEmail = cursor.getColumnIndex(KEY_EMAIL);
+ int columnMobile = cursor.getColumnIndex(KEY_MOBILE);
+ String result = "";
+
+ for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) //Read each character
+ {
+ result = result +
+ "Id: " + cursor.getString(columnId) + "\n" +
+ "Name: " + cursor.getString(columnName) + "\n" +
+ "Email: " + cursor.getString(columnEmail) + "\n" +
+ "Mobile: " + cursor.getString(columnMobile) + "\n\n\n";
+ }
+ db.close();
+ return result;
+ }
+
+ //Delete Data
+ public void deleteData(long l) {
+ db = this.getWritableDatabase();
+ db.delete(TABLE, KEY_ID + "=" + l, null);
+ }
+
+ //Update Data
+ public void updateData(long l, String name, String email, String mobile) {
+ db = this.getWritableDatabase();
+ ContentValues values = new ContentValues();
+ values.put(KEY_NAME, name);
+ values.put(KEY_EMAIL, email);
+ values.put(KEY_MOBILE, mobile);
+ db.update(TABLE, values, KEY_ID + "=" + l, null);
+ db.close();
+ }
+
+ //get the Name from the table
+ public String getName(long l1) {
+ db = this.getReadableDatabase();
+ String[] columns = new String[]{KEY_ID, KEY_NAME, KEY_EMAIL, KEY_MOBILE};
+ Cursor cursor = db.query(TABLE, columns, KEY_ID + "=" + l1, null, null, null, null);
+ if (cursor != null) {
+ cursor.moveToFirst();
+ String name = cursor.getString(1);
+ return name;
+ }
+ return null;
+ }
+
+ //get the Email from the table
+ public String getEmail(long l1) {
+ db = this.getReadableDatabase();
+ String[] columns = new String[]{KEY_ID, KEY_NAME, KEY_EMAIL, KEY_MOBILE};
+ Cursor cursor = db.query(TABLE, columns, KEY_ID + "=" + l1, null, null, null, null);
+ if (cursor != null) {
+ cursor.moveToFirst();
+ String name = cursor.getString(2);
+ return name;
+ }
+ return null;
+ }
+
+ //get the Mobile Number from the table
+ public String getMobile(long l1) {
+ db = this.getReadableDatabase();
+ String[] columns = new String[]{KEY_ID, KEY_NAME, KEY_EMAIL, KEY_MOBILE};
+ Cursor cursor = db.query(TABLE, columns, KEY_ID + "=" + l1, null, null, null, null);
+ if (cursor != null) {
+ cursor.moveToFirst();
+ String name = cursor.getString(3);
+ return name;
+ }
+ return null;
+ }
+}
+
+```
+
+## Cursor
+A Cursor represents the entire result set of the Query. Once we get the query we check whether it is empty or not. If we get an empty set, we call moveToFirst() to move the cursor to the first result.
+
+Now, let us implement the CRUD functions in our App. For this we create an object of the DBHelper class.
+
+```java
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.View;
+import android.widget.EditText;
+import android.widget.Toast;
+
+public class MainActivity extends AppCompatActivity {
+ EditText nameET, emailET, phoneET, idET;
+ String name, email, phone, id;
+ DBHelper dbHelper;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ dbHelper = new DBHelper(this);
+ nameET = findViewById(R.id.editTextTextPersonName);
+ emailET = findViewById(R.id.editTextTextEmailAddress);
+ phoneET = findViewById(R.id.editTextPhone);
+ idET = findViewById(R.id.editTextNumber);
+ }
+
+ //Saving new Data
+ public void Save(View view) {
+ name = nameET.getText().toString();
+ email = emailET.getText().toString();
+ phone = phoneET.getText().toString();
+ dbHelper.insertData(name, email, phone);
+ Toast.makeText(this, "Data Saved!", Toast.LENGTH_SHORT).show();
+ }
+
+ //Update Existing Data
+ public void Update(View view) {
+ id = idET.getText().toString();
+ name = nameET.getText().toString();
+ email = emailET.getText().toString();
+ phone = phoneET.getText().toString();
+ dbHelper.updateData(Long.parseLong(id), name, email, phone);
+ Toast.makeText(this, "Data Updated!", Toast.LENGTH_SHORT).show();
+ }
+
+ //Delete data
+ public void Delete(View view) {
+ id = idET.getText().toString();
+ dbHelper.deleteData(Long.parseLong(id));
+ Toast.makeText(this, "Data Deleted!", Toast.LENGTH_SHORT).show();
+ }
+
+
+}
+
+```
+
+
+
diff --git a/Android_Development_With_Java/6 Android SQLite/06.01 How to make a todo app using SQLite_ .md b/Android_Development_With_Java/6 Android SQLite/06.01 How to make a todo app using SQLite_ .md
new file mode 100644
index 0000000000..fa4b86b11d
--- /dev/null
+++ b/Android_Development_With_Java/6 Android SQLite/06.01 How to make a todo app using SQLite_ .md
@@ -0,0 +1,698 @@
+# How to make a todo app using SQLite?
+To make a To Do App all we need is to perform the CRUD functions using SQLite.
+
+We will be making an app which shows all the tasks added by an user in a recycler view. For each task there will be an option to update the task or to delete the task.
+So we start by making the basic layout of our home page/start screen :
+
+
+
+
+`layout\activity_main.xml`
+
+```xml
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+
+
+For the Recycler View we need to make an item layout.
+
+`layout\item_layout.xml`
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+We will be storing the data in SQLite Database. For that we need to create a DataBase Helper Class.
+
+`DBHelper.java`
+
+```java
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+
+import androidx.annotation.Nullable;
+
+import java.util.ArrayList;
+
+public class DBHelper extends SQLiteOpenHelper {
+ SQLiteDatabase db;
+ private static final String DATABASE_NAME = "database.db"; //Name of the database
+ private static final int DATABASE_VERSION = 1; //Version
+ private static final String TABLE = "ToDoList"; //Table in which our data will be saved
+ private static final String KEY_ID = "id"; //ID is the Primary Key,i.e., it will have an unique value
+ private static final String KEY_TITLE = "title";
+ private static final String KEY_DESCRIPTION = "description";
+ private static final String KEY_DATE = "date";
+
+ //Constructor
+ public DBHelper(Context context) {
+ super(context, DATABASE_NAME, null, DATABASE_VERSION);
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase sqLiteDatabase) {
+ //Create the SQLite Table
+ String Query_Table = " CREATE TABLE " + TABLE + "(" + KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + KEY_TITLE + " TEXT, " + KEY_DESCRIPTION + " TEXT, " + KEY_DATE + " TEXT);"; //Query to create table
+ sqLiteDatabase.execSQL(Query_Table); //The ID will be implemented automatically
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase sqLiteDatabase, int oldVersion, int newVersion) {
+ sqLiteDatabase.execSQL("DROP TABLE IF EXISTS " + TABLE); // delete table if version is upgraded
+ onCreate(sqLiteDatabase);//Create a new Table
+ }
+
+ //to insert and save new data in the table
+ public long insertData(String title, String description, String date) {
+ db = this.getWritableDatabase();
+ ContentValues values = new ContentValues();
+ values.put(KEY_TITLE, title);
+ values.put(KEY_DESCRIPTION, description);
+ values.put(KEY_DATE, date);
+ return db.insert(TABLE, null, values); //the values are inserted in the table
+ }
+
+
+ //Delete Data
+ public void deleteData(long l) {
+ db = this.getWritableDatabase();
+ db.delete(TABLE, KEY_ID + "=" + l, null);
+ }
+
+ //Update Data
+ public void updateData(long l, String title, String description, String date) {
+ db = this.getWritableDatabase();
+ ContentValues values = new ContentValues();
+ values.put(KEY_TITLE, title);
+ values.put(KEY_DESCRIPTION, description);
+ values.put(KEY_DATE, date);
+ db.update(TABLE, values, KEY_ID + "=" + l, null);
+ db.close();
+ }
+
+ public ArrayList getList() {
+ ArrayList arrayList = new ArrayList<>();
+
+ // select all query
+ String select_query = "SELECT *FROM " + TABLE;
+
+ SQLiteDatabase db = this.getWritableDatabase();
+ Cursor cursor = db.rawQuery(select_query, null);
+
+ // looping through all rows and adding to list
+ if (cursor.moveToFirst()) {
+ do {
+ ModelClass modelClass = new ModelClass();
+ modelClass.setId(cursor.getLong(0));
+ modelClass.setTitle(cursor.getString(1));
+ modelClass.setDescription(cursor.getString(2));
+ modelClass.setDate(cursor.getString(3));
+ arrayList.add(modelClass);
+ } while (cursor.moveToNext());
+ }
+ return arrayList;
+ }
+}
+
+```
+
+Thus we have created the Database with columns id, title, description and date. The id is the primary key which is autogenerated.
+Next we will create the AddTask activity which will add new tasks in our list. This activity will be opened on clicking the floating action button in the Start Screen.
+
+`layout\activity_add_task.xml`
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+
+
+
+
+
+`AddTask.java`
+
+```java
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.Toast;
+
+import com.google.android.material.textfield.TextInputLayout;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+
+public class AddTask extends AppCompatActivity {
+ private TextInputLayout add_title, add_description;
+ private Button add;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_add_task);
+ add_title = findViewById(R.id.add_title);
+ add_description = findViewById(R.id.add_desc);
+ add = findViewById(R.id.add_task);
+ DBHelper dbHelper = new DBHelper(this); // Create object of DBHelper class
+ add.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ String title = add_title.getEditText().getText().toString();
+ String description = add_description.getEditText().getText().toString();
+ if (title.isEmpty()) {
+ Toast.makeText(getApplicationContext(), "Enter Task Title!", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ if (description.isEmpty()) {
+ Toast.makeText(getApplicationContext(), "Enter Description!", Toast.LENGTH_SHORT).show();
+ return;
+ }
+ //get the current date
+ Calendar calendar = Calendar.getInstance();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy");
+ String date = dateFormat.format(calendar.getTime());
+ //Add the task in the database
+ dbHelper.insertData(title, description, date);
+ Toast.makeText(getApplicationContext(), "Task Added to your ToDoList!", Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
+
+ public void goBack(View view) {
+ onBackPressed();
+ }
+}
+```
+
+For the Recycler View we need a Model Class :
+
+```java
+public class ModelClass {
+ private String title;
+ private String description;
+ private String date;
+ private long id;
+
+ public ModelClass(String title, String description, String date, long id) {
+ this.title = title;
+ this.description = description;
+ this.date = date;
+ this.id = id;
+ }
+
+ public ModelClass() {
+ }
+
+ public String getDescription() {
+ return description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public String getDate() {
+ return date;
+ }
+
+ public void setDate(String date) {
+ this.date = date;
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+}
+```
+
+Next we will create the Recycler View Adapter and the View Holder classes :
+
+```java
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.List;
+
+public class ToDoAdapter extends RecyclerView.Adapter {
+
+ Context context;
+ List list;
+
+ //Constructor
+ public ToDoAdapter(Context context, List list) {
+ this.context = context;
+ this.list = list;
+ }
+
+ @NonNull
+ @Override
+ public ToDoViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+ View view = LayoutInflater.from(context).inflate(R.layout.item_layout, parent, false);
+ return new ToDoViewHolder(view);
+ }
+
+ @Override
+ public void onBindViewHolder(@NonNull ToDoViewHolder holder, int position) {
+ ModelClass modelClass = list.get(position);
+ long id = modelClass.getId();
+ DBHelper dbHelper = new DBHelper(context);
+ holder.title.setText(modelClass.getTitle());
+ holder.description.setText(modelClass.getDescription());
+ holder.date.setText(modelClass.getDate());
+
+ //Update Data
+ holder.edit.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ //Create an Alert Dialog Box where the message will be edited.
+ AlertDialog.Builder alertDialog = new AlertDialog.Builder(context);
+ alertDialog.setTitle(modelClass.getTitle());
+ final EditText input = new EditText(context);
+ LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT,
+ LinearLayout.LayoutParams.MATCH_PARENT);
+ lp.gravity = 0;
+ input.setLayoutParams(lp);
+ input.setText(modelClass.getDescription());
+ input.setTextColor(context.getResources().getColor(R.color.purple_500));
+ alertDialog.setView(input);
+ alertDialog.setPositiveButton("UPDATE", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialogInterface, int i) {
+ String desc = input.getText().toString();
+ Calendar calendar = Calendar.getInstance();
+ SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy");
+ String date = dateFormat.format(calendar.getTime()) + "(edited)";
+ dbHelper.updateData(id, modelClass.getTitle(), desc, date);
+ modelClass.setDate(date);
+ modelClass.setTitle(modelClass.getTitle());
+ modelClass.setDescription(desc);
+ notifyDataSetChanged();
+ }
+ });
+ alertDialog.setNegativeButton("CANCEL", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialogInterface, int i) {
+ dialogInterface.dismiss();
+ }
+ });
+ alertDialog.show();
+ }
+ });
+ holder.delete.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ dbHelper.deleteData(id);
+ notifyItemRemoved(position); //delete data
+ }
+ });
+
+ }
+
+ @Override
+ public int getItemCount() {
+ return list.size(); //get the number of elements in the list
+ }
+
+
+ //ViewHolder Class
+ public class ToDoViewHolder extends RecyclerView.ViewHolder {
+ TextView title, description, date;
+ Button edit, delete;
+
+ public ToDoViewHolder(@NonNull View itemView) {
+ super(itemView);
+ title = itemView.findViewById(R.id.title);
+ description = itemView.findViewById(R.id.description);
+ date = itemView.findViewById(R.id.date);
+ edit = itemView.findViewById(R.id.edit);
+ delete = itemView.findViewById(R.id.delete);
+ }
+ }
+}
+
+```
+
+Finally we will complete the Main Activity from where we can access all the components of our App.
+
+
+```java
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.Toast;
+
+import com.google.android.material.floatingactionbutton.FloatingActionButton;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ RecyclerView recyclerView = findViewById(R.id.rv_list);
+ FloatingActionButton add = findViewById(R.id.floatingActionButton);
+ DBHelper dbHelper = new DBHelper(this);
+
+ //Move to AddTask Activity
+ add.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View view) {
+ startActivity(new Intent(MainActivity.this, AddTask.class));
+ }
+ });
+ //Create a layout manager
+ LinearLayoutManager layout = new LinearLayoutManager(this);
+ layout.setReverseLayout(true);
+ recyclerView.setLayoutManager(layout);
+ List list = new ArrayList<>(dbHelper.getList());
+
+ //Make an object of the Adapter and add it to the recycler view.
+ ToDoAdapter adapter = new ToDoAdapter(this, list);
+ recyclerView.setAdapter(adapter);
+
+ }
+}
+```
+
+With this our app is now ready.
+
diff --git a/Android_Development_With_Java/6 Android SQLite/index.md b/Android_Development_With_Java/6 Android SQLite/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/7 Android XML & JSON/7.00 XML in android.md b/Android_Development_With_Java/7 Android XML & JSON/7.00 XML in android.md
new file mode 100644
index 0000000000..74d47b0815
--- /dev/null
+++ b/Android_Development_With_Java/7 Android XML & JSON/7.00 XML in android.md
@@ -0,0 +1,64 @@
+## XML in android
+
+* **The Android platform uses `XML` files in projects for many purposes, from providing basic configuration of the application in the `Manifest File`, to using `XML` Layout Files to define the user interface.**
+
+* **Each layout file must contain one (and only one!) root element. `Linear Layouts`, `Relative Layouts`, and `Frame Layouts` (see Root Views section below) may all be root elements. Other layouts may not be. All other `XML` elements will reside within this root object.**
+
+> ### View & ViewGroup
+
+
+A `View` is simply an object from Android's built-in View class. It represents a rectangular area of the screen, and is responsible for displaying information or content, and event handling. Text, images, and buttons are all Views in Android.
+
+A `ViewGroup` is a subclass of View, and is essentially an 'invisible container' that holds multiple Views or ViewGroups together, and defines their layout properties.
+
+> ### Root Views
+
+
+The following three layout types may be the root element in an Android XML Layout:
+
+* A `Linear Layout` aligns its contents into a single direction, whether vertical or horizontal.
+
+* A `Relative Layout` displays its child content in positions relative to the parent. (ie: lining an element up to the top edge of a parent, centering it within a parent, etc.)
+
+* A `Frame Layout` is a placeholder on a screen that can display only a single view. (For this reason, Frame Layouts should be used sparingly; usually as a placeholder for Fragments, which we will cover later.)
+
+> Example of XML
+
+```xml
+
+
+
+
+```
+> ### Layout Attributes
+
+Every type of layout has attributes that define the way its elements appear. There are both common attributes that all layouts share, and attributes specific to some of the layout types listed above. The following are attributes that apply to all layouts:
+
+* `android:id`: A unique ID that corresponds to the view.
+* `android:layout_width`: The width of the layout. (required for every view)
+* `android:layout_height`: The height of the layout. (required for every view)
+* `android:layout_marginTop`: Extra space on the top of the layout.
+* `android:layout_marginBottom`: Extra space on the bottom of the layout.
+* `android:paddingTop`: Padding at the top of the view.
+* `android:paddingBottom`: Padding at the bottom of the view.
+
+> ### Targeting Views by ID / Using XML Elements in Java.
+
+We target individual XML elements and interact with them. The following code can be used to target the example XML button:
+
+```java
+Button myButton = (Button) findViewById(R.id.search_button);
+```
+
+The `findViewById()` method can locate both `Views` and `root views`. Just notice that we're re-using the same id attribute we assigned in the `XML` to later locate this element in our Java logic.
+
+**For more information visit [Android Official Documentation](https://developer.android.com/guide/topics/ui/declaring-layout)**
\ No newline at end of file
diff --git a/Android_Development_With_Java/7 Android XML & JSON/7.01 JSON vs XML.md b/Android_Development_With_Java/7 Android XML & JSON/7.01 JSON vs XML.md
new file mode 100644
index 0000000000..9355093288
--- /dev/null
+++ b/Android_Development_With_Java/7 Android XML & JSON/7.01 JSON vs XML.md
@@ -0,0 +1,68 @@
+## JSON vs XML
+
+
+**Both `JSON` and `XML` can be used to receive data from a web server.**
+
+### JSON
+
+`JSON` (JavaScript Object Notation) is a lightweight data-interchange format and it is completely language independent. It is based on the JavaScript programming language and is easy to understand and generate.
+
+**Basic data types supported by `JSON` are:**
+
+* Strings
+* Number
+* Booleans
+* Null
+
+>Example :
+
+```json
+{"Geeks":[
+ { "firstName":"Vivek", "lastName":"Kothari" },
+ { "firstName":"Suraj", "lastName":"Kumar" },
+ { "firstName":"John", "lastName":"Smith" },
+ { "firstName":"Peter", "lastName":"Gregory" }
+]}
+```
+### XML
+`XML` (Extensible markup language) was designed to carry data, not to display data. The design goals of XML focus on simplicity, generality, and usability across the Internet. It is a textual data format with strong support via Unicode for different human languages.
+
+> Example :
+
+```XML
+
+
+ VivekKothari
+
+
+ SurajKumar
+
+
+ JohnSmith
+
+
+ PeterGregory
+
+
+```
+### JSON and XML Similarity.
+
+1. Both JSON and XML are "self-describing" (human-readable).
+
+2. Both JSON and XML are hierarchical (values within values).
+
+3. Both JSON and XML can be parsed and used by lots of programming languages.
+
+4. Both JSON and XML can be fetched with an XMLHttpRequest
+
+### JSON and XML Differences.
+
+1. JSON doesn't use an end tag.
+
+2. JSON is shorter.
+
+3. JSON is quicker to read and write.
+
+4. JSON can use arrays
+
+**The biggest difference is, XML has to be parsed with an XML parser. JSON can be parsed by a standard JavaScript function.**
\ No newline at end of file
diff --git a/Android_Development_With_Java/7 Android XML & JSON/index.md b/Android_Development_With_Java/7 Android XML & JSON/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/8 Android Notifications/08.01 Heads Up Notification in android.md b/Android_Development_With_Java/8 Android Notifications/08.01 Heads Up Notification in android.md
new file mode 100644
index 0000000000..ce61d900dc
--- /dev/null
+++ b/Android_Development_With_Java/8 Android Notifications/08.01 Heads Up Notification in android.md
@@ -0,0 +1,118 @@
+# Heads-Up Notification in Android
+
+The heads-up notification appears the moment your app issues the notification and it disappears after a moment, but remains visible in the notification drawer as usual.
+This behavior is normally for important notifications that the user should know about immediately, and it appears only if the device is unlocked.
+
+### Conditions that might trigger heads-up notifications include:
+
+- The user's activity is in fullscreen mode.
+- The notification has high priority and uses ringtones or vibrations on devices running Android 7.1 (API level 25) and lower.
+- The notification channel has high importance on devices running Android 8.0 (API level 26) and higher.
+
+### Example for Heads-Up Notification with Action
+
+### Step 1: Write the Java Code
+
+```java
+package com.example.headsupnoti;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+
+public class MainActivity extends AppCompatActivity {
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ notificationChannel();
+ }
+
+ private void notificationChannel(){
+ NotificationChannel channel = null;
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
+ channel = new NotificationChannel(Utils.CHANNEL_ID, Utils.CHANNEL_NAME,
+ NotificationManager.IMPORTANCE_HIGH);
+
+ channel.setDescription(Utils.CHANNEL_Desc);
+ NotificationManager managerCompat = getSystemService(NotificationManager.class);
+ managerCompat.createNotificationChannel(channel);
+ }
+ }
+ public void headsupnotification(View view) {
+ Intent intent = new Intent(Intent.ACTION_VIEW);
+ intent.setData(Uri.parse("https://github.com/girlscript/winter-of-contributing"));
+ PendingIntent pendingIntent = PendingIntent.getActivity(this,0,intent,0);
+
+ NotificationCompat.Builder Builder = new NotificationCompat.Builder(this, Utils.CHANNEL_ID)
+ .setSmallIcon(R.mipmap.ic_launcher)
+ .setContentTitle(Utils.NOTI_TITLE)
+ .setContentText(Utils.NOTI_DESC)
+ .setDefaults(Notification.DEFAULT_ALL)
+ .setPriority(NotificationCompat.PRIORITY_HIGH)
+ .addAction(R.mipmap.ic_launcher, "Visit to GWOC GitHub Repo", pendingIntent)
+ .setAutoCancel(true);
+
+ NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(this);
+ notificationManagerCompat.notify(Utils.NOTI_ID, Builder.build());
+ }
+}
+```
+
+### Step 2: Make a Utils Class
+
+```java
+package com.example.headsupnoti;
+
+public class Utils {
+ public static final String CHANNEL_ID = "channnel_id";
+ public static final String CHANNEL_NAME = "channnel_name";
+ public static final String CHANNEL_Desc = "channnel_desc";
+ public static final String NOTI_TITLE = "Open Source Contribution";
+ public static final String NOTI_DESC = "Welcome to GWOC Program. I am making a documentation on Heads-Up Notification.";
+ public static final int NOTI_ID = 001;
+}
+```
+
+### Step 3: Write the XML Code
+
+```xml
+
+
+
+
+
+
+```
+
+### Result: The above code will produce the following output.
+
+
diff --git a/Android_Development_With_Java/8 Android Notifications/Types of Notifications .md b/Android_Development_With_Java/8 Android Notifications/Types of Notifications .md
new file mode 100644
index 0000000000..524e130d63
--- /dev/null
+++ b/Android_Development_With_Java/8 Android Notifications/Types of Notifications .md
@@ -0,0 +1,186 @@
+# Notifications in Android Studio
+
+Notifications are short timely messages received by the User to provide some information from the App.
+The different types of Notifications that can be implemented in our Apps are :
+* Simple Notification
+* Big Text Style Notification
+* Big Picture Style Notification
+* Inbox Style Notification
+* Notification Actions
+
+
+## Simple Notification :
+These are the most fundamental type of Notification which includes a title, a message body and a picture (optional).
+The following code shows how one can implement this type of notification in their apps:
+
+
+
+
+
+
+ NotificationCompat.Builder builder=new NotificationCompat.Builder(MainActivity.this)
+ .setSmallIcon(R.drawable.gwoc)
+ .setLargeIcon(BitmapFactory.decodeResource(getResources(),R.drawable.gwoc))
+ .setContentTitle("Simple Notifications")
+ .setContentText("This is the basic type of Notification")
+ .setAutoCancel(true)
+ .setDefaults(NotificationCompat.DEFAULT_ALL);
+
+ Uri uri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+ builder.setSound(uri); // this is used to get sound on receiving the notification
+ NotificationManager notificationManager=(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ String channelId = "CHANNEL_ID";
+ NotificationChannel channel = new NotificationChannel(channelId, "GWOC",
+ NotificationManager.IMPORTANCE_DEFAULT);
+ notificationManager.createNotificationChannel(channel);
+ builder.setChannelId(channelId);
+ notificationManager.notify(0, builder.build());
+ }
+
+ ## Big Text Style Notification
+ This type is used to create Notifications containing more than one line of text. The below code shows this type.
+
+
+
+
+
+
+ public void showNotification(View view) {
+ createNotificationChannel();
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(MainActivity.this, "Big Text Notification")
+ .setSmallIcon(R.drawable.gwoc)
+ .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.gwoc))
+ .setContentTitle("Big Text Notifications")
+ .setStyle(new NotificationCompat.BigTextStyle().bigText("This is the second type of Notification"))
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+ NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(getApplicationContext());
+ notificationManagerCompat.notify(1, builder.build());
+ }
+
+ //create notification channel if you target android 8.0 or higher version
+ private void createNotificationChannel() {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ CharSequence name = "BigTextStyle Notification";
+ String description = "Includes all the BigTextStyle notification";
+ int importance = NotificationManager.IMPORTANCE_DEFAULT;
+ NotificationChannel notificationChannel = new NotificationChannel("Big Text Notification", name, importance);
+ notificationChannel.setDescription(description);
+ NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+ notificationManager.createNotificationChannel(notificationChannel);
+ }
+ }
+
+ ## Big Picture Style Notification :
+ This type includes large pictures in the Notification on expanding it. This can be implemented using the following code:
+
+
+
+
+
+
+ public void showNotification(View view) {
+ createNotificationChannel();
+ Bitmap picture=BitmapFactory.decodeResource(getResources(), R.drawable.gwoc);
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(MainActivity.this, "Big Image Notification")
+ .setSmallIcon(R.drawable.gwoc)
+ .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.gwoc))
+ .setContentTitle("Big Image Notifications")
+ .setStyle(new NotificationCompat.BigPictureStyle().bigPicture(picture))
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+ NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(getApplicationContext());
+ notificationManagerCompat.notify(1, builder.build());
+ }
+
+ //create notification channel if you target android 8.0 or higher version
+ private void createNotificationChannel() {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ CharSequence name = "BigPictureStyle Notification";
+ String description = "Includes all the BigPictureStyle notification";
+ int importance = NotificationManager.IMPORTANCE_DEFAULT;
+ NotificationChannel notificationChannel = new NotificationChannel("Big Image Notification", name, importance);
+ notificationChannel.setDescription(description);
+ NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+ notificationManager.createNotificationChannel(notificationChannel);
+ }
+ }
+
+ ## Inbox Style Notification :
+ This is seen mostly in Chat Applications where all the messages from the other Users can be seen in the Notification.
+
+
+
+
+
+
+ public void showNotification(View view) {
+ createNotificationChannel();
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(MainActivity.this, "Inbox Notification")
+ .setSmallIcon(R.drawable.gwoc)
+ .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.gwoc))
+ .setContentTitle("5 New Chats")
+ .setStyle(new NotificationCompat.InboxStyle()
+ .addLine("Hi")
+ .addLine("How are you?")
+ .setSummaryText("+3 more"))
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+
+ NotificationManagerCompat notificationManagerCompat = NotificationManagerCompat.from(getApplicationContext());
+ notificationManagerCompat.notify(1, builder.build());
+ }
+
+ //create notification channel if you target android 8.0 or higher version
+ private void createNotificationChannel() {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ CharSequence name = "Inbox Notification";
+ String description = "Includes all the Inbox notification";
+ int importance = NotificationManager.IMPORTANCE_DEFAULT;
+ NotificationChannel notificationChannel = new NotificationChannel("Inbox Notification", name, importance);
+ notificationChannel.setDescription(description);
+ NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+ notificationManager.createNotificationChannel(notificationChannel);
+ }
+ }
+
+ ## Notification Actions :
+ Sometimes we need to perform a task directly from the Notification itself. In such cases we use the notification Actions.
+
+
+
+
+
+
+
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(MainActivity.this)
+ .setSmallIcon(R.drawable.gwoc)
+ .setLargeIcon(BitmapFactory.decodeResource(getResources(), R.drawable.gwoc))
+ .setContentTitle("Action Buttons")
+ .setStyle(new NotificationCompat.BigTextStyle().bigText("Click view to visit Google"))
+ .setAutoCancel(true)
+ .setDefaults(NotificationCompat.DEFAULT_ALL);
+ //the actions in a notification are handled through intent
+ Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.google.com"));
+ PendingIntent pendingIntent = PendingIntent.getActivity(MainActivity.this, 0, intent, 0);
+
+ builder.addAction(android.R.drawable.ic_menu_view, "VIEW", pendingIntent);
+
+ Uri path = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
+ builder.setSound(path);
+
+ NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ String channelId = "CHANNEL_ID";
+ NotificationChannel channel = new NotificationChannel(channelId, "Channel Title",
+ NotificationManager.IMPORTANCE_DEFAULT);
+ notificationManager.createNotificationChannel(channel);
+ builder.setChannelId(channelId);
+ }
+ notificationManager.notify(2, builder.build());
+
+
+ This is how various types of Notifications can be viewed in our Apps.
+
+ # _______________________________________________________________________________________________________________________________________________________________________
diff --git a/Android_Development_With_Java/8 Android Notifications/index.md b/Android_Development_With_Java/8 Android Notifications/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/8.0 Notifications_In_Java.md b/Android_Development_With_Java/8.0 Notifications_In_Java.md
new file mode 100644
index 0000000000..27fb224c0d
--- /dev/null
+++ b/Android_Development_With_Java/8.0 Notifications_In_Java.md
@@ -0,0 +1,307 @@
+# Notifications In Android
+Notification is a message that you can display to the user outside your app’s UI. Android Notifications provide short and precise information about the action that happened in your app. The notification displays the icon, title, and some amount of the content text.
+## Appearances on a device
+Notifications could be of various formats and designs depending upon the developer such as an icon in the status bar, a more detailed entry in the notification drawer, as a badge on the app's icon.
+1. Status Bar Notification - When you issue a notification, it first appears as an icon in the status bar. It appears in the same layout as the current time, battery percentage
+2. Notification drawer Notification - It appears in the drop-down menu. Users can swipe down on the status bar to open the notification drawer, where they can view more details and take action with the notification.
+3. Heads-Up Notification - Beginning with Android 5.0, notifications can briefly appear in a floating window called a heads-up notification. It appears on the overlay screen, ex: Whatsapp notification, OTP messages
+4. Lock-Screen Notification - It appears on the lock screen. Beginning with Android 5.0, notifications can appear on the lock screen.
+5. App icon badge - In supported launchers on devices running Android 8.0 (API level 26) and higher, app icons indicate new notifications with a colored "badge" (also known as a "notification dot") on the corresponding app launcher icon.
+
+
+
+
+
+
+## Create a Notification
+The design of notification is quite simple, it contains an icon, title, some brief about the message(optional), and click. An example of the same is shown below:
+
+1. Small Icon - This can be set using [setSmallIcon()](https://developer.android.com/reference/android/app/Notification.Builder#setSmallIcon(int,%20int)).
+2. App Name - This is provided by the app itself.
+3. Timestamp - This is provided by the system but you can override it with [setWhen()](https://developer.android.com/reference/android/app/Notification.Builder#setWhen(long)) or hide it with [setShowWhen(false)](https://developer.android.com/reference/android/app/Notification.Builder#setShowWhen(boolean)).
+4. Large icon - This is optional (usually used only for contact photos; do not use it for your app icon) and set with [setLargeIcon()](https://developer.android.com/reference/android/app/Notification.Builder#setLargeIcon(android.graphics.Bitmap)).
+5. Title - This is optional and set with [setContentTitle()](https://developer.android.com/reference/android/app/Notification.Builder#setContentTitle(java.lang.CharSequence)).
+6. Text - This is optional and set with [setContentText()](https://developer.android.com/reference/android/app/Notification.Builder#setContentText(java.lang.CharSequence)).
+
+
+
+
+## Using Notification Channels
+Notification Channels provide you with the ability to group the notifications that our application sends into manageable groups. Starting in Android 8.0 (API level 26), all notifications must be assigned to a channel or they will not appear.
+By managing different channels, users will be able to disable specific notifications (instead of disabling all notifications), and users can control the visual and auditory options for each channel.
+One app can have multiple notification channels—a separate channel for each type of notification the app issues. An app can also create notification channels in response to choices made by users of your app.
+For example, have a look at the Clock app that is installed with Android (tap Settings > App Notifications > Notifications and select Clock from the list).
+
+## How to Create a Notification
+Below are the steps which are required for creating a notification in android -
+1. Add the support Library
+Many projects made with Android Studio already include the necessary dependencies to use [NotificationCompat](https://developer.android.com/reference/androidx/core/app/NotificationCompat), if not you should add the following dependencies in build.gradle file:
+
+ ```
+ val core_version = "1.6.0"
+ dependencies {
+ implementation "androidx.core:core:$core_version"
+ }
+
+ ```
+
+2. Create a basic notification
+A basic notification contains an icon, title, a short description. Below are some steps, from which you can learn how to create a simple notification that a user can click on.
+
+
+
+
+- Set notification content
+First of all, we need to set the notification content and channel using a [NotificationCompat.Builder object](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder).
+A small icon can be set using [setSmallIcon()](https://developer.android.com/reference/android/app/Notification.Builder#setSmallIcon(int,%20int)), title by [setContentTitle()](https://developer.android.com/reference/android/app/Notification.Builder#setContentTitle(java.lang.CharSequence)), text of the notification by [setContentText()](https://developer.android.com/reference/android/app/Notification.Builder#setContentText(java.lang.CharSequence)), and notification priority by using [setPriority()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#setPriority(int)). If you want a notification to be longer, you can use [setStyle()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#setStyle(androidx.core.app.NotificationCompat.Style)) for the same.
+Example code for Java is -
+
+ ```
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+ .setSmallIcon(R.drawable.notification_icon)
+ .setContentTitle(textTitle)
+ .setContentText(textContent)
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT);
+ ```
+
+- Create a channel and set the importance
+For the version Android 8.0 and higher, you need to register the notification channel of your app with the system by passing an instance of NotificationChannel to createNotificationChannel(). To create a notification channel, you need to follow the following steps-
+Construct a NotificationChannel object which requires unique channel_id and channel_name strings. The Importance argument is an int that specifies the level of interruption by the notification. . It can be one of the following values:
+
+ | Importance (Android 8.0 and higher) | Description |
+ | --- | --- |
+ | IMPORTANCE_DEFAULT | Shows up in the system tray. Makes sound. Doesn’t visually pop up. |
+ | IMPORTANCE_HIGH | Visually pops up too. |
+ | IMPORTANCE_LOW | Shows in the tray. No pop-up. No sound. |
+ | IMPORTANCE_NONE | Doesn’t show up. Kind of blocked notifications. |
+
+ The sample code for creating a channel is -
+
+```
+ private void createNotificationChannel() {
+ // Create the NotificationChannel, but only on API 26+ because
+ // the NotificationChannel class is new and not in the support library
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ CharSequence name = getString(R.string.channel_name);
+ String description = getString(R.string.channel_description);
+ int importance = NotificationManager.IMPORTANCE_DEFAULT;
+ NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
+ channel.setDescription(description);
+ // Register the channel with the system; you can't change the importance
+ // or other notification behaviors after this
+ NotificationManager notificationManager = getSystemService(NotificationManager.class);
+ notificationManager.createNotificationChannel(channel);
+ }
+}
+
+```
+
+- Set the notification's tap action
+When a user taps on any notification, it should respond by opening an activity in the app which corresponds to that particular notification. For the same, you need to specify a content intent defined with a [PendingIntent](https://developer.android.com/reference/android/app/PendingIntent) object and pass it to [setContentIntent()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#setContentIntent(android.app.PendingIntent)).
+The following sample code shows how to create a basic intent to open an activity when the user taps the notification:
+ ```
+ // Create an explicit intent for an Activity in your app
+ Intent intent = new Intent(this, AlertDetails.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
+ PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+ .setSmallIcon(R.drawable.notification_icon)
+ .setContentTitle("My notification")
+ .setContentText("Hello World!")
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+ // Set the intent that will fire when the user taps the notification
+ .setContentIntent(pendingIntent)
+ .setAutoCancel(true);
+ ```
+
+- Show the notification
+To make the notification appear on the screen, we need to call [NotificationManagerCompat.notify()](https://developer.android.com/reference/androidx/core/app/NotificationManagerCompat#notify(int,%20android.app.Notification)), passing it a unique ID for the notification and the result of [NotificationCompat.Builder.build()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#build()).
+ ```
+ NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+ // notificationId is a unique int for each notification that you must define
+ notificationManager.notify(notificationId, builder.build());
+ ```
+3. Add action buttons
+When we receive a notification, there is only a single action available -tapping on the notification. However, Action Buttons allow more than one action to be taken on a notification, allowing for greater interactivity within notifications, like snooze or dismiss, etc.
To add an action button, pass a PendingIntent to the addAction() method. This is just like setting up the notification's default tap action, except instead of launching an activity.
+
+
+
+
+
+ ```
+ Intent snoozeIntent = new Intent(this, MyBroadcastReceiver.class);
+ snoozeIntent.setAction(ACTION_SNOOZE);
+ snoozeIntent.putExtra(EXTRA_NOTIFICATION_ID, 0);
+ PendingIntent snoozePendingIntent = PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);
+
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+ .setSmallIcon(R.drawable.notification_icon)
+ .setContentTitle("My notification")
+ .setContentText("Hello World!")
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+ .setContentIntent(pendingIntent)
+ .addAction(R.drawable.ic_snooze, getString(R.string.snooze),
+ snoozePendingIntent);
+ ```
+ Above is the code that shows how to send a broadcast to a specific receiver.
+
+4. Add a direct reply action
+The direct reply action allows the user to directly enter text into the notification. Such features are commonly seen in messaging applications like WhatsApp, Facebook messenger, etc.
+The direct reply action opens a text input for the user to type the reply message. When the user finishes, the system attaches the response to the intent you had specified for the notification action and sends the intent to your app.
+
+
+
+
+
+- Add the reply button
+Steps to create notification action with a direct reply
+
+ - Create an instance of [RemoteInput.Builder](https://developer.android.com/reference/androidx/core/app/RemoteInput.Builder) that you can add to your notification action.
+ ```
+ // Key for the string that's delivered in the action's intent.
+ private static final String KEY_TEXT_REPLY = "key_text_reply";
+ String replyLabel = getResources().getString(R.string.reply_label);
+ RemoteInput remoteInput = new RemoteInput.Builder(KEY_TEXT_REPLY)
+ .setLabel(replyLabel)
+ .build();
+ ```
+
+ - Create a [PendingIntent](https://developer.android.com/reference/android/app/PendingIntent) for the reply action.
+ ```
+ // Build a PendingIntent for the reply action to trigger.
+ PendingIntent replyPendingIntent =
+ PendingIntent.getBroadcast(getApplicationContext(),
+ conversation.getConversationId(),
+ getMessageReplyIntent(conversation.getConversationId()),
+ PendingIntent.FLAG_UPDATE_CURRENT);
+ ```
+
+ - Attach the [RemoteInput](https://developer.android.com/reference/android/app/RemoteInput) object to an action using [addRemoteInput()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Action.Builder#addRemoteInput(android.support.v4.app.RemoteInput)).
+ ```
+ // Create the reply action and add the remote input.
+ NotificationCompat.Action action =
+ new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon,
+ getString(R.string.label), replyPendingIntent)
+ .addRemoteInput(remoteInput)
+ .build();
+ ```
+ - Apply the action to notification and issue the notification.
+ ```
+ // Build the notification and add the action.
+ Notification newMessageNotification = new Notification.Builder(context, CHANNEL_ID)
+ .setSmallIcon(R.drawable.ic_message)
+ .setContentTitle(getString(R.string.title))
+ .setContentText(getString(R.string.content))
+ .addAction(action)
+ .build();
+ // Issue the notification.
+ NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+ notificationManager.notify(notificationId, newMessageNotification);
+ ```
+- Retrieve user input from the reply
+To receive the input from the notification's reply UI which the user has entered, you need to call [RemoteInput.getResultsFromIntent()](https://developer.android.com/reference/androidx/core/app/RemoteInput#getResultsFromIntent(android.content.Intent)) ,passing it the Intent received by your [BroadcastReceiver](https://developer.android.com/reference/android/content/BroadcastReceiver).
+ ```
+ private CharSequence getMessageText(Intent intent) {
+ Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
+ if (remoteInput != null) {
+ return remoteInput.getCharSequence(KEY_TEXT_REPLY);
+ }
+ return null;
+ }
+ ```
+ After this step, you need to update the notification, so as to hide the direct reply UI, by calling
+ [NotificationManagerCompat.notify()](https://developer.android.com/reference/androidx/core/app/NotificationManagerCompat#notify(int,%20android.app.Notification)) with the same ID and tag (if used).
+
+ ```
+ // Build a new notification, which informs the user that the system
+ // handled their interaction with the previous notification.
+ Notification repliedNotification = new Notification.Builder(context, CHANNEL_ID)
+ .setSmallIcon(R.drawable.ic_message)
+ .setContentText(getString(R.string.replied))
+ .build();
+ // Issue the new notification.
+ NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+ notificationManager.notify(notificationId, repliedNotification);
+ ```
+
+ When working with this new notification, use the context that's passed to the receiver's [onReceive()](https://developer.android.com/reference/android/content/BroadcastReceiver#onReceive(android.content.Context,%20android.content.Intent)) method. You
+ should also append the reply to the bottom of the notification by calling [setRemoteInputHistory()](https://developer.android.com/reference/android/app/Notification.Builder#setRemoteInputHistory(java.lang.CharSequence[])).
+
+- Add a progress bar
+You can also include a progress bar in a notification to show the progress of the ongoing operation. Example -
+
+
+
+
+The progress bar supports two modes to represent progress: determinate, and indeterminate. To set the determinate form of the progress you can use [setProgress(max, progress, false)](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#setProgress(int,%20int,%20boolean)). The first parameter “max” is the complete value of the process and the second parameter “progress” shows how much action is completed. The last parameter “false” shows that it is a determinate progress bar.
+
+ ```
+ NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID);
+ builder.setContentTitle("Picture Download")
+ .setContentText("Download in progress")
+ .setSmallIcon(R.drawable.ic_notification)
+ .setPriority(NotificationCompat.PRIORITY_LOW);
+
+ // Issue the initial notification with zero progress
+ int PROGRESS_MAX = 100;
+ int PROGRESS_CURRENT = 0;
+ builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
+ notificationManager.notify(notificationId, builder.build());
+
+ // Do the job here that tracks the progress.
+ // Usually, this should be in a
+ // worker thread
+ // To show progress, update PROGRESS_CURRENT and update the notification with:
+ // builder.setProgress(PROGRESS_MAX, PROGRESS_CURRENT, false);
+ // notificationManager.notify(notificationId, builder.build());
+
+ // When done, update the notification one more time to remove the progress bar
+ builder.setContentText("Download complete").setProgress(0,0,false);
+ notificationManager.notify(notificationId, builder.build());
+ ```
+
+ Remember to update the notification text to show that the operation is complete. If you actually need to
+ download a file, you should consider using [DownloadManager](https://developer.android.com/reference/android/app/DownloadManager), which provides its own notification to track your
+ download progress.
+
+- Set a system-wide category
+Android has a special category named system-wide category to determine whether to disturb a user by showing the particular notification if the user has enabled [Do Not Disturb mode](https://developer.android.com/guide/topics/ui/notifiers/notifications#dnd-mode).
+If the notification comes under the pre-defined categories defined in NotificationCompat the only you should declare it by passing the appropriate category to setCategory() as shown below.
+
+ ```
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+ .setSmallIcon(R.drawable.notification_icon)
+ .setContentTitle("My notification")
+ .setContentText("Hello World!")
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+ .setCategory(NotificationCompat.CATEGORY_MESSAGE);
+ ```
+
+- Show an urgent message
+Sometimes the app requires to show an urgent message, such as an upcoming alarm or a phone call, then you can associate full-screen intent with that particularly for the urgent notification.
+If the user’s device is locked, then it will cover the full locked screen to show this message, or if it’s not locked then the notification appears in an expanded form.
+The following code shows how to integrate the notification message with full-screen intent -
+
+ ```
+ Intent fullScreenIntent = new Intent(this, ImportantActivity.class);
+ PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(this, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
+ .setSmallIcon(R.drawable.notification_icon)
+ .setContentTitle("My notification")
+ .setContentText("Hello World!")
+ .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+ .setFullScreenIntent(fullScreenPendingIntent, true);
+ ```
+
+- Update a notification
+To update the notification after the user has received it, call the NotificationManagerCompat.notify() again, and pass it a notification with the same ID you used previously. If the previous notification has been dismissed, a new notification is created in its place.
+
+- Remove a notification
+The notification remains visible until the following action is not performed -
+ - Dismiss the notification
+ - Click on the notification and you called [setAutoCancel()](https://developer.android.com/reference/androidx/core/app/NotificationCompat.Builder#setAutoCancel(boolean)) when you created the notification.
+ - You call [cancel()](https://developer.android.com/reference/android/app/NotificationManager#cancel(int)) for a specific notification ID.
+ - You call [cancelAll()](https://developer.android.com/reference/android/app/NotificationManager#cancelAll()), which removes all of the notifications you previously issued.
+
diff --git a/Android_Development_With_Java/9 Android Multimedia/09.04 Media streaming using ExoPlayer in android.md b/Android_Development_With_Java/9 Android Multimedia/09.04 Media streaming using ExoPlayer in android.md
new file mode 100644
index 0000000000..1d8e12d8b1
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/09.04 Media streaming using ExoPlayer in android.md
@@ -0,0 +1,299 @@
+# Media streaming using ExoPlayer in Android
+
+ExoPlayer is an open-source project. This is not a part of Android SDK.
+In Android, ExoPlayer is an application level media player. It’s standard audio and video components are built on Android’s MediaCodec API, which was released in Android
+
+Many Google apps use ExoPlayerView for streaming audios and videos such as YouTube, Netflix, and many video streaming platforms.
+
+ExoPlayer is a media player library that provides a way to play audio and video with lots of customization in it.
+This library will also help you to customize your media player according to our requirements.
+
+## Advantages and Disadvantages of Using ExoPlayer
+
+ExoPlayer has a number of advantages over Android’s built in MediaPlayer:
+
+- The ability to customize and extend the player to suit your use case. ExoPlayer is designed specifically with this in mind,
+and allows many components to be replaced with custom implementations.
+- Support for playlists. You can clip or merge your media.
+- With the help of ExoPlayer, you can directly fetch media files such as audios and videos directly from the internet and play them inside the ExoPlayer.
+- It provides smooth encryption and streaming of video and audio files.
+- ExoPlayer easily handles buffering of audio and video files. It’s important to note that there are also some disadvantages:
+
+It’s important to note that there are also some disadvantages:
+
+- For audio only playback on some devices, ExoPlayer may consume significantly more battery than MediaPlayer.
+- Including ExoPlayer in your app adds a few hundred kilobytes to the APK size. This is likely only a concern for extremely lightweight apps.
+
+## Implementation of ExoPlayer in Android
+
+### Step 1: Add dependency to the build.gradle(Module:app)
+
+```
+ implementation 'com.google.android.exoplayer:exoplayer:2.16.1'
+```
+
+### Step 2: Java Code
+
+```java
+package com.example.exoplayerapp;
+
+import android.annotation.SuppressLint;
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.ImageView;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.google.android.exoplayer2.ExoPlayer;
+import com.google.android.exoplayer2.MediaItem;
+import com.google.android.exoplayer2.Player;
+import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.trackselection.DefaultTrackSelector;
+import com.google.android.exoplayer2.ui.PlayerControlView;
+import com.google.android.exoplayer2.ui.PlayerView;
+
+public class MainActivity extends AppCompatActivity {
+
+ PlayerView playerView;
+ ImageView vdoFullscreen;
+// ProgressBar progressBar;
+ SimpleExoPlayer simpleExoPlayer;
+// boolean flag = false;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // assign variable
+ playerView = findViewById(R.id.player_view);
+// progressBar = findViewById(R.id.progress_bar);
+ vdoFullscreen = findViewById(R.id.vdo_fullscreen);
+
+ // make activity full screen
+ getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+ // video url
+ Uri uri = Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.video);
+
+ DefaultTrackSelector trackSelector = new DefaultTrackSelector(this);
+ simpleExoPlayer = new SimpleExoPlayer.Builder(this).setTrackSelector(trackSelector).build();
+ playerView.setPlayer(simpleExoPlayer);
+ MediaItem mediaItem = MediaItem.fromUri(uri);
+ simpleExoPlayer.addMediaItem(mediaItem);
+ simpleExoPlayer.prepare();
+// simpleExoPlayer.play();
+
+ simpleExoPlayer.addListener(new Player.Listener() {
+ @Override
+ public void onPlaybackStateChanged(int state) {
+ if (state == ExoPlayer.STATE_ENDED) {
+
+ }
+ }
+ });
+
+ playerView.setControllerVisibilityListener(new PlayerControlView.VisibilityListener() {
+ @Override
+ public void onVisibilityChange(int visibility) {
+
+ }
+ });
+
+
+ vdoFullscreen.setOnClickListener(new View.OnClickListener() {
+ @SuppressLint("SourceLockedOrientationActivity")
+ @Override
+ public void onClick(View view) {
+
+
+ int orientation = MainActivity.this.getResources().getConfiguration().orientation;
+ if (orientation == Configuration.ORIENTATION_PORTRAIT) {
+ // code for portrait mode
+
+ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+
+
+ } else {
+ // code for landscape mode
+ setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+
+ }
+ }
+ });
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ // play video when ready
+ simpleExoPlayer.setPlayWhenReady(true);
+ simpleExoPlayer.getPlaybackState();
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+ // stop video when ready
+ simpleExoPlayer.setPlayWhenReady(false);
+ // get playback state
+ simpleExoPlayer.getPlaybackState();
+ }
+}
+
+```
+
+### Step 3: PlayerView XML Code
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Step 4: Custom Controller Layout Code
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Result:
+
+
+
+## References
+
+- https://www.geeksforgeeks.org/exoplayer-in-android-with-example/
+- YouTube
diff --git a/Android_Development_With_Java/9 Android Multimedia/9.0 Android_Multimedia.ipynb b/Android_Development_With_Java/9 Android Multimedia/9.0 Android_Multimedia.ipynb
new file mode 100644
index 0000000000..3fdb9e4e46
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/9.0 Android_Multimedia.ipynb
@@ -0,0 +1,430 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "9.0 Android Multimedia.ipynb",
+ "provenance": [],
+ "authorship_tag": "ABX9TyNEoLsAGA0BNoESrof1gL7v",
+ "include_colab_link": true
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "view-in-github",
+ "colab_type": "text"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "O0gYmom99iPY"
+ },
+ "source": [
+ "
Introduction :
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "HaalJy09zTAl"
+ },
+ "source": [
+ "Hello Everyone, \n",
+ "Today we will be discussing about audio and video files in android.\n",
+ "By hearing about audio and video, the first thing which comes in our mind is playing songs or watching movies on our devices. \n",
+ "And today we will be discussing about this that how we work with these entities in android."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NXxGqGsZ0jeE"
+ },
+ "source": [
+ "Before deep diving in this core concept of android we need to know some basic terms and terminologies for better understanding of this topic. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "vxs6KWGo1Czz"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "1. **Media :** \n",
+ " It's a collective word which is used for audio and video.\n",
+ " We will be using this word throught this documentation. \n",
+ "2. **Media Controls :** \n",
+ " You can also think of play,pause & stop funtionalities in your media player.\n",
+ "\n",
+ "\n",
+ "3. **Media Session :** \n",
+ " This is the thing which is responsible for communication with media player. \n",
+ "4. **Media Controller :** \n",
+ " Consider it as a view which has controls for media player.\n",
+ " It takes care of synchronizing the controls with the state of the MediaPlayer.\n",
+ "\n",
+ "\n",
+ "5. **Media Browser Service :** \n",
+ " It enable applications to browse media content provided by an application and ask to start playing it.\n",
+ " They may also be used to control content that is already playing by way of a MediaSession .\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gzKfEenc9Vke"
+ },
+ "source": [
+ "
Supported Formats :"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EkCrh3vt9yCu"
+ },
+ "source": [
+ "Variety of file formats are supported for audio and video files in android like mp3 , mp4 , wav , mkv , 3gp , etc.\n",
+ "To see more of the different formats head over to [Supported media formats](https://developer.android.com/guide/topics/media/media-formats)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kjZfAoWG-0S1"
+ },
+ "source": [
+ "**Note :** Just as we when work with images in our application we keep them in drawable's folder, similarly we create a raw folder to keep our audio and video files while working with them in our android studio. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EKALDZLFAkqo"
+ },
+ "source": [
+ "
Architecture of Media App :
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "aV_tA2BYBdxF"
+ },
+ "source": [
+ "Basically any media application can be divided into two parts i.e Media Controller and Media Sessions. For better understanding consider that you made a music player app, whatever controls which are displayed over the screen(UI) are the Media Controllers and Media session is your actual player.These media session and media controller are two classes which are defined inside android framework to impose a well-defined structure for building a media player app. \n",
+ "These both parts interacts with each other via callbacks. While the APIs for the UI and player can be arbitrary, the nature of the interaction between the two pieces is basically the same for all media player apps.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7RoirtJVECyh"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cWkJuaQTEmO-"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "* **Media Sessions :** \n",
+ "Media sessions maintains the representation of the Media player state and information about what is playing. A session can receive callbacks from one or more media controllers thus making it possible for our player to be controlled by your app's UI. The logic that responds to callbacks must be consistent. The response to a MediaSession callback should be the same no matter which client app initiated the callback. \n",
+ "\n",
+ "* **Media Controller :** \n",
+ "A Media Controller isolates your UI. Your UI code only communicates with the media controller, not the player itself. The media controller translates our actions into callbacks to the media session. It also receives callbacks from the media session whenever the session state changes. This provides a mechanism to automatically update the associated UI with it. **A media controller can only connect to one media session at a time**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZGJ_qedfPtik"
+ },
+ "source": [
+ "We can deploy different interfaces or players at runtime when we use a media controller and media session. We can change our app's appearance as well as performance independently depending on the capabilities of the device on which it is running."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pySQjQc2Py52"
+ },
+ "source": [
+ "Now instead of just peeping into the therotical stuff of how audio and video app's looks like we'll try to understand it in pictorial way."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JAJwuD6WQy6o"
+ },
+ "source": [
+ " \n",
+ "Video player Activity."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "P4Q4PPVFQ685"
+ },
+ "source": [
+ " \n",
+ "Audio Activity."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "execepabVnDE"
+ },
+ "source": [
+ "In the above picture we are seeing a new term i.e Media Browser Service. Let's see what it is : \n",
+ " Media browser services enable applications to browse media content provided by an application and ask the application to start playing it. They may also be used to control content that is already playing by way of a MediaSession ."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NtFRjLz4RNU-"
+ },
+ "source": [
+ "
Media-compat Library :
\n",
+ "This library contains classes which are used to create audio and video app's. These classes also work with other Android features to create a comfortable, familiar Android experience.\n",
+ " \n",
+ "MediaSessionCompat and MediaControllerCompat are the two classes which are defined inside the media-compat library.They replace earlier versions of the classes MediaSession and MediaController. \n",
+ "These compat classes offer the same functionality but make it easier to develop your app because you only need to write to one API."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "TpfGrIRBK3pF"
+ },
+ "source": [
+ "
Media Player :
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2zo3fcKKnyr3"
+ },
+ "source": [
+ "There are many ways to control playback of audio and video files in android. One such way is Media Player. There is also alternate way to Media Player i.e Exo-Player which we will be also seeing below in this documentation. \n",
+ "Android Multimedia framework provides this Media Player class to access built-in mediaplayer services like playing audio,video e.t.c. In order to use MediaPlayer, we have to call a static Method **create()** of this class. \n",
+ "\n",
+ "Syntax : \n",
+ " MediaPlayer < nameofMediaPlayer > = MediaPlayer.create(this, R.raw.song);\n",
+ " \n",
+ " \n",
+ "You have to make a new folder under your project with name raw and place the music file into it."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IAPTq0wUteWi"
+ },
+ "source": [
+ "After creating media player object we can call some methods like \n",
+ "For now consider our object name \"mediaPlayer\". \n",
+ "* mediaPlayer.start();\n",
+ "* mediaPlayer.pause();\n",
+ "\n",
+ "start method starts playing the msinc from beginning and pause button stop playing the music and save that state so that if again start method in invoked it will resume playing from same state.\n",
+ "\n",
+ "In order to start music from the beginning, you have to call reset() method.\n",
+ "\n",
+ "Syntax : mediaPlayer.reset();\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "m8ZLKRWryS2b"
+ },
+ "source": [
+ "
Manifest Declaration :
\n",
+ "Before developing application using Media Player, we need to make some appropriate declarations.\n",
+ "\n",
+ "\n",
+ "* Internet Permission :\n",
+ " To stream network based content you require network access.\n",
+ " Add this line tou your manifest file : \n",
+ " \n",
+ "* Wake Lock Permission :\n",
+ " To use methods like MediaPlayer.setScreenOnWhilePlaying() or MediaPlayer.setWakeMode() so that your screen or processor keeps from sleeping.\n",
+ " \n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "S6217I602rD0"
+ },
+ "source": [
+ "
Important Methods Of Media Player :
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Q3fuKIWK3FBi"
+ },
+ "source": [
+ "1. isPlaying()\n",
+ "\n",
+ " This method just returns true/false indicating the song is playing or not.\n",
+ "\n",
+ "2.\tseekTo(position)\n",
+ "\n",
+ " This method takes an integer, and move song to that particular position millisecond.\n",
+ "\n",
+ "3.\tgetCurrentPosition()\n",
+ "\n",
+ " This method returns the current position of song in milliseconds.\n",
+ "\n",
+ "4.\tgetDuration()\n",
+ "\n",
+ " This method returns the total time duration of song in milliseconds.\n",
+ "\n",
+ "5.\treset()\n",
+ "\n",
+ " This method resets the media player.\n",
+ "\n",
+ "6.\trelease()\n",
+ "\n",
+ " This method releases any resource attached with MediaPlayer object.\n",
+ "\n",
+ "7.\tsetVolume(float leftVolume, float rightVolume)\n",
+ "\n",
+ " This method sets the up down volume for this player.\n",
+ "\n",
+ "8.\tsetDataSource(FileDescriptor fd)\n",
+ "\n",
+ " This method sets the data source of audio/video file.\n",
+ "\n",
+ "9.\tselectTrack(int index)\n",
+ "\n",
+ " It takes an integer and select the track from list on that particular index.\n",
+ "\n",
+ "10.\tgetTrackInfo()\n",
+ "\n",
+ " This method returns an array of track information."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GnypngZR4w8m"
+ },
+ "source": [
+ "
ExoPlayer :
\n",
+ "ExoPlayer is an application level media player for Android. It provides an alternative to Android’s MediaPlayer API for playing audio and video both locally and over the Internet. It is not a part of Android multimedia framework. It supports features not currently supported by Android’s MediaPlayer API. It is easy to customize and extend, and can be updated through Play Store application updates."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "p_7NZaxn-gZ_"
+ },
+ "source": [
+ "ExoPlayerView is one of the most used UI components in many apps. It is used for audio as well as video streaming in applications. ExoPlayer is a library that is the best alternative source for playing audio and videos on Android. This library will also help you to customize your media player according to our requirements. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2Mu2hYBpRE3j"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "* **Advantages of Exo Player :**\n",
+ "\n",
+ "\n",
+ " 1. ExoPlayer supports dynamic streaming over HTTP.\n",
+ " 2. It provides smooth streaming and encryption for the played video. \n",
+ " 3. ExoPlayer provides the support for the playlist and with this, you can clip or merge your media.\n",
+ " 4. ExoPlayer provides you the ability to customize your media player according to your requirements.\n",
+ " 5. ExoPlayer easily handles buffering of audio and video files. \n",
+ " 6. ExoPlayer is able to stream audio and video files directly from the server without downloading. \n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RCtF5aICSj5G"
+ },
+ "source": [
+ "To use ExoPlayer you need to add some dependencies in your build.gradle file of your project.\n",
+ "\n",
+ "\n",
+ "\n",
+ "* ExoPlayer\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer:r2.4.0’\n",
+ "* ExoPlayer core support\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer-core:r2.4.0’\n",
+ "* Dash support in ExoPlayer\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer-dash:r2.4.0’\n",
+ "* hls support in ExoPlayer\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer-hls:r2.4.0’\n",
+ "* Smooth streaming of videos in ExoPlayer\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer-smoothstreaming:r2.4.0’\n",
+ "* Default UI odf ExoPlayer\n",
+ " implementation ‘com.google.android.exoplayer:exoplayer-ui:r2.4.0’\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "a4J9xKcwUA3R"
+ },
+ "source": [
+ "* Image credit goes to official documentation of android [Link](https://developer.android.com/docs)\n",
+ "\n",
+ "**Other references :**\n",
+ "\n",
+ "* GeeksForGeeks\n",
+ "* Tutorials Point\n",
+ "* https://developer.android.com/docs\n",
+ "* https://exoplayer.dev/\n",
+ "* https://android-developers.googleblog.com/\n",
+ "\n"
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/Android_Development_With_Java/9 Android Multimedia/9.03 Play Video from URL using VideoView.md b/Android_Development_With_Java/9 Android Multimedia/9.03 Play Video from URL using VideoView.md
new file mode 100644
index 0000000000..4d789ee347
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/9.03 Play Video from URL using VideoView.md
@@ -0,0 +1,88 @@
+## Play Video from URL in Android using VideoView.
+
+`VideoView` widget is capable of playing media files, and the formats supported by the `VideoView` are 3gp and MP4. By using `VideoView` you can play media files from the local storage and also from the internet.
+
+* We aslo need to convert our `URL` to [Uniform Resource Identifier (URI) reference.](https://developer.android.com/reference/java/net/URI)
+
+
+## Sample Project
+---
+
+
+## Adding the Internet Permission.
+
+For playing the video from the the `URL` we need internet permission.
+
+Navigate to `app > manifest > AndroidManifest.xml` and the internet permission to that file as shown below.
+
+```xml
+
+```
+
+## Source Code
+> XML
+
+```XML
+
+
+
+
+
+
+
+
+
+
+
+
+```
+> JAVA
+
+```java
+
+public class MainActivity extends AppCompatActivity {
+
+ // Your Video URL
+ String videoUrl = "https://youtu.be/vBjTXKpaFj8";
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // finding videoview by its id
+ VideoView videoView = findViewById(R.id.videoview);
+
+ // Uri object to refer the resource from the videoUrl
+ Uri uri = Uri.parse(videoUrl);
+
+ // sets the resource
+ videoView.setVideoURI(uri);
+
+ // starts the video
+ videoView.start();
+ }
+}
+```
+For more help please vist [here](https://www.geeksforgeeks.org/how-to-play-video-from-url-in-android/).
+
+
+
+
+
diff --git a/Android_Development_With_Java/9 Android Multimedia/9.05 Media Recorder.md b/Android_Development_With_Java/9 Android Multimedia/9.05 Media Recorder.md
new file mode 100644
index 0000000000..8327d7c45e
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/9.05 Media Recorder.md
@@ -0,0 +1,293 @@
+## MediaRecorder
+
+**`MediaRecorder`** class can be used to record audio and video files.
+
+
+
+### Sample Project.
+
+Here we will be making a simple app which `Start`, `Strop`, and `Play` the recorded audio.
+
+## Sample Process
+
+**We will create a simple app with Record and play the audio.**
+
+
+
+## Process
+
+### Step 1 - Adding `Start`, `Strop` and `Play` Buttons to the `activity_main.xml` layout.
+
+ ```XML
+
+
+
+
+
+
+
+
+
+
+
+ ```
+ ### Step 2 - Adding Audio recording permission to the `AndroidManifest.xml`
+
+ ```XML
+
+ ```
+ After addition your `AndroidManifest.xml`should look like this.
+ ```XML
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ```
+### Step 3 - Setting up the `MediaRecoder` and `MediaPlayer`.
+
+This is full source code, every part of the code is explained below.
+
+```java
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import java.io.File;
+import java.io.IOException;
+import android.Manifest;
+import android.content.ContextWrapper;
+import android.content.pm.PackageManager;
+import android.media.MediaPlayer;
+import android.media.MediaRecorder;
+import android.os.Bundle;
+import android.os.Environment;
+import android.view.View;
+import android.widget.Button;
+import android.widget.Toast;
+public class MainActivity extends AppCompatActivity {
+ MediaRecorder recorder;
+ MediaPlayer mediaPlayer;
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+ if (isMicPresent()) {
+ getMicPermission();
+ }
+ }
+ public void startRecording(View view) {
+ try {
+ //Creating MediaRecorder and specifying audio source, output format, encoder & output format
+ recorder = new MediaRecorder();
+ // Setting up the audio source
+ recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+ recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+ recorder.setOutputFile(getRecordingPath());
+ recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+ recorder.prepare();
+ recorder.start();
+ Toast.makeText(this, "Recording Started", Toast.LENGTH_SHORT).show();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ public void stopRecording(View view) {
+ //stopping recorder
+ recorder.stop();
+ recorder.release();
+ recorder = null;
+ Toast.makeText(this, "Recording Stopeed", Toast.LENGTH_SHORT).show();
+ }
+ public void playButton(View v) {
+ try {
+ mediaPlayer = new MediaPlayer();
+ mediaPlayer.setDataSource(getRecordingPath());
+ mediaPlayer.prepare();
+ mediaPlayer.start();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ public boolean isMicPresent() {
+ if (this.getPackageManager().hasSystemFeature(PackageManager.FEATURE_MICROPHONE)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ public void getMicPermission() {
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_DENIED) {
+ ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, 200);
+ }
+ }
+ private String getRecordingPath() {
+ ContextWrapper contextWrapper = new ContextWrapper(getApplicationContext());
+ File musicDir = contextWrapper.getExternalFilesDir(Environment.DIRECTORY_MUSIC);
+ File file = new File(musicDir, "TestRecording" + ".mp3");
+ return file.getPath();
+ }
+}
+```
+### Checking whether the mic is available or not.
+
+Here first we need to check for mic hardware availability. If it's available the function will return `true` otherwise `false`
+
+ ```java
+ public boolean isMicPresent() {
+ if (this.getPackageManager().hasSystemFeature(PackageManager.FEATURE_MICROPHONE)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ ```
+
+### Getting mic permission.
+
+Here if the current state of mic permission is `DENIED` we will ask for the permission.
+
+ ```java
+ public void getMicPermission() {
+ if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_DENIED) {
+ ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, 200);
+ }
+ }
+ ```
+
+### Getting Mic permission from user at the start of the App.
+
+Here we simply check if the mic is available we can simply ask the user for permission.
+
+```java
+if (isMicPresent()) {
+ getMicPermission();
+ }
+```
+
+### Setting up the Recording Path.
+
+Here we define the naming and path of the recorded audio file.
+
+```java
+ private String getRecordingPath() {
+ ContextWrapper contextWrapper = new ContextWrapper(getApplicationContext());
+ File musicDir = contextWrapper.getExternalFilesDir(Environment.DIRECTORY_MUSIC);
+ File file = new File(musicDir, "TestRecording" + ".mp3");
+ return file.getPath();
+ }
+```
+
+### Recoding the audio on button click.
+
+Here we are setting up MediaRecoder and start recording the audio. It's in the `Try And Catch` block because `I/O Exception` may occur
+
+Here we define the naming and path of the recorded audio file.
+
+```java
+ public void startRecording(View view) {
+ try {
+ //Creating MediaRecorder and specifying audio source, output format, encoder & output format
+ recorder = new MediaRecorder();
+
+ // Setting up the audio source
+ recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+ recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
+
+ // Here we are setting up the path which we already defined in the method above.
+ recorder.setOutputFile(getRecordingPath());
+ recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
+ recorder.prepare();
+ recorder.start();
+ Toast.makeText(this, "Recording Started", Toast.LENGTH_SHORT).show();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+```
+### Stop Recoding the audio on button click.
+
+Here we simply stop the audio recording.
+
+```java
+public void stopRecording(View view) {
+ //stopping recorder
+ recorder.stop();
+ recorder.release();
+ recorder = null;
+ Toast.makeText(this, "Recording Stopeed", Toast.LENGTH_SHORT).show();
+ }
+```
+
+### Playing the recorded audio.
+
+```java
+ public void playButton(View v) {
+ try {
+ mediaPlayer = new MediaPlayer();
+ mediaPlayer.setDataSource(getRecordingPath());
+ mediaPlayer.prepare();
+ mediaPlayer.start();
+
+ Toast.makeText(this, "Audio Palying", Toast.LENGTH_SHORT).show();
+ }
+ catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ ```
+ For more help please visit [Android Official Documentation](https://developer.android.com/reference/android/media/MediaRecorder)
+
diff --git a/Android_Development_With_Java/9 Android Multimedia/9.1 Media Player.md b/Android_Development_With_Java/9 Android Multimedia/9.1 Media Player.md
new file mode 100644
index 0000000000..4785b29304
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/9.1 Media Player.md
@@ -0,0 +1,173 @@
+# Media Player
+**Android** provides many ways to control the playback of audio/video files and streams. One of these ways is through a class called MediaPlayer.In order to use MediaPlayer, we have to call a static method `create()` of this class. This method returns an instance of the MediaPlayer class.
+
+ ```java
+ // The second parameter is the name of the song that you want to play.
+ MediaPlayer mediaPlayer = MediaPlayer.create(this, R.raw.song);
+ ```
+
+**Before that let's see how we can import our music files into Android Studio.**
+
+create a new `raw` folder in the `res` directory and add music file like as shown below.
+
+
+
+**After the Mediaplayer object is created, we can call some methods.**
+
+```java
+mediaPlayer.start(); //Music will start
+mediaPlayer.pause(); //Music will get paused
+mediaPlayer.reset(); //Music will start from the beginning
+mediaplayer.setOnCompletionListener() // Help us to detect whether the song has completed or not
+```
+* **There is a special method that helps us to clean up the resources which are taken to create a MediaPlayer. It is a good practice to clear up resources for optimization and other activity usages, We will clean up the resources i.e `release()` generally in 3 conditions**
+
+ * Media Player completed its songs.
+ * Activicty/ application is closed/stop.
+ * when `stop()` method is called.
+
+```java
+mediaPlayer.release();
+```
+
+Apart from this there are various methods you can check them out [here](https://www.tutorialspoint.com/android/android_mediaplayer.htm).
+
+> In this example we will construct a simple music player which simply `Play`, `Pause` and `Stop`.
+
+
+
Sorry, sound can't be added to GIF.
+
+> **Java code**
+```java
+
+public class MainActivity extends AppCompatActivity {
+ MediaPlayer mediaPlayer;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_main);
+
+ // Finding Buttons with the help of findViewById() method.
+ Button playButton = findViewById(R.id.button1);
+ Button pauseButton = findViewById(R.id.button2);
+ Button stopButton = findViewById(R.id.button3);
+
+ // PLAY BUTTON
+ playButton.setOnClickListener(new View.OnClickListener() {
+ public void onClick(View v) {
+ Toast.makeText(MainActivity.this,"START", Toast.LENGTH_SHORT).show();
+ // Checking if the Media Player is created or not
+ if (mediaPlayer==null){
+ //otherwise create it.
+ mediaPlayer = MediaPlayer.create(MainActivity.this,R.raw.got);
+
+ // It's will get Auto triggered whn song is completed
+ mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
+ public void onCompletion(MediaPlayer mp) {
+ Toast.makeText(MainActivity.this,"STARTED",Toast.LENGTH_LONG).show();
+ releaseMediaPlayer();
+
+ }
+ });
+ }
+ // Song will start playing
+ mediaPlayer.start();
+ }
+ });
+
+ // PAUSE BUTTON
+ pauseButton.setOnClickListener(new View.OnClickListener() {
+
+ public void onClick(View v) {
+ if (mediaPlayer != null){
+ mediaPlayer.pause();
+ Toast.makeText(MainActivity.this,"PAUSED", Toast.LENGTH_SHORT).show();
+ }
+ }
+ });
+
+ stopButton.setOnClickListener(new View.OnClickListener() {
+
+ public void onClick(View v) {
+ mediaPlayer.stop();
+ releaseMediaPlayer();
+ Toast.makeText(MainActivity.this,"STOPPED", Toast.LENGTH_SHORT).show();
+ }
+ });
+ }
+
+ /**
+ * Clean up the media player by releasing its resources.
+ * Instead of applying same sets of code again and again (and DRY principle), we put into a method.
+ */
+
+ private void releaseMediaPlayer() {
+ // If the media player is not null, then it may be currently playing a sound.
+ if (mediaPlayer != null) {
+
+ // Regardless of the current state of the media player, release its resources
+ // because we no longer need it.
+
+ mediaPlayer.release();
+
+ // Set the media player back to null. For our code, we've decided that
+ // setting the media player to null is an easy way to tell that the media player
+ // is not configured to play an audio file at the moment.
+ mediaPlayer = null;
+ }
+ }
+
+ // If the App will get closed then also we will release Media Player resources.
+ @Override
+ protected void onStop() {
+ super.onStop();
+ releaseMediaPlayer();
+ }
+}
+
+```
+> **XML code**
+```xml
+
+
+
+
+
+
+
+
+
+
+```
+For more help, please visit [Android official Documentation.](https://developer.android.com/guide/topics/media/mediaplayer)
diff --git a/Android_Development_With_Java/9 Android Multimedia/IntelliJ.md b/Android_Development_With_Java/9 Android Multimedia/IntelliJ.md
new file mode 100644
index 0000000000..5a26433dd7
--- /dev/null
+++ b/Android_Development_With_Java/9 Android Multimedia/IntelliJ.md
@@ -0,0 +1,39 @@
+# Installing Intellij
+
+__Java8__ must be installed on the system as a prerequisite.
+
+To install IntelliJ IDEA on your machine, follow the procedures outlined below:
+
+
+
+ 1. Get IntelliJ IDEA from the Jetbrains website or from the link below:
+
+ [link](https://www.jetbrains.com/idea/download/)
+
+
+
+
+
+2. After you've downloaded the file, go to the Download location and run the installation. There's a chance you'll get a security warning. Select 'Run' from the drop-down menu.
+
+3. The setup will begin loading after the security check is completed. There will be a welcome screen. Follow the installer's instructions by clicking next.
+
+4. Select a suitable installation location. Next should be selected.
+
+
+
+
+5. Select a suitable desktop shortcut. If the user is using a 64-bit system, make the appropriate selection. Select the '.java' file as well. This will automatically correlate the java files with IntelliJ IDEA.
+
+
+
+6. Choose 'JetBrains' as the start menu folder (by default). After that, click Install.
+
+
+
+7. IntelliJ IDEA will begin installing on your computer.
+
+8. After the setup is complete, select Next, then Finish.IntelliJ IDEA will be installed on the system in this manner.
+
+
+
diff --git a/Android_Development_With_Java/9 Android Multimedia/index.md b/Android_Development_With_Java/9 Android Multimedia/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Android_Development_With_Java/Add_firebase_with_android_app.md b/Android_Development_With_Java/Add_firebase_with_android_app.md
new file mode 100644
index 0000000000..bb4467fc14
--- /dev/null
+++ b/Android_Development_With_Java/Add_firebase_with_android_app.md
@@ -0,0 +1,26 @@
+## Add Firebase to your Android project
+Firebase is a mobile and web application development platform. It provides services that a web application or mobile application might require.
+You can very easily add firebase to your android application by following the below steps -
+
+### Using Firebase Assistant -
+- First step is to update the android studio.
+- Now click on Create a project to create a new project in firebase.
+
+
+
+- Go to android studio and click on the Tools in the upper left corner. Select Firebase from the drop-down menu.
+
+
+
+- A menu will get open on the right side of your screen showing various services offered by Firebase.
+- Choose any desired option like the Cloud Messaging option and click on Set up Firebase Cloud Messaging.
+
+
+
+- Now click on Connect to Firebase option.
+- Add the dependencies of your service by clicking on the Add [YOUR SERVICE NAME] to the app option.
+
+
+
+
+Now Firebase is added to your android aapp successfully!!
diff --git a/Android_Development_With_Java/Android Studio Debugger.md b/Android_Development_With_Java/Android Studio Debugger.md
new file mode 100644
index 0000000000..29aec3b4c7
--- /dev/null
+++ b/Android_Development_With_Java/Android Studio Debugger.md
@@ -0,0 +1,203 @@
+# **About Debugging**
+
+
+Debugging is the process of finding and fixing errors (bugs) or unexpected behavior in your code. All code has bugs, from incorrect behavior in your app, to
+behavior that excessively consumes memory or network resources, to actual app freezing or crashing.
+
+Bugs can result for many reasons:
+
+•Errors in your design or implementation
+•Android framework limitations (or bugs)
+•Missing requirements or assumptions for how the app should work
+•Device limitations (or bugs)
+
+#### **Use the debugging, testing, and profiling capabilities in Android Studio to help you reproduce, find, and resolve all of these problems. Those capabilities include:**
+
+•The Logcat pane for log messages
+•The Debugger pane for viewing frames, threads, and variables
+•Debug mode for running apps with breakpoints
+•Test frameworks such as JUnit or Espresso
+•Dalvik Debug Monitor Server (DDMS), to track resource usage
+•In this chapter you learn how to debug your app with the Android Studio debugger, set and view breakpoints, step through your code, and examine variables.
+
+
+## **Running the debugger**
+Running an app in debug mode is similar to running the app. You can either run an app in debug mode, or attach the debugger to an already-running app.
+
+
+## **Run your app in debug mode**
+To start debugging, click Debug icon Debug in the toolbar. Android Studio builds an APK, signs it with a debug key, installs it on your selected device, then
+runs it and opens the Debug pane with the Debugger and Console tabs.
+
+
+
+
+The figure above shows the *Debug* pane with the *Debugger* and *console* tabs. The *Debugger* tab is selected, showing the *Debugger* pane with the
+following features:
+
+ ➊**Frames tab**
+Click to show the *Frames* pane with the current execution stack frames for a given *thread*. The execution stack shows each class and method
+that have been called in your app and in the *Android runtime*, with the most recent method at the top.
+
+Click the *Threads* tab to replace the *Frames* pane with the *Threads* pane.
+
+➋**Watches button**
+ Click to show the *Watches* pane within the *Variables* pane, which shows the values for any *variable* watches you have set. *Watches* allow you to keep track of a specific *variable* in your program, and see how that *variable* changes as your program runs.
+
+➌**Variables pane**
+Shows the *variables* in the current scope and their values. Each *variable* in this pane has an expand icon to expand the list of object properties for the *variable*. Try expanding a *variable* to explore its properties.
+
+
+
+## **Debug a running app** ##
+If your app is already running on a device or emulator, start debugging that app with these steps:
+
+➊ Select *Run > Attach debugger to Android process* or click the *Attach* icon Attach icon in the toolbar.
+In the **Choose Process** dialog, select the process to which you want to attach the debugger.
+
+➋ By default, the debugger shows the device and app process for the current project, as well as any connected hardware devices or virtual devices on your computer. Check the Show all processes option to *show all processes* on all devices.
+
+➌ Click *OK*. The *Debug pane* appears as before.
+
+
+
+## **Resume or stop debugging** ##
+➊ To resume executing an app after debugging it, select *Run > Resume Program* or click the Resume Resume icon icon.
+
+➋ To stop debugging your app, select *Run > Stop* or click the Stop icon Stop icon in the toolbar.
+
+
+## **Using breakpoints** ##
+Android Studio supports several types of breakpoints that trigger different debugging actions. The most common type is a breakpoint that pauses the execution of
+your app at a specified line of code. While paused, you can examine variables, evaluate expressions, then continue execution line by line to determine the causes
+of runtime errors.
+
+You can set a breakpoint on any executable line of code.
+
+
+## **Add breakpoints** ##
+To add a breakpoint to a line in your code, use these steps:
+
+➊ Locate the line of code where you want to pause execution.
+➊ Click in the left gutter of the editor pane at that line, next to the line numbers. A red dot appears at that line, indicating a breakpoint. The red dot includes
+ a check mark if the app is already running in debug mode.
+
+As an alternative, you can choose *Run > Toggle Line Breakpoint* or press *Control-F8 (Command-F8 on a Mac)* to set or clear a breakpoint at a line.
+
+
+
+If your app is already running, you don't need to update it to add the breakpoint.
+
+If you click a breakpoint by mistake, you can undo it by clicking the breakpoint. If you clicked a line of code that is not executable, the red dot includes an "x"
+and a warning appears that the line of code is not executable.
+
+When your code execution reaches the breakpoint, Android Studio pauses execution of your app. *You can then use the tools in the Debug pane to view the state of the app and debug that app as it runs.*
+
+## **View and configure breakpoints** ##
+To view all the breakpoints you've set and configure *breakpoint* settings, click the View *Breakpoints icon* View *breakpoints icon* on the left edge of the *Debug pane*.
+The Breakpoints window appears.
+
+
+
+
+In this window all the breakpoints you have set appear in the left pane, and you can enable or disable each breakpoint with the checkboxes. If a breakpoint is
+disabled, Android Studio does not pause your app when execution reaches that breakpoint.
+
+Select a breakpoint from the list to configure its settings. You can configure a breakpoint to be disabled at first and have the system enable it after a different breakpoint is encountered. You can also configure whether a breakpoint should be disabled after it has been reached.
+
+To set a breakpoint for any exception, select *Exception Breakpoints* in the list of breakpoints.
+
+## **Disable (mute) all breakpoints** ##
+Disabling a breakpoint enables you to temporarily "mute" that breakpoint without removing it from your code. If you remove a breakpoint altogether you also lose any conditions or other features you created for that breakpoint, so disabling it can be a better choice.
+
+To mute all breakpoints, click the *Mute Breakpoints icon* . Click the icon again to enable (unmute) all breakpoints.
+
+
+#### Use conditional breakpoints ####
+Conditional breakpoints are breakpoints that only stop execution of your app if the test in the condition is true. To define a test for a conditional breakpoint, use these steps:
+
+*Right-click* (or *Control*-click) a breakpoint, and enter a test in the Condition field. Entering a test in the *Condition field*
+
+
+➊The test you enter in this field can be any Java expression as long as it returns a boolean value. You can use variable names from your app as part of the expression.
+
+You can also use the *Breakpoints* window to enter a breakpoint condition.
+
+➋Run your app in debug mode. Execution of your app stops at the conditional breakpoint, if the condition evaluates to true.
+
+
+## **Stepping through code** ##
+After your app's execution has stopped because a breakpoint has been reached, you can execute your code from that point one line at a time with the Step Over, Step Into, and Step Out functions.
+
+To use any of the step functions:
+
+➊Begin debugging your app. Pause the execution of your app with a breakpoint.
+
+Your app's execution stops, and the *Debugger* pane shows the current state of the app. The current line is highlighted in your code.
+
+➋Click the *Step Over* icon Step Over icon , *select Run > Step Over*, or press F8. Step Over executes the next line of the code in the current class and method, executing all of the method calls on that line and remaining in the same file.
+
+➌Click the *Step Into* icon Step Into icon , *select Run > Step Into*, or press F7. Step Into jumps into the execution of a method call on the current line
+(as compared to just executing that method and remaining on the same line). The Frames pane (which you'll learn about in the next section) updates to show the
+new stack frame (the new method). If the method call is contained in another class, the file for that class is opened and the current line in that file is
+highlighted. You can continue stepping over lines in this new method call, or step deeper into other methods.
+
+➍Click the *Step Out* icon Step Out icon , *select Run > Step Out*, or press *Shift-F8*. Step Out finishes executing the current method and returns to the point
+where that method was called.
+
+To resume normal execution of the app, select *Run > Resume Program* or click the Resume icon.
+
+## **Viewing execution stack frames** ##
+The *Frames* pane of the *Debug* pane allows you to inspect the execution stack and the specific frame that caused the current breakpoint to be reached.
+
+
+The execution stack shows all the classes and methods (frames) that are being executed up to this point in the app, in reverse order (most recent frame first). As execution of a particular frame finishes, that frame is popped from the stack and execution returns to the next frame.
+
+Clicking a line for a frame in the *Frames* pane opens the associated source in the editor and highlights the line where that frame was initially executed. The *Variables* and *Watches* panes also update to reflect the state of the execution environment when that frame was last entered.
+
+
+## **Inspecting and modifying variables** ##
+The Variables pane of the *Debugger pane* allows you to inspect the variables available at the current stack frame when the system stops your app on a breakpoint. Variables that hold objects or collections such as arrays can be expanded to view their components.
+
+The *Variables* pane also allows you to evaluate expressions on the fly using static methods or variables available within the selected frame.
+
+If the *Variables* pane is not visible, click the *Restore Variables View icon* .
+
+
+To modify variables in your app as it runs:
+
+➊*Right-click* (or *Control-click*) any variable in the *Variables pane*, and select *Set Value*. You can also press *F2*.
+
+➋Enter a new value for the variable, and press *Return*.
+
+The value you enter must be of the appropriate type for that variable, or Android Studio returns a "type mismatch" error.
+
+
+## **Setting watches** ##
+The *Watches* pane provides similar functionality to the *Variables* pane except that expressions added to the Watches pane persist between debugging sessions.
+Add watches for variables and fields that you access frequently or that provide state that is helpful for the current debugging session.
+
+To use watches:
+
+➊Begin debugging your app.
+
+➋Click the Show Watches icon Show Watches icon . The Watches pane appears next to the Variables pane.
+
+➌In the Watches pane, click the plus (+) button. In the text box that appears, type the name of the variable or expression you want to watch and then press *Enter*.
+
+Remove an item from the Watches list by selecting the item and then clicking the minus (–) button.
+
+Change the order of the elements in the *Watches pane* list by selecting an item and then clicking the up or down icons.
+
+
+## **Evaluating expressions** ##
+➊Use Evaluate Expression to explore the state of variables and objects in your app, including calling methods on those objects. To evaluate an expression:
+Click the *Evaluate Expression icon* , or *select Run > Evaluate Expression*.
+The *Evaluate Code Fragment* window appears. You can also right-click on any variable and choose *Evaluate Expression.*
+
+➋Enter any Java expression into the top field of the *Evaluate Code Fragment* window, and click *Evaluate.*
+
+The Result field shows the result of that expression. Note that the result you get from evaluating an expression is based on the app's current state. Depending on the values of the variables in your app at the time you evaluate expressions, you may get different results. Changing the values of variables in your expressions also changes the current running state of the app.
+
+
+
diff --git a/Android_Development_With_Java/README.md b/Android_Development_With_Java/README.md
new file mode 100644
index 0000000000..d08323a3c0
--- /dev/null
+++ b/Android_Development_With_Java/README.md
@@ -0,0 +1,129 @@
+
+
+
+
+
+
+
-: TABLE OF CONTENTS :-
+
+
+
+ ## 1. Introduction
+ - [What to Learn to get started with Android App Development with java](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/What%20to%20Learn%20to%20get%20started%20with%20Android%20App%20Development%20with%20java.md)
+ - [Introduction to Android Studio](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/Android_Java_1_0_Introduction_to_Android_Studio.ipynb)
+ - [Android_studio_installation](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.3%20Installing%20Android%20studio.ipynb)
+ - [Creating First Project](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.4%20Creating%20First%20Project.md)
+ - [Run your app using virtual device and real device.](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.5%20Running%20your%20app%20using%20virtual%20device.md)
+ - [Dalvik-Virtual-Machine](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.12%20Dalvik-Virtual-Machine.md)
+ - [Setup_Git_Github_On_Android_Studio](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.6_Setup_Git_Github_On_Android_Studio.md)
+ - [Uploading Project on GitHub from Android Studio](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.6.1%20Uploading%20Project%20on%20GitHub%20from%20Android%20Studio.md)
+ - [Clone Android Project from GitHub in Android Studio](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.6.2%20Clone%20Android%20Project%20from%20GitHub%20in%20Android%20Studio.md)
+ - [Updating_IDE_and_Essential_SDK_Tools](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.9%20Updating_IDE_and_Essential_SDK_Tools.ipynb)
+ - [Introduction to android manifest file](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.8%20Introduction%20to%20android%20manifest%20file.ipynb)
+ - [Updating_IDE_and_Essential_SDK_Tools](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.9%20Updating_IDE_and_Essential_SDK_Tools.ipynb)
+ - [Memory Profile](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/1.91%20Memory%20Profile.md)
+ - [Drawable Resource Overview](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/Drawable%20Resource%20Overview.md)
+ - [ANDROID_ARCHITECTURE_OVERVIEW](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/ANDROID_ARCHITECTURE_OVERVIEW.md)
+ - [Components of Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/1%20%20Introduction/Components%20of%20Android.md)
+
+
+ ## 2. Android UI Widget
+ - [Use of Material Designs in UI](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.1%20Use%20of%20Material%20Designs%20in%20UI.md)
+ - [Recyclerview in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.1.3%20Recyclerview%20in%20Android.md)
+ - [ViewPager in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.1.4%20ViewPager%20in%20Android.md)
+ - [DrawerLayout in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.1.5%20DrawerLayout%20in%20Android.md)
+ - [CardView in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.1.7%20CardView%20in%20Android.md)
+ - [onClickListener](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.2%20onClickListener.md)
+ - [Toast](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.3%20Toast.md)
+ - [LAYOUTS_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4%20LAYOUTS_IN_ANDROID.md)
+ - [LINEAR_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.1%20LINEAR_LAYOUT_IN_ANDROID.md)
+ - [RELATIVE_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.2%20RELATIVE_LAYOUT_IN_ANDROID.md)
+ - [CONSTRAINT_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.3%20CONSTRAINT_LAYOUT_IN_ANDROID.md)
+ - [TABLE_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.4%20TABLE_LAYOUT_IN_ANDROID.md)
+ - [ABSOLUTE_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.5%20ABSOLUTE_LAYOUT_IN_ANDROID.md)
+ - [FRAME_LAYOUT_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.6%20FRAME_LAYOUT_ANDROID.md)
+ - [GRID_LAYOUT_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.7%20GRID_LAYOUT_IN_ANDROID.md)
+ - [LIST_VIEW_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.8%20LIST_VIEW_IN_ANDROID.md)
+ - [SCROLL_VIEW_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.9%20SCROLL_VIEW_IN_ANDROID.md)
+ - [WEB_VIEW_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.4.10%20WEB_VIEW_IN_ANDROID.md)
+ - [CheckBox in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.5%20CheckBox%20in%20Android.md)
+ - [Radio-Buttons](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.6%20Radio-Buttons.md)
+ - [Image View](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.7%20Image%20View.md)
+ - [Bottom Sheet Dialog in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.10%20Bottom%20Sheet%20Dialog%20in%20android.md)
+ - [EditText with TextWatcher in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/02.12%20EditText%20with%20TextWatcher%20in%20Android.md)
+ - [Nested RecyclerView in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.17%20Nested%20RecyclerView%20in%20Android.md)
+ - [NESTED_SCROLL_VIEW_IN_ANDROID](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.18%20NESTED_SCROLL_VIEW_IN_ANDROID.md)
+ - [Expandable RecyclerView in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.19%20Expandable%20RecyclerView%20in%20Android.md)
+ - [Chips in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.21%20Chips%20in%20android.md)
+ - [Top App Bar](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.22%20Top%20App%20Bar.md)
+ - [Toolbar - Custom Action Bar](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.23%20Toolbar%20-%20Custom%20Action%20Bar.md)
+ - [RatingBar in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/2.36%20RatingBar%20in%20Android.md)
+ - [Alert Dialog Box](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/Alert%20Dialog%20Box.md)
+ - [Progress Bar](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/2%20%20Android%20UI%20Widgets/Progress%20Bar.md)
+
+
+ ## 3. Activity and Intents
+ - [Spinners](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/3.2%20Spinners.md)
+ - [EventListener in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/Android-Java%203.3_EventListener%20in%20Android.ipynb)
+ - [Implicit Intents](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/3.4%20Implicit%20Intents.md)
+ - [Explicit Intent](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/3.5%20Explicit%20Intent.md)
+ - [Intent Filter in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/3.07%20Intent%20Filter%20in%20android.md)
+ - [Activity and Activity LifeCycle](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/3.8%20Activity%20and%20Activity%20LifeCycle.md)
+ - [Start Activity For Result](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/3%20%20Activity%20and%20Intents/4.3%20Start%20Activity%20For%20Result.md)
+
+ ## 4. Android Menu
+ - [Android Menu](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/4%20%20Android%20Menu/4.01%20Android%20Menu.md)
+ - [Option Menu](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/4%20%20Android%20Menu/Option%20Menu.md)
+ - [Popup_Menu](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/4%20%20Android%20Menu/4.2%20Popup_Menu.md)
+ - [Context Menu](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/4%20%20Android%20Menu/4.4%20Android%20Context%20Menu.md)
+ ## 5. Android storage
+ - [Android External Storage](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/5%20%20Android%20storage/5.02%20Android%20External%20Storage%20.md)
+ - [Room Database](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/5%20%20Android%20storage/Room%20Database.md)
+
+ ## 6. Android SQLite
+ - [SQLite tutorial in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/6%20%20Android%20SQLite/06.00%20SQLite%20tutorial%20in%20android.md)
+ - [How to make a todo app using SQLite](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/6%20%20Android%20SQLite/06.01%20How%20to%20make%20a%20todo%20app%20using%20SQLite_%20.md)
+
+ ## 7. Android XML & JSON
+ - [XML in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/7%20%20Android%20XML%20%26%20JSON/7.00%20XML%20in%20android.md)
+ - [JSON vs XML](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/7%20%20Android%20XML%20%26%20JSON/7.01%20JSON%20vs%20XML.md)
+ ## 8. Android Notification
+ - [Types of Notifications](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/8%20%20Android%20Notifications/Types%20of%20Notifications%20.md)
+ - [Heads Up Notification in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/8%20%20Android%20Notifications/08.01%20Heads%20Up%20Notification%20in%20android.md)
+ ## 9. Android Multimedia
+ - [IntelliJ](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/IntelliJ.md)
+ - [Android_Multimedia](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/9.0%20Android_Multimedia.ipynb)
+ - [Media Player](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/9.1%20Media%20Player.md)
+ - [how to make a video player app in android?](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/09.02%20how%20to%20make%20a%20video%20player%20app%20in%20android%3F.md)
+ - [Play Video from URL using VideoView](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/9.03%20Play%20Video%20from%20URL%20using%20VideoView.md)
+ - [Media Recorder](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/9%20%20Android%20Multimedia/9.05%20Media%20Recorder.md)
+
+ ## 10. Android Device
+ - [Bluetooth Tutorial](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/10%20Android%20Device/10.00%20Bluetooth%20Tutorial.md)
+ - [Wifi example](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/10%20Android%20Device/10.01%20Wifi%20example.md)
+ ## 11. Android Sensor Tutorial
+ - [Sensor Introduction](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/11%20Android%20Sensor%20Tutorial/11.1%20Sensor%20Introduction.md)
+ ## 12. Android Graphics Tutorial
+ - [Android_Graphics](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/12%20Android%20Graphics%20Tutorial/12.1.Android_Graphics.md)
+ - [Motion Sensors in android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/11%20Android%20Sensor%20Tutorial/11.02%20Motion%20Sensors%20in%20android.md)
+ - [EnvironmentSensors](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/11%20Android%20Sensor%20Tutorial/EnvironmentSensors.ipynb)
+ ## 13. Android Animation Tutorial
+ - [Animations in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/13%20Android%20Animation%20Tutorial/13.00%20Animations%20in%20Android.md)
+ - [Start an activity using an animation](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/13%20Android%20Animation%20Tutorial/13.01%20Start%20an%20activity%20using%20an%20animation.md)
+ - [SlidingAnimations](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/13%20Android%20Animation%20Tutorial/13.02SlidingAnimations.md)
+ - [Use of Shimmer Library in Android](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/13%20Android%20Animation%20Tutorial/13.03%20Use%20of%20Shimmer%20Library%20in%20Android.md)
+ - [TextView_fading](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/13%20Android%20Animation%20Tutorial/13.04%20TextView_fading.md)
+ ## 14. Android Web Services
+ - [Network Call Using Retrofit](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/14%20Android%20Web%20Services/Network%20Call%20Using%20Retrofit.md)
+ - [Network Call Using Volley](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/14%20Android%20Web%20Services/Network%20Call%20Using%20Volley.md)
+ ## 15. Android FireBase
+ - [RecyclerView_with_FirebaseRecyclerAdapter](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/15%20Android%20Firebase/15.00%20RecyclerView_with_FirebaseRecyclerAdapter.md)
+ - [OTP_Verification_using_Firebase](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/15%20Android%20Firebase/15.01%20OTP_Verification_using_Firebase.md)
+ ## 16. Android Components
+ - [BroadcastReceivers](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/16%20Android%20Components/BroadcastReceivers.ipynb)
+ - [Easy Runtime Permissions with Dexter](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/16%20Android%20Components/Easy%20Runtime%20Permissions%20with%20Dexter.md)
+ - [ViewBinding and ButterKnife](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/16%20Android%20Components/ViewBinding%20and%20ButterKnife.md)
+ ## 17. Android Date And Time
+ - [DatePicker Dialog](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/17%20Android%20Date%20And%20Time/17.1%20DatePicker%20Dialog.md)
+ - [Time Picker Dialog](https://github.com/girlscript/winter-of-contributing/blob/Android_Development_With_Java/Android_Development_With_Java/17%20Android%20Date%20And%20Time/17.2%20Time%20Picker%20Dialog.md)
+
diff --git a/Android_Development_With_Java/index.md b/Android_Development_With_Java/index.md
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Backend_Development_With_Java/AOP/Introduction_to_Aspect_Oriented_Programming.ipynb b/Backend_Development_With_Java/AOP/Introduction_to_Aspect_Oriented_Programming.ipynb
deleted file mode 100644
index 50deb1175d..0000000000
--- a/Backend_Development_With_Java/AOP/Introduction_to_Aspect_Oriented_Programming.ipynb
+++ /dev/null
@@ -1,73 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 2,
- "metadata": {
- "colab": {
- "name": "Introduction to Aspect Oriented Programming.ipynb",
- "provenance": []
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
- },
- "cells": [
- {
- "cell_type": "markdown",
- "source": [
- "##**Introduction to Aspect Oriented Programming**\r\n",
- "\r\n",
- "In Object Oriented Programming, class is the unit of modularity which means a piece of code that is intended to perform a particular function. While in AOP the unit of modularity is Aspect. These aspects increase modularity by allowing the separation of cross-cutting concerns.\r\n",
- "\r\n",
- "\r\n",
- "**Cross cutting concerns** - For example, we may need to log the parameters of methods in all classes. Rather than adding a repeating logging code, we can use Aspect Oriented Programming for logging. An aspect can be configured to be executed before method invocation, so the parameters can be logged within the aspect. \r\n",
- "\r\n",
- "Examples of concerns that tend to be cross-cutting include:\r\n",
- "Caching, Data validation, Logging, Format data, Transaction processing.\r\n",
- "\r\n",
- "\r\n",
- "**Some basic concepts in AOP**\r\n",
- "- ***Aspect***: In Spring an aspect is a POJO class that contains the logic which is common across modules, in other words an aspect is a words module which has a set of cross-cutting functions. For example a logging aspect contains the code for logging. @Aspect annotation is used to mark an aspect. \r\n",
- "E.g: ValidateAspect, FormatAspect. To form an aspect, we define pointcut and advice.\r\n",
- "\r\n",
- "- ***Join point***: refers to the point in the application execution where we can apply the aspect. For example we can say the aspect needs to be called when a method invocation happens or an exception is thrown.\r\n",
- "\r\n",
- "- ***Advice*** : This says when and where an aspect needs to be invoked. The actual execution of aspect logic happens here. It is the actual code that gets executed before or after the join point.\r\n",
- "\r\n",
- " Types of Advice\r\n",
- "\r\n",
- "\r\n",
- " 1. **Before**: Runs before the advised method is invoked. It is denoted by @Before annotation.\r\n",
- " 2. **After**: Runs after the advised method completes regardless of the outcome, whether successful or not. It is denoted by @After annotation.\r\n",
- " 3. **AfterReturning**: Runs after the advised method successfully completes ie without any runtime exceptions. It is denoted by @AfterReturning annotation.\r\n",
- " 4. **Around**: This is the strongest advice among all the advice since it wraps around and runs before and after the advised method. This type of advice is used where we need frequent access to a method or database like- caching. It is denoted by @Around annotation.\r\n",
- " 5. **AfterThrowing**: Runs after the advised method throws a Runtime Exception. It is denoted by @AfterThrowing annotation.\r\n",
- "\r\n",
- "- ***Point cut***: Point cuts are specified using expressions or patterns which say where an aspect to be executed. Usually an Advice comes with a Pointcut expression and runs at any Joinpoint matched by the Pointcut.\r\n",
- "\r\n",
- "- ***Target object*** : A target object is an object being advised by one or more aspects. Also referred to as the advised object.\r\n",
- "\r\n",
- "- ***Weaving*** : Weaving is the process of linking aspects with other objects to create an advised object.\r\n",
- "\r\n",
- "**Dominant Frameworks in AOP:**\r\n",
- "AOP includes programming methods and frameworks on which modularisation of code is supported and implemented. Here are three dominant frameworks in AOP:\r\n",
- "\r\n",
- "\r\n",
- "\r\n",
- "\r\n",
- "- **AspectJ**: It is an extension for Java programming created at PARC research centre. It uses Java like syntax and included IDE integrations for displaying crosscutting structure. It has its own compiler and weaver, on using it enables the use of full AspectJ language.\r\n",
- "- **JBoss**: It is an open source Java application server developed by JBoss, used for Java development.\r\n",
- "- **Spring**: It uses XML based configuration for implementing AOP, also it uses annotations which are interpreted by using a library supplied by AspectJ for parsing and matching.\r\n",
- "\r\n",
- "\r\n",
- "[For more information please refer](https://www.geeksforgeeks.org/aspect-oriented-programming-and-aop-in-spring-framework/)"
- ],
- "metadata": {
- "id": "9L4rx7kOrlI-"
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/Backend_Development_With_Java/Autowiring_Dependencies/autowiring_dependencies.md b/Backend_Development_With_Java/Autowiring_Dependencies/autowiring_dependencies.md
deleted file mode 100644
index 1c4848993f..0000000000
--- a/Backend_Development_With_Java/Autowiring_Dependencies/autowiring_dependencies.md
+++ /dev/null
@@ -1,225 +0,0 @@
-
-# Autowiring and dependency injection in spring
-To understand Autowiring, good understanding of dependency injection is required, so let’s first do that.
-# Dependency injection
-Dependency injection or DI is a design pattern that is used to make our program independent in and of itself. Dependency injection helps us achieve more abstraction, loose coupling and flexibility in the program. Tight coupling can be easily managed in a small sized program, but when it comes to large scale and gigantic programs it becomes very tedious, difficult and overwhelming to manage the dependencies, because for every minor or major change, we will also have to modify all the other parts that depend on this particular piece of code. To dodge such situations dependency injection comes handy.
-
-That was quick overview of dependency injection as a whole. Let’s dig deeper and understand it in the context of java.
-
-In java we have loads of classes and to use any class we will have to create an object of that class, with all these different objects dependency of one object on another is unavoidable.
-That doesn’t sound like such a big deal isn’t it? I mean what is so problematic about
-```java
-className object = new className();
-```
-Well it is, the moment we declare the new object we have made the program implementation concrete and endorsed tight coupling and now this doesn’t sound good, right? Hence, we require dependency injection. Dependency injection helps this scenario by acting as an external agent which will provide these dependencies for us. Concepts like dependency injection containers are responsible for creating such objects and injecting them in the places required, the Spring framework offers to be this external agent in java.
-
-
-Other reason why tight coupling is avoided is “testing”. Tight coupling makes it hard to perform black box testing of the application. (Black-box testing is a method of software testing that examines the functionality of an application without peering into its internal structures or workings.)
-# Autowiring
-Autowiring is a feature of spring framework wherein the spring container injects the dependencies automatically. Before the spring framework, dependencies have to be manually injected by the programmer.
-
-Before we dig deeper in Autowiring, the concept of "beans" must be made clear.
-- Beans
-
-Dependency injection in spring is possible because spring behaves as a container of beans; it’s like a factory of beans. These beans are nothing but the objects that we talked about a while ago. All the objects that the dependency injection creates are called beans. In spring, the container is known as the spring container. Inside this container we can have as many objects/beans and the spring container manages them: their lifecycles, injection, instantiation and destruction. With this we are not required to create new objects with new keyword method, rather the spring container will do that for us, in addition, it will also manage them.
-
-
-## Autowiring in java can be achieved in two ways.
-1) XML configuration
-2) Annotations
-# Autowiring using XML
-To practically demonstrate Autowiring using xml firstly we need to make two classes under the same package that depends on each other.
-```java
-class Company
-{
- private Product prod;
-
- public Product getProduct()
- {
- return prod;
- }
-
- public void setProduct()
- {
- this.prod= prod;
- }
-
- public Company(Product prod)
- {
- this.prod=prod;
- }
-}
-
-class Product
-{
- private float price;
- private String modelNo;
-
- public float getPrice()
- {
- return price;
- }
-
- public void setPrice()
- {
- this.price=price;
- }
- public String getModelNo()
- {
- return modelNo;
- }
-
- public void setModelNo()
- {
- this.modelNo=modelNo;
- }
-
-
-
-}
-```
-We have two classes, company and product. The class product is dependent on Class Company. Now, coming to the injection part. In the .xml configuration file we will have to declare the beans
-```java
-
-
-
-
-
-
-
-
-
-
-
- />
-
-
-```
-
-
-That’s all the .xml file is setup.
-After this the company class will automatically get injected with object/bean of product class.
-
-The interfaces BeanFactory and ApplicationContext represent the Spring IoC container. the ApplicationContext is a sub-interface of the BeanFactory. This application context interface will fetch the bean from the spring ioc container. So, in the main() we need to do some work.
-
-```java
- public static void main(String[] args) {
- ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
- Company comp=context.getBean("prod",Company.class);
- System.out.println(comp); //this will print Company [ prod=Product [ price=34.95 modelNo=IND9970]]
- }
-```
-
-
-## Modes of Autowiring
-1) byName: the bean is searched by name, in this case the property name and the bean name must be same.
-```java
-
-```
-
-2) byType: the search is made on the basis of type, the type of property name and the type of bean must be same but the names can be different.
-```java
-
-```
-
-3) Constructor: the dependency is injected by calling the constructor of the class, the constructor with maximum number of parameters is called.
-```java
-
-```
-
-4) no: this is the default Autowiring mode, it means Autowiring is disabled by default.
-
-# Autowiring using annotations
-With Spring 2.5 we can skip all the drama in xml and easily achieve Autowiring using annotations.
-As the annotation wiring is not enabled in the spring container, it has to be turned on. Inside the xml configuration, between the beans tag include this:
-```java
-
-
-i.e.,
-
-
-
-
-
-
-
-
-```
-
-
- Both XML and annotation based configuration can be made, but the annotation injection is performed before the XML one, so the former will override the latter.
-
-
-Using the annotation wiring, the above company and product problem can be solved by just using @Autowired annotation.
-```java
-@Component
-class Company
-{
- @Autowired
- private Product prod;
-
- public Product getProduct()
- {
- return prod;
- }
-
- public void setProduct()
- {
- this.prod= prod;
- }
-
- public Company(Product prod)
- {
- this.prod=prod;
- }
-}
-
-@Component
-class Product
-{
-
- private float price;
- private String modelNo;
-
- public float getPrice()
- {
- return price;
- }
-
- public void setPrice()
- {
- this.price=price;
- }
- public String getModelNo()
- {
- return modelNo;
- }
-
- public void setModelNo()
- {
- this.modelNo=modelNo;
- }
-
-
-
-}
-```
-That's all !!
-Happy coding :)
-
-
-
-
diff --git a/Backend_Development_With_Java/Backend with Java RoadMap.pdf b/Backend_Development_With_Java/Backend with Java RoadMap.pdf
deleted file mode 100644
index d736cc30a9..0000000000
Binary files a/Backend_Development_With_Java/Backend with Java RoadMap.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/OOPs.md b/Backend_Development_With_Java/Basic_Concepts/OOPs.md
deleted file mode 100644
index 19b8c09ea4..0000000000
--- a/Backend_Development_With_Java/Basic_Concepts/OOPs.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# Introduction to OOPs
-
-**Object Oriented Programming** or (**OOP**) is a programming paradigm or methodology which relies on the concept of **object** and **class**. The concepts in OOPs help programmers to write codes into simple, reusable and understandable pieces. This can be understood with the help of an example - Suppose you are building a larger application with your Text Editor and it has the following features:
-
-1. Has options for Bold, Italics, and Underline
-
-2. Has options for changing the alignment, font family, and font color.
-
-3. Has options for undo and redo.
-
-These are the basic features that a Text Editor should have. So suppose you start building this application from scratch. It wouldn't be a good practice that you write all the functions that perform those above-mentioned features in a single file, this would bring up several complexities in the development of software of a larger scale like _debugging_ the code would be very confusing since it would take a lot of time which piece of code could be causing that error.
-
-Let's try a different approach for a program - Try writing the functions which will perform the above-mentioned features in different files and then compile them in a single file. This would help programmers in several numbers of ways. Your code would be **modular**, **simple** to understand, and above all, it would be **reusable**. You could use those functions at any other point in a different application that might have the same feature or a certain upgrade in the same functionality.
-
-In the introduction you came across two words **class** and **object**. So let us try to understand those in much more depth.
-
-## Object
-
-Any entity that has a state and behavior is known as an object. It can be defined as an instance of a class that contains some logical functions and takes up some space in memory.
-
-## Class
-
-Collection of objects can be said to as a _class_. It is a logical entity. It can also be said to be a blueprint that can be used to create more specific and concrete objects.
-
-Those above are programming world definitions.
-
-Let us understand with a real-world example.
-
-**Car** can be considered as a real-world equivalent to **class** which has some properties which are to be operated on by functions or methods -
-
-1. **repaint the car** - change the color of the car
-
-2. **play music** - plays music/radio from the soundbox in the car
-
-3. **fill up petrol tank** - fill the petrol tank to run the car
-
-and many more.
-
-Some common properties that every car might contain - soundbox, tires, engine, petrol tank, windshields, wipers, and many more.
-
-Now suppose I want to create a car that has all the above features as a base and I could modify them or add more features to that car. This car of mine can be considered as an **object** derived from the **class Car**. You also would have heard about different car models which are just objects of class Car with new features and some modifying the old ones.
-
-
-
-
-
-There are several languages that implement this programming approach - _JAVA, C++, C, Simula_
-
-Let's dive deep into the concept of OOP:
-
-Some of the concepts provided by OOPs are:
-
-1. Object
-2. Class
-3. Inheritance
-4. Abstraction
-5. Polymorphism
-6. Encapsulation
-
-
-
-
-
-
-
-
-## Inheritance
-
-When one _object acquires all the properties of the parent class_, it is known as **inheritance**. It provides code reusability.
-
-In the example of Car and myCar explained by the flowchart in fig. 1, we could see that myCar acquires all the properties of the main class Car with some addition to the existing features. This is also a kind of inheritance (**single-level**). In creating myCar I didn't need to create it from scratch I just had to work on the existing basic Car model and modify it. This is an example of reusability.
-
-## Polymorphism
-
-_If one task is performed in different ways_, it is known as **polymorphism**.
-
-Example: To communicate with people we might use different languages but at the core we still are trying to share the same thoughts, drawing a shape be it oval, circle, square, or rectangle, different animals make the sound in different ways.
-
-In JAVA, we use **method overloading** and **method overriding** to achieve polymorphism.
-
-
-
-
-
-
-
-
-
-
-
-
-
-## Abstraction
-
-_Hiding internal details and showing functionality_ is known as **abstraction**.
-
-
-
-
-
-
-
-In the above image, you can see that a man is requesting money from the ATM, but he is unable to see what process or algorithm run behind that enables the ATM to give the exact required amount of cash. This is an example of abstraction.
-
-In JAVA we achieve abstraction through **abstract classes** and **interface**
-
-## Encapsulation
-_Binding (or wrapping) data code and data together in a single unit_ are known as **encapsulation**.
-
-For example, whenever you take a medicine in the form of a capsule, its outer covering holds the content of medicine together inside it (binding in a single unit), also in programming world-class encapsulates all the attributes and functions together.
-
-
-
-
-
-
-
-
-
-## Reference links
-
-1. [JavatPoint](https://www.javatpoint.com/java-oops-concepts)
\ No newline at end of file
diff --git a/Backend_Development_With_Java/Basic_Concepts/assets/objectClass.jpg b/Backend_Development_With_Java/Basic_Concepts/assets/objectClass.jpg
deleted file mode 100644
index 15431bff65..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/assets/objectClass.jpg and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/assets/shapes.jpg b/Backend_Development_With_Java/Basic_Concepts/assets/shapes.jpg
deleted file mode 100644
index 7efb92c63a..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/assets/shapes.jpg and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Car.class b/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Car.class
deleted file mode 100644
index 5e650355f5..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Car.class and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Ford.class b/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Ford.class
deleted file mode 100644
index 1307f96e01..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Ford.class and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Holden.class b/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Holden.class
deleted file mode 100644
index eea07a25ea..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Holden.class and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Main.class b/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Main.class
deleted file mode 100644
index 26de37b5f1..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Main.class and /dev/null differ
diff --git a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Mitsubishi.class b/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Mitsubishi.class
deleted file mode 100644
index 4007eb0f05..0000000000
Binary files a/Backend_Development_With_Java/Basic_Concepts/polymorphismChallenge/Mitsubishi.class and /dev/null differ
diff --git a/Backend_Development_With_Java/Configurations/.DS_Store b/Backend_Development_With_Java/Configurations/.DS_Store
deleted file mode 100644
index 8f1d98383c..0000000000
Binary files a/Backend_Development_With_Java/Configurations/.DS_Store and /dev/null differ
diff --git a/Backend_Development_With_Java/Configurations/Java_Annotations.md b/Backend_Development_With_Java/Configurations/Java_Annotations.md
deleted file mode 100644
index ee1a025295..0000000000
--- a/Backend_Development_With_Java/Configurations/Java_Annotations.md
+++ /dev/null
@@ -1,196 +0,0 @@
-### Java Annotations
-
----
-
-##### Introduction:
-
-- Annotations are used to provide supplement information about a program.
-- Annotations usually start with a '@'
-- Annotations help to associate metadata (information or data about data) to the program elements i.e. instance variables, constructors, methods, classes, etc.
-- Annotations are not pure comments as they can change the way a program is treated by compiler.
-
-##### Built-In Java Annotations:
-
-Java defines a set of annotations that are built into the language. Of the seven standard annotations, three are part of java.lang, and the remaining four are imported from java.lang.annotation.
-
-Annotations applied to Java code:
-
-- `@Override` - Checks that the method is an override. Causes a compilation error if the method is not found in one of the parent classes or implemented interfaces.
-- `@Deprecated` - Marks the method as obsolete. Causes a compile warning if the method is used.
-- `@SuppressWarnings` - Instructs the compiler to suppress the compile time warnings specified in the annotation parameters.
-
-Annotations applied to Meta Annotations:
-
-- `@Retention` - Specifies how the marked annotation is stored, whether in code only, compiled into the class, or available at runtime through reflection.
-- `@Documented` - Marks another annotation for inclusion in the documentation.
-- `@Target` - Marks another annotation to restrict what kind of Java elements the annotation may be applied to.
-- `@Inherited` - Marks another annotation to be inherited to subclasses of annotated class (by default annotations are not inherited by subclasses).
-
-Since Java 7, three additional annotations have been added to the language.
-
-- `@SafeVarargs` - Suppress warnings for all callers of a method or constructor with a generics varargs parameter, since Java 7.
-- `@FunctionalInterface` - Specifies that the type declaration is intended to be a functional interface, since Java 8.
-- `@Repeatable` - Specifies that the annotation can be applied more than once to the same declaration, since Java 8.
-
-Some Examples of Built-In Annotations:
-
-```
-public class MyParentClass {
-
- public void randomMethod() {
- System.out.println("Parent class method");
- }
-}
-
-
-public class MyChildClass extends MyParentClass {
-
- @Override
- public void randomMethod() {
- System.out.println("Child class method");
- }
-}
-```
-
-```
-import java.util.*;
-
-class TestAnnotation2{
- @SuppressWarnings("unchecked")
- public static void main(String args[]){
- ArrayList list=new ArrayList();
- list.add("sonoo");
- list.add("vimal");
- list.add("ratan");
-
- for(Object obj:list){
- System.out.println(obj);
- }
- }
-}
-```
-
-```
-class A{
-void m(){System.out.println("hello m");}
-
-@Deprecated
-void n(){System.out.println("hello n");}
-}
-
-class TestAnnotation3{
-public static void main(String args[]){
-
-A a=new A();
-a.n();
-}}
-```
-
-##### Custom Annotations:
-
-Annotation type declarations are similar to normal interface declarations. An at-sign (@) precedes the interface keyword. Each method declaration defines an element of the annotation type. Method declarations must not have any parameters or a throws clause. Return types are restricted to primitives, String, Class, enums, annotations, and arrays of the preceding types. Methods can have default values.
-
-ex:
-
-```
- // @Twizzle is an annotation to method toggle().
- @Twizzle
- public void toggle() {
- }
-
- // Declares the annotation Twizzle.
- public @interface Twizzle {
- }
-```
-
-Some key points to remember while using Custom Annotations:
-
-1. Method should not have any throws clauses
-2. Method should return one of the following: primitive data types, String, Class, enum or array of these data types.
-3. Method should not have any parameter.
-4. We should attach @ just before interface keyword to define annotation.
-5. It may assign a default value to the method.
-
-##### Types of Annotations:
-
-1. Marker Annotation
-2. Single-Value Annotation
-3. Multi-Value Annotation
-
-- Marker Annotation: An annotation that has no method, is called marker annotation. The @Override and @Deprecated are marker annotations.
- ex:
-
-```
-@interface MyAnnotation{}
-```
-
-- Single-Value Annotation: An annotation that has one method, is called single-value annotation.
- ex:
-
-```
-@interface MyAnnotation{
-int value();
-}
-```
-
-- Multi-Value Annotation: An annotation that has more than one method, is called Multi-Value annotation.
- ex:
-
-```
-@interface MyAnnotation{
-int value1();
-String value2();
-String value3();
-}
-```
-
-##### Built-In Annotations used in custom annotations in Java:
-
-- `@Target`
-- `@Retention`
-- `@Inherited`
-- `@Documented`
-
-@Target tag is used to specify at which type, the annotation is used.
-The java.lang.annotation.ElementType enum declares many constants to specify the type of element where annotation is to be applied such as TYPE, METHOD, FIELD etc.
-ex:
-
-```
-@Target(ElementType.TYPE)
-@interface MyAnnotation{
-int value1();
-String value2();
-}
-```
-
-@Retention annotation is used to specify to what level annotation will be available.
-ex:
-
-```
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-@interface MyAnnotation{
-int value1();
-String value2();
-}
-```
-
-@Inherited By default, annotations are not inherited to subclasses. The @Inherited annotation marks the annotation to be inherited to subclasses.
-ex:
-
-```
-@Inherited
-@interface ForEveryone { }
-//Now it will be available to subclass also
-
-@interface ForEveryone { }
-class Superclass{}
-
-class Subclass extends Superclass{}
-```
-
-The @Documented Marks the annotation for inclusion in the documentation.
-
----
-
-Credits: GeeksforGeeks, javaTpoint, Wikipedia
diff --git a/Backend_Development_With_Java/Configurations/Java_and_Spring_Annotations.ipynb b/Backend_Development_With_Java/Configurations/Java_and_Spring_Annotations.ipynb
deleted file mode 100644
index c9e27059dd..0000000000
--- a/Backend_Development_With_Java/Configurations/Java_and_Spring_Annotations.ipynb
+++ /dev/null
@@ -1,269 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "name": "Java and Spring Annotations.ipynb",
- "provenance": [],
- "collapsed_sections": []
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
- },
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "v2by048j9ysr"
- },
- "source": [
- "#Java Annotations\n",
- "\n",
- "Yes I know we are doing Spring framework and backend development with Java but let us revise basic Java annotations first.\n",
- "\n",
- "Annotations help to store the metadata of the program and they start with a @ sign.\n",
- "\n",
- "It is a great alternative to XML and Java marker interfaces.\n",
- "\n",
- "The below image explains the structure of Java annotations.
\n",
- "\n",
- "\n",
- "Built-In Java Annotations used in Java code\n",
- "\n",
- "* @Override\n",
- "* @SuppressWarnings\n",
- "* @Deprecated\n",
- "\n",
- "\n",
- "Built-In Java Annotations used in other annotations (meta-annotations)\n",
- "* @Target\n",
- "* @Retention\n",
- "* @Inherited\n",
- "* @Documented\n",
- "\n",
- "##Built-in annotations\n",
- "\n",
- "* @Override: @Override annotation assures that the subclass method is overriding the parent class method. If it is not so, compile time error occurs.\n",
- "\n",
- "* @SuppressWarnings: @SuppressWarnings annotation is used to suppress warnings issued by the compiler.\n",
- "\n",
- "* @Deprecated: @Deprecated annoation marks that this method is deprecated so compiler prints warning. It informs user that it may be removed in the future versions. So, it is better not to use such methods.\n",
- "\n",
- "##Custom annotations\n",
- "\n",
- "Java Custom annotations or Java User-defined annotations are easy to create and use. The @interface element is used to declare an annotation.\n",
- "\n",
- "###Types of Java annotations\n",
- "\n",
- "\n",
- "\n",
- "1. Marker Annotation\n",
- "2. Single value annotation\n",
- "3. Multi-value annotation\n",
- "\n",
- "An annotation that has no method, is called marker annotation. For example:\n",
- "`@interface MyAnnotation{} `\n",
- "\n",
- "An annotation that has one method, is called single-value annotation. For example:\n",
- "\n",
- "\n",
- "\n",
- "```\n",
- "@interface MyAnnotation{ \n",
- "int value(); \n",
- "}\n",
- "```\n",
- "\n",
- "An annotation that has more than one method, is called Multi-Value annotation. For example:\n",
- "\n",
- "```\n",
- "@interface MyAnnotation{ \n",
- "int value1(); \n",
- "String value2(); \n",
- "String value3(); \n",
- "} \n",
- "} \n",
- "```\n",
- "\n",
- "#Spring annotations\n",
- "\n",
- "Alright let's come back to Spring now that we had a quick overview of annotations in core Java programming.\n",
- "\n",
- "###Spring core annotations\n",
- "\n",
- "* @Required: This is applied on Bean Setter methods. It is used when you want to enforce a required property. It indicates that the annotated bean must be populated at configuration time with the required property, else it throws an exception BeanInitilizationException. \n",
- "\n",
- "Example: \n",
- "\n",
- "```\n",
- "public class Bike \n",
- "{ \n",
- " private Integer amount; \n",
- " \n",
- " @Required \n",
- " public void setAmount(Integer amount) \n",
- " { \n",
- " this.amount = amount; \n",
- " } \n",
- " \n",
- " public Integer getAmount() \n",
- " { \n",
- " return amount; \n",
- " } \n",
- "} \n",
- "```\n",
- "\n",
- "* @Autowired: We use @autowired to mark the dependencies which Spring is going to handle for us. This saves us from configuring the dependencies in a XML file.\n",
- "\n",
- "When you use @Autowired on fields and pass the values for the fields using the property name, Spring will automatically assign the fields with the passed values\n",
- "\n",
- "Example: \n",
- "\n",
- "```\n",
- "@Component \n",
- "public class Customer \n",
- "{ \n",
- " private Person person; \n",
- " \n",
- " @Autowired \n",
- " public Customer(Person person) \n",
- " { \n",
- " this.person=person; \n",
- " } \n",
- "\n",
- "} \n",
- "```\n",
- "\n",
- "* @Configuration: It defines bean classes. ava class annotated with @Configuration is a configuration by itself and will have methods to instantiate and configure the dependencies.\n",
- "\n",
- "```\n",
- "@Configuration \n",
- "public class Dog \n",
- "{ \n",
- " @BeanDog leg() \n",
- " { \n",
- " return new Dog(); \n",
- " } \n",
- "} \n",
- "```\n",
- "\n",
- "* @Bean: It is a method leval annotation to instantiate beans. It tells Spring to manage a bean by Spring Container.\n",
- "\n",
- "```\n",
- "@Bean \n",
- "public Example mrbean() \n",
- "{ \n",
- "return new Example (); \n",
- "} \n",
- "```\n",
- "\n",
- "* @ComponentScan: It is used when we want to scan a package for beans. It is used with @Configuration. We can also specify the base packages to scan for Spring Components.\n",
- "\n",
- "```\n",
- "@ComponentScan(basePackages = \"com.yash\") \n",
- "@Configuration \n",
- "public class ScanComponent \n",
- "{ \n",
- " // code\n",
- "} \n",
- "```\n",
- "\n",
- "#Stereotype annotation\n",
- "\n",
- "Annotations denoting the roles of types or methods in the overall architecture (at a conceptual, rather than implementation, level).\n",
- "\n",
- "* @Component: It is used to mark a Java class as a bean. The Spring Framework pick it up and configure it in the application context as a Spring Bean.\n",
- "\n",
- "```\n",
- "@Component \n",
- "public class Student \n",
- "{ \n",
- "....... \n",
- "} \n",
- "```\n",
- "* @Controller: It is used to mark a class which handles requests and to mark the controller from the mvc architecture project.\n",
- "\n",
- "```\n",
- "@Controller \n",
- "@RequestMapping(\"students\") \n",
- "public class StudentController \n",
- "{ \n",
- " @RequestMapping(value = \"/{name}\", method = RequestMethod.GET) \n",
- " public Employee getStudentsByName() \n",
- " { \n",
- " return studentTemplate; \n",
- " } \n",
- "} \n",
- "```\n",
- "\n",
- "* @Service: It is used to mark a Spring class that contains business logic.\n",
- "\n",
- "``` \n",
- "@Service \n",
- "public class Test \n",
- "{ \n",
- " public void service1() \n",
- " { \n",
- " //business code \n",
- " } \n",
- "} \n",
- "```\n",
- "\n",
- "* @Repository: This is used to mark the DAO (Data Access Object) classes.\n",
- "@Repository is used for classes that deal with database operations.\n",
- "```\n",
- "public class TestRepository \n",
- "{ \n",
- " public void delete() \n",
- " { \n",
- " //persistence code \n",
- " } \n",
- "} \n",
- "```\n",
- "\n",
- "###Spring boot annotations\n",
- "\n",
- "* @SpringBootApplication: Used to mark a Spring Boot application\n",
- "\n",
- "###Spring Web/MVC annotations\n",
- "\n",
- "* @GetMapping: Used to map the GET requests to a method which handles it.\n",
- "* @PostMapping: Used to map the POST requests to a method which handles it.\n",
- "* @PutMapping: Used to map the PUT requests to a method which handles it.\n",
- "* @DeleteMapping: Used to map the DELETE requests to a method which handles it.\n",
- "* @PatchMapping: Used to map the PATCH requests to a method which handles it.\n",
- "* @RequestBody: It is used to bind HTTP request with an object in a method parameter. \n",
- "* ResponseBody: It is used to bind value returned by the body to the response body.\n",
- "* @PathVariable: Used to create REST APIs.It is used to extract the values from the URI.\n",
- "\n",
- "* @RequestParam: Used to get parameters from a query which is present in a URL.\n",
- "* @RequestHeader: It is used to get the details about the HTTP request headers.\n",
- "* @RestController: It is used to declare a controller which is used to make REST APIs. It can be considered as a combination of @Controller and @ResponseBody annotations.\n",
- "\n",
- "* @RequestAttribute: t binds a method parameter to request attribute. It provides convenient access to the request attributes from a controller method. With the help of @RequestAttribute annotation, we can access objects that are populated on the server-side.\n",
- "\n",
- "
\n",
- "sources used: https://www.javatpoint.com/spring-boot-annotations \n",
- "https://www.baeldung.com/spring-core-annotations \n",
- "https://www.javatpoint.com/java-annotation\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "\n"
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/Backend_Development_With_Java/Configurations/POM_xml_file_configuration.ipynb b/Backend_Development_With_Java/Configurations/POM_xml_file_configuration.ipynb
deleted file mode 100644
index 85da69c5f5..0000000000
--- a/Backend_Development_With_Java/Configurations/POM_xml_file_configuration.ipynb
+++ /dev/null
@@ -1,96 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "name": "POM.xml file configuration.ipynb",
- "provenance": [],
- "collapsed_sections": []
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
- },
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "3QiQPxN2N5m8"
- },
- "source": [
- "#POM.xml\n",
- "\n",
- "When you create a Maven project in your editor, you will see a pom.xml file in the project folder itself. Something like this.\n",
- "\n",
- "\n",
- "\n",
- "Now what is a pom.xml file. POM stands for Project Object Model. It contains all the information of your project like the configurations, dependencies, plugins, etc.\n",
- "
\n",
- "Maven reads the xml and runs it accordingly. Now what is the benefit of it. You do not have to download every dependency. Say, if you wanted to include MySQL in your project, you would have to install the .jar files and configure them in your project. Similarly, each dependency would have to be added manually. Now how many would you add like that? Some dependencies or plugins even have dependencies for themselves so they can run. For example you want to include a payment option in your project and say the dependency for the payment option you want to use has further many dependencies for itelf to run.\n",
- "
\n",
- "\n",
- "But it is quite simple to add a few lines of xml code to your pom.xml file and not having to go through the hassle of adding every small dependency file to your project. Now let's configure Spring framework in our pom.xml file so that we can configure it and get started with backend development in Spring framework.\n",
- "
\n",
- "To work with Spring framework or let's say to perform backend development with Java even without framework, we use something called servlet API to implement our servlets. If you are new to servlets, don't worry they are just a type of interfaces which enable to do development with java. So go to google and just type servlet api maven. You will see a link with an mvnrepository.com URL. \n",
- "\n",
- "\n",
- "
\n",
- "Go there and just copy the xml code and paste it in your pom.xml and save it. This will now enable us to use servlets in our project. \n",
- "\n",
- "Now in the next step, we have to add spring configurations to enable Spring framework in our project.\n",
- "\n",
- "Spring framework consists of features organized into 20 modules. These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, and Test, as shown in the following diagram.\n",
- "\n",
- "\n",
- "\n",
- "Image source: https://docs.spring.io/spring-framework/docs/3.0.x/spring-framework-reference/html/overview.html\n",
- "\n",
- "###Core container\n",
- "\n",
- "The Core Container consists of the Core, Beans, Context, and Expression Language modules.\n",
- "\n",
- "The core module is the life of Spring. It implements the singleton design patter which is what Spring mainly does, i.e, making the program efficient and making the life of a programmer easy. It implements the soul of Spring, IOC container and dependency injection which we will study later. This module contains the BeanFactory, an implementation of factory pattern which creates the bean as per the configurations provided by the developer in an xml file.\n",
- "\n",
- "The context module inherits its features from Beans module. According to the official Spring documentation, \"Context module inherits its features from the Beans module and adds support for internationalization (using, for example, resource bundles), event-propagation, resource-loading, and the transparent creation of contexts by, for example, a servlet container.\"\n",
- "\n",
- "The language may be heavy but don't worry if you do not get it, you will still be able to do everything.\n",
- "\n",
- "Expression Language (EL) module is like JSP with powers. It is written inside JSP only. It simplifies accessing data like request, session, application etc.\n",
- "\n",
- "###Web\n",
- "The web module contains mvc features which you will need to implement Spring Web/Spring MVC features. It also integrates well with the most popular mvc frameworks like struts, tapestry, jsf, wicket etc.\n",
- "\n",
- "###AOP\n",
- "\n",
- "The aspect oriented programming module allows developers to define method-interceptors and point cuts to keep the concerns apart. it is configured at run time so the compilation step is skipped. it aims at declarative transaction management which is easier to maintain.\n",
- "\n",
- "###Data Access/ Integration\n",
- "\n",
- "This is the database-related or integrations part. For example you will add an JDBC API dependency for database operations or an ORM framework like Hibernate.\n",
- "\n",
- "Don't worry if you did not understand any of the above things. You will learn about them in the future.\n",
- "\n",
- "###What to have to get started.\n",
- "\n",
- "Initially to get started, you should add Core, Beans, Context, Expression Language(No need to add EL dependency separately), Servlet and Spring Web/MVC dependency to get started with your Spring project.\n",
- "\n",
- "Just google them and and you will find the xml code just like we did for the servlet API above. For Spring dependencies i.e, Core, Beans, Context, Web, or any other Spring module that you add, make sure that the versions are same otherwise there are chances of errors. After doing this your pom.xml file should look like this.\n",
- "\n",
- "\n",
- "
\n",
- "\n",
- "\n",
- "\n",
- "\n",
- "Inspiration for some of the parts for this article were taken from:\n",
- "https://dzone.com/articles/spring-framework-architecture#:~:text=the%20spring%20framework%20is%20a,in%20the%20enterprise%20application%20development.\n",
- "\n",
- "https://docs.spring.io/spring-framework/docs/3.0.x/spring-framework-reference/html/overview.html"
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/Backend_Development_With_Java/Configurations/custom_annotation_documentation.ipynb b/Backend_Development_With_Java/Configurations/custom_annotation_documentation.ipynb
deleted file mode 100644
index bcc946aaf9..0000000000
--- a/Backend_Development_With_Java/Configurations/custom_annotation_documentation.ipynb
+++ /dev/null
@@ -1,149 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
- "colab": {
- "name": "custom_annotation_documentation.ipynb",
- "provenance": [],
- "collapsed_sections": []
- },
- "kernelspec": {
- "name": "python3",
- "display_name": "Python 3"
- },
- "language_info": {
- "name": "python"
- }
- },
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "LhSx555GPdUi"
- },
- "source": [
- "# CUSTOM ANNOTATION \n",
- "\n",
- "---\n",
- "\n",
- "Annotations are information about data i.e are metadata. Annotations are like comments in a source code. But they offer more than just comments. There are several builds in annotations in Java but we can create annotations to satisfy our requirements. \n",
- "\n",
- "\n",
- "Firstly a custom annotation looks something like this : \n",
- "\n",
- "```\n",
- "@Documented\n",
- "@Target(ElementType.TYPE)\n",
- "@Inherited\n",
- "@Retention(RetentionPolicy.SOURCE)\n",
- "public @interface annotationName{\n",
- "\tString methodWithDefaultValue() default 'defaultValue';\n",
- "\tString methodWithoutDefaultValue();\n",
- "}\n",
- "\n",
- "```\n",
- "\n",
- "Now, let's break this piece of code down, \n",
- "\n",
- "The part \"public @interface annotationName\" is the annotation declaration.\n",
- "\n",
- "Annotations are declared using the @ sign followed by the \"interface\" keyword. Then the name of the annotation, in this case, \"annotationName\". Each annotation can have zero or more methods in it. These methods do not have any parameters or \"throws\" keyword. An Annotation can have methods with default values and also methods without any default values. \n",
- "\n",
- "\n",
- "---\n",
- "\n",
- "## TYPE OF ANNOTATIONS :\n",
- "\n",
- "There are 3 types of annotations :\n",
- " 1. **Market Annotations**: \n",
- " Annotation which does not have any methods/elements.\n",
- "```\n",
- "public @interface markerAnnotationEg {} \n",
- "```\n",
- "\n",
- "2. **Single-Value Annotation**:\n",
- "Annotation that has one/single element.\n",
- "```\n",
- "public @interface singleValueAnnotationEg{\n",
- "\tint numericValue;\n",
- "}\n",
- "```\n",
- "\n",
- "3. **Multi_value Annotation**:\n",
- "Annotations that have more than one element.\n",
- "```\n",
- "public @interface multiValueAnnotationEg{\n",
- "\tint methodThatRetunsIntValue();\n",
- "\tString methodThatReturnsStringValue() default 'STRINGDEFAULT';\n",
- "}\n",
- "```\n",
- "\n",
- "\n",
- "\n",
- "---\n",
- "\n",
- "## META ANNOTATION :\n",
- "\n",
- "\n",
- "The lines above the \"public @interface annotationName\" are called META ANNOTATION.\n",
- "\n",
- "There are 5 types of Meta Annotations : \n",
- "1. **@Documentation:** This is used to specify that this annotation is to be included in the documentation. By default, annotations are not included for documentation.\n",
- "\n",
- "2. **@Target:** This is a meta-annotation that specifies where the annotation is applied at e.g annotation is to be applied at the METHOD level, Filed Level, Constructor Level, etc.\n",
- "We can specify this using an already declared enum ElementType in the java.lang.annotation package. This enum consist of constants: FIELD, TYPE, METHOD, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PARAMETER.\n",
- "\n",
- "3. **@Inherited:** Annotations are not inheritable by any subclass by default, But using this meta-annotation we can mark such as it can be inherited by subclasses.\n",
- "\n",
- "4. **@Retention:** using this meta-annotation we can specify the existence of the annotation.\n",
- "This can have 3 values: SOURCE, CLASS, RUNTIME. These values are constants declared in the java.lang.annotation.RententionPolicy. \n",
- "SOURCE: This means that annotation will be removed from the compilation and won't be included in the class file.\n",
- "CLASS: This means that annotation will be included in the compiled class file.\n",
- "RUNTIME: This means that annotation will be processed during runtime. \n",
- "\n",
- "5. **@Repeated:** When we want that the annotation can be applied to a particular code multiple times.\n",
- "\n",
- "\n",
- "---\n",
- "## CALLING ANNOTATION : \n",
- "Once the Annotation is defined, all that's left is to call the annotation to use it. \n",
- "\n",
- "Annotations when used consist of a @ sign along with the annotation name and list of element-value pairs. Such as : \n",
- "\n",
- "1. **Calling a Marker annotation** :\n",
- "```\n",
- "@markerAnnotationEg\n",
- "public class className{ ... }\n",
- "```\n",
- "\n",
- "2. **Calling a single Value Annotation** :\n",
- "```\n",
- "@singleValueAnnotationEg(numbericMethod = 10)\n",
- "public class className{ ... } \n",
- "OR \n",
- "@singleValueAnnotationEg(10)\n",
- "public class className{ ... } \n",
- "```\n",
- "\n",
- "3. **Calling a multiValue Annotation** : \n",
- "```\n",
- "@multiValueAnnotationEg(methodThatRetunsIntValue = 10)\n",
- "public class className{ ... } \n",
- "// in this case the methodThatReturnsStringValue will use the default value. \n",
- "OR\n",
- "@multiValueAnnotationEg(methodThatRetunsIntValue = 10,methodThatReturnsStringValue='NEWSTRINGVALUE')\n",
- "public class className{ ... }\n",
- "```\n",
- "---\n",
- "\n",
- "\n",
- "\n",
- "*That's all for the custom annotations, Thanks for joining me.* \n",
- "\n",
- "\n",
- "\n",
- "\n"
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/Backend_Development_With_Java/Hibernate Queries & Annotations/Hibernate Queries & Annotations.pdf b/Backend_Development_With_Java/Hibernate Queries & Annotations/Hibernate Queries & Annotations.pdf
deleted file mode 100644
index b5ff1b98cc..0000000000
Binary files a/Backend_Development_With_Java/Hibernate Queries & Annotations/Hibernate Queries & Annotations.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Hibernate/Intoduction to Hibernate.pdf b/Backend_Development_With_Java/Hibernate/Intoduction to Hibernate.pdf
deleted file mode 100644
index b827a03062..0000000000
Binary files a/Backend_Development_With_Java/Hibernate/Intoduction to Hibernate.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Java Persistence API/Java Persistent API.pdf b/Backend_Development_With_Java/Java Persistence API/Java Persistent API.pdf
deleted file mode 100644
index 8c9e9a67bd..0000000000
Binary files a/Backend_Development_With_Java/Java Persistence API/Java Persistent API.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Java_OOPs/Inheritance in Java(Java OOPs Concepts).pdf b/Backend_Development_With_Java/Java_OOPs/Inheritance in Java(Java OOPs Concepts).pdf
deleted file mode 100644
index ac132a2ebe..0000000000
Binary files a/Backend_Development_With_Java/Java_OOPs/Inheritance in Java(Java OOPs Concepts).pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Java_OOPs/Streams.md b/Backend_Development_With_Java/Java_OOPs/Streams.md
deleted file mode 100644
index 096643ca93..0000000000
--- a/Backend_Development_With_Java/Java_OOPs/Streams.md
+++ /dev/null
@@ -1,171 +0,0 @@
-
Prerequisites
-
-* Java Loops
-* OOPS
-* Optional Usage
-* Kindly, take the liberity to google basic definition of streams before proceeding with this tutorial
-* https://www.geeksforgeeks.org/stream-in-java/
-
-
If you are looking to simplify your boring code, yet finish up the task. You are in a right place, what java offers you is a powerful functionality called streams. Streams combined with collections is a match made in heaven. In this tutorial, we will cover functions provided by Stream API
-
-Let's say you are writing code for sifting all the ready to eat items from a mix of items you bought at a local store. Let's represent each item as an object with three attributes , Item-name and isReadyToEat and Price for each item. The data types used to represent these three properties of each item are String, Boolean and Integer.
-
-Let's say we have following items in our bag,
-
-
Sample Example 1
-
-| Item Name | ReadyToEat | Price /- |
-| ------------- |:-------------:| :-------------:|
-| Bananas | True | 40 |
-| Ice cream | True | 200 |
-| Mason Jar | False | 100 |
-| Tube Light | False | 109 |
-| Chocolate | True | 60 |
-
-So we can have a class named item, with three attributes/state - name,isReadyToEat,price. In Java syntax we can write like this.
-
-````
-public class Item
-{
- String name;
- Boolean isReadyToEat;
- Integer price;
-
- ----Constructors-----
-
- ----Getters And Setters----
-}
-
-````
-And now, Let's assume we have an arrayList say **items**, of Type item with values as we discussed in the sample example 1. Now to filter out all the eatable items and place it in an arraylist named as **eatableItems** , as a java developer you would code something like this.
-
-
-````
-List eatableItems = new ArrayList();
-
-for(Item item : items)
-{
- if(item.isReadyToEat.equals(true))
- {
- eatableItems.add(item);
- }
-}
-
-````
-
-This approach is called an imperative approach, and could lead to a lot of redundancy , monotony, bugs and issues in a large code base. Now, how to avoid such situations? Java Streams come to our rescue. Instead of writing this monotonous code, we can simply ask streams what we want in our collection. This is called a declarative approach. Streams are very powerful and support methods like
-
- * Filter
- * Sort
- * All Match
- * Any Match
- * None Match
- * Max
- * Min
-
-
-
-
Filter
-So let's go ahead and start with filter, the first step is to convert items into a stream. This can be done by saying items.stream(), from now you simply need to ask what we want. We want to filter based on a condition which takes in a predicate and returns true or false. So, we do items.stream().filter(item -> item.isReadyToEat.equals(true)). Now that we performed a filter action we need to collect this information to a list. For that we can simply say, items.stream().filter(item -> item.isReadyToEat.equals(true)).collect(Collectors.toList()). Here is a clear picture
-
-List eatableItems = items.stream().filter(item -> item.isReadyToEat.equals(true)).collect(Collectors.toList())
-
-If you print the above list output will be
-
-Output:
-
-
-````
-Bananas true 40
-Ice Cream true 200
-Chocolate true 60
-
-````
-
-
Sort
-
-For sorting, we convert the list to a stream and then call sorted which takes in a comparator, within this we can give based on what value we are aiming to sort this collection(our list). And then we perform a terminal operation which is collecting this result to a list.
-
-
-List eatableItems = items.stream().sorted(Comparator.comparing(item->item.name)).collect(Collectors.toList())
-
-
-Output if you print the above list:
-
-````
-Bananas true 40
-Chocolate true 60
-Ice Cream true 200
-Mason Jar false 100
-Tube Light false 109
-
-````
-
-
All Match
-
-If you want to know if all the items in the list are eatables, then you can use allMatch(condition) which returns a boolean value.
-
-Boolean allMatch = items.stream().allMatch(item->item.isReadyToEat.equals(true));
-
-Since, we also have items which are not ready to eat (i.e items readyToEat set as false). We will get our output as
-
-````
-False
-
-````
-
-
Any Match
-
-
-Similarly, anyMatch checks for atleast one match and if it is satisfied, it will return true
-
-Boolean anyMatch = items.stream().anyMatch(item->item.isReadyToEat.equals(true));
-
-
-Since we have atleast one item which is ready to eat, our result will be
-
-````
-True
-
-````
-
None Match
-
-None match checks for the item in the list and if the item is not there it returns true, else it returns false.
-For example, we want to know that strawberry is not one of the items in the list, then you provide noneMatch, saying check if there is any item strawberry in the list, because there is no item named strawberry in the list none match will return true as it didn't find any match for strawberry. Incase, you provide bananas it will return false, because there is an item bananas in the list.
-
-
-Boolean noMatch = items.stream().noneMatch(item->item.name.equals("strawberry"));
-
-````
-True
-
-````
-
-
Max
-
-
-If you ant to find the item with max price, you can get that with help of Max() function in streams.
-
-Optional maxPriceItem = items.steam().max(Comparator.comparing(item->item.price));
-
-If you print the item's name it will be
-
-
-````
-Ice Cream
-
-````
-Reason being Ice Cream has the maximum price amongst the list of items.
-
-
Min
-
-Similarly, we can also find the item with minimum price,
-
-Optional maxPriceItem = items.steam().min(Comparator.comparing(item->item.price));
-
-Here, if you print the item's name it will be... , yes you guessed it right
-
-````
-Bananas
-
-````
diff --git a/Backend_Development_With_Java/Java_OOPs/lambda_expressions.md b/Backend_Development_With_Java/Java_OOPs/lambda_expressions.md
deleted file mode 100644
index cbbf092a46..0000000000
--- a/Backend_Development_With_Java/Java_OOPs/lambda_expressions.md
+++ /dev/null
@@ -1,81 +0,0 @@
- ## Lambda Expression
-Lambda expressions basically express instances of functional interfaces (An interface with single abstract method is called functional interface. An example is java.lang.Runnable). lambda expressions implement the only abstract function and therefore implement functional interfaces
-
-Lambda expressions are added in Java 8 and provide below functionalities.
-
-- Enable to treat functionality as a method argument, or code as data.
-- A function that can be created without belonging to any class.
-- A lambda expression can be passed around as if it was an object and executed on demand.
-
-e.g-
-```java
-interface Lambda{
- public void demo();
-}
-public class App{
- public static void main(String[] args){
- Lambda lambda = ()->{
- System.out.println("statement 1");
- System.out.println("statement 2");
- };
- lambda.demo();
- }
-}
-```
-* Must be a [functional interface](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html) ,i.e., shoudl have exactly one abstract method in the interface class.
-* [Interface Runnable](https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html) is a functional interfact having only one abstract method - void Run(), and can therefore be used as the assignment target for a lambda expression or method reference.
-
-```java
-public class App{
- public static void main(String[] args){
- Thread t1 = new Thread(new Runnable){
- public void run(){
- System.out.println("statement 1");
- }
- }
- t1.start();
- }
-}
-```
-or
-```java
-public class App{
- public static void main(String[] args){
- Thread t1 = new Thread(()->
- System.out.println("statement 1"));
- t1.start();
- }
-}
-```
-* Lambda expressions for [comparator funcitons](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html), e.g. -
-```java
-Collections.sort(listName, (listType o1, litType o2)->o1.getName().compareTo(o2.getName()));
-```
-* [Effectively final variable](https://stackoverflow.com/questions/20938095/difference-between-final-and-effectively-final) concept also applies here, as we saw in the anonymous classes.
-```java
-int x = 10;
-// x++ -> any opertn on x makes it non final.
-new Thread(()->System.out.println("The value of x is : " + x)).start();
-```
-* More examples like using forEach loop
-```java
-List list = new ArrayList<>();
-list.forEach(temp->println(temp.genName())); // simply print all
-```
-* Interface [Predicate](https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html) => a functional interface and represents a predicate (boolean-valued function) of one argument.
-```java
-IntPredicate lestThan18 = new IntPredicate(){
- public boolean test(int value){
- if(value < 18) return true;
- else retur false;
- }
-};
-println(lessThan18.test(12));
-```
-using lambda expression
-```
- IntPredicate lessThan18 = i->i<18;
- IntPredicate moreThan10 = temp -> temp>10;
- System.out.println(lessThan18.
- and(MoreThan10).test(10); // output is true
-```
diff --git a/Backend_Development_With_Java/Maven_Week2/Maven.md b/Backend_Development_With_Java/Maven_Week2/Maven.md
deleted file mode 100644
index f17cfed4cc..0000000000
--- a/Backend_Development_With_Java/Maven_Week2/Maven.md
+++ /dev/null
@@ -1,121 +0,0 @@
-# Important keywords
-
-1. JAR - JAR (**Java Archive**) is a package file format that typically aggregates many java classes, metadata associated with them, and resources into a single file that can distribute software or application over the JAVA platform.
-
-2. POM - Project object model is an XML file that contains information about the project and configuration details used by Maven to build a project,i.e, project dependencies, source code, etc.
-
-3. Localization of plugins - Most of the plugins involved with site generation is internationalized. This means that adapting them to other languages is very easy and this process is called localization.
-
-## Introduction
-
-Before Maven was developed each project had its own **Ant** build files, that were all slightly different. JARs were checked into CVS. So to have a standard way of building a project, a clear definition of what the project consists of, and allow easy sharing of JAR files across several other projects **Maven** was developed.
-
-## Maven's Objectives
-
-Its main objective is to allow a developer to comprehend or understand the complete state of a development effort in the shortest period of time. The main area of Maven's concerns are:
-
-### 1. Making the build process easy
-
-Maven although doesn't eliminate the need to know the underlying mechanisms to develop an application, it shields developers from many details just like abstraction.
-
-### 2. Providing a uniform build system
-
-Maven uses its POM model and set of plugins to develop the project. If a developer learns how to build a single Maven project, he knows how to build all other Maven projects. This saves time when navigating between many projects.
-
-### 3. Providing quality project information
-
-Maven provides useful information related to your project that is in part taken from POM and is in part generated from your project's resources. It can provide:
-
-1. Change log created directly from source control
-2. Dependencies used by project
-3. Unit test reports including coverage
-
-### 4. Encouraging better development practices
-
-Maven aims to gather current principles for best practices development and make it easy to guide a project in that direction.
-
-For example, specification, execution, and reporting of unit tests are part of the normal build cycle using Maven. Current unit-testing best practices were used as guidelines:
-
-1. Keeping test source code in a separate, but parallel source tree
-2. Using test case naming conventions to locate and execute tests
-3. Having test cases setup their environment instead of customizing the build for test preparation
-
-Maven also assists in project workflows such as release and issue management.
-
-Maven also suggests some guidelines on how to layout your project’s directory structure. Once you learn the layout, you can easily navigate other projects that use Maven.
-
-## Maven Plugins
-
-Maven is - at its core - a **plugin execution framework**; all work is done by the plugins themselves. The two types of plugins are:
-
-### 1. Build Plugin
-
-Plugins that are executed during the build and are listed under the `````` element of the POM are called **build plugins**.
-
-### 2. Reporting plugin
-
-These plugins are executed during the site generation and are listed under the `````` element of the POM. As a result of this reporting plugins are a part of the generated site. These plugins should be both internationalized and localized.
-
-To read more about the Maven plugins head over
-[Maven Plugins](https://maven.apache.org/plugins/index.html)
-
-## Maven Dependencies
-
-Managing dependencies for a single project is an easy task but in cases of multi-module projects and applications with hundreds of modules managing dependencies for such a case becomes a tedious task. Here Maven comes into play. Maven helps a great deal in defining, creating, and maintaining reproducible builds with well-defined class paths and library versions.
-
-### Transitive dependencies
-
-Maven avoids the need to specify and discover the libraries that your dependencies require by including **transitive dependencies automatically**. This feature is achieved by - Maven reads the project files of your dependencies from the remote repositories specified. In general, all dependencies of those projects would be used by your project or any project which inherits from those parent projects.
-
-The problem arises when there is a cyclic graph in the dependency tree structure and to limit the number of dependencies that are included there are additional features for this.
-
-1. Dependency Mediation: When multiple versions of a dependency are found, Maven chooses the _nearest definition_ of that dependency, i.e, it picks the version of the closest dependency to your project.
-
-2. Dependency management - this allows project authors to specify specific types of artifacts that will be used when they meet a changing or dependent dependency where the version is not indicated. In the example in the previous section, the reliance was added directly to A even though it was not used directly by A. Instead, A can include D as dependent on its dependence phase, sometimes referred to.
-
-3. Dependency range - this allows you to enter only dependencies that are appropriate for the current construction phase. This is explained in detail below.
-
-4. Exemptions - If project X depends on project Y, and project Y is dependent on project Z, project owner X may explicitly exclude project Z as a dependency, using the term "exclusion".
-
-5. Optional dependence - If project Y depends on project Z, project owner Y can mark project Z as an optional dependency, using the "optional" item. Where project X depends on project Y, X will only rely on Y and not on Y's choice. Project X owner can obviously add a reliance on Z, at his or her discretion. (It may be helpful to think of optional dependence as "automatically issued.")
-
-To read more about the Maven plugins head over to
-[Maven Dependecies](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html)
-
-Sample **pom.xml** file with dependencies and plugins:
-
-```xml
-
- 4.0.1
- Example Maven Project
-
-
-
- maven-clean-plugin
- 2.5
-
-
- default-clean
- clean
-
- clean
-
-
-
-
-
-
-
-
- junit
- junit
- 3.6.1
- test
-
-
-
-```
-
-### Resources
-
-1. [Maven](https://maven.apache.org/index.html)
diff --git a/Backend_Development_With_Java/Multithreading/ThreasClass&RunnableInteface.md b/Backend_Development_With_Java/Multithreading/ThreasClass&RunnableInteface.md
deleted file mode 100644
index 98df67a5ef..0000000000
--- a/Backend_Development_With_Java/Multithreading/ThreasClass&RunnableInteface.md
+++ /dev/null
@@ -1,97 +0,0 @@
-## Multitasking in computers can be achieved in two ways:
-1) Multiprocessing -> this is based on multiple processes being performed at the same time.
-2) Multithreading -> this is based on multiple threads executed at the same time.
-
-Here, we will be talking about multithreading.
-
-# Multithreading
-
-Multithreading, as the name suggests, helps perform multitasking in java. It is a process of executing multiple threads concurrently.
-
-Multithreading is quite famous for reasons like it operates on shared memory, i.e., threads do not allocate separate memory which helps in saving memory and thread shifting takes less time. Hence, it is both memory and time efficient.
-
-Multithreading is also execution efficient, meaning as multiple threads can operate at the same time; it doesn’t block the execution of the program which is a great feature. The main motive of multithreading is the proper utilization of the CPU. Today multi-core processors are available and multithreading makes it possible to take advantage of such processors.
-
-Now, we are quite convinced of why multithreading is needed. So, let’s dig deeper.
-
-## What are threads?
-
-The **orderly flow of control** of a program, the **path** followed in the execution of the program or the **sequential flow of a part of a program** is known as thread. One process can have multiple threads. Threads can also be understood as a **sub-process** or **unit of a process**.
-
- Even though Java supports multithreading, it should not be confused with the fact that at a time only one thread is being executed.
-
-# Java Thread Class
-In Java, multithreading is achieved with the help of thread class (in-built class in java), which in turn provides us with constructors and methods for processing and achieving the desired result using them.
-Some of the methods and their types are provided below as it won’t be feasible to list each and every method over here.
-1) start() [void] -> to start the execution of a program
-2) run() [void] -> to perform an action for a thread
-3) getPriority() [int] -> returns the priority of a thread
-4) setPriority() [void] -> to impose the priority of a thread
-5) currentThread() [static thread] -> reference to the currently executing thread
-
-## Now, how do we achieve threads?
-As thread is an in-built class in java, they can be inherited using the keyword extends:
-
-```Java
-class Multithreading extends Thread
-{
- public void run() //over-riding the run method of thread class
- {
- for(int i=0; i<3; ++i )
- System.out.println("we are learning multihreading");
- }
-}
-
-class ThreadsAndMultithreading()
-{
- public static void main(String[] args)
- {
-
- Multithreading object= new Multithreading();
- object.start(); //start will automatically call run()
- }
-}
-```
-
-Here, we will also be having our main() method which is another thread, we will be calling this function from the main() to execute the run() method, but we will not call run() method directly, rather we will call the start(), [that we saw above] which in turn will automatically call the run() method.
-
-Well, this is not the best way to use the thread class, reason being that the class multithreading might want to extend some other class and since **multiple inheritance** is **not** allowed in java, the class multithreading can only either inherit thread class or the other class that it desires to inherit.
-
-# Java Runnable Interface
-To overcome the problem we faced above due to multiple inheritance in java we use the Runnable interface. Runnable interface is a functional interface and it has only one method i.e., run().
-
-
-
-This picture makes it clear that Thread is a class and Runnable is an interface, both are used for multithreading. Thread class has one of the methods as run() while Runnable has only one method i.e., run().
-
-So as per this our code will also be modified. Lets, have a look at that also.
-
-```java
-class Multithreading implements Runnable
-{
- public void run() {
- for (int i = 0; i < 3; ++i)
- System.out.println("we are learning multihreading");
- }
-}
-class ThreadsAndMultithreading()
-{
- public static void main(String[] args)
- {
-
- Multithreading object= new Multithreading();
- object.start(); // Now this will give error because runnable doesn't have any method called start()
- Thread obj= new Thread();
- obj.start(); // this will not give error but it will also not do anything because it will call the start method of the thread class as it is called by an object of thread class
- Thread obj2 =new Thread(object); //you can pass the object of runnable
- obj.start(); //this will successfully call the method run() of our class multithreading
-
- }
-}
-```
-
-This way of using the thread class with help of Runnable interface is much efficient as it also lets us inherit the class of our choice.
-
-That's all.
-## Happy learning :)
-
diff --git a/Backend_Development_With_Java/Multithreading/img/runnable.jpg b/Backend_Development_With_Java/Multithreading/img/runnable.jpg
deleted file mode 100644
index f0c39cb805..0000000000
Binary files a/Backend_Development_With_Java/Multithreading/img/runnable.jpg and /dev/null differ
diff --git a/Backend_Development_With_Java/Qualifier in Spring (Video)/README.md b/Backend_Development_With_Java/Qualifier in Spring (Video)/README.md
deleted file mode 100644
index 530e0b1f04..0000000000
--- a/Backend_Development_With_Java/Qualifier in Spring (Video)/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# What is Qualifier in Spring?
-
-A video to get knowledge about Qualifier in Spring.
-It contains detail explanation and example about Qualifier.
-
-Link-(https://drive.google.com/file/d/1zWWV0pn-xEA81GDpj4xa5EMAzAe7QPDM/view?usp=sharing
-)
-
-Source code in the video:-
-[**Source Code**](SourceCode.ipynb)
-
-
-
-
diff --git a/Backend_Development_With_Java/Qualifier in Spring (Video)/SourceCode.ipynb b/Backend_Development_With_Java/Qualifier in Spring (Video)/SourceCode.ipynb
deleted file mode 100644
index d41a80ef62..0000000000
--- a/Backend_Development_With_Java/Qualifier in Spring (Video)/SourceCode.ipynb
+++ /dev/null
@@ -1,185 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Source Code\n",
- "\n",
- "1. Apple.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "import org.springframework.stereotype.Component;\n",
- "\n",
- "@Component\n",
- "public class Apple implements FruitPicker {\n",
- "\n",
- "\tpublic void getFruit() {\n",
- "\t\t\n",
- "\t\tSystem.out.println(\"You selected a Apple, 'A Apple a day keeps Doctor away :)'\");\n",
- "\t}\n",
- "\n",
- "}\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "2. Orange.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "import org.springframework.stereotype.Component;\n",
- "@Component\n",
- "\n",
- "public class Orange implements FruitPicker {\n",
- "\n",
- "\tpublic void getFruit() {\n",
- "\t\n",
- "\t\tSystem.out.println(\"You selected a Orange, 'A Orange fruit is always good :)'\");\n",
- "\t}\n",
- "\n",
- "}\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "3. FruitPicker.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "public interface FruitPicker {\n",
- "\tvoid getFruit();\n",
- "\n",
- "}\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "4. AppConfig.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "import org.springframework.context.annotation.ComponentScan;\n",
- "import org.springframework.context.annotation.Configuration;\n",
- "\n",
- "@Configuration\n",
- "@ComponentScan(basePackages=\"com.saniya.Fruits\")\n",
- "public class AppConfig {\t\n",
- "\n",
- "}\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "5. App.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "import org.springframework.context.ApplicationContext;\n",
- "import org.springframework.context.annotation.AnnotationConfigApplicationContext;\n",
- "\n",
- "public class App \n",
- "{\n",
- " public static void main( String[] args )\n",
- " {\n",
- " \tApplicationContext factory=new AnnotationConfigApplicationContext(AppConfig.class);\n",
- " \tFruit f1=factory.getBean(Fruit.class);\n",
- " \tf1.config();\n",
- " }\n",
- "}\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "6. Fruit.java"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "package com.saniya.Fruits;\n",
- "\n",
- "import org.springframework.beans.factory.annotation.Autowired;\n",
- "import org.springframework.beans.factory.annotation.Qualifier;\n",
- "import org.springframework.stereotype.Component;\n",
- "@Component\n",
- "\n",
- "public class Fruit {\n",
- "\t@Autowired\n",
- "\t@Qualifier(\"orange\")\n",
- "\tFruitPicker fruit;\n",
- "\n",
- "\tpublic FruitPicker getFruit() {\n",
- "\t\treturn fruit;\n",
- "\t}\n",
- "\n",
- "\tpublic void setFruit(FruitPicker fruit) {\n",
- "\t\tthis.fruit = fruit;\n",
- "\t}\n",
- "\t\n",
- "\tpublic void config()\n",
- "\t{\n",
- "\t\tfruit.getFruit();\n",
- "\t}\n",
- "}\n"
- ]
- }
- ],
- "metadata": {
- "language_info": {
- "name": "python"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/Backend_Development_With_Java/README.md b/Backend_Development_With_Java/README.md
deleted file mode 100644
index 97b1287ef2..0000000000
--- a/Backend_Development_With_Java/README.md
+++ /dev/null
@@ -1,63 +0,0 @@
-
-
-
-
-
-
-## New Issue Format
-Labels: GWOC21, Backend-Java, Documentation/Audio/Video
-
-Format: Documentation/Video/Audio
-
-Topic: ...
-
-Description: Describe what you are contributing
-
-
-## Pull Request Format
-Labels: GWOC21, Backend-Java, Documentation/Audio/Video
-
-Fixes: Link Issue Here
-
-Format: Documentation/Video/Audio
-
-Topic: ...
-
-Description: Describe what you are contributing
-
-
-
-
-
diff --git a/Backend_Development_With_Java/Spring Framework/Why Spring.pdf b/Backend_Development_With_Java/Spring Framework/Why Spring.pdf
deleted file mode 100644
index c948ba3740..0000000000
Binary files a/Backend_Development_With_Java/Spring Framework/Why Spring.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Spring week 3/Qualifiers-In-Spring/Qualifiers.md b/Backend_Development_With_Java/Spring week 3/Qualifiers-In-Spring/Qualifiers.md
deleted file mode 100644
index 355f358dde..0000000000
--- a/Backend_Development_With_Java/Spring week 3/Qualifiers-In-Spring/Qualifiers.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# Qualifiers
-
-There may me instances where we create more than one bean of the same type but wish to wire only one of them with a property (as you shall se in the example below). In such cases, we can use Qualifiers to remove the confusion by specifying which exact bean will be wired.
-
-Let us look at an example
-
-## Main.java
-
-```java
-package com.gwoc;
-
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.support.ClassPathXmlApplicationContext;
-
-public class Main {
- public static void main(String[] args) {
- ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
-
- Person person = (Person) context.getBean("person");
- person.printBookName();
- person.printBookAuthor();
- }
-}
-```
-
-## config.xml (Configuration file)
-
-```xml
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-```
-
-## Person.java
-
-```java
-package com.gwoc;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-
-public class Person {
-
- @Autowired
- private Book myBook;
-
- public Person()
- {
- System.out.println("Person() : Constructor called");
- }
-
- public void printBookName(){
- System.out.println("My Book's name is "+myBook.getName());
- }
- public void printBookAuthor() {
- System.out.println("My Book's author is "+myBook.getAuthor());
- }
-}
-```
-
-## Book.java class
-
-```java
-com.gwoc
-
-public class Book {
- private String name;
- private String author;
-
- public void setName(String name) {
- this.name = name;
- }
- public String getName() {
- return name;
- }
- public void setAuthor(String author) {
- this.author = author;
- }
- public String getAuthor() {
- return author;
- }
-}
-```
-
-In the config.xml file we have two beans of the same type `(com.gwoc.Book)`. In Person class, the field `myBook` has the `@autowired` annotation, which means it will inject the property at runtime. Since we have two beans of the same type, there would be a confusion as to which one will be wired. In such cases, we can use the `@Qualifier` annotation along with `@Autowired` to remove the confusion by specifying which exact bean will be wired.
-
-## Person.java (After adding `@Qualifier` annotation)
-```java
-package com.gwoc;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-
-public class Person {
-
- @Autowired
- @Qualifier("book1") //Added Here
- private Book myBook;
-
- public Person()
- {
- System.out.println("Person() : Constructor called");
- }
-
- public void printBookName(){
- System.out.println("My Book's name is "+myBook.getName());
- }
- public void printBookAuthor() {
- System.out.println("My Book's author is "+myBook.getAuthor());
- }
-}
-```
-
-On Running Main.java , we will get the following output
-```
-Person() : Constructor called
-My Book's name is Broken Wings
-My Book's author is Sarojini Naidu
-```
-
-
diff --git a/Backend_Development_With_Java/Spring week 4/View Resolver/ViewResolver.md b/Backend_Development_With_Java/Spring week 4/View Resolver/ViewResolver.md
deleted file mode 100644
index 3356db1717..0000000000
--- a/Backend_Development_With_Java/Spring week 4/View Resolver/ViewResolver.md
+++ /dev/null
@@ -1,200 +0,0 @@
-# View Resolver
-
-For rendering models in browsers, Spring provides a way of working with views without binding the implementation to a specific technology, via the view resolvers. The `ViewResolver` maps the view names to actual views.
-
-## How does Resolvers work in Spring MVC ?
-
-Resolvers are responsible for returning correct views to the client, both in the Spring MVC application as well as on REST APIs. Take a look at example using `InternalResourceViewResolver` .
-
-### FormController.java
-
-```java
-package com.gwoc;
-
-@Controller
-public class FormController
-{
- @RequestMapping("/form")
- public String displayForm()
- {
- return "form";
- }
-
-}
-```
-
-For example, if a user tries to access `/form` URL and FormController returns "form" then `DispatcherServlet` will consult `InternalResourceViewResolver` and it will use prefix and suffix to find the actual physical view which is integral to a web application.
-
-
-
-If `prefix` is "/WEB-INF/views/" and `suffix` is ".jsp" then "form" will be resolved to "/WEB-INF/views/form.jsp" by InternalResourceViewResolver.
-
-
-## How to setup InternalResourceViewResolver in Spring MVC
-
-Follow below steps to configure ViewResolver in your Spring MVC Application.
-
-
-
-### Configuring ViewResolver using Java Configuration
-
-```java
-@Bean
-public ViewResolver viewResolver()
-{
- InternalResourceViewResolver vResolver = new InternalResourceViewResolver();
- vResolver.setPrefix("/WEB-INF/views/");
- vResolver.setSuffix(".jsp");
- return vResolver;
-}
-```
-
-
-### Configuring ViewResolver using XML Configuration
-
-```xml
-
-```
-
-`Note : `suffix will change according to the type of view you want to render. For example, if it is JSON, then suffix will be `"/json"`, and if it is xml, then suffix will be `"/xml"`, and so on.
-
-
-
-## Demo
-
-
-
-### Configure `Dispatcher Servlet` in web.xml ( /WEB-INF/web.xml )
-
-
-## web.xml
-
-```xml
-
-
-
- Archetype Created Web Application
-
-
-
- spring
- org.springframework.web.servlet.DispatcherServlet
-
-
-
- spring
- /
-
-
-
-
-```
-
-### Create `Spring Configuration` File
-
-
-## spring-servlet.xml
-```xml
-
-
-
-
-
-
-```
-
-### Configure `View Resolver`
-
-
-## spring-servlet.xml
-```xml
-
-
-
-
-
-
-
-
-
-
-
-
-
-```
-
-
-### Create a `Controller`
-
-
-## TestController.java
-```java
-package com.gwoc;
-
-@Controller
-public class TestController
-{
- @RequestMapping("/home")
- public String homePage()
- {
- return "home";
- }
-
-}
-
-```
-
-### Add `views` directory in WEB_INF directory and add `home.jsp` file in views directory
-
-
-## home.jsp
-
-```html
-
-
-
-
-
-
-
- Home Page
-
-
-
-
Welcome
-
-
-```
-
-
-Lastly, call `/home` after running the application and you will see the `home.jsp` being rendered.
-
-
-
-
-
-
-
-
-
diff --git a/Backend_Development_With_Java/Spring week 4/View Resolver/img/FileStructureSS.png b/Backend_Development_With_Java/Spring week 4/View Resolver/img/FileStructureSS.png
deleted file mode 100644
index 0b95cc40d2..0000000000
Binary files a/Backend_Development_With_Java/Spring week 4/View Resolver/img/FileStructureSS.png and /dev/null differ
diff --git a/Backend_Development_With_Java/Spring week2/instructions.md b/Backend_Development_With_Java/Spring week2/instructions.md
deleted file mode 100644
index de080459b8..0000000000
--- a/Backend_Development_With_Java/Spring week2/instructions.md
+++ /dev/null
@@ -1 +0,0 @@
-
All changes for week 2 shall be done here in this folder
diff --git a/Backend_Development_With_Java/SpringBoot/Spring Boot.pdf b/Backend_Development_With_Java/SpringBoot/Spring Boot.pdf
deleted file mode 100644
index 2a8aebe2d8..0000000000
Binary files a/Backend_Development_With_Java/SpringBoot/Spring Boot.pdf and /dev/null differ
diff --git a/Backend_Development_With_Java/Spring_Beans/Beans_and_Bean_Annotations.md b/Backend_Development_With_Java/Spring_Beans/Beans_and_Bean_Annotations.md
deleted file mode 100644
index 21979bdd0e..0000000000
--- a/Backend_Development_With_Java/Spring_Beans/Beans_and_Bean_Annotations.md
+++ /dev/null
@@ -1,147 +0,0 @@
-# Introduction
-
-_In the Spring framework the objects which form the backbone of your application and that are managed by the Spring **IOC** container are called beans. A **bean** is an object that is **instantiated, assembled** and otherwise **managed** by the Spring IOC container._ Also beans can be said to be one of the many objects of your application.
-
-Let's get a more glimpse of what are beans by firstly understanding what is **Spring IOC container** and more precisely **Inversion of Control (IOC)**.
-
-## Inversion of Control (IOC)
-
-An object which defines what dependencies are required without creating them such a process is called **Inversion of Control**. Such an object delegates the job of constructing and instantiating the dependencies to an IOC container.
-
-Example:
-
-We are defining two domain classes as follows:
-
-```java
-//Person class having a property of class Name which is declared below
-public class Person {
- private Name name;
-
- //Parameterized constructor
- public Person(Name name) {
- this.name = name;
- }
-
- //Getter, setter and other methods
-}
-```
-
-```java
-//Name class with arguements f_name and l_name
-public class Name {
- private String f_name, l_name;
-
- public Address(String f_name, String l_name) {
- this.f_name = f_name;
- this.l_name = l_name;
- }
-
- //Getter, setter and other methods
-}
-```
-
-To instantiate **Person** class we traditionally create an object of that class and also the collaborator class **Name** with the following syntax:
-
-```java
-Name name = new Name("Yash", "Maroo");
-Person person = new Person(name);
-```
-
-There is no harm with this approach, wouldn't it be better if we could instantiate it in a better method.
-
-Meaning, here we are only dealing with one instance of Person class, which takes a property of class **Name**, but what if there is a case that we are given a dozen of instances of **Person** class which requires different properties of the **Name** class. Handling such a situation with the above traditional approach would make the task tedious and more prone to errors. So here IOC comes to the rescue.
-
-Instead of constructing the dependencies by ourselves, an object can retrieve its dependencies from the IOC container. All we need to do is provide the container with the correct and appropriate configuration metadata.
-
-So let's learn the syntax of the above-described method in the next section
-
-## Configuration (@Configuration)
-
-Annotating a class with the ```@Configuration``` annotation indicates that the class will be used by the ```JavaConfig``` as a source of bean definitions.
-
-Syntax for ```@Configuration``` anootation:
-
-```java
-@Configuration(defaultAutowire = Autowire.BY_TYPE, defaultLazy = Lazy.false)
-public class class_Name {
- // bean definitions
-}
-```
-
-Let us solve the previous problem using ```@Configuration```
-
-```java
-@Container
-public class Person {
- @Autowired
- private Name name;
-
- // ...
-}
-```
-
-Instantiating the Name class with the bean annotations as follows:
-
-```java
-@Configuration
-public class Name {
- @Bean
- public Name getName() {
- return new Name("Yash", "Maroo");
- }
-}
-```
-
-An instance of **Person** class will already get injected with the instance of **Name** class already instantiated as (```f_name="Yash", l_name="Maroo"```).
-
-## @Bean annotation
-
-```@Bean``` is a method-level annotation and a direct analog of the XML `````` element.
-
-In the previous section you would have already seen the ```@Bean``` annotation in use so just let us once again go through the declaration of the annotation:
-
-```java
-@Congiguration
-public class AppConfig {
- @Bean
- public TransferService transnferService() {
- return new TransferServiceImpl();
- }
-}
-```
-
-This is equivalent to the following ```Spring XML```:
-
-```xml
-
-
-
-```
-
-Both will result in a bean named ```transferService``` being available in the ```BeanFactory/ApplicationContext```.
-
-Let us see the IOC container in action or how to get the beans for the previous example:
-
-## IOC in action
-
-First, we setup an instance of the ```AnnotationConfigApplicationContext``` class to build up a container
-
-```java
-ApplicationContext context = new AnnotationConfigApplicationContext(Config.class)
-```
-
-Now the following test verifies whether the bean and its values exist or not:
-
-```java
-Person person = context.getBean("person", Person.class)
-//check for value equality
-assertEquals("Yash", company.getName().getFirst())
-```
-
-In this documentation we have covered the most basic annotations ```@Bean``` and ```@Configuration```. If you want to learn more annotations you could head to [Spring Beans Annotations](https://javatechonline.com/spring-boot-bean-annotations-with-examples/).
-
-### References
-
-1. [Spring Beans Baeldung](https://www.baeldung.com/spring-bean)
-2. [Bean Annotations](https://medium.com/javarevisited/spring-beans-in-depth-a6d8b31db8a1)
-3. [Spring Beans Doc](https://docs.spring.io/spring-javaconfig/docs/1.0.0.M4/reference/html/ch02s02.html)
diff --git a/Backend_Development_With_Java/Spring_Models/Models.md b/Backend_Development_With_Java/Spring_Models/Models.md
deleted file mode 100644
index 7f4bcbcd08..0000000000
--- a/Backend_Development_With_Java/Spring_Models/Models.md
+++ /dev/null
@@ -1,155 +0,0 @@
-# Introduction
-
-**Model** works as a container for the data of the application. Hera a data can be in any form such as objects, strings, data from the database, etc.
-
-Model is the most basic concept of Spring. Putting in simple words, the model can supply attributes used for rendering views.
-
-To provide a view with usable data, we simply add this data to ```Model``` object.
-
-Example:
-
-```java
-@GetMapping("/showViewPage")
-public String passParametersWithModel(Model model) {
- model.addAttribute("message", "Adding attributes to the object model");
- return "viewPage";
-}
-```
-
-## Model Attributes ```@ModelAtrribute``` Annotation
-
-This annotation binds a method return value or a method parameter to a named model attribute and exposes it to the web view.
-
-This annotation can be used both as a method paramater or at the method level.
-
-### 1. At the method level
-
-This type of usage indicates the purpose of that method is to add multiple model attributes. **Such methods support the same argument types as ```@RequestMapping``` methods but that cannot be mapped directly to requests.**
-
-Example:
-
-```java
-@ModelAttribute
-public void addAttribute(Model model) {
- model.addAttribute("msg", "Hello from model attribute");
-}
-```
-
-In the above example, we are adding the attribute ```msg``` with the specified value to all the _models_ defined in the **Controller** class.
-
-In general, Spring MVC always makes the first call to the method which specifies the attributes for the model before making further calls to the request handler methods. **That is, ```@ModelAttribute``` methods are invoked before the controller methods annotated with `@RequestMapping` are invoked.** In simple terms, model creation takes place first before further processing starts.
-
-### 2. As a Method Argument
-
-When used as a method argument, it indicates the argument should be retrieved from the model. When not present, it should be first instantiated and then added to the model, and once present in the model, the arguments fields should be populated from all request parameters that have matching names.
-
-Example:
-
-```java
-@RequestMapping(value="/addEmployee", method=RequestMethod.POST)
-public String Submit(@ModelAttribute("emp") Employee employee) {
- //use the employee object as required
-
- return "employeeView";
-}
-```
-
-In the baove code snippet we are populating the model attribute with the data submitted in a for at the endpoint `/addEmployee`.
-
-## Example Program
-
-Let us create a simple program wherein a user enters his or her personal details and if no error is prompted he or she can see his data that was submitted in the form previously.
-
-Creating a simple from for taking details:
-
-```xml
-
- Name
-
-
- Age
-
-
- Id
-
-
-
-
-```
-
-Controller class for the previously mentioned form or `view`:
-
-```java
-@Controller
-@ControllerAdvice
-public class UserController {
-
- //Creating a user map for storing the users
- private Map userMap = new HashMap<>();
-
- @RequestMapping(value = "/addDetails", method = RequestMethod.POST)
- public String submit(
- @ModelAttribute("user") User user,
- BindingResult result, ModelMap model) {
- //checnking if any errors is encountered or not
- if (result.hasErrors()) {
- return "error";
- }
-
- //adding attributes name, age and id to the model
- model.addAttribute("name", user.getName());
- model.addAttribute("age", user.getAge())
- model.addAttribute("id", user.getId());
-
- //Mapping user to the userMap
- userMap.put(user.getId(), user);
-
- return "userView";
- }
-
- @ModelAttribute
- public void addAttributes(Model model) {
- model.addAttribute("msg", "Welcome to the Netherlands!");
- }
-}
-```
-
-In the `submit()` method we have an _User_ object bound to the _View_. From the form we are collecting the data and setting them to the _ModelMap_.
-
-In the end we are returning ``userView``, which means that the respective JSP file is going to be called as a _View_ representative.
-
-There is also `addAttributes()` method whose purpose is to add values to the _Model_ which will be identified globally,i.e, default value for every model which will be returned as a response for every request to a controller method.
-
-The **Model** is as follows:
-
-```java
-@XmlRootElement
-public class User {
- private long id;
- private String name;
- private int age;
-
- public User(long id, String name, int age) {
- this.id = id;
- this.name = name;
- this.age = age;
- }
-}
-```
-
-Results View:
-
-```xml
-
${msg}
-Name: ${name}
-Age: ${age}
-ID: ${id}
-```
-
-The above code prints the data which we recieved from the form.
-
-### References
-
-1. [Spring Model Baeldung](https://www.baeldung.com/spring-mvc-model-model-map-model-view)
-2. [Model Annotation Baeldung](https://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation)
-3. [Spring Beans Doc](https://docs.spring.io/spring-javaconfig/docs/1.0.0.M4/reference/html/ch02s02.html)
diff --git a/Backend_Development_With_Java/Tools_and_IDEs/Setting_Up_VSCODE.md b/Backend_Development_With_Java/Tools_and_IDEs/Setting_Up_VSCODE.md
deleted file mode 100644
index 7f33711f6f..0000000000
--- a/Backend_Development_With_Java/Tools_and_IDEs/Setting_Up_VSCODE.md
+++ /dev/null
@@ -1,40 +0,0 @@
-## Downloading and setting up Visual Studio Code for Java Development
-
-**Step** 1: [Here](https://code.visualstudio.com/) is a link for the officail website of VSCode. You can download as per your requirement.
-
-**Step** 2: For Java development, the most important thing that you need after your IDE is the **Java** **Development** **Kit** or **JDK**.
-
-These days Java 17 is available and [there goes](https://www.oracle.com/java/technologies/downloads/ ) the link to the official Oracle website for downloading JDK.
-
-Again, they have a very user friendly interface and you can find direct download link as per your device's requirement and the operating system.
-
-In future, if other versions are available make sure that you install it from the **ORACLE** website.
-
-**Step** 3: An important step is setting up the environment variable. For this just follow these steps:
-- Go to "This PC" .
-- Enter the "Local Disk (C).
-- There you can find Java folder, open it and get inside the bin folder. Now, copy this path and get back to "This PC".
-- Right click and you can see "properties" at the end, click it.
-- Click "Advanced System Settings".
-- Click on "Environment Variables".
-- In the "System Variable" box, find "path" and click on it.
-- Now, click on "edit" and just paste the path copied.
-- Congratulations, we have just set the environment variable.
-- Now open a complete new Command Prompt and type "Java -version" if you are able to see the version, then everything is perfectly set.
-
-**Step** 4: Now, visit [this](https://code.visualstudio.com/docs/languages/java) VS Code Website for installing some coding pack for java.
-
-In the "Install Visual Studio Code for Java" section you can find the links for installation of the pack. Install it.
-
-**Step** 5: Here are some of the useful extensions that will help you in the Java development.
-
-- Language Support for Java(TM) by Red Hat
-- Debugger for Java
-- Java Test Runner
-- Maven for Java
-- Project Manager for Java
-- Visual Studio IntelliCode
-
-Now you are good to go. Now you can easily do Java development on VS Code.
-
-## Happy Learning
diff --git a/Backend_Development_With_Java/Tools_and_IDEs/Top5_IDEs.md b/Backend_Development_With_Java/Tools_and_IDEs/Top5_IDEs.md
deleted file mode 100644
index ee5ae6be30..0000000000
--- a/Backend_Development_With_Java/Tools_and_IDEs/Top5_IDEs.md
+++ /dev/null
@@ -1,18 +0,0 @@
-Listing below top 5 IDEs for Java Development.
-
-### 5) BLUEJ :
-- Platforms supported : Linux, Windows, MacOS
-
-### 4) JDEVELOPER : JDeveloper is a freeware Java IDE by Oracle.
-- Platforms supported : Linux, Windows, MacOS
-
-### 3) NETBEANS : Netbeans is the offical IDE for Java 8.
-- Platforms supported : Linux, Windows, MacOS, Solaris
-
-### 2) ECLIPSE :
-- Platforms supported : Linux, Windows, MacOS, Solaris
-
-### 1) INTELLIJ IDEA : Released in 2001, one of the best IDE used for Java Development
-- Linux, Windows, MacOS
-
-The choice of the IDE differ from person to person, so feel free to use the IDE of your choice.
\ No newline at end of file
diff --git a/Backend_Development_With_Java/newfile.md b/Backend_Development_With_Java/newfile.md
deleted file mode 100644
index 8b13789179..0000000000
--- a/Backend_Development_With_Java/newfile.md
+++ /dev/null
@@ -1 +0,0 @@
-
+
+
+
+
+ > To begin with you should have installed git in your system, if not already then here's the download link -
+ > [Download git](https://git-scm.com/downloads)
+
+ > Check if it is successfully installed, open command promt and write the command
+
+ ```bash
+ git --version
+ ```
+ this will show the version of git installed in your system.
+
+ 
+
+ ## Setup git in Android Studio
+
+ Navigate to file and click on settings *file > settings*
+
+ Shortcut keys to open *settings* =>
+ **windows/linux**(Ctrl + Alt + S) | **mac**(Cmd + ,)
+ 
+
+ Head towards *Git > Version Control* in the right menu, here you can see **Path to Git executable** Android Studio will automatically detect your git.exe path, if it doesn't then select provide the path manually. git.exe resides in *Git -> cmd* directory.
+
+ Once you're done setting up the path click on **Test**
+ and git version installed in your system will be displayed.
+
+ 
+
+ Click OK
+ You've successfully connected git in your Android Studio !
+
+ ## Connecting Github account
+ Go to setting and navigate to Github from right menu. Here tap on the + button, you will see three ways to connect your github account click **log in with token** with this you can simply provide a token generated in your github account for authorization.
+
+ 
+
+ A tab will pop-up here click on **Generate**
+
+ 
+
+
+ It will redirect to Github page scroll down and tap **Generate Token**
+
+ 
+
+
+
+ 
+
+
+ A token will be generated copy that and paste it in **Token** section then click **Add Account**
+
+ Done !
+![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XIeqVFFJXzxK"
+ },
+ "source": [
+ "# Introduction to **AndroidManifest.xml**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "t-0miPvNYcXJ"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KJxRjeKrYkWF"
+ },
+ "source": [
+ "\n",
+ "Think about the feeling when you first time opens a project on android studio.\n",
+ "You are shocked up to see so many folders and files are piled up on one side. Let's try to find out where the manifest file is."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "4-AaClipY0x2"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "L73xswuKY334"
+ },
+ "source": [
+ "## **Where is the manifest.xml file present inside Android studio? **"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9ptHkPjelh1U"
+ },
+ "source": [
+ "Create a new project in android studio or you can go through your existing project."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "LSEcLTMnag5Y"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MBAb92gHaiCe"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "RANsdK9Zaqpr"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GTucmLPNawM9"
+ },
+ "source": [
+ "Then, move on to the app folder. As soon as you click on this, you will see another folder named manifest.Inside the manifest folder, you will found our desired file AndroidManifest.xml"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "gkEqZekWd7KD"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hKS80ZWMb4zJ"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DgYWqM1seVRY"
+ },
+ "source": [
+ "We solved our first problem.\n",
+ "Let us clear another confusion, why do we need this file."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "hg16pRksdM65"
+ },
+ "source": [
+ ""
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Jsx1z2IQgedo"
+ },
+ "source": [
+ "# Role of AndroidManifest.xml file in our development:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qb0qDk6xFdh8"
+ },
+ "source": [
+ "Before saying anything about the role of manifest.xml, I would like to ask a question. Let us assumed you have created an application.\n",
+ "Suppose you have more than one activity in your application. One of which is your launcher activity, this means you want as soon as a user opens your app, \n",
+ "this activity will come in front of him."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Bx8ioCE2F-by"
+ },
+ "source": [
+ "### How can you specify this?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ouvpcip3GOZv"
+ },
+ "source": [
+ "Now, android does not mention it anywhere that you just named your activity as MainActivity, Then it became a launcher activity.\n",
+ "Manifest.xml helps us in this task. This manifest file categorizes all the activities which we will create when we go to develop an application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "k5InmdZaGmpc"
+ },
+ "source": [
+ "**AndroidManifest.xml** helps us in this task. This manifest file categorizes all the activities which we will create when we go to develop an application.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KO8fzYyxG87s"
+ },
+ "source": [
+ "*Let us consider another scenario*."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kELt8UkWIkPG"
+ },
+ "source": [
+ "Suppose one user has installed your application on his device.\n",
+ "Now, your application will ask the user for permission to access some of the system apps (For example, camera, gallery, phone contact, audio recorder, video recorder, internet, wifi) present in the device as per its requirement.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Rr3sDFnvJYzO"
+ },
+ "source": [
+ "\n",
+ "The **manifest file** helps us in this task. Here we ask permission from the user as per our application's requirement. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YbWN0JTMJv_X"
+ },
+ "source": [
+ "## **Summary:**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6xM4mRLiKD0R"
+ },
+ "source": [
+ "AndroidManifest.xml describes the fundamental characteristics of the app and defines each of its components.\n",
+ "Here we define all the components of android which system must have before it runs any code of the application.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e0qqTwMvKb6e"
+ },
+ "source": [
+ "It is important to note that every application has its own manifest file. This manifest file is storing in the package manager of the android phone, in which we installed the application.\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2TXTVGxTT_Se"
+ },
+ "source": [
+ "## Some important point about XML:\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xtC9W3fjUU9_"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "* XML stands for eXtensible Markup Language much like HTML.\n",
+ "* It is a software- and hardware-independent tool for storing and transporting data.\n",
+ "\n",
+ "\n",
+ "* XML was designed to carry data - with a focus on what data is.\n",
+ "*XML elements can have attributes, just like HTML. Attributes are designed to contain data related to a specific element.\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "h5_jxRQVWfMM"
+ },
+ "source": [
+ "# Manifest file structure:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jv3TaFBDXSpu"
+ },
+ "source": [
+ "Manifest is an XML file and We have discussed its role before. Here we will see how it does this. We will learn about the common elements we are using to develop our application."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "axIeIxv4T9cV"
+ },
+ "source": [
+ " "
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "s4KNSZkNgUsF"
+ },
+ "source": [
+ "\n",
+ "Let us discuss some elements of manifest.xml, which we use most of the time for our application development. Here I have made a chart of them according to the order of root elements."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QMsnY9C2RQT4"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dzatryRxohCM"
+ },
+ "source": [
+ "\n",
+ "## `
![](\"https://www.tutorialspoint.com/android/images/studio8.jpg\")
\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1obMY7M1T7QW"
+ },
+ "source": [
+ "After completing the downloading process, we get the finish button then it will be open the Android Studio project with a Welcome to android studio message as shown below."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hoZ8ux1rXPom"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "![\"Drawing\"/](\"https://linuxhint.com/wp-content/uploads/2020/07/12-23.png\")
\n",
+ "![\"Drawing\"/](\"https://linuxhint.com/wp-content/uploads/2020/07/13-20.png\")
\n",
+ " ![\"Drawing\"/](\"https://www.tutorialspoint.com/android/images/studio12.jpg\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1-SZrCyIYEgx"
+ },
+ "source": [
+ "Now, Configure your project and click the next button."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-lo0mqCuY0mQ"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ckd36CDsbiuB"
+ },
+ "source": [
+ "Now your setup is done for the project."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tGNkpU--cKWQ"
+ },
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "A2sswSbVcuRd"
+ },
+ "source": [
+ "### Introduction to Files and Folders:\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WE7tDDrthjmd"
+ },
+ "source": [
+ "**Android Project folder Structure:**\n",
+ "\n",
+ "---\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Eu6xJznliiA9"
+ },
+ "source": [
+ "The android project contains different type of app modules, source code files and resource files. We will explore all the folders and files in android app.\n",
+ "\n",
+ "![](\"https://media.geeksforgeeks.org/wp-content/uploads/2018-02-05-1.png\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jIO5UNh8pBgQ"
+ },
+ "source": [
+ "### **How can we use Android Studio to develop an application?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SzH5qK1QpQyT"
+ },
+ "source": [
+ "Let's create an application that will take two Integer inputs from the user. Then with the click of a button, we see the output, which is the sum of those two integers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rIB9p3bV-y0Z"
+ },
+ "source": [
+ "For this, we will first create a project, as we did a while ago. I have named my project here **Add-on**, you are independent in this regard.\n",
+ "An application usually consists of two parts. One is the user interface, which is visible in front of the user. Another is its internal coding part, which enlivens our user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rMTky01A5owN"
+ },
+ "source": [
+ "\n",
+ "As soon as your project opens, you will see two files. One is MainActivity.java, where we will do internal coding, Another is activity_main.xml, where we will design the user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KYWLOov1CU4o"
+ },
+ "source": [
+ "Let us first create the user interface."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "21PlnZkzCgcC"
+ },
+ "source": [
+ "**Required view :**\n",
+ "* Two EditText (For user input.)\n",
+ "\n",
+ "* One Button (To determine the result.)\n",
+ "\n",
+ "* One TextView (To show the result.)\n",
+ "\n",
+ "Here I have used ConstraintLayout as the parent layout.\n",
+ "\n",
+ " See an example of the use of ConstraintLayout.\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "v1k7R8FlY9vb"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ "
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+ 
+
+
+ 
+
+ 
+ 
+
+
+
+
+
+
+
+ 
+ 
+ 
+
+
+
+ 
+ 
+ 
+
+
+
+
+
... 
+
+ 
+
+
+
+
+### 2. Give some overview of JVM, DVM, ART, JIT,AOT
+
+##### a.) JVM:
+JVM is the virtual machine that runs java code on different platforms. It acts as an abstract layer between the program and the platform on which the java code is running. The portability of Java code is possible only because of the JVM. The javac compiler converts the source code file(.java file) into an intermediate java bytecode format which is machine/platform independent. This intermediate file is then provided to the target machine/platform where it gets translated into machine code. JVM supports multiple host architecture and it is the reason why Java applications are called WORA(Write Once Run Anywhere).
+
+ 
+
+
+
+
+##### b.) DVM:
+DVM stands for “Dalvik Virtual Machine”. It is a Register-Based virtual machine. It was designed and written by Dan Bornstein with contributions of other Google engineers as part of the Android mobile phone platform. The Dalvik virtual machine was named after Bornstein after the fishing village “Dalvík” in Iceland, where some of his ancestors used to live.
+
+
+
+
+
+
+
+##### c.) ART:
+ART or Android Runtime is an Android runtime that uses Ahead Of Time (AOT). By using AOT, what is does is it converts or compiles the whole High-level language code into Machine level code and at the time of installation of the app and not dynamically as the application runs(like in case of Dalvik). By compiling the whole code during installation results in no lag that we see when we run our app on our device. By doing so, the compilation becomes very faster.
+
+
+
+
+
+
+
+##### d.) JIT:
+JIT stands for "Just In Time," and we use it to describe a Dalvik JIT compiler, which was added to Android with the 2.2 release. It compiles bytecode into native machine code at runtime. Essentially it takes the code for an app, analyzes it and converts it into something that runs faster. It does all this while the application is running, and that's where the "just in time" tag comes from. The JIT compiler designed for Android also can do this with a very short "warm up" time, meaning it doesn't take very long to analyze the code before it starts working. It stores information in a cache in your phone's RAM, which means it's not an ideal solution for devices with low memory.
+
+
+
+
+
+
+
+##### e.) AOT:
+AOT stands for Ahead of Time compilation, and compiles your code, to the native platform, dependent upon the architecture. The reason you would use AOT, is because it has a drastically reduces startup time, and app performance.
+
+
+
+
+
+### 3. JVM V/s DVM
+
+##### Difference Table
+
+
+
+
+### 4. Why Android OS used DVM instead of JVM ?
+One of the main reasons of using DVM in android is because it follows the register based model and it is much faster than stack based model while JVM follows the stack based model which takes a lot of memory and also slower than DVM.
+
+There are couple of reasons why Google not choose JVM over DVM, so let’s understand each one of them one by one.
+· Though JVM is free, it was under GPL license, which is not good for Android as most the Android is under Apache license.
+· JVM was designed for desktops and it is too heavy for embedded devices.
+· DVM takes less memory, runs and loads faster compared to JVM.
+
+
+
+### 5. Why Android deprecated DVM & started to use ART?
+In Android Lollipop, DVM has been replaced by ART. Because DVM converts bytecode every time you launch a specific app. But ART converts it just once at the time of app installation.
+ART is extremely fast and smooth. Apps are very snappy and responsive. Any comparison between Dalvik and ART, will surely make the ART device win by a significant margin.
+Dalvik used Just-In-Time (JIT) approach in which the compilation was done on demand. All the dex files were converted into their respective native representations only when it was needed.
+But ART uses the Ahead-Of-Time (AOT) approach, in which the dex files were compiled before they were demanded. This itself massively improves the performance and battery life of any Android device.
+
+
+
+
+
+
+### 6. DVM V/s ART
+ Difference Between DVM and ART
+
+DALVIK VIRTUAL MACHINE ANDROID RUN TIME
+Faster Booting time Rebooting is significantly longer
+Cache builds up overtime The cache is built during the first boot
+Occupies less space due to JIT Consumes a lot of storage space internally due to AOT
+Works best for small storage devices Works best for Large storage devices
+Stable and tested virtual machine Experimental and new – not much app support comparatively
+Longer app loading time Extremely Faster and smoother Faster and app loading time and lower processor usage
+Uses JIT compiler(JIT: Just-In-Time)
+Thereby resulting in lower storage space consumption Uses AOT compiler(Ahead-Of-Time) thereby compiling apps when installed
+Application lagging due to garbage collector pauses and JIT Reduced application lagging and better user experience
+App installation time is comparatively lower as the compilation is performed later App installation time is longer as compilation is done during installation
+
+
+
+
+##### What’s Better?
+It depends on the device and one’s own device and preferences: in the long run, ART is better, but the apps do get bigger, requiring large storage space over time, unlike flappy bird which was just 1MB and required less space. Therefore, the devices in the future need to expand storage if ART is going to dominate the market in the next few years.
+
+
+
+### 7. Why Android is reintroducing JIT with ART?
+This is done in order to tackle problems such as initial installation time and memory. Using the Hybrid Runtime, there won't be any compilation during install, and applications can be started right away, the bytecode is interpreted. Now with ART and the new JIT the application installation is faster.
+
+
+
+
+### 8. JIT V/s AOT
+JIT compilers have way more information at their disposal than AOT compilers. Static analysis is impossible in the general case (nearly everything interesting you would want to know about a program can be reduced to either the Halting Problem or Rice's Theorem), and hard even in the special case. JIT compilers don't have this problem: they don't have to statically analyze the program; they can observe it dynamically at runtime.
+Plus, a JIT compiler has techniques at its disposal that AOT compilers don't, the most important one being de-optimization. Now, you might think, we is de-optimization important for performance? Well, if you can de-optimize, then you can be over-aggressive in making optimizations that are actually invalid (like inlining a method call that may or may not be polymorphic), and if it turns out that you are wrong, you can then de-optimize back to the un-inlined case (for example).
+However, there's the problem of resources: an AOT compiler can take as much time as it wants, and use as much memory as it wants. A JIT compiler has to steal its resources away from the very program that the user wants to use right now.
+
+
+
+
+
+
+###### References:
+1. https://azure.microsoft.com/en-in/overview/what-is-a-virtual-machine/#overview
+2. https://medium.com/programming-lite/android-core-jvm-dvm-art-jit-aot-855039a9a8fa
+3. https://medium.com/android-news/virtual-machine-in-android-everything-you-need-to-know-9ec695f7313b
+4. https://www.geeksforgeeks.org/what-is-dvmdalvik-virtual-machine/
+5. https://www.geeksforgeeks.org/difference-between-jvm-and-dvm/
+6. https://blog.mindorks.com/what-are-the-differences-between-dalvik-and-art
+7. https://www.journaldev.com/23464/android-runtime-dvm-vs-art-aot-vs-jit
+8. https://towardsdatascience.com/jvm-vs-dvm-b257229d18a2
+9. https://stackoverflow.com/questions/31957568/what-is-difference-between-dvm-and-art-why-dvm-has-been-officially-replaced-wi
+10. https://stackoverflow.com/questions/40336455/difference-between-aot-and-jit-compiler-in-the-art
diff --git a/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md b/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md
new file mode 100644
index 0000000000..6fe8d59315
--- /dev/null
+++ b/Android_Development_With_Java/2 Android UI Widgets/Progress Bar.md
@@ -0,0 +1,98 @@
+# Progress Bar
+Progress Bar is used to determine how much an event has progressed or is in progress. It can be done in two modes: Indeterminant and Determinant.
+
+An Indeterminate Progress Bar is used when we do not know how long an event will take place. It is commonly seen in Apps when some page is being loaded or some action is to be starting soon.
+
+
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+### Android Context Menu -
+
+**This menu appears when a user performs a long click on one of your UI elements. The options found in this menu affect what UI element the user made the click on. It is common to use this type of menu in list or grid views, where the user’s interaction with each item can lead to a specific action.**
+
+
+
+### Android Popup Menu -
+
+**A popup menu is a type of menu that displays items in a vertical list. This list is attached to the view the user has clicked on to invoke this menu. It is important to keep in mind, that when choosing a popup menu, you do not want the user’s choice to affect the previous content the user pressed.**
+
+
+
+**For more help please visit [Android Official Documentation](https://developer.android.com/guide/topics/ui/menus)**
\ No newline at end of file
diff --git a/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md b/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md
new file mode 100644
index 0000000000..995a545308
--- /dev/null
+++ b/Android_Development_With_Java/4 Android Menu/4.2 Popup_Menu.md
@@ -0,0 +1,151 @@
+# Popup Menu Android Studio
+
+We are going to discuss the Popup Menu.
+A Popup Menu displays a Menu in a popup window anchored to a View.
+The popup will be shown below the anchored View if there is room (space) otherwise above the View.
+If any IME (Input Method Editor) is visible the popup will not overlap it until the View (to which the popup is anchored) is touched.
+Touching outside the popup window will dismiss it.
+
+- Go to Android Studio and create Empty Project in Java Language.
+
+- In this step, we will add a button to the **activity_main.xml** layout file and give it an id as btn to it.
+
+``` xml
+
+
+
+
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+ 
+ 
+ 
+ 
+
-
- 
-
-
-
- 
-
- 
