KAHIBARO Bookshelves
Discord Login Register

1.1. What is Android

Understanding Android as a Platform

Android is an operating system created primarily for mobile devices such as smartphones and tablets. It is based on the Linux kernel, but it is not a typical desktop Linux system. Instead, it is designed to make it easy to build and run apps that focus on touch input, battery efficiency, and constant connectivity.

Android manages everything that happens on a device. It controls how apps are started and stopped, how they share resources like memory and storage, how they access hardware like the camera or GPS, and how they appear on the screen. When you build an Android app, you are building software that runs inside this managed environment rather than directly controlling the whole device.

Most Android devices use the Google Play Store to distribute apps, but the operating system itself is open source through a project called AOSP, the Android Open Source Project. This combination of an open base system and commercial services on top helped Android become the dominant mobile platform in the world.

Android as a Mobile Operating System

At its core, Android provides the essential services every mobile device needs. It handles touch input, gestures, notifications, connectivity through Wi-Fi and mobile networks, and access to hardware such as cameras, microphones, sensors, and GPS.

Every visible piece of your app, such as screens, dialogs, and notifications, is coordinated by the Android system. The system decides when your app can run in the foreground, when it should be paused or stopped, and when it should be removed from memory to free resources for other apps.

Compared to traditional desktop systems, Android is optimized for limited resources and battery life. Apps are isolated from each other for security and stability. Each app runs in its own process and has its own user ID, which means it cannot directly access another app's data unless both apps explicitly agree.

Android, Google, and Open Source

Android started as an independent project and was later acquired by Google. The core of Android is developed in the open under the Android Open Source Project. This means device manufacturers can take the base Android code and customize it for their own phones and tablets.

On top of this open base, Google provides additional services such as Google Play Store, Google Maps, and Google Play Services. These are not part of the open source project, but they are very common on consumer devices.

As an app developer, you target the Android platform as provided on the device. On many devices this includes Google services, but the operating system itself does not require them. This is why Android can appear on very different devices, from phones and tablets to some TVs, cars, and watches, each with its own vendor customizations.

The Layered Architecture of Android

Android is organized in several layers that work together. Understanding these layers helps you see where your app fits in.

At the lowest layer, Android uses a modified Linux kernel. This kernel handles low level tasks such as process management, memory management, device drivers, and security enforcement. As an app developer, you do not work with the kernel directly. You access its capabilities through higher level APIs.

Above the kernel, there are native libraries written in C and C++. These libraries handle tasks like graphics rendering, database access with SQLite, and media playback. Android apps can indirectly use these libraries through the standard Android APIs. In some advanced cases they can also use them directly through the NDK, the Native Development Kit, but this is beyond beginner level.

On top of the native libraries is the Android runtime. For modern Android versions this is called ART, the Android Runtime. Apps are written in languages such as Kotlin or Java and are compiled into bytecode that ART can execute. ART manages memory, runs your code, and performs optimizations to make apps faster and more efficient.

Next is the application framework layer. This is what you work with most of the time as an Android developer. It provides high level classes and services such as activities, services, content providers, notifications, resource management, and access to system features like location or connectivity. Kotlin or Java code in your app talks to this framework layer.

At the top are the applications themselves. This includes both system apps such as the home screen launcher, phone app, and settings app, and user installed apps like the ones you will build. Every app uses the same underlying framework and runtime, which is why skills you learn are transferable across many types of apps.

Key idea: Your Android app runs on top of the Android runtime and application framework. You do not control the whole device. You cooperate with the system, which decides when and how your components run.

Android’s Component Based App Model

Android apps are not single continuous programs that run from start to finish. They are made of components that the system can start and stop independently. Although this course will cover components in detail later, it is important here to understand that Android uses this model to manage apps efficiently.

Common component types include activities for screens, services for background work, broadcast receivers for reacting to system or app wide events, and content providers for sharing structured data. The Android system creates and destroys these components when needed. As a developer you describe your components in configuration files such as AndroidManifest.xml and in code, and the system uses that description to manage them.

