Mobile Platforms: Types, Features & Market Share

TAKEAWAYS:

• Mobile platforms are operating systems + hardware ecosystems (e.g., iOS = Apple’s OS + iPhones; Android = Google’s OS + OEM devices) that define app development rules, security, and user experience.
• Android dominates globally (70% market share) due to open-source flexibility, while iOS leads in revenue per user ($100 vs. Android’s ~$40) because of Apple’s walled-garden ecosystem.
• Cross-platform frameworks (Flutter, React Native) reduce development time but may sacrifice native performance or access to platform-specific APIs.
• Fragmentation in Android (varied hardware, OS versions) forces developers to test rigorously, while iOS’s uniformity simplifies development but limits hardware choices.
• App ecosystems (Google Play Store, Apple App Store) enforce strict guidelines, sandboxing, and monetization models (e.g., 15–30% revenue cuts).
• Security models differ: iOS uses a closed-source kernel and strict sandboxing, while Android relies on open-source transparency but faces more malware risks due to sideloading.

1. What Is a Mobile Platform?

A mobile platform is a combination of:

• Hardware: The physical device (e.g., iPhone, Samsung Galaxy).
• Operating System (OS): The software that manages hardware and apps (e.g., iOS, Android).
• App Ecosystem: Stores (App Store/Play Store), development tools (Xcode, Android Studio), and services (iCloud, Google Play Services).
• Developer Tools: SDKs, APIs, and IDEs for building apps.

Key Components of a Mobile Platform

classDiagram
    class Hardware {
        +CPU, RAM, Sensors
        +Screen, Battery
    }
    class OS {
        +Kernel (Linux/macOS-based)
        +Runtime (ART/Dalvik, iOS Runtime)
        +Services (Location, Camera, Notifications)
    }
    class AppEcosystem {
        +App Store/Play Store
        +Payment Gateways (In-App Purchases)
        +Cloud Services (iCloud, Firebase)
    }
    class DeveloperTools {
        +SDK (Software Development Kit)
        +IDE (Xcode, Android Studio)
        +APIs (Google Maps, Firebase)
    }
    Hardware --> OS : Runs on
    OS --> AppEcosystem : Hosts
    OS --> DeveloperTools : Provides
    AppEcosystem --> DeveloperTools : Uses

2. Major Mobile Platforms: iOS vs. Android

A. iOS (Apple)

• Developed by: Apple Inc.
• Market Share: 25% globally (2023), but **90% in Nepal’s urban areas** (due to high smartphone penetration in Kathmandu/Pokhara).
• Hardware: Exclusive to iPhones, iPads, and Apple Watches.
• OS Versioning: Uniform (all iPhones run the same iOS version after 1 year).
• Development Tools:
  • Xcode (IDE)
  • Swift/Objective-C (programming languages)
  • iOS SDK (includes UIKit, SwiftUI, Core ML).

Advantages:

• Performance: Optimized for Apple’s hardware (e.g., iPhone’s A-series chips).
• Security: Closed-source kernel, strict App Store review, and hardware-level encryption.
• User Experience: Consistent UI/UX across devices.
• Revenue: Higher average spending per user ($100 vs. Android’s $40).

Disadvantages:

• Hardware Limitations: No choice of manufacturers (only Apple devices).
• Development Costs: Requires a Mac and pays Apple’s 15–30% App Store fee.
• Less Flexibility: No sideloading (users can’t install apps outside the App Store).

B. Android (Google)

• Developed by: Google (open-source), customized by OEMs (Samsung, Xiaomi, etc.).
• Market Share: 70% globally (2023), **75% in Nepal** (due to affordable Samsung/Xiaomi devices).
• Hardware: Runs on diverse devices (phones, tablets, wearables, TVs).
• OS Versioning: Fragmentation—users run outdated versions (e.g., only 10% of Android users have the latest OS).
• Development Tools:
  • Android Studio (IDE)
  • Kotlin/Java (programming languages)
  • Android SDK (includes Jetpack, AndroidX libraries).

Advantages:

