Unit 02: Installation and Configuration of Android 06 Marks

Operating System (OS) :-

An Operating System (OS) is a vital software layer that acts as an intermediary between a
computer's hardware and its user. It manages hardware resources, provides essential services,
and allows the execution of software applications.

Advantages of an Operating System

 Ease of Use: Simplifies interaction with hardware.

 Resource Management: Efficient utilization of CPU, memory, and storage.
 Security: Protects data and resources.
 Multitasking: Allows multiple applications to run simultaneously.

Java JDK (Java Development Kit) :-

The Java Development Kit (JDK) is a comprehensive software development environment

provided by Oracle and other vendors for developing Java applications, applets, and
components. It is an essential tool for Java programmers, containing all the tools required for
Java development.

Components of Java JDK

The JDK consists of several key components that facilitate Java application development:

1. Development Tools

 A collection of tools used for compiling, debugging, and running Java programs.
 Examples:
o javac: Java compiler, converts Java source code into bytecode.
o java: Java runtime launcher, executes Java applications.
o javadoc: Generates API documentation in HTML format.
o jdb: Java debugger for debugging Java programs.
o jar: Archives Java classes into a JAR file.

2. Java Runtime Environment (JRE)

 A subset of the JDK that allows the execution of Java applications.

 Includes:
o Java Virtual Machine (JVM): Executes Java bytecode.
o Core Libraries: Provides essential functionality like collections, I/O, and
networking.

3. Java API (Application Programming Interface)

 A vast collection of pre-written libraries and APIs that developers use to build Java
applications.
 Examples:
o java.lang: Core language classes.
o java.util: Utility classes for collections, date, and more.
o java.io: Classes for input and output.
o javax.swing: GUI development classes.

1
4. Java Debugging Tools

 Tools to debug Java programs and identify runtime issues.

 Examples:
o jconsole: Monitors JVM performance.
o jvisualvm: Provides detailed information on applications running in the JVM.

5. Native Code Tools

 Tools like javah for generating native header files.

Usage of JDK

1. Writing Java Programs :- Developers write Java code in .java files.

2. Compiling Java Programs :- Use the javac command to compile .java files into .class files
containing bytecode.
3. Running Java Programs :- Use the java command to execute the compiled .class files on the
JVM.
4. Building Applications :- Use tools like jar to package compiled classes into executable JAR
files.

Key Features of JDK

1. Platform Independence
2. Backward Compatibility
3. Robust Development Tools

Applications of JDK

 Desktop Applications: Swing and JavaFX for GUIs.

 Web Applications: Using frameworks like Spring or Java EE.
 Mobile Applications: Android development (uses a modified version of the JDK).
 Enterprise Systems: Middleware solutions like Apache Tomcat, JBoss.

Android SDK (Software Development Kit) :-

The Android SDK is a collection of tools, libraries, and resources provided by Google to
facilitate the development of Android applications. It acts as the foundation for Android app
development, enabling developers to create, debug, and test apps for various Android devices.

Components of the Android SDK

1. Android Platform Tools

 Includes tools essential for interacting with Android devices and emulators during
development.
 Key Tools:
o adb (Android Debug Bridge): Communicates with devices for tasks like
installing apps, debugging, and accessing the shell.
o fastboot: For modifying the device's flash file system.
o systrace: Captures system activity for performance analysis.
o

2
2. Android Emulator
 A virtual Android device that mimics the functionality of real hardware.
 Features:
o Simulates various device configurations (screen size, resolution, etc.).
o Supports GPS, call simulation, and hardware features like cameras.
o Allows testing across multiple API levels without physical devices.

3. SDK Tools
 Utilities for building and managing Android apps.
 Examples:
o apksigner: Signs APK files for deployment.
o lint: Analyzes code for potential errors and optimizations.

4. SDK Manager
 Manages the installation and updates of SDK components.
 Accessible via:
o Android Studio: Integrated GUI for SDK management.
o Command Line: Use sdkmanager to install or update SDK packages.

5. Android Libraries
 Prebuilt libraries for app development.
 Categories:
o Support Libraries: For backward compatibility with older Android versions.
o Android Jetpack Libraries: Modern libraries for common app features (e.g.,
Room for databases, Navigation for routing).

6. APIs (Application Programming Interfaces)

 Allows apps to leverage Android system features.
 Examples:
o Media APIs: For audio and video playback.
o Location APIs: Access device location and geofencing.
o Connectivity APIs: Manage Wi-Fi, Bluetooth, and mobile data.

