THEORY FILE : Android Programming

(FULL NOTES: BY SAHIL RAUNIYAR / PTU-CODER) .

SUBJECT CODE: UGCA- 1943

BACHELOR OF COMPUTER APPLICATIONS

ER
MAINTAINED BY: TEACHER’S /MAM’:
Sahil Kumar Prof. Jiwanpreet Kaur

COLLEGE ROLL NO: 226617

D
UNIVERSITY ROLL NO: 2200315
O
C
U
PT
@

DEPARTMENT OF COMPUTER SCIENCE ENGINEERING

BABA BANDA SINGH BAHADUR ENGINEERING

COLLEGE FATEGARH SAHIB

 1

Program BCA ➖➖
Course Name
Semester
➖ 6th.
Android Programming (Theory).

UNIT ➖01
●​ # Characteristics of Mobile applications, Introduction to Android Development
Environment, Advantages and Futures of Android, Architecture and working of

ER
➖
Android, User-interface design for mobile applications and managing application
data :

Characteristics of Mobile Applications ➖

1.​ Portability and Compatibility

D
○​ Mobile applications are designed to run on a variety of devices such as smartphones,
tablets, and wearables.
O ○​ They support multiple operating systems (e.g., Android, iOS).
2.​ Touch Interaction
○​ Optimized for touch screens, enabling gestures like tap, swipe, and pinch-to-zoom.
3.​ Connectivity
○​ Mobile apps leverage network features like Wi-Fi, cellular data, Bluetooth, NFC, and GPS
C
for communication and functionality.
4.​ Performance Efficiency
○​ Optimized to run on devices with limited hardware resources such as low RAM, CPU, and
battery life.
U

5.​ Context Awareness

○​ Utilize sensors like accelerometers, gyroscopes, cameras, and GPS for location-based
services and user-specific functionalities.
PT

6.​ User-centric Design

○​ Intuitive, user-friendly interfaces that prioritize usability and accessibility.
7.​ Security Features
○​ Ensure secure data storage, communication, and user authentication (e.g., biometric
authentication and encryption).
@

Introduction to Android Development Environment ➖

What is Android?

●​ Android Development Environment refers to the tools, frameworks, and resources used for
developing Android applications. It provides the necessary setup to create, test, and deploy apps
for the Android operating system.
●​ Android is an open-source mobile operating system developed by Google, based on the
Linux kernel.
●​ It powers billions of devices globally, including smartphones, tablets, TVs, and IoT devices.
 ➖
2
Key Components of Android Development Environment

1.​ Android Studio

○​ What is it?
■​ Android Studio is the official Integrated Development Environment (IDE) for Android app
development, introduced by Google.
○​ Features:
■​ Code Editor: Intuitive, with syntax highlighting and error detection.
■​ Layout Editor: Drag-and-drop UI builder with a live preview.
■​ Emulator: Allows testing of apps on virtual Android devices.
■​ Debugging Tools: Includes step-through debugging and breakpoints.
■​ Gradle Build System: Automated build processes, dependencies, and versioning.

ER
2.​ Android Software Development Kit (SDK)
○​ A collection of tools, libraries, and resources required for Android development.
○​ Key Components:
■​ APIs: Predefined libraries to handle UI, multimedia, sensors, networking, etc.
■​ ADB (Android Debug Bridge): Command-line tool for interacting with devices.
■​ SDK Tools: Includes tools for debugging, profiling, and performance monitoring.
3.​ Emulator

D
○​ Simulates an Android device for app testing without physical hardware.
○​ Features:
O ■​ Supports various Android versions and screen sizes.
■​ Allows testing of features like GPS, camera, and network conditions.
4.​ Build Automation Tools
○​ Gradle: Default build system in Android Studio for managing dependencies and build
configurations.
C
○​ Maven and Ant: Alternative build tools for advanced users.
5.​ Programming Languages
○​ Java: Traditional language for Android app development.
○​ Kotlin: Modern, concise, and fully supported by Google as the preferred language.
U

○​ C++/C: Used with the Android Native Development Kit (NDK) for performance-critical parts
of an app.
6.​ Version Control System
PT

○​ Tools like Git and platforms like GitHub, GitLab, or Bitbucket are used for versioning and
collaboration.

Setting Up Android Development Environment ➖

@

1.​ Install Android Studio:

○​ Download Android Studio from the official site: https://developer.android.com/studio.
○​ Follow the installation steps for your operating system.
2.​ Set Up SDK:
○​ During the installation, Android Studio prompts to install the SDK.
○​ Select additional components like system images, emulator tools, and platform tools.
3.​ Configure the Emulator:
○​ Open the AVD (Android Virtual Device) Manager in Android Studio.
○​ Create a new emulator configuration by selecting a device model and Android version.
4.​ Create Your First Project:
○​ Launch Android Studio and click on "Create New Project."
○​ Choose a project template (e.g., Empty Activity).
 3
○​ Configure project details like name, package name, and API level.
5.​ Write and Test Code:
○​ Use the code editor for writing Java or Kotlin code.
○​ Run the app on the emulator or a connected physical device.

Advantages of the Android Development Environment ➖

●​ Integrated Tools: Combines code writing, designing, testing, and debugging in one platform.
●​ Cross-Platform Compatibility: Supports development on Windows, macOS, and Linux.