• Open-Source: Customizable by manufacturers (e.g., Samsung’s One UI, Xiaomi’s MIUI).
• Hardware Diversity: Affordable options (e.g., Redmi, Realme) and high-end (Samsung Galaxy S23).
• Flexibility: Sideloading allowed (users can install APKs from anywhere).
• Developer Freedom: No strict App Store policies (but Google Play still enforces guidelines).

Disadvantages:

• Fragmentation: Apps must support older Android versions (e.g., Android 10 vs. Android 13).
• Security Risks: Open-source nature leads to malware if not updated (e.g., fake banking apps on third-party stores).
• Performance Variability: Depends on OEM optimizations (e.g., Xiaomi’s bloatware).

Comparison Table: iOS vs. Android

3. Cross-Platform Development

To target both iOS and Android with one codebase, developers use frameworks like:

• Flutter (Google): Uses Dart language, compiles to native ARM code.
• React Native (Meta): Uses JavaScript/React, bridges to native components.
• Xamarin (Microsoft): Uses C#, shares ~75% code between platforms.

When to Use Cross-Platform?

flowchart TD
    A["Need to target both iOS & Android?"] --> B{"Yes"}
    B --> C["Prioritize development speed?"]
    C -->|"Yes"| D["Use Flutter/React Native"]
    C -->|"No"| E["Build native apps"]
    B -->|"No"| F["Choose one platform"]

Example: eSewa (Nepal’s Mobile Wallet)

• Problem: eSewa needed a mobile app for both iOS and Android users.
• Solution: Used React Native to build a single codebase, reducing development time by 40%.
• Result: Saved costs while reaching ~10M users across platforms.

Worked Example: Flutter vs. Native for a Banking App

4. Mobile Platform Fragmentation

Fragmentation occurs when:

• Different Android devices run different OS versions (e.g., Android 8 vs. Android 13).
• Hardware variations (screen sizes, CPU/GPU differences).
• Manufacturer customizations (e.g., Xiaomi’s MIUI vs. Samsung’s One UI).

Impact on Developers

• Testing: Must test on multiple devices/OS versions.
• API Support: Some APIs are only available on newer Android versions.
• Performance: Apps may run slower on low-end devices.

Example: NTC’s Mobile App (Nepal Telecom)

• Challenge: NTC’s app must work on Redmi Note 5 (Android 8) and Samsung Galaxy S23 (Android 13).
• Solution:
  • Use AndroidX libraries for backward compatibility.
  • Test on emulators (Pixel 3, OnePlus 6) and real devices.
  • Provide fallback features (e.g., basic UI for old OS versions).

Visual: Android Version Fragmentation (2023)

pie
    title Android OS Version Distribution (Nepal, 2023)
    "Android 10" : 30
    "Android 11" : 25
    "Android 12" : 20
    "Android 13" : 15
    "Older (7/8)" : 10

5. App Ecosystems and Monetization

A. Apple App Store

• Revenue Model: 15% for most apps, 30% for subscriptions.
• Review Process: Strict (rejects apps with privacy issues, bugs, or copyright violations).
• Example: Khalti (Nepal’s mobile payment app) earns ~20% revenue from App Store sales.

B. Google Play Store

• Revenue Model: 15–30% (varies by country).
• Review Process: Less strict than Apple but still enforces policies (e.g., no malware).
• Example: Pathao (ride-hailing app) uses Play Store for global expansion.

C. Third-Party Stores (Nepal)

• Examples: ApkPure, Aptoide, GetJar.
• Risks: Malware, outdated apps, no revenue sharing.
• Use Case: Some Nepalese apps (e.g., HamroPatri) distribute via third-party stores to avoid App Store fees.

6. Security Models

Example: Ncell’s Mobile Banking App

• Security Measures:
  • Uses iOS’s sandboxing and Android’s Keystore for biometric authentication.
  • Implements Firebase App Check to prevent APK tampering.
  • Regular penetration testing for vulnerabilities.

In the Real World

1. eSewa (Mobile Wallet, Nepal)

   • Platform: Primarily Android (due to Nepal’s smartphone market), but also iOS.
   • Why Cross-Platform? Used React Native to reduce development costs and reach both iPhone and Android users.
   • Key Idea: Single codebase for two ecosystems, saving time and resources.