7. Build Tools
 Converts source code into APK files for deployment.
 Includes:
o aapt (Android Asset Packaging Tool): Packages resources.
o dx/d8: Converts Java bytecode to Dalvik bytecode.
o Gradle Build System: Automates the build process and manages dependencies.

8. System Images
 Virtualized versions of Android OS for emulators.
 Allows testing apps on different API levels and device configurations.

9. Android NDK (Native Development Kit)

 Enables the use of C and C++ in Android app development.
 Useful for performance-critical applications like games.

10. Android Debugging Tools

 Tools to debug and optimize apps.
 Examples:
o Logcat: Displays logs for real-time debugging.
o Hierarchy Viewer: Visualizes app layouts to identify UI issues.
3
 o Android Profiler: Analyzes performance metrics (CPU, memory, and network
usage).

Advantages of the Android SDK

1. Wide Device Compatibility

o Provides tools to develop apps for a wide range of Android devices and API levels.
2. Comprehensive Testing Environment
o The emulator supports various device configurations, screen sizes, and Android
versions.
3. Integration with Android Studio
o Offers a seamless environment for coding, building, and testing.
4. Access to APIs
o Enables developers to use Android-specific features like location services, sensors,
and media playback.

Android Development Tools :-

Android development involves using a variety of tools to help developers create, debug, test,
and deploy applications. These tools range from integrated development environments (IDEs)
to specialized libraries and frameworks, and they help ensure that Android apps are high-
quality, performant, and compatible across a range of devices. Below is a detailed look at the
key Android development tools.

1. Integrated Development Environment (IDE)

1.1 Android Studio

 Android Studio is the official IDE for Android app development, based on IntelliJ IDEA.
 Features:
o Code Editor: Offers features like code completion, syntax highlighting, and smart
code editing.
o UI Designer: Helps design app layouts using drag-and-drop features and XML.
o Emulator: Built-in emulator for testing Android apps on virtual devices with
various configurations.
o Gradle Integration: Automates the build process, managing dependencies and
the packaging of APK files.
o Profiler Tools: Monitors CPU, memory, and network usage during runtime for
performance optimization.
o Android Virtual Device (AVD) Manager: For creating and managing emulators.

2. Android SDK (Software Development Kit)

The Android SDK is essential for developing Android apps. It includes:

 Tools and APIs: Necessary libraries and tools like adb, emulator, and fastboot for
working with Android devices.
 Platform-specific APIs: For accessing device features like sensors, cameras,
Bluetooth, etc.
 Build Tools: Automate tasks such as compiling code, linking resources, and packaging
APKs.
 Android Debug Bridge (adb): Facilitates communication with Android devices for
debugging, app installation, and file management.

4
3. Version Control Tools

3.1 Git

 Git is a distributed version control system used for tracking code changes and
collaborating with other developers.
 GitHub, GitLab, and Bitbucket are popular platforms that allow hosting Git
repositories.
 Benefits for Android Development:
o Branching: Allows managing different versions of your code.
o Collaboration: Easily share code and manage pull requests.
o Code Review: Platforms like GitHub offer easy integration for code reviews and
collaboration.

5. Testing Tools

5.1 Android Emulator,5.2 Unit Testing Frameworks,5.3 UI Testing Frameworks,5.4 Firebase

Test Lab

6. Performance and Debugging Tools

6.1 Android Profiler :- Android Profiler in Android Studio helps monitor an app’s performance
by providing insights into the CPU, memory, and network usage during runtime.
6.2 Logcat:- Logcat is a command-line tool for viewing system logs, error messages, and other
outputs from Android applications during development.
6.3 LeakCanary;- LeakCanary is an open-source memory leak detection library for Android. It
automatically detects and reports memory leaks, making it easier to optimize app memory
usage.

7. Design Tools

7.1 Layout Editor :- Android Studio Layout Editor provides a visual interface for designing
app UIs.

 Features include:
o Drag-and-drop components like buttons, text fields, and images.
o Ability to preview layouts across multiple screen sizes and densities.

8. Deployment and Distribution Tools

8.1 Google Play Console

 The Google Play Console is a web-based tool for developers to manage, publish, and
distribute their apps on the Google Play Store.
 Features:
o App Submission: Upload APKs and app bundles, manage store listings.
o Analytics: Monitor app performance, crashes, and user engagement.

5
Android Virtual Devices (AVD)