This component based design makes Android well suited to multitasking on devices with limited resources. Different apps can share the screen over time and can react to system events without having to run all the time.

Dalvik, ART, and the Role of Kotlin

Earlier versions of Android used a runtime called Dalvik. Modern devices use ART, which offers better performance and more efficient memory management. From the perspective of a beginner app developer, the important part is that your Kotlin code is compiled into a form that ART can execute.

Kotlin is now the recommended language for Android app development. It is designed to work smoothly with the existing Java based APIs, but it adds features that help you write safer and more concise code. Through this course, you will write Kotlin code that calls Android framework classes and interacts with the runtime, without having to worry about the internal details of ART itself.

Android and Device Diversity

One of the defining characteristics of Android is its presence on many different devices produced by many manufacturers. Screen sizes, shapes, resolutions, and hardware features can vary widely. Some devices have physical buttons, some have on screen buttons, some have stylus support, and some do not.

Android provides a common platform so that a single app can run on many of these devices. It handles differences in hardware through standardized APIs and a powerful resource system. As a developer you learn to design layouts and resources that adapt to different screens and configurations. This flexibility is one reason Android is used in more than just phones. It appears in tablets, TVs, wearables, cars, and more, each with its own specialized user interface.

Why Android Matters for Developers

Learning Android development gives you access to a very large user base. Billions of devices in many countries run Android, which means your apps can reach users across many markets and price ranges. The platform supports many business models through app sales, ads, subscriptions, and in app purchases.

Because Android is based on open technologies and has a strong ecosystem of tools and libraries, it is also a friendly environment for experimentation and learning. You can build small apps for yourself, publish apps for others, or contribute to larger projects, all using the same core skills that this course will introduce.

As you progress through the course, you will start from this understanding of Android as a layered, component based mobile operating system, and gradually learn how to use its tools and APIs to create useful and reliable applications.

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Introduction to Android Development
    • ☰ 1.1. What is Android
      • ☰ 1.2. Android Ecosystem and Versions
        • ☰ 1.3. Native vs Cross-Platform Development
          • ☰ 1.4. Course Structure and Goals
          • ☰ 2. Setting Up the Development Environment
            • ☰ 2.1. Installing Android Studio
              • ☰ 2.2. Android SDK and Tools
                • ☰ 2.3. Emulator Setup
                  • ☰ 2.4. Running Apps on a Physical Device
                  • ☰ 3. Kotlin Basics for Android
                    • ☰ 3.1. Variables and Data Types
                      • ☰ 3.2. Control Flow (if, when, loops)
                        • ☰ 3.3. Functions
                          • ☰ 3.4. Null Safety
                            • ☰ 3.5. Packages and Imports
                            • ☰ 4. Object-Oriented Programming in Kotlin
                              • ☰ 4.1. Classes and Objects
                                • ☰ 4.2. Constructors
                                  • ☰ 4.3. Inheritance and Polymorphism
                                    • ☰ 4.4. Interfaces
                                      • ☰ 4.5. Data Classes and Enums
                                      • ☰ 5. Android Project Structure
                                        • ☰ 5.1. Android Studio Project Overview
                                          • ☰ 5.2. Gradle Build System
                                            • ☰ 5.3. AndroidManifest.xml
                                              • ☰ 5.4. Resource Directories
                                              • ☰ 6. Your First Android App
                                                • ☰ 6.1. Creating a New Project
                                                  • ☰ 6.2. Understanding MainActivity
                                                    • ☰ 6.3. Running and Debugging the App
                                                    • ☰ 7. Android App Lifecycle
                                                      • ☰ 7.1. Activity Lifecycle
                                                        • ☰ 7.2. Lifecycle Callbacks
                                                          • ☰ 7.3. Configuration Changes
                                                          • ☰ 8. Layouts and Views
                                                            • ☰ 8.1. XML Layout Basics
                                                              • ☰ 8.2. LinearLayout
                                                                • ☰ 8.3. ConstraintLayout
                                                                  • ☰ 8.4. View Attributes
                                                                    • ☰ 8.5. Responsive Layouts
                                                                    • ☰ 9. User Interaction
                                                                      • ☰ 9.1. Buttons and Click Listeners
                                                                        • ☰ 9.2. TextView and EditText
                                                                          • ☰ 9.3. Handling User Input
                                                                            • ☰ 9.4. Toasts and Snackbars
                                                                            • ☰ 10. Styling and Themes
                                                                              • ☰ 10.1. Colors and Dimensions
                                                                                • ☰ 10.2. Styles
                                                                                  • ☰ 10.3. Themes
                                                                                    • ☰ 10.4. Dark Mode Support
                                                                                    • ☰ 11. Navigation Between Screens
                                                                                      • ☰ 11.1. Intents
                                                                                        • ☰ 11.2. Passing Data Between Activities
                                                                                          • ☰ 11.3. Activity Back Stack
                                                                                          • ☰ 12. Fragments
                                                                                            • ☰ 12.1. Fragment Basics
                                                                                              • ☰ 12.2. Fragment Lifecycle
                                                                                                • ☰ 12.3. Fragment Transactions
                                                                                                  • ☰ 12.4. Fragment Communication
                                                                                                  • ☰ 13. RecyclerView and Lists
                                                                                                    • ☰ 13.1. RecyclerView Basics
                                                                                                      • ☰ 13.2. Adapters and ViewHolders
                                                                                                        • ☰ 13.3. Click Handling in Lists
                                                                                                        • ☰ 14. Data Storage Basics
                                                                                                          • ☰ 14.1. SharedPreferences
                                                                                                            • ☰ 14.2. Internal Storage
                                                                                                              • ☰ 14.3. File Handling
                                                                                                              • ☰ 15. Databases with Room
                                                                                                                • ☰ 15.1. SQLite Overview
                                                                                                                  • ☰ 15.2. Room Entities
                                                                                                                    • ☰ 15.3. Data Access Objects
                                                                                                                      • ☰ 15.4. Database Migrations
                                                                                                                      • ☰ 16. Working with Images and Media
                                                                                                                        • ☰ 16.1. ImageView and Drawable Resources
                                                                                                                          • ☰ 16.2. Loading Images from the Internet
                                                                                                                            • ☰ 16.3. Audio and Video Playback
                                                                                                                            • ☰ 17. Permissions and Security
                                                                                                                              • ☰ 17.1. App Permissions
                                                                                                                                • ☰ 17.2. Runtime Permissions
                                                                                                                                  • ☰ 17.3. Security Best Practices
                                                                                                                                  • ☰ 18. Networking Fundamentals
                                                                                                                                    • ☰ 18.1. HTTP Basics
                                                                                                                                      • ☰ 18.2. REST APIs
                                                                                                                                        • ☰ 18.3. JSON Parsing
                                                                                                                                        • ☰ 19. Networking with Retrofit
                                                                                                                                          • ☰ 19.1. Retrofit Setup
                                                                                                                                            • ☰ 19.2. API Interfaces
                                                                                                                                              • ☰ 19.3. Error Handling
                                                                                                                                              • ☰ 20. Background Tasks
                                                                                                                                                • ☰ 20.1. Threads and Handlers
                                                                                                                                                  • ☰ 20.2. Kotlin Coroutines
                                                                                                                                                    • ☰ 20.3. Lifecycle-Aware Tasks
                                                                                                                                                    • ☰ 21. Services and WorkManager
                                                                                                                                                      • ☰ 21.1. Services Overview
                                                                                                                                                        • ☰ 21.2. Foreground vs Background Services
                                                                                                                                                          • ☰ 21.3. WorkManager
                                                                                                                                                          • ☰ 22. Architecture Components
                                                                                                                                                            • ☰ 22.1. ViewModel
                                                                                                                                                              • ☰ 22.2. LiveData
                                                                                                                                                                • ☰ 22.3. MVVM Architecture
                                                                                                                                                                • ☰ 23. Dependency Injection
                                                                                                                                                                  • ☰ 23.1. Dependency Injection Concepts
                                                                                                                                                                    • ☰ 23.2. Hilt Basics
                                                                                                                                                                    • ☰ 24. Material Design
                                                                                                                                                                      • ☰ 24.1. Material Design Principles
                                                                                                                                                                        • ☰ 24.2. Material Components
                                                                                                                                                                          • ☰ 24.3. Adaptive UI Design
                                                                                                                                                                          • ☰ 25. Animations and Motion
                                                                                                                                                                            • ☰ 25.1. View Animations
                                                                                                                                                                              • ☰ 25.2. Property Animations
                                                                                                                                                                                • ☰ 25.3. Transitions
                                                                                                                                                                                • ☰ 26. Notifications
                                                                                                                                                                                  • ☰ 26.1. Notification Basics
                                                                                                                                                                                    • ☰ 26.2. Notification Channels
                                                                                                                                                                                      • ☰ 26.3. Action Buttons
                                                                                                                                                                                      • ☰ 27. Location and Sensors
                                                                                                                                                                                        • ☰ 27.1. Location Services
                                                                                                                                                                                          • ☰ 27.2. Using GPS
                                                                                                                                                                                            • ☰ 27.3. Device Sensors
                                                                                                                                                                                            • ☰ 28. Maps and Geolocation
                                                                                                                                                                                              • ☰ 28.1. Google Maps Integration
                                                                                                                                                                                                • ☰ 28.2. Markers and Map Events
                                                                                                                                                                                                • ☰ 29. Testing Android Apps
                                                                                                                                                                                                  • ☰ 29.1. Unit Testing
                                                                                                                                                                                                    • ☰ 29.2. UI Testing with Espresso
                                                                                                                                                                                                    • ☰ 30. Performance Optimization
                                                                                                                                                                                                      • ☰ 30.1. Memory Management
                                                                                                                                                                                                        • ☰ 30.2. Profiling Tools
                                                                                                                                                                                                          • ☰ 30.3. Performance Best Practices
                                                                                                                                                                                                          • ☰ 31. App Debugging
                                                                                                                                                                                                            • ☰ 31.1. Logcat
                                                                                                                                                                                                              • ☰ 31.2. Breakpoints
                                                                                                                                                                                                                • ☰ 31.3. Debugging Common Issues
                                                                                                                                                                                                                • ☰ 32. App Packaging and Signing
                                                                                                                                                                                                                  • ☰ 32.1. APK vs AAB
                                                                                                                                                                                                                    • ☰ 32.2. Signing Configurations
                                                                                                                                                                                                                      • ☰ 32.3. Release Builds
                                                                                                                                                                                                                      • ☰ 33. Publishing on Google Play
                                                                                                                                                                                                                        • ☰ 33.1. Google Play Console
                                                                                                                                                                                                                          • ☰ 33.2. Store Listing
                                                                                                                                                                                                                            • ☰ 33.3. Release Tracks
                                                                                                                                                                                                                            • ☰ 34. Monetization Strategies
                                                                                                                                                                                                                              • ☰ 34.1. Ads
                                                                                                                                                                                                                                • ☰ 34.2. In-App Purchases
                                                                                                                                                                                                                                  • ☰ 34.3. Subscriptions
                                                                                                                                                                                                                                  • ☰ 35. Advanced Topics
                                                                                                                                                                                                                                    • ☰ 35.1. Custom Views
                                                                                                                                                                                                                                      • ☰ 35.2. Introduction to Jetpack Compose
                                                                                                                                                                                                                                      • ☰ 36. Capstone Project
                                                                                                                                                                                                                                        • ☰ 36.1. Project Planning
                                                                                                                                                                                                                                          • ☰ 36.2. Implementation