CIE1 Mobile Application Development - Complete MCQ Study

Guide
Exam Date: September 1, 2025 | Time: 1:50 PM - 2:50 PM

MODULE 1: INTRODUCTION TO MOBILE APP DEVELOPMENT

1. Mobile Apps vs Web Apps

Mobile Applications

Installation: Downloaded from app stores (Google Play/App Store)

Storage: Need device storage space

Offline Access: Can work without internet connection

Performance: Faster browsing experience

Approval: Must be approved by app stores
Security: More sophisticated security features

Updates: Need manual updates by users

Hardware Access: Full access to device features (camera, GPS, accelerometer)

Web Applications

Access: Through browsers, no installation required

Internet: Require constant internet connection
Updates: Automatic updates, no user action needed

Performance: May load slower than mobile apps

Approval: No app store approval needed

Security: May have less heightened security

Platform: Accessible from any device with browser

2. Types of Mobile Applications

Native Applications

Platform: Built for ONE specific OS (either iOS OR Android)

Performance: Best performance, optimized for platform
Languages:
Android: Java, Kotlin
 iOS: Swift, Objective-C

Code Reuse: Cannot reuse code across platforms

APIs: Direct access to platform-specific APIs

User Experience: Best UX with native UI components

Development Cost: Higher (separate apps for each platform)

Hybrid Applications

Platform: Run on ANY platform (iOS and Android)

Technology: Web technologies (HTML, CSS, JavaScript) in native container

Code Reuse: Single codebase for all platforms

APIs: Access native features through plugins

Performance: Moderate performance

Examples: Ionic, Cordova apps

Cross-Platform Applications

Definition: Single shared codebase for Android, iOS, and desktop

Frameworks: Flutter, React Native, Xamarin

Languages: Dart (Flutter), JavaScript (React Native)

Development Time: Faster than native

Performance: Near-native performance

Code Reusability: High reusability across platforms

3. Mobile Operating Systems

Android

Base: Linux kernel (modified version)

Nature: Open-source (AOSP - Android Open Source Project)

Developer: Google (primary), Open Handset Alliance

Current Version: Android 16 (as of June 2025)

Languages: Java, Kotlin (official since 2017)

Market Share: 46% global OS market, 3 billion+ users

Distribution: Google Play Store, Samsung Galaxy Store, APK format

iOS

Developer: Apple Inc.

 Nature: Proprietary, closed-source
Current Version: iOS 18 (September 2024)

Languages: Swift, Objective-C

Devices: iPhone, iPad exclusively

Distribution: App Store only

Ecosystem: Seamless integration with Apple devices

4. Programming Languages for Mobile Development

Primary Languages

Java: Android development, object-oriented only

Kotlin: Android (official), functional + object-oriented

Swift: iOS development, modern syntax

Objective-C: iOS legacy development

Dart: Flutter framework

JavaScript: React Native, hybrid apps

C#: Xamarin development

Python: Kivy framework

C++: Game development, performance-critical apps

HTML/CSS: Web-based and hybrid apps

5. Mobile App Development Life Cycle (MADLC)

Phase 1: Planning & Research

Define: App purpose and problem to solve

Research: Competitors and market trends

Establish: Goals and objectives

Create: Timeline and budget

Tools: Trello, Jira, Google Trends, Miro

Example: WhatsApp - free instant messaging solution

Phase 2: Requirement Analysis & Strategy

Functional Requirements: Login, chat, payments, notifications

Non-Functional Requirements: Security, performance, scalability

Technology Stack: Native/Hybrid/Cross-platform decision

Risk Analysis: Compliance checks
 Tools: Confluence, Notion, Jira
Example: PayTm - Wallet & UPI functionality

Phase 3: UI/UX Design

Wireframing: Basic sketches of app screens

Prototyping: Interactive models for testing flow

UI Design: Visual elements (fonts, colors, icons, layout)

UX Design: User journey, navigation, accessibility

Tools: Figma, Adobe XD, Sketch, InVision

Example: Instagram - minimal, photo-centric design

Phase 4: Development

Frontend (Client-side):
Languages: Kotlin (Android), Swift (iOS), Flutter/React Native

Role: User interface and experience

Backend (Server-side):
Technologies: Node.js, Python (Django/Flask), Java (Spring Boot)
Role: Database, APIs, authentication

Integration: Link frontend-backend, third-party services

Tools: Android Studio, Xcode, VS Code, Firebase, GitHub

Example: Swiggy - React Native + Django + AWS

Phase 5: Testing

Unit Testing: Individual modules

Integration Testing: Module interactions

System Testing: Overall functionality