Android Virtual Devices (AVD) are emulator configurations that allow developers to test
Android apps on a variety of virtual Android devices without the need for physical devices. AVDs
simulate real Android hardware and software environments, enabling the testing of apps on
different screen sizes, Android versions, and device configurations. They are an essential part
of the Android development workflow, especially when testing applications for a wide range of
devices and configurations.

Key Features of Android Virtual Devices (AVD)

1. Simulate Real Devices: AVDs replicate the behavior of actual Android devices,
including physical features like sensors, cameras, and GPS, making it easier to test
applications in various environments.
2. Multiple Device Configurations: You can create AVDs with different screen sizes,
resolutions, and Android versions to test compatibility with multiple device types (e.g.,
tablets, smartphones, wearables).
3. Flexible API Levels: AVDs can run different versions of Android (API levels), helping
developers ensure their apps work on both new and older versions of the Android
operating system.
4. Simulate Device Features: AVDs can simulate device sensors, such as accelerometer,
gyroscope, and proximity sensor, as well as location data and network conditions (Wi-
Fi, cellular, etc.).
5. Testing Without Physical Devices: Developers can test their apps on AVDs without
needing access to a range of physical Android devices. This is particularly useful for
testing on devices that may not be available for development.
6. Performance and Resource Monitoring: The Android Emulator provides tools to
monitor the performance of the virtual device, including CPU, memory, and network
usage.

What is an Android Emulator?

An Android Emulator mimics the behavior of an Android device (smartphone, tablet,

wearable, or TV) on your computer. It runs an Android operating system and allows developers
to test applications under different conditions (e.g., different Android versions, screen sizes, or
geographic locations) without the need for physical devices.

Emulators are powered by the Android Emulator component of the Android SDK and are part
of Android Studio, the official IDE for Android development.

Key Features of Android Emulators

1. Multiple Device Configurations:

o Simulate different types of Android devices (e.g., smartphones, tablets,
wearables, Android TVs) with varying screen sizes, resolutions, and hardware
capabilities.
o Developers can choose specific models (e.g., Pixel, Nexus) or create custom
device configurations.
2. Simulate Real-World Conditions:
o Emulators allow you to simulate real-world scenarios such as network conditions
(Wi-Fi, 3G, LTE), battery levels, device orientation (portrait/landscape), and
physical sensors (accelerometer, GPS, etc.).
3. Test Multiple Android Versions:
o You can create and run emulators for different Android versions (API levels),
allowing you to test your app on both the latest release and older versions.
6
 4. Camera and Sensor Simulation:
o The emulator can simulate camera usage, sensor data, and location services,
enabling testing of apps that rely on these features.
5. Performance Monitoring:
o Android Emulators come with built-in tools to monitor the emulator’s performance,
including CPU, memory, and network usage.
6. Support for Google APIs:
o Emulators can run system images that include Google APIs, enabling testing of
apps that rely on Google Play services, such as Firebase, Maps, or Google Sign-
In.

Dalvik Virtual Machine (DVM) :-

The Dalvik Virtual Machine (DVM) was the original process virtual machine used by the
Android operating system for running Android applications. Dalvik is part of the Android runtime
and is responsible for executing compiled Android application code.

Key Features of Dalvik Virtual Machine

1. Optimized for Mobile Devices:

o Dalvik was specifically designed for low-power devices with limited memory and
CPU resources. This made it more efficient for mobile devices compared to
traditional Java Virtual Machines (JVMs), which were optimized for desktop
systems.
o
2. Bytecode Execution:
o Dalvik executed code compiled into DEX (Dalvik Executable) files, a specialized
binary format designed for efficient execution on mobile devices.
o Unlike the traditional Java JVM, which runs bytecode from .class files, Dalvik uses
.dex files, which are optimized for smaller memory footprint and faster execution
on mobile hardware.
o
3. Registers-Based:
o Dalvik is a register-based virtual machine, meaning it uses a small number of
registers (as opposed to the stack-based architecture used by traditional JVMs).
This results in more efficient memory usage and faster performance for mobile
devices.
o
4. Memory Management:
o Dalvik's memory management system was optimized to reduce the memory usage
of running apps. This is important for mobile devices, which have limited RAM and
storage resources compared to desktop computers.
o The Dalvik VM utilized garbage collection to automatically reclaim memory used
by objects that are no longer in use, similar to the JVM's garbage collector.
o
5. Multiple Processes:
o Each Android app ran in its own process, isolated from other apps, to ensure
security and prevent apps from interfering with each other.
o Dalvik allowed each app to run in a sandboxed environment with its own instance
of the Dalvik VM.

