Mobile Application Development

What is Mobile Computing?

Mobile Computing System = computing systems that can be easily moved physically and whose computing can be used while being moved.

Distinguishing Aspects of Mobile vs Stationary Computing

Four Pieces of the Mobile Problem

• Mobile User — moving, context-switching, not focused on computing task
• Mobile Device — hardware with limited capabilities
• Mobile Application — software optimized for mobile settings
• Mobile Network — wireless, variable, potentially unreliable

Wireless Communication Generations

Mobile Application Types

Application Context Types

Mobile Platform Architecture Layers

A mobile platform consists of multiple layers from hardware up to developer tools:

Android Platform Architecture

Architectural Styles for Mobile Apps

• Thin-client wireless client-server — logic on server, thin UI on device
• Thick-client wireless client-server — significant logic on device too
• Stand-alone applications — works fully offline, no server needed

What is SDLC?

Software Development Life Cycle (SDLC) = a structured series of steps to design, develop, test, and maintain software. Goal: ensure software meets user needs and works correctly.

Benefits of SDLC

• Ensures quality and consistency
• Efficiency in time and cost
• Easier maintenance and updates
• Better team collaboration
• Adaptability to changes

Core Software Development Activities

Process Flow Types

Waterfall Model

The classic linear process model. Each phase must fully complete before moving to the next. You cannot skip two phases back.

Agile Methodology

Agile collects requirements iteratively and evolutionarily. A functionality is completed fully (requirements → code → unit tests) before starting the next.

The Agile Manifesto (4 Values)

Agile Variants

• Scrum (sprint-based, 2-week cycles)
• Kanban (flow-based, continuous)
• Extreme Programming (XP)
• Feature Driven Development (FDD)
• Dynamic Systems Development Method (DSDM)
• Agile Unified Process (AUP)

SDLC for Mobile Apps — 6 Phases

Adapted Agile for Mobile — 5 Practices

Key Terms

The Key Challenge: Fragmentation

Each mobile platform has different interfaces, standards, programming languages, APIs, capabilities, and SDKs. Even within the same platform, devices differ in memory, screen resolution, etc.

3 Mobile Development Approaches

Why Use Cross-Platform?

• Reusable code across platforms
• Rapid time to market
• Robust performance
• Close-to-native UX
• Broad audience reach (Android + iOS simultaneously)
• Greater cost efficiencies

React Native (by Meta/Facebook)

Open-source framework using JavaScript + React to build native apps for Android, iOS, and more. First developed in 2013 internally at Facebook, public release in 2015.

React Native Architecture Components

React Native Render Pipeline

// The 3-step pipeline:
Render  →  Commit  →  Mount

// View Flattening: optimization to avoid deep layout trees
// Views (2) and (3) merged into (1) via diffing algorithm

Core Components (Native Components wrapped for JS)

• View — basic rectangular container
• Text — displays text
• Image — displays images
• TextInput — text input field
• ScrollView — scrollable container
• FlatList — optimized list rendering

Flutter (by Google)

Open-source framework for building natively compiled, multi-platform apps from a single codebase. Uses Dart language. Released as open source in 2017.

Flutter Architecture (Layered)

Flutter Rendering Process (Widget → Pixels)

React Native vs Flutter Comparison

Framework Choice Guidelines

What is Android?

• Mobile OS based on Linux kernel
• UI designed for touch screens
• Used on over 80% of all smartphones
• Powers watches, TVs, cars, and more
• Open-source. 3+ billion monthly active devices.
• 2.5+ billion monthly active Google Play users. 2M+ apps.

Android Software Developer Kit (SDK)

• Development tools: debugger, monitors, editors
• Libraries: maps, wearables, ML
• Virtual devices (emulators/AVDs)
• Documentation at developer.android.com
• Sample code

Kotlin — The Language for Android

API Levels — Three Key SDK Versions

4 Types of Application Components

App Building Blocks

Views — Building Blocks of UI

"Everything you see is a View." Views are Android's basic UI building blocks — rectangular elements on screen.

Common View Classes

View Size Options

ViewGroups — Layout Containers

Event Handling

// SAM (Single Abstract Method) — concise click listener
button.setOnClickListener { view ->
    /* handle click */
}

// Modify a View dynamically
val resultTextView: TextView = findViewById(R.id.textView)
resultTextView.text = "Goodbye!"