2. Khalti (Digital Payments, Nepal)

   • Platform: iOS and Android, but iOS generates 40% more revenue due to higher spending habits.
   • Why iOS-First? Leverages Apple Pay and higher transaction values.
   • Key Idea: Platform choice affects monetization—iOS users spend more.

3. Daraz (E-Commerce, Nepal/Global)

   • Platform: Android-heavy (70% of Nepal’s users), but iOS for premium users.
   • Challenge: Fragmentation—must optimize for low-end phones (e.g., Redmi) and high-end (Samsung Galaxy).
   • Key Idea: Hardware diversity requires adaptive UI/UX (e.g., lighter images for slow networks).

4. NTC’s Mobile App (Telecom, Nepal)

   • Platform: Android (dominant in Nepal), but iOS for corporate users.
   • Security Focus: Uses Android’s SafetyNet and iOS’s Secure Enclave for SIM-based authentication.
   • Key Idea: Platform-specific security APIs must be integrated carefully.

5. Pathao (Ride-Hailing, Nepal/Global)

   • Platform: Started with Android (Nepal’s market), then expanded to iOS.
   • Monetization: Uses Google Play’s 15% cut and Apple’s 30% for in-app purchases.
   • Key Idea: Revenue share varies by platform—optimize for high-spending users (iOS).

Exam Tip

What Examiners Look For

1. Definitions:

   • Clearly distinguish between mobile platform, OS, and app ecosystem.
   • Example: "A mobile platform is not just an OS—it includes hardware, developer tools, and the app store."

2. Comparisons:

   • iOS vs. Android: Always compare market share, development tools, and security in your answer.
   • Native vs. Cross-Platform: Mention performance trade-offs (e.g., Flutter’s ~5% slower UI rendering).

3. Real-World Applications:

   • Nepal-specific examples (e.g., eSewa, Khalti, NTC) carry extra marks.
   • Global examples (e.g., WhatsApp’s cross-platform success) show broader understanding.

4. Fragmentation:

   • Explain why Android has fragmentation (open-source, OEM customizations).
   • Describe how developers handle it (emulators, backward compatibility).

5. Security:

   • iOS: Closed-source, sandboxing.
   • Android: Open-source but relies on OEM patches.
   • Cross-Platform: Inherits weaknesses of the underlying OS.

Common Mistakes to Avoid

• Mixing up iOS and Android features: Don’t say Android has a "walled garden"—that’s iOS!
• Ignoring Nepal’s market: Always relate examples to eSewa, Khalti, or NTC if possible.
• Overlooking fragmentation: If asked about Android challenges, always mention OS version diversity.
• Assuming cross-platform is always better: State when to use native (e.g., high-security apps like banking).

Sample Exam Question & Answer

Question: "Compare iOS and Android platforms, highlighting their impact on app development in Nepal. Discuss why a fintech app like Khalti might prefer iOS for certain features."

Model Answer: iOS and Android differ fundamentally in hardware, OS updates, and developer tools, directly affecting app development in Nepal.

Why Khalti Prefers iOS for Certain Features:

1. Apple Pay Integration: iOS supports seamless NFC payments, while Android relies on Google Pay (less adoption in Nepal).
2. Higher Transaction Values: iPhone users in Kathmandu/Pokhara spend more on digital payments.
3. Stricter Security: iOS’s sandboxing reduces fraud risks for financial apps.

Conclusion: While Android dominates Nepal’s market (~75%), iOS’s higher revenue and security make it critical for fintech apps like Khalti. A cross-platform approach (React Native) balances reach and performance.

Visual for Exam:

flowchart LR
    A["Khalti App"] --> B["Android Users<br/>75% of Nepal"]
    A --> C["iOS Users<br/>25% but 40% revenue"]
    B --> D["Fragmented OS<br/>Must support Android 8-13"]
    C --> E["Uniform OS<br/>Easier security & payments"]
    D --> F["Testing on Emulators<br/>Pixel 3, OnePlus 6"]
    E --> G["Apple Pay<br/>Higher transaction success"]