Mobile Platforms: OS, SDKs, App Stores & Market Trends

Key Concepts and Mobile Ecosystems

1. Mobile Platforms: Definitions and Types

Mobile platforms are software frameworks that enable the development, deployment, and execution of mobile applications. They include:

• Operating Systems (OS): Core software managing hardware and apps (e.g., Android, iOS).
• Software Development Kits (SDKs): Tools/libraries for building apps (e.g., Android Studio, Xcode).
• App Stores: Digital marketplaces for distributing apps (e.g., Google Play Store, Apple App Store).

Comparison Table: Android vs. iOS

2. Android Architecture: Layered Model

Android’s architecture is divided into 4 layers:

1. Linux Kernel: Manages hardware (CPU, memory, drivers).
2. Hardware Abstraction Layer (HAL): Interfaces between kernel and hardware (e.g., camera, GPS).
3. Android Runtime (ART): Executes apps (Dalvik VM → ART for AOT compilation).
4. Java API Framework: Provides libraries for UI, networking, etc.

classDiagram
    class LinuxKernel {
        +Device Drivers
        +Memory Management
        +Process Management
    }
    class HAL {
        +Hardware Abstraction
        +Camera/GPS APIs
    }
    class AndroidRuntime {
        +ART (Ahead-of-Time)
        +Dalvik (Just-in-Time)
    }
    class JavaAPI {
        +Activity Manager
        +View System
        +Content Providers
    }
    LinuxKernel --> HAL : Uses
    HAL --> AndroidRuntime : Provides
    AndroidRuntime --> JavaAPI : Executes

Worked Example: Android’s ART vs. Dalvik

• Dalvik (Old): Used JIT compilation (slower startup).
• ART (New): Uses AOT compilation (faster performance, but larger app size). Example: A game app benefits from ART’s speed, while a simple note-taking app might use Dalvik for lower memory overhead.

3. iOS Architecture: Monolithic Design

iOS is built on a Unix-based core with these layers:

1. Core OS: Low-level services (security, networking).
2. Core Services: System frameworks (Foundation, Core Foundation).
3. Media & Cocoa Touch: UI and app frameworks (UIKit, SwiftUI).
4. C Language: Underlying language for performance-critical tasks.

4. Mobile App Development Tools

classDiagram
    class AndroidStudio {
        +Emulator
        +SDK Manager
        +NDK
    }
    class Xcode {
        +Simulator
        +Interface Builder
        +SwiftUI
    }
    AndroidStudio --> "Kotlin/Java" : Uses
    Xcode --> "Swift/Objective-C" : Uses
    AndroidStudio ..> "Google Play" : Deploys
    Xcode ..> "App Store" : Deploys

Android SDK (Software Development Kit)

• Components:
  • Android Studio: Official IDE (based on IntelliJ).
  • Emulator: Virtual devices for testing.
  • SDK Manager: Downloads APIs, tools, and documentation.
  • NDK (Native Development Kit): For C/C++ performance optimizations.

iOS SDK (Xcode)

• Components:
  • Xcode IDE: Integrates Swift/Objective-C development.
  • Simulator: Emulates iOS devices.
  • Interface Builder: Drag-and-drop UI design.

Comparison Table: Android Studio vs. Xcode

In the Real World

1. eSewa (Nepal):

   • Platform: Uses Android/iOS SDKs to build its payment app.
   • Key Idea: Leverages Android’s PaymentRequest API and iOS’s PassKit for secure transactions.
   • Example: When you scan a QR code to pay, the app uses the device’s camera via Android’s CameraX library.

2. Khalti (Nepal):

   • Platform: Hybrid app (React Native) targeting both Android and iOS.
   • Key Idea: Uses Firebase Authentication for login and SQLite for offline transaction history.
   • Example: If your internet drops, Khalti syncs data when reconnected using Android’s WorkManager.

3. Google Maps (Global):

   • Platform: Native Android/iOS apps with Google Maps SDK.
   • Key Idea: Uses Android’s LocationManager and iOS’s CoreLocation for GPS tracking.
   • Example: When you search for "NTC office Kathmandu," the app fetches real-time traffic data via Google’s servers.

5. App Distribution Models

Google Play Store

• Pros:
  • Open to all developers (after one-time $25 fee).
  • Supports sideloading (APK installation).
  • Google Play Billing: Handles in-app purchases.
• Cons:
  • 30% revenue cut for paid apps.
  • App review process can delay updates.

Apple App Store

• Pros:
  • Strict quality control (fewer malware apps).
  • TestFlight: Beta testing for users.
• Cons:
  • 30% revenue cut (same as Google).
  • Closed ecosystem: No sideloading without jailbreaking.

Worked Example: Publishing a Nepalese News App

1. Android:
   • Upload APK/AAB to Google Play Console.
   • Set pricing (e.g., $0 with ads or $2.99 premium).
   • Use Firebase Analytics to track user engagement.
2. iOS:
   • Archive app in Xcode → Upload to App Store Connect.
   • Submit for review (Apple checks for compliance with Human Interface Guidelines).

6. Mobile Market Trends (2023–2024)

7. Exam Tip: How This Unit is Tested

1. Definitions (5 marks):

   • Expect questions like: "Define Android’s ART and explain its advantage over Dalvik." Answer: ART (Android Runtime) uses AOT compilation for faster app execution, unlike Dalvik’s JIT, which compiles bytecode at runtime.

2. Comparisons (10 marks):

   • "Compare Android and iOS architectures with a focus on customization." Answer: Use the table above + add:
     • Android allows sideloading (installing APKs from sources other than Play Store).
     • iOS restricts sideloading to approved developers only.

3. Scenario-Based (15 marks):

   • "A Nepalese bank wants to build a mobile app for loan applications. Choose between Android and iOS and justify your choice." Answer:
     • Android: Better for reach (70% market share in Nepal) and customization (e.g., integrating with local payment gateways like Khalti).
     • iOS: Better for security (strict app review) if targeting urban users with higher disposable income.
     • Bonus: Mention Firebase for backend services (authentication, real-time updates).

4. Diagrams (10 marks):

   • Draw and label:
     • Android’s 4-layer architecture.
     • iOS’s monolithic stack.
   • Tip: Use arrows to show data flow (e.g., "HAL → Android Runtime").

5. Code Snippets (5 marks):

   • "Write a Kotlin snippet to check if a device supports 5G."

     val telephonyManager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
     val networkType = telephonyManager.networkType
     val is5G = networkType == TelephonyManager.NETWORK_TYPE_NR // 5G
     

8. Practical Exercise: Build a Simple App

Task: Create a "Nepal Traffic Status" app that shows real-time traffic data (e.g., from NTC’s API).

1. Platform Choice: Android (higher user base in Nepal).
2. Tools:
   • Android Studio (SDK: API 33).
   • Retrofit for API calls (e.g., https://api.ntc.gov.np/traffic).
3. Key Code:

   interface TrafficApiService {
       @GET("traffic")
       suspend fun getTrafficData(): Response<TrafficResponse>
   }
   

4. UI: Use RecyclerView to display routes with traffic status (green/red icons).
5. Testing: Emulate a 5G connection in Android Studio’s emulator.

Visual Trace: API Call Flow

sequenceDiagram
    App->>+API: GET /traffic (Retrofit)
    API-->>-App: JSON Response (200 OK)
    App->>UI: Update RecyclerView
    UI->>User: Show "Kathmandu-Thamel: Heavy Traffic"

Summary Table for Quick Revision