// Event flow: User interacts → Event fired → Check callback → Execute or ignore

Gradle — Build System

• Build automation system
• Manages the build cycle via a series of tasks (compile Kotlin, run tests, install APK)
• Determines proper task order and manages dependencies

Accessibility Best Practices

• Touch target size: at least 48dp × 48dp
• Set contentDescription on images and controls for screen readers
• Use TalkBack — Google's screen reader for Android
• Use Switch Access for users who cannot use touch

Size Units in Android

DP Formula

Screen Density Buckets

View Rendering Cycle

View Spacing

android:layout_margin="16dp"
android:layout_marginTop="8dp"

android:padding="16dp"
android:paddingStart="8dp"

ConstraintLayout

Recommended default layout for Android. Solves the costly issue of too many nested layouts while allowing complex behavior. Positions and sizes views using constraints.

Constraint Format

Example Constraints

<TextView
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintEnd_toEndOf="parent" />  ← centers the view

Constraint Widget Sizes

Chains in ConstraintLayout

Chains let you position views in relation to each other (horizontally or vertically). Provide much of LinearLayout functionality.

Guidelines

Invisible layout helpers that let you position multiple views relative to a single guide. Can be vertical or horizontal. Not drawn on device.

<Guideline
    android:orientation="vertical"
    app:layout_constraintGuide_begin="16dp" />

<!-- Specify one of these: -->
layout_constraintGuide_begin   ← from start
layout_constraintGuide_end     ← from end
layout_constraintGuide_percent ← percentage of parent (0.0–1.0)

Groups

Control the visibility of a set of widgets as a group.

// Toggle group visibility
if (group.visibility == View.GONE) {
    group.visibility = View.VISIBLE
} else {
    group.visibility = View.GONE
}
// Visibility constants:
// VISIBLE   → shown
// INVISIBLE → not shown but TAKES space
// GONE      → not shown and does NOT take space

Data Binding

Bind UI components in layouts directly to data sources — replaces repetitive findViewById() calls.

Setup

// 1. Enable in build.gradle
android {
    buildFeatures { dataBinding = true }
}

// 2. Wrap layout in <layout> tag
<layout>
    <data>
        <variable name="name" type="String"/>
    </data>
    <ConstraintLayout>
        <TextView android:text="@{name}" />
    </ConstraintLayout>
</layout>

// 3. Use binding in Activity
val binding: ActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main)
binding.name = "John"

RecyclerView

Widget for displaying lists of data. "Recycles" (reuses) item views when they scroll off-screen to make scrolling more performant.

RecyclerView Key Parts

class MyAdapter(val data: List<Int>) : RecyclerView.Adapter<MyAdapter.MyViewHolder>() {

    class MyViewHolder(val row: View) : RecyclerView.ViewHolder(row) {
        val textView = row.findViewById<TextView>(R.id.number)
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
        val layout = LayoutInflater.from(parent.context).inflate(R.layout.item_view, parent, false)
        return MyViewHolder(layout)
    }

    override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
        holder.textView.text = data.get(position).toString()
    }

    override fun getItemCount(): Int = data.size
}

Overview

Core Design Principles

Navigation Patterns

Visual Elements: Icons, Colors, Animations

Layout Approach

UI Components Comparison

Apple Liquid Glass (2025 — new in HIG)

Impact on UX

The Problem: The Billion-Dollar Mistake

Kotlin's Solution: Non-Nullable by Default

In Kotlin, all reference variables are non-nullable by default. If you want a nullable reference, you must explicitly declare it with the ? suffix (nullability marker).

// Non-nullable (default) — cannot be null
var name: String = "Alice"
    name = null  // COMPILE ERROR

// Nullable — must use ? suffix
var name: String? = "Alice"
    name = null  // OK

Null Safety Operators

val len = name?.length  // Int? (nullable)
// Chaining:
user?.address?.city?.name

val name = nullableName ?: ""
// Equivalent to:
val l: Int = if (b != null) b.length else 0
// Elvis version:
val l: Int = b?.length ?: 0

val b = a!!  // Throws NPE if a is null
// Use sparingly — defeats null safety purpose

lateinit var result: TextView

override fun onCreate(...) {
    result = findViewById(R.id.result)
}

Summary: Null Handling Decision Tree

Language Null Safety Comparison