ER
●​ Extensive Documentation: Well-documented resources, tutorials, and APIs.
●​ Open Source: Android SDK and tools are freely available, fostering innovation and collaboration.

Android Development Tools

1.​ Android Studio:

○​ Official Integrated Development Environment (IDE) for Android development.
○​ Provides features like code editing, debugging, and performance analysis.

D
2.​ Android Software Development Kit (SDK):
○​ A set of tools, libraries, and APIs used to develop Android apps.
3.​ Build Automation Tools:
○​ Gradle: Manages builds, dependencies, and versioning.
O
4.​ Android Emulator:
○​ Simulates an Android device for testing apps on different configurations.
5.​ Version Control Tools:
C
○​ Git for source code versioning and collaboration.

➖
U

Advantages and Futures of Android

Advantages
PT

1.​ Open Source

○​ Android is freely available and can be customized by manufacturers and developers.
2.​ Massive User Base
○​ Android holds the largest share in the global smartphone market, offering developers a wide
audience.
3.​ Versatility
○​ Android apps can run on phones, tablets, TVs, wearables, and IoT devices.
@

4.​ Extensive Library Support

○​ Offers a vast collection of APIs for multimedia, machine learning, and cloud integration.
5.​ Regular Updates
○​ Google provides frequent updates to enhance security and add features.

Future of Android

1.​ Integration with AI and Machine Learning

○​ Enhanced personalization and automation through AI.
○​ TensorFlow Lite and ML Kit for embedding ML models in apps.
2.​ Wearable and IoT Expansion
○​ Increased focus on WearOS and smart device integration.
 4
3.​ 5G Compatibility
○​ Optimizing applications to leverage the speed and low latency of 5G networks.
4.​ Cross-Platform Development
○​ Kotlin Multiplatform and Flutter for building apps that work on multiple platforms.

Architecture and Working of Android ➖

Android Architecture

1.​ Linux Kernel:

ER
○​ Core layer providing hardware abstraction, memory management, and security features.
2.​ Hardware Abstraction Layer (HAL):
○​ Interfaces between the hardware and Android runtime.
3.​ Libraries:
○​ Includes SQLite (database), OpenGL (graphics), WebKit (browser), etc.
4.​ Android Runtime (ART):
○​ Executes app code in a virtualized environment for performance and security.

D
○​ Uses Just-In-Time (JIT) and Ahead-Of-Time (AOT) compilation.
5.​ Application Framework:
O ○​ APIs for UI design, app lifecycle management, notifications, and background processes.
6.​ Applications Layer:
○​ The user-facing apps (e.g., Contacts, Browser) run on this topmost layer.

Working of Android
C
1.​ User interacts with an app.
2.​ App communicates with the Application Framework to request resources.
3.​ Framework interacts with the runtime and libraries to process the request.
U

4.​ Runtime interacts with the kernel for hardware-level operations.

5.​ Output is rendered back to the user interface.
PT

User Interface Design for Mobile Applications ➖

1.​ Responsive Design
○​ Ensures apps adapt to various screen sizes and resolutions.
2.​ Material Design Guidelines
○​ Google’s guidelines for creating consistent and visually appealing UI.
@

○​ Features include flat designs, bold colors, and dynamic transitions.

3.​ Accessibility
○​ Design for inclusivity, including features like screen readers, high-contrast modes, and large
font options.
4.​ Simplified Navigation
○​ Use tab bars, menus, and gestures to facilitate easy movement within the app.
5.​ Animation and Feedback
○​ Smooth transitions and animations for a more engaging user experience.
6.​ Consistency
○​ Maintain uniformity in layout, typography, and colors across all app screens.
 5

Managing Application Data ➖

Data Storage Methods

1.​ Shared Preferences

○​ Used for storing small amounts of key-value data like user preferences.
2.​ SQLite Database
○​ Built-in lightweight database for storing structured data.
3.​ File Storage

ER
○​ Used for saving files like images or documents.
○​ Supports internal and external storage.
4.​ Cloud-Based Storage
○​ Services like Firebase for real-time syncing and cloud backups.
5.​ Content Providers
○​ Facilitates sharing of data between different apps in a secure way.

D
HAPPY ENDING BY : SAHIL RAUNIYAR / PTUCODER 😀
O
C
U
PT
@
 6

UNIT ➖ 02
●​ # Integrating cloud services, networking, OS and hardware into mobile applications.

➖
Enterprise requirements in mobile applications: Performance, Scalability,
Modifiability, Availability and Security :

Integrating Cloud Services, Networking, OS, and Hardware into Mobile Applications ➖

ER
Modern mobile applications leverage various technologies to deliver seamless and efficient user
experiences. Integration with cloud services, networking capabilities, operating systems (OS), and
hardware is essential to meet functional and enterprise requirements.

D
1. Integrating Cloud Services

Cloud services provide the backbone for mobile applications by enabling remote storage, data
synchronization, and scalable computational resources.
O
●​ Benefits:
○​ Data Storage and Backup: Securely store user data on cloud platforms like AWS, Azure,
or Google Cloud.
C
○​ Real-Time Sync: Sync user data across devices (e.g., Google Drive, iCloud).
○​ Scalability: Handle sudden spikes in traffic with elastic cloud resources.
○​ AI/ML Integration: Utilize advanced services like machine learning APIs for speech
recognition, image processing, etc.
U

○​ Push Notifications: Implement cloud-based push notification services (e.g., Firebase

Cloud Messaging).
○​ Cost-Effectiveness: Pay-as-you-go pricing reduces infrastructure costs.
○​ Reliability: Cloud services offer high uptime and disaster recovery options.
PT

➖
○​ Global Reach: Content Delivery Networks (CDNs) ensure fast content delivery globally.
○​ Examples
○​ Storing app user files in Amazon S3.
○​ Using Firebase Authentication for secure login processes.
●​ Key Tools and Platforms:
○​ Firebase (Google)
@

○​ AWS Amplify
○​ Microsoft Azure Mobile Apps
○​ Backend-as-a-Service (BaaS) providers like Backendless.

Features of Cloud Integration ➖

●​ Data Storage and Backup: Cloud platforms like AWS, Google Cloud, or Microsoft Azure store user
data, enabling easy backups and retrieval.
●​ Scalable Backend Services: Handle fluctuating user demands with auto-scaling services.
●​ Real-Time Synchronization: Synchronize user data across devices using tools like Firebase
Realtime Database or Firestore.
 7
●​ Advanced Features: Enable AI/ML functionalities, push notifications, and serverless functions for
apps.

2. Networking in Mobile Applications ➖

Networking capabilities enable applications to communicate with servers, APIs, and other devices.

●​ Common Networking Features:

○​ RESTful APIs: Use HTTP-based APIs to fetch and send data.
○​ WebSocket Protocol: Enable real-time communication for messaging or live updates.

ER
○​ OAuth Authentication: Secure access using tokens from third-party services.
○​ Data Encryption: Use HTTPS, SSL/TLS for secure data transmission.
●​ Challenges:
○​ Network Variability: Handle different network speeds (Wi-Fi, 4G/5G, etc.).
○​ Offline Functionality: Ensure the app works with cached data or local storage during
connectivity loss.
●​ Networking Libraries and Frameworks:

D
○​ Retrofit, Volley (Android)
○​ Alamofire (iOS)
O ○​ GraphQL APIs for structured queries.

3. OS Integration ➖
C
Integration with the mobile OS is critical for accessing system-level features and ensuring compatibility.

●​ Key Features:
○​ Platform APIs: Use platform-specific APIs for sensors, camera, and notifications.
U

○​ System Updates: Keep the app compatible with the latest OS versions.
○​ Permissions: Manage user permissions for location, storage, and camera.
○​ UI Guidelines: Follow platform-specific design guidelines (e.g., Material Design for
Android, Human Interface Guidelines for iOS).
PT

4. Hardware Integration ➖
Mobile devices come with various hardware components that apps can use to deliver enhanced
functionality.
@

●​ Hardware Features to Integrate:

○​ Sensors: Access accelerometer, gyroscope, and proximity sensors for motion and
context-aware apps.
○​ Camera and Microphone: Enable photo, video, and audio recording capabilities.
○​ GPS: Provide location-based services.
○​ Biometrics: Utilize fingerprint or face recognition for secure authentication.
○​ IoT Integration: Connect with smart devices via Bluetooth or Wi-Fi.
●​ Development Tips:
○​ Use platform-specific SDKs for hardware (e.g., CameraX for Android).
○​ Ensure efficient use of battery and processing power when using hardware components.
 8

Enterprise Requirements in Mobile Applications ➖

Enterprise applications must adhere to strict requirements to ensure reliability, usability, and security for
business operations.

1. Performance ➖
●​ Definition: The app must provide fast, responsive, and smooth functionality.

ER
●​ Key Metrics:
○​ Load time (e.g., < 2 seconds for most actions).
○​ Minimal lag or stutter during animations and operations.
●​ Optimization Techniques:
○​ Use efficient algorithms and asynchronous programming.
○​ Compress images, videos, and other assets.
○​ Optimize database queries and API calls.

D
2. Scalability
O ➖
●​ Definition: The app should handle an increasing number of users or data without performance
degradation.
●​ Strategies:
C
○​ Use cloud services for elastic scalability.
○​ Design microservices architecture to handle specific app features.
○​ Load balance across multiple servers or instances.
U

3. Modifiability ➖
PT

●​ Definition: The app should be easily updated or extended to add new features or fix bugs.
●​ Best Practices:
○​ Write modular and well-documented code.
○​ Use version control systems like Git.
○​ Follow design patterns such as MVVM or MVC for code organization.
@

4. Availability ➖
●​ Definition: The app should be accessible and functional at all times with minimal downtime.
●​ Key Strategies:
○​ Implement failover systems and redundancy.
○​ Use cloud-based Content Delivery Networks (CDNs) for global availability.
○​ Monitor app performance and downtime using tools like New Relic or Firebase Crashlytics.
 ➖
9
5. Security

●​ Definition: Protect user data and ensure secure communication between devices and servers.
●​ Critical Aspects:
○​ Data Encryption: Encrypt sensitive data using AES or RSA.
○​ Authentication: Implement secure login mechanisms, such as OAuth or SSO.
○​ Data Validation: Prevent attacks like SQL injection or XSS by validating input.
○​ Compliance: Adhere to data privacy regulations like GDPR or HIPAA.
●​ Tools:
○​ Use security libraries like OWASP ZAP for penetration testing.
○​ Implement token-based security for APIs (JWT).

ER
Conclusion ➖
Integrating cloud services, networking, OS, and hardware into mobile applications is essential for creating
robust, feature-rich apps that meet enterprise requirements. By focusing on performance, scalability,
modifiability, availability, and security, developers can ensure their applications meet user expectations

D
and enterprise standards.

😀
O HAPPY ENDING BY : SAHIL RAUNIYAR / PTUCODER
C
U
PT
@
 10

UNIT ➖ 03
➖
●​ # Mobile Software Engineering (Design Principles, Development, Testing
methodologies for mobile applications

Mobile Software Engineering ➖

ER
Mobile software engineering focuses on the systematic design, development, testing, and maintenance of
mobile applications. It emphasizes unique challenges like varying devices, operating systems, screen
sizes, and performance limitations.

1. Design Principles for Mobile Applications ➖

D
Key Principles

1.​ User-Centered Design (UCD):

O ○​ Prioritize user needs and behaviors.
○​ Conduct user research, create personas, and map user journeys.
2.​ Responsive Design:
○​ Ensure app works seamlessly across different screen sizes and orientations.
C
○​ Use responsive layouts like grids and flexible images.
3.​ Performance Optimization:
○​ Minimize resource consumption (CPU, memory, battery).
○​ Reduce app load times with lightweight assets and caching.
U

4.​ Consistency:
○​ Maintain a uniform interface using platform-specific guidelines (Material Design for Android,
HIG for iOS).
○​ Keep branding consistent across screens.
PT

5.​ Minimize Input Effort:

○​ Simplify forms with autofill, dropdowns, and suggestions.
○​ Use biometric authentication to avoid frequent logins.
6.​ Accessibility:
○​ Make the app usable for all, including people with disabilities.
○​ Support screen readers, high contrast, and dynamic text sizes.
@

7.​ Security and Privacy:

○​ Encrypt sensitive data and use secure communication protocols.
○​ Adhere to data privacy regulations (e.g., GDPR).

Design Tools

●​ Figma, Sketch, Adobe XD for prototyping and UI design.

●​ InVision for interactive mockups.
 ➖
11
2. Development Methodologies for Mobile Applications

a. Native Development

●​ Definition: Develop apps specifically for one platform (Android or iOS).

●​ Technologies:
○​ Android: Java, Kotlin.
○​ iOS: Swift, Objective-C.
●​ Advantages:
○​ High performance and full access to device features.
○​ Adherence to platform guidelines.

ER
b. Cross-Platform Development

●​ Definition: Create apps that run on multiple platforms using a single codebase.
●​ Technologies:
○​ Flutter (Dart): Fast, with customizable UI components.
○​ React Native (JavaScript): Great for reusable components and a vast ecosystem.
●​ Advantages:

D
○​ Faster development and reduced costs.
○​ Consistency across platforms.

c. Hybrid Development
O
●​ Definition: Use web technologies (HTML, CSS, JavaScript) inside a native wrapper.
●​ Technologies: Ionic, Apache Cordova.
●​ Advantages:
C
○​ Simplifies development for simple apps.
○​ Faster time to market.

d. Progressive Web Applications (PWAs)

U

●​ Definition: Web apps that behave like native apps.

●​ Technologies: Service Workers, Web App Manifest.
●​ Advantages:
PT

○​ No installation required.
○​ Works offline and provides app-like experience.

e. Backend as a Service (BaaS)

●​ Platforms like Firebase, AWS Amplify offer ready-made backend solutions, including
authentication, databases, and cloud storage.
@

3. Testing Methodologies for Mobile Applications ➖

Testing is crucial to ensure the quality, functionality, and performance of mobile applications.

Types of Testing

1.​ Functional Testing:

○​ Ensures the app performs its intended functions.
○​ Tests UI, workflows, and interactions.
 12
2.​ Performance Testing:
○​ Measures speed, responsiveness, and stability under different conditions.
○​ Tools: JMeter, Firebase Performance Monitoring.
3.​ Compatibility Testing:
○​ Ensures app works on various devices, screen sizes, and OS versions.
○​ Tools: BrowserStack, Sauce Labs.
4.​ Security Testing:
○​ Identifies vulnerabilities and ensures data protection.
○​ Tools: OWASP ZAP, Burp Suite.
5.​ Usability Testing:
○​ Focuses on user experience, ease of use, and accessibility.

ER
○​ Conduct with real users or tools like UserTesting.
6.​ Regression Testing:
○​ Verifies that new updates do not break existing functionality.
○​ Automate using tools like Appium, Selenium.
7.​ Localization Testing:
○​ Checks for correct translations, formatting, and cultural appropriateness.

D
Testing Strategies

●​ Manual Testing: Conducted by testers for exploratory and usability testing.

●​ Automated Testing: Scripts automate repetitive tests, improving efficiency.
O
Popular Testing Frameworks

●​ Appium: Open-source for automating Android, iOS, and web apps.

C
●​ Espresso: For Android UI testing.
●​ XCTest/XCUITest: For iOS app testing.
●​ Detox: For React Native end-to-end testing.
U

4. Challenges in Mobile Software Engineering ➖

PT

1.​ Device Fragmentation:

○​ Wide variety of devices with different screen sizes, resolutions, and capabilities.
2.​ OS Fragmentation:
○​ Multiple OS versions in use (e.g., Android older versions).
3.​ Performance Optimization:
○​ Ensure smooth performance on low-end devices with limited resources.
@

4.​ Security Risks:

○​ Protect against threats like data breaches and unauthorized access.
5.​ Network Dependence:
○​ Handle varying network speeds and offline scenarios.

5. Best Practices for Mobile Software Engineering ➖

1.​ Use Agile Development:
○​ Iterative approach with continuous feedback for better outcomes.
2.​ Implement CI/CD Pipelines:
 13
○​ Automate testing and deployment for faster releases.
3.​ Focus on MVP (Minimum Viable Product):
○​ Launch a basic version to gather feedback and iteratively improve.
4.​ Monitor App Metrics:
○​ Use tools like Google Analytics or Firebase Crashlytics to track performance and errors.
5.​ Adopt Design Patterns:
○​ Follow patterns like MVVM, MVC, or MVP for maintainable code.

Conclusion ➖

ER
Mobile software engineering is a dynamic field requiring an understanding of design principles, modern
development methodologies, and rigorous testing approaches. Following best practices ensures the
delivery of high-quality, user-centric, and secure mobile applications.

HAPPY ENDING BY : SAHIL RAUNIYAR / PTUCODER 😀

D
O
C
U
PT
@
 14

UNIT ➖ 04
➖
●​ # Directory Structure of an Android Project, Common Default Resources Folders,
The Values Folder, Leveraging Android XML :

Directory Structure of an Android Project ➖

ER
An Android project follows a specific directory structure to organize code, resources, assets, and other
configurations. The structure ensures that the application is modular, maintainable, and easy to navigate.

Here’s a deep dive into the typical directory structure of an Android project:

1. Root Directory

The root directory contains essential files for configuring and building the Android project.

D
●​ build.gradle (Project-level): Contains configuration for the entire project, including
dependencies, repositories, and build options.
●​ settings.gradle: Defines settings related to the structure of the project, such as which
Omodules to include in the build.
●​ gradle: A directory containing Gradle wrapper files, which ensure a consistent Gradle version
across different machines.
C
●​ local.properties: Contains the local settings, like the location of the SDK.

2. app/ Directory
U

This is the module directory that contains the core application code. Within the app/ directory, you’ll find
several important subdirectories and files:

2.1. src/
PT

This folder contains the source code for the application. It is divided into multiple subdirectories:

●​ main/: Contains the primary code, resources, and configurations for the application.
○​ java/: This directory contains all Java/Kotlin files (for Android development).
■​ com.example.appname/: The package structure for your application. Typically,
@

you'll find files like MainActivity.java here.

○​ res/: This directory contains all the resources used by your application, such as layouts,
images, and strings.
○​ assets/: Contains raw files that the app can access directly, such as databases, fonts, or
media files. These are stored in their original format.
○​ AndroidManifest.xml: The manifest file that declares the app's components,
permissions, and other important configurations.
○​ build/: Contains all compiled output (generated APK files, etc.) after the build process.

2.2. test/ and androidTest/

 15
●​ test/: Unit tests that are run on the local JVM.
●​ androidTest/: Contains tests that run on an Android device or emulator (instrumented tests).

Common Default Resources Folders ➖

Android projects support multiple types of resources, like layouts, drawables, strings, etc., and these are
placed in specific resource folders under the res/ directory. Each folder has its role:

1.​ drawable/: Stores graphical resources like images, vector files, and other drawable assets. You

ER
can have different drawable folders based on screen density (e.g., drawable-mdpi/,
drawable-hdpi/).
2.​ layout/: Contains XML files defining the structure of your user interfaces. These layouts are
used to arrange UI elements like buttons, text fields, and more.
3.​ mipmap/: Similar to drawable/ but optimized for launcher icons.
4.​ values/: This folder contains XML files that define resources such as strings, colors, dimensions,

D
and styles. Key files include:
○​ strings.xml: Defines text that can be referenced throughout the app.
○​ colors.xml: Defines color values for the app.
○​ styles.xml: Contains theme and style definitions.
O ○​ dimens.xml: Defines fixed dimension values like padding, margin, and font sizes.

These folders allow for resource organization, and the system automatically selects the appropriate
C
resources based on the device's screen size, density, locale, etc.

➖
U

The values/ Folder

The values/ folder is one of the most important directories in the res/ folder. It stores various XML files
used for defining resource values that the application can reference. Here's a breakdown of common files
PT

found within values/:

1. strings.xml

This file is used to store string resources, which can then be referenced in Java/Kotlin code or XML
layout files.
@

Example:

xml
<resources>
<string name="app_name">My Application</string>
<string name="hello_message">Hello, World!</string>
</resources>

●​ Why it’s used: Storing strings in this file allows for easier localization and avoids hardcoding text
into your application code.
 16
2. colors.xml

Defines color resources for the app, so that you can use them consistently across layouts and themes.

Example:

xml
<resources>
<color name="primary_color">#FF0000</color>
<color name="secondary_color">#00FF00</color>
</resources>

ER
●​ Why it’s used: This ensures that you can easily change your app’s color scheme by modifying the
colors.xml file, which is easier to manage than changing each individual color in your code.

3. dimens.xml

D
Contains dimension values like padding, margin, and text size.

Example:

xml
O
<resources>
<dimen name="padding_small">8dp</dimen>
<dimen name="padding_large">16dp</dimen>
C
</resources>

●​ Why it’s used: By using this file, developers can define standard sizes that can be reused across
U

different parts of the app, improving consistency and easing maintenance.

4. styles.xml
PT

This file is used to define and customize the visual appearance of your app by declaring themes, colors,
and fonts. A theme defines the look and feel of the application (or an activity).

Example:

xml
<resources>
@

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">

<item name="colorPrimary">@color/primary_color</item>
<item name="android:textColor">@color/text_color</item>
</style>
</resources>

●​ Why it’s used: Styles enable you to easily reuse UI properties across different elements in your
app, allowing for faster updates and changes to your app’s look.
 17
5. attrs.xml

This file defines custom attributes that can be used to style or configure UI elements. This file is not
always necessary but is often used in custom views.

Example:

xml
<declare-styleable name="CustomButton">
<attr name="customTextColor" format="color"/>
</declare-styleable>

ER
●​ Why it’s used: Custom attributes enable customization of UI components via XML and allow for
more flexibility in developing reusable custom views.

Leveraging Android XML

D
Android XML is used extensively throughout the development process. It's used for defining layouts,
resources, themes, and more. Here’s how Android XML is leveraged:
O
1. Layout Files (res/layout/)

XML layout files define the UI structure of the app. For example:
C
xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
U

android:layout_height="match_parent"
android:orientation="vertical">
PT

<TextView
android:id="@+id/hello_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_message" />
</LinearLayout>
@

●​ Why it’s used: Layout files use a declarative syntax to define UI components. The XML file is
easy to understand and modify, separating the UI structure from the logic.

2. Defining Resources

As discussed earlier, values like strings, colors, and dimensions are defined in XML and referenced
throughout the code. This promotes reuse and consistency.
 ➖
18
Example in layout:

xml
<Button
android:text="@string/login_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />

3. Custom Views and Attributes

ER
XML can also be used to define custom views and allow attributes to be passed to them.

Example in attrs.xml:

xml
<declare-styleable name="CustomView">
<attr name="backgroundColor" format="color" />

D
</declare-styleable>

●​ Why it’s used: Custom attributes in XML allow developers to easily configure UI elements through
OXML rather than programmatically.
C
Conclusion

The Android project directory structure helps organize the code, resources, and assets in a modular and
easy-to-maintain way. The values/ folder plays a vital role in defining reusable resources like strings,
U

colors, and styles, which can be referenced throughout the application. Leveraging XML in Android
ensures that the UI is scalable, flexible, and easy to maintain. By understanding the directory structure
and resource management in Android, developers can streamline the development process and create
PT

efficient, maintainable applications.

HAPPY ENDING BY : SAHIL RAUNIYAR / PTUCODER 😀

@
 19

Previous Year Questions

BCA (Sem.–6)
ANDROID PROGRAMMING
Subject Code : UGCA-1943
M.Code : 91681
Date of Examination : 04-07-22

SECTION ➖A

ER
1. Write briefly :
a) Java and JVM
b) Intent
c) Security
d) HTTP
e) XML
f) Spinner

D
g) Framework
h) DVM
i) Android XML
O
j) GPS

Detailed Explanations
C
a) Java and JVM​
Java is a high-level, object-oriented programming language widely used for web, mobile, and enterprise
applications. It follows the principle of "Write Once, Run Anywhere" (WORA) because Java code is
U

compiled into bytecode, which can run on any platform with a Java Virtual Machine (JVM).

The Java Virtual Machine (JVM) is a runtime environment that executes Java bytecode. It provides
memory management, garbage collection, and security features. JVM is platform-specific, but Java
PT

bytecode remains platform-independent, allowing Java applications to run on different operating systems
without modification.

b) Intent​
In Android, an Intent is a messaging object used to request actions from other components. It facilitates
@

communication between activities, services, and broadcast receivers.

There are two types of intents:

Explicit Intent – Specifies the exact component to be launched (e.g., opening a specific activity).​
java​
Intent intent = new Intent(CurrentActivity.this, NextActivity.class);
startActivity(intent);

1.​
 20
Implicit Intent – Does not specify the target component, allowing the system to decide based on the
action (e.g., sharing text, opening a URL).​
java​
Intent intent = new Intent(Intent.ACTION_VIEW,
Uri.parse("https://www.google.com"));
startActivity(intent);

c) Security​
Security refers to protecting systems, applications, and data from threats such as hacking, malware, and
unauthorized access. Key security concepts include:

ER
●​ Authentication – Verifying user identity (e.g., login with username and password).
●​ Encryption – Converting data into an unreadable format to prevent unauthorized access (e.g.,
SSL/TLS for secure communication).
●​ Data Privacy – Ensuring that sensitive user data is protected (e.g., Android's permission system
for accessing user data).
●​ Secure Coding Practices – Preventing vulnerabilities such as SQL injection, cross-site scripting

D
(XSS), and buffer overflows.

O
d) HTTP (HyperText Transfer Protocol)​
HTTP is a communication protocol that allows web browsers and servers to exchange data over the
internet. It follows a request-response model:
C
1.​ Client (browser/app) sends an HTTP request (e.g., requesting a webpage).
2.​ Server processes the request and responds with the requested resource (e.g., HTML, JSON).

HTTP methods include:

U

●​ GET – Retrieve data from a server.

●​ POST – Send data to a server (e.g., form submission).
●​ PUT – Update an existing resource.
PT

●​ DELETE – Remove a resource.

Secure communication is ensured using HTTPS (HTTP Secure), which encrypts data using SSL/TLS.

e) XML (Extensible Markup Language)​

@

XML is a markup language used for storing and transporting structured data. It defines custom tags to
organize data in a human-readable and machine-readable format.

Example of an XML file:

xml
<employee>
<name>John Doe</name>
<age>30</age>
<department>IT</department>
</employee>
 21
In Android, XML is used for:

●​ UI layouts (e.g., activity_main.xml).

●​ Configuration files (e.g., AndroidManifest.xml).
●​ Data exchange (e.g., RSS feeds, APIs).

f) Spinner​
A Spinner is an Android UI widget that provides a dropdown list for users to select an option. It is similar
to a combo box in desktop applications.

ER
Example of a Spinner in XML:

xml
<Spinner
android:id="@+id/spinner"
android:layout_width="wrap_content"

D
android:layout_height="wrap_content"/>

In Java:

java
O
Spinner spinner = findViewById(R.id.spinner);
ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
android.R.layout.simple_spinner_item, items);
C
spinner.setAdapter(adapter);
U

Spinners are useful for selecting options like country lists, categories, or filter settings.
PT

g) Framework​
A framework is a pre-built collection of tools, libraries, and best practices that provide a structured way to
develop applications.

Examples of frameworks:

●​ Android Framework – Provides APIs and tools for building Android apps.
@

●​ Spring Framework – Java framework for enterprise applications.

●​ Django – Python framework for web development.
●​ React.js – JavaScript framework for building web applications.

A framework helps developers by offering reusable components, reducing development time, and
ensuring code consistency.

h) DVM (Dalvik Virtual Machine)​

DVM is a virtual machine designed for running Android applications. It executes Dalvik bytecode, which
is optimized for mobile devices with limited resources.
 22
Key features of DVM:

●​ Memory-efficient – Uses register-based architecture instead of stack-based (JVM).

●​ Multi-tasking support – Optimized for running multiple apps on Android.
●​ Optimization for low-power devices – Reduces battery consumption.

Since Android 5.0 (Lollipop), DVM has been replaced by ART (Android Runtime), which improves
performance by using ahead-of-time (AOT) compilation instead of just-in-time (JIT).

i) Android XML​

ER
Android uses XML extensively for defining UI components, themes, and settings. Important XML files in
Android include:

Layout XML – Defines UI structure.​

xml​
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"

D
android:layout_height="match_parent">
<TextView
O android:text="Hello World!"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</LinearLayout>
C
1.​ Manifest XML (AndroidManifest.xml) – Contains app metadata, permissions, and component
declarations.​
xml​
U

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="com.example.app">
<application
PT

android:allowBackup="true"
android:label="My App">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
@

<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
</manifest>
 23
2.​ Drawable XML – Defines vector graphics, shapes, and animations.

j) GPS (Global Positioning System)​

GPS is a satellite-based navigation system that provides location tracking and positioning. Android apps
use GPS for:

●​ Maps and navigation (e.g., Google Maps).

●​ Location-based services (e.g., ride-hailing apps).
●​ Geo-tagging (e.g., tagging location in photos).

ER
Example of accessing GPS in Android:

java
LocationManager locationManager = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
Location location =
locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);

D
To use GPS, the app must request location permissions in AndroidManifest.xml:
O
xml
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
C
GPS works by receiving signals from multiple satellites to calculate the device’s exact position. It can also
be enhanced using Wi-Fi, cellular networks, and Bluetooth for better accuracy.
U
PT
@
 ➖B
24
SECTION

2. Discuss the architecture and working of Android Phone.

3. Write a note on Android development environment.
4. Discuss the directory structure of an Android Project.
5. Describe these App components - Intent, Activity and Threads.
6. Develop an App and make use of checkbox and radio buttons.
7. Discuss the process of testing an application.

ER
2. Architecture and Working of Android Phone
Android Architecture

Android follows a layered architecture, which consists of five main components:

D
1. Linux Kernel:

●​ The foundation of Android OS, responsible for process management, memory management,
security, and drivers for hardware components like the camera, Bluetooth, and Wi-Fi.
O
●​ Provides a stable and secure environment for app execution.

2. Hardware Abstraction Layer (HAL):

C
●​ Acts as an interface between hardware components and higher-level Android services.
●​ Consists of multiple libraries that allow Android to communicate with device-specific hardware like
audio, sensors, and graphics.
U

3. Native Libraries:

●​ A set of C/C++ libraries that provide core functionalities, including:

PT

○​ SQLite – Database management.

○​ OpenGL ES – Graphics rendering.
○​ WebKit – Web browsing engine.
○​ Media Framework – Supports playback and recording of audio/video.

4. Android Runtime (ART):

@

●​ ART replaces the older Dalvik Virtual Machine (DVM) to improve performance.
●​ Uses Ahead-of-Time (AOT) Compilation to convert bytecode into native machine code for faster
execution.
●​ Includes Garbage Collection (GC) to manage memory efficiently.

5. Application Framework:

●​ Provides APIs for developers to interact with core system components.

●​ Includes:
○​ Activity Manager – Manages app life cycle.
○​ Content Providers – Manages shared app data.
 25
○​ Notification Manager – Handles user notifications.

6. Applications Layer:

●​ The topmost layer, where user applications run (e.g., Phone, Messages, Camera, and third-party
apps).

Working of an Android Phone

1.​ When an Android phone starts, it loads the bootloader, which initializes the Linux Kernel.
2.​ The Android Runtime (ART) loads system services and manages app execution.

ER
3.​ The System Server launches system components like Wi-Fi, telephony, and notifications.
4.​ When a user launches an app, the Activity Manager starts the app's process, and the UI is
displayed.
5.​ The system efficiently manages memory, processes, and battery life to ensure smooth operation.

D
3. Android Development Environment
The Android development environment consists of the tools and software required to build Android
applications.
O
1. Android Studio

●​ The official Integrated Development Environment (IDE) for Android development, based on
C
IntelliJ IDEA.
●​ Features include:
○​ Code editor with auto-completion
○​ Built-in emulator for testing
U

○​ Gradle-based build system

2. Android SDK (Software Development Kit)

PT

●​ Includes APIs, libraries, debugging tools, and system images for developing apps.

3. Java/Kotlin Programming Languages

●​ Java and Kotlin are the primary languages for Android app development.
@

4. Emulator and Physical Device Testing

●​ The Android Emulator simulates different devices for testing apps without needing a physical
device.

5. Firebase and Google Play Services

●​ Firebase provides cloud-based features like authentication, databases, and push notifications.
●​ Google Play Services enables integration of maps, location services, and analytics.
 26
4. Directory Structure of an Android Project
An Android project consists of several directories:

1. app/ (Main Application Folder)

●​ Contains the main source code and resources.

2. manifests/

●​ Contains AndroidManifest.xml, which defines application metadata like permissions,

ER
activities, and services.

3. java/

●​ Contains all Java/Kotlin source code files for activities, services, and other components.

4. res/ (Resources Folder)

D
●​ Stores XML-based resources:
O ○​ layout/ – UI designs (.xml files).
○​ drawable/ – Images and vector graphics.
○​ values/ – Strings, colors, and styles.

5. gradle/
C
●​ Contains Gradle build scripts for managing dependencies and compiling the app.
U

5. App Components: Intent, Activity, and Threads

PT

1. Intent

●​ Intent is a messaging object used to start activities, services, or pass data.

Types of Intents
Explicit Intent – Targets a specific activity within the app.​
java​
@

Intent intent = new Intent(CurrentActivity.this, NextActivity.class);

startActivity(intent);
Implicit Intent – Requests an action without specifying the exact component.​
java​
Intent intent = new Intent(Intent.ACTION_VIEW,
Uri.parse("https://www.google.com"));
startActivity(intent);
 27
2. Activity

●​ An Activity represents a single screen with a user interface.

●​ The Lifecycle of an Activity includes:
○​ onCreate() – Initializes the activity.
○​ onStart() – Makes the activity visible.
○​ onResume() – Activity comes to the foreground.
○​ onPause() – Activity goes to the background.
○​ onStop() – Activity is no longer visible.
○​ onDestroy() – Activity is destroyed.

ER
3. Threads

●​ Threads allow execution of tasks in parallel.

●​ Main Thread (UI Thread): Handles UI updates.
●​ Worker Threads: Used for background tasks (e.g., network operations).

Example of using a Thread:

D
java
new Thread(new Runnable() {
O
@Override
public void run() {
// Background task
}
C
}).start();
U

6. Develop an App Using Checkbox and Radio Buttons

Steps to Create an App
PT

1.​ Create a New Android Project

2.​ Design UI (activity_main.xml)

xml
<CheckBox
android:id="@+id/checkBox"
@

android:text="Subscribe"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />

<RadioGroup
android:id="@+id/radioGroup"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
 28
<RadioButton
android:id="@+id/radioButton1"
android:text="Male"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>

<RadioButton
android:id="@+id/radioButton2"
android:text="Female"
android:layout_width="wrap_content"

ER
android:layout_height="wrap_content"/>
</RadioGroup>

3.​ Handle Click Events (MainActivity.java)

D
java
CheckBox checkBox = findViewById(R.id.checkBox);
RadioGroup radioGroup = findViewById(R.id.radioGroup);
O
checkBox.setOnCheckedChangeListener((buttonView, isChecked) -> {
if (isChecked) Toast.makeText(this, "Subscribed!",
Toast.LENGTH_SHORT).show();
C
});

radioGroup.setOnCheckedChangeListener((group, checkedId) -> {

U

if (checkedId == R.id.radioButton1) {
Toast.makeText(this, "Male selected", Toast.LENGTH_SHORT).show();
} else {
PT

Toast.makeText(this, "Female selected", Toast.LENGTH_SHORT).show();

}
});

7. Process of Testing an Application

@

1. Unit Testing

●​ Tests individual components using JUnit.

2. UI Testing

●​ Uses Espresso or UI Automator to test user interactions.

3. Integration Testing

●​ Ensures modules work together correctly.

 29
4. Manual Testing

●​ Performed on real devices to check UI, performance, and usability.

5. Performance Testing

●​ Tests app performance under different loads.

6. Deployment and Beta Testing

●​ Uses Google Play Beta Testing for real-world feedback.

ER
HAPPY ENDING BY : SAHIL RAUNIYAR / PTUCODER 😀

D
O
C
U
PT
@