7
Differences Between Dalvik Virtual Machine (DVM) and Java Virtual Machine (JVM) :-

Feature Dalvik Virtual Machine (DVM) Java Virtual Machine (JVM)

Used for running Java applications on a

Used specifically for Android
Purpose wide range of platforms (desktops,
applications on mobile devices.
servers, embedded devices, etc.).

Executes DEX (Dalvik Executable)

Bytecode Executes Java bytecode stored in
files, which are optimized for mobile
Format .class files.
devices.

Register-based architecture. Uses Stack-based architecture. Uses a

Execution registers for storing data during stack to store data during execution,
Model execution, making it more efficient which is less efficient in comparison to
for mobile devices. the register-based approach.

Dalvik was designed to work with JVM is optimized for desktop/server

limited resources (CPU, memory) on environments, where resources like
Optimization
mobile devices. It is optimized for memory and processing power are
mobile hardware constraints. more abundant.

Uses Just-in-Time (JIT)

Also uses JIT compilation, but
compilation, where the bytecode is
Compilation typically runs precompiled Java
compiled into native machine code at
bytecode from .class files.
runtime.

Dalvik uses garbage collection to JVM also uses garbage collection, which
Garbage
manage memory, though it was less is designed for more powerful systems
Collection
efficient than ART, which replaced it. with higher memory availability.

Cross-platform; runs on various

Exclusive to Android OS, optimized
Platform operating systems such as Windows,
for mobile devices.
macOS, and Linux.

Dalvik was designed to be more JVM generally performs better on

Performance lightweight and memory-efficient for desktop or server environments, where
resource-constrained devices. more resources are available.

Uses .dex (Dalvik Executable) Uses .class files containing Java

File Format files, which are compact and bytecode, which are standard for Java
optimized for mobile use. applications.

8
Steps to install and configure android studio and SDK :-

Android Studio System Requirements for Windows

 Microsoft Windows 7/8/10 (32-bit or 64-bit)
 4 GB RAM minimum, 8 GB RAM recommended (plus 1 GB for the Android Emulator)
 2 GB of available disk space minimum, 4 GB recommended (500 MB for IDE plus 1.5 GB
for Android SDK and emulator system image)
 1280 x 800 minimum screen resolution

2. Download Android Studio

1. Go to the Android Studio Download Page:

o Visit the official Android Studio download page:
https://developer.android.com/studio.
2. Download the Installer:
o Choose the appropriate version for your operating system (Windows, macOS, or
Linux).
o Download and save the installer to your system.

3. Install Android Studio

On Windows:

1. Run the downloaded .exe file.

2. Follow the setup wizard instructions to install Android Studio.
o Select the components to install (default is usually fine).
o Choose the installation location.
o The installer will automatically install Android Studio, the Android SDK, and
Android Virtual Device (AVD).
3. After installation, click Finish.

4. First-Time Setup of Android Studio

1. Launch Android Studio:

o When you open Android Studio for the first time, you'll be prompted to complete
the initial setup.
2. Configure Android Studio Settings:
o Android Studio will ask if you want to import previous settings (if any). Select the
appropriate option.
o Choose the Standard installation type (this includes the Android SDK, emulator,
etc.).
3. Install Android SDK:
o During setup, Android Studio will prompt you to install the Android SDK, the
Android Emulator, and other tools. Make sure to choose Install to proceed.
4. Download Android SDK Packages:
o The Android SDK is automatically downloaded during setup. Make sure you allow
the SDK manager to install the necessary components.
o Select the recommended SDK version and tools.

5. Set Up Android SDK

Once Android Studio is installed, you'll want to configure the SDK settings:

9
1. Access SDK Manager:
o Open Android Studio.
o Go to Tools > SDK Manager.
2. Install SDK Components:
o In the SDK Manager, make sure the following components are installed:
 Android SDK (Latest version)
 SDK Platform Tools
 SDK Build Tools
 Android Emulator (for testing apps)
 Google APIs (if required by your app)
3. Install Additional SDK Packages (Optional):
o In the SDK Platforms tab, you can install additional versions of Android (e.g.,
Android 10, Android 9, etc.).
o In the SDK Tools tab, you can install tools like Android NDK, Intel HAXM (for
emulator performance), and other libraries.
4. Configure SDK Location:
o If needed, you can change the default SDK location under the SDK Location tab
in the SDK Manager.

10