Performance Testing: Speed, load, memory

Security Testing: Data protection, encryption

UAT: User Acceptance Testing

Tools: JUnit, Espresso, XCTest, Appium, Firebase Test Lab

Phase 6: Deployment

Prepare: Store listing (name, description, screenshots)

Upload: APK (Android) or IPA (iOS)

Backend: Deploy on cloud (AWS, Firebase, Azure)

 Approval: App store review process
Tools: Google Play Console, App Store Connect, Docker

Note: iOS approval more strict than Android

Phase 7: Post-Deployment & Maintenance

Monitor: Crashes, errors, performance

Updates: Bug fixes and patches

Features: Add based on user feedback

Security: Updates for new OS versions

Tools: Firebase Analytics, Crashlytics, Mixpanel

Example: WhatsApp - constant security patches

6. IDEs (Integrated Development Environment)

Definition & Purpose

What: Software application providing comprehensive development tools

Purpose: Maximize programmer productivity

Interface: Common UI for integrated components

Key Features

Code Editor: Syntax highlighting, auto-completion, formatting

Compiler/Interpreter: Translates code to executable

Debugger: Find and fix errors, breakpoints, variable inspection

Build Automation: Compile and run projects quickly

Version Control: Git integration

Mobile Development IDEs

Android Studio:
Official Android IDE

Based on IntelliJ IDEA

Gradle build system

AVD Manager for emulators

Xcode:
Official iOS IDE

Swift/Objective-C support
Interface Builder
 Visual Studio Code:
Lightweight, extensible

Flutter, React Native support

7. SDKs (Software Development Kit)

Definition & Components

What: Collection of development tools for specific platform

Purpose: Provide necessary components for app creation

Major Components

APIs: Predefined functions for platform features

Libraries/Frameworks: Ready-to-use code packages

Emulators/Simulators: Virtual devices for testing

Documentation: Guides and references

Runtime Components: Required for execution

Common Mobile SDKs

Android SDK: APIs for Android development

iOS SDK: APIs for iOS development

Firebase SDK: Authentication, notifications, analytics

Google Maps SDK: Map integration (Uber example)

Facebook SDK: Social media integration

Payment SDKs: Stripe, PayPal integration

SDK vs Framework

SDK: Developer code invokes SDK

Framework: Framework invokes developer code

MODULE 2: NATIVE ANDROID APP DEVELOPMENT

1. Android Studio Overview

Key Features

Code Editor: Java, Kotlin, C++ support with intelligent completion

Gradle Build System: Flexible project management

 AVD Manager: Android Virtual Device emulation
Performance Profilers: CPU, memory, network, battery analysis

Debugging Tools: Inline debugging, breakpoints, Logcat

Layout Editor: Visual drag-and-drop UI design

2. Activity Lifecycle

Core Concept

Activity: Single screen with user interface

Lifecycle: States an activity transitions through

Purpose: Proper resource management and user experience

Six Core Callbacks

onCreate()

When: Activity first created

Purpose: Basic startup logic

Frequency: Called ONCE per activity instance

Parameters: savedInstanceState Bundle

Tasks:
Bind data to lists

Associate with ViewModel

Initialize class variables

setContentView() call

onStart()

When: Activity becomes visible

Purpose: Prepare for foreground

State: Activity visible but not interactive

Tasks: Initialize UI components

Next: Quickly transitions to onResume()

onResume()

When: Activity enters foreground

Purpose: Begin user interaction

State: App interacts with user

 Tasks:
Start camera preview

Enable functionality while visible

Resume animations

Previous: Called after onPause() when returning

onPause()

When: Activity losing focus

State: Still visible but not in foreground

Triggers:
Interrupting event (phone call)

Multi-window mode (other app focus)

Semi-transparent activity (dialog)

Tasks:
Pause operations

Release resources (GPS, sensors)

Save quick state

onStop()

When: Activity no longer visible

Triggers:
New activity covers screen

Activity finishing

Tasks:
Release resources
Save data to database

Stop animations
CPU-intensive shutdown operations

onDestroy()

When: Activity destroyed

Reasons:
finish() called

User dismisses activity

Configuration change (rotation)

 Tasks: Final cleanup
Note: Use ViewModel for configuration changes

Lifecycle State Transitions

Created → Started → Resumed: App launch

Resumed → Paused → Stopped: App backgrounded

Stopped → Started → Resumed: App returned

Any State → Destroyed: System kills or finish()

3. UI Components

View Hierarchy

View: Single UI element (Button, TextView)

ViewGroup: Container for Views (Layouts)

Hierarchy: Tree structure of nested Views/ViewGroups

Common UI Components

TextView

Purpose: Display static text

Customization: Font, size, color, style

Features: Clickable links, HTML support

EditText

Purpose: User text input

Input Types: text, number, email, password

Features: Hints, filters, validation

Button

Purpose: Trigger actions

Content: Text or images

Events: onClick listener

RecyclerView

Purpose: Efficient scrollable lists

Components:
Adapter: Binds data
 ViewHolder: Holds view references
LayoutManager: Arranges items

Performance: Recycles views for memory efficiency

4. Layouts in Android

Layout Declaration Methods

1. XML Declaration: Separate presentation from logic

2. Programmatic: Create at runtime in Java/Kotlin

Layout Parameters

wrap_content: Size to content requirements

match_parent: Expand to fill parent

0dp: Used with weight in LinearLayout

Specific values: 16dp, 100px (not recommended)

5. LinearLayout

Key Characteristics

Arrangement: Single direction (horizontal/vertical)

Orientation: android:orientation attribute

Stacking: One child per row (vertical) or column (horizontal)

Layout Weight

Purpose: Distribute remaining space

Default: 0 (no expansion)

Equal Distribution:
Set width/height to "0dp"

Set weight to "1" for all children

Unequal Distribution: Different weight values

Attributes

android:orientation="vertical|horizontal"

android:layout_weight="1"
android:layout_gravity="center|left|right"

android:gravity="center"
android:padding, android:margin
6. ConstraintLayout

Key Features

Flat Hierarchy: No nesting needed

Performance: Best for complex layouts

Flexibility: Constraints, chains, guidelines

Visual Editor: Full drag-and-drop support

Constraint Rules

Minimum: One horizontal + one vertical constraint

Planes: Vertical constraints to vertical planes only

Handles: One constraint per handle

Missing Constraints: Shows error in editor

Important Attributes

layout_constraintTop_toTopOf
layout_constraintBottom_toBottomOf
layout_constraintLeft_toLeftOf

layout_constraintRight_toRightOf

layout_constraintHeight_max/min

layout_constraintHorizontal_weight
layout_constraintVertical_weight

Advanced Features

Chains: Distribute space between views

Guidelines: Invisible alignment lines

Barriers: Dynamic constraints

Aspect Ratio: Fixed height:width ratio

7. RelativeLayout

Positioning Attributes

Parent Alignment:
layout_alignParentTop="true"

layout_alignParentBottom="true"

layout_centerInParent="true"
 Relative to Views:
layout_below="@id/view"

layout_toRightOf="@id/view"

layout_above="@id/view"

Usage Note

Can eliminate nested views

May create deep hierarchies

Recommendation: Use ConstraintLayout instead

8. Layout Comparison
Feature LinearLayout ConstraintLayout RelativeLayout

Hierarchy Can be nested Flat Can be deeply nested

Performance Good for simple Best overall Moderate

Flexibility Limited to linear Highest Good

Positioning Sequential only Any position Relative only

Weight Support Yes Yes No

Visual Editor Basic Full support Basic

Learning Curve Easy Moderate Easy

 

9. Android Development Key Points

Resource Management

R.java: Auto-generated resource IDs

@+id/name: Create new ID

@id/name: Reference existing ID

Resource Types: drawable, layout, values, mipmap

AndroidManifest.xml

Declares all activities

Permissions
App metadata

Intent filters

Best Practices

Use ConstraintLayout for new projects

 Avoid deep view hierarchies
Implement proper lifecycle handling

Save state in onSaveInstanceState()

Use ViewModel for configuration changes

Test on multiple screen sizes

Important Terms & Definitions

APK: Android Package Kit
IPA: iOS App Store Package

AVD: Android Virtual Device

UAE: User Acceptance Testing

API: Application Programming Interface

XML: Extensible Markup Language

UI: User Interface

UX: User Experience

AOSP: Android Open Source Project

Gradle: Build automation tool for Android

Quick MCQ Tips

1. Native vs Hybrid: Native = one platform, Hybrid = all platforms

2. Kotlin vs Java: Kotlin supports functional programming, Java doesn't

3. Lifecycle Order: onCreate → onStart → onResume → onPause → onStop → onDestroy
4. Layout Performance: ConstraintLayout > LinearLayout > RelativeLayout

5. Weight: Only in LinearLayout, not in RelativeLayout

6. Constraints: Minimum 2 required (1 horizontal, 1 vertical)

7. Testing Types: Remember all 6 types (Unit, Integration, System, Performance, Security, UAT)
8. MADLC Phases: 7 phases in order
9. Android Studio: Based on IntelliJ IDEA

10. Current Versions: Android 16, iOS 18