So far in this course, steps have been taken to set up an environment suitable for the development
of Android applications using Android studio.
An initial step has also been taken into the process of application development through the creation
of Android Studio Application Project.
Before delving further into practical matters of Android application development, however, it is important
to gain an understanding of some of the more abstract concepts of both Android software development
kit and Android development in general.
Gaining a clear understanding of these concepts now will provide a sound foundation on which to build
further knowledge.
So starting with an overview of Android of Android application in this course and continuing to in the
next few lectures of this course, the goal is to provide a detailed overview of the fundamentals of
Android development.
My name is Stephan and let's get started with our lecture.
The Android software stack on Android is a structured in the form of software stack comprising applications
and operating systems, runtime, environment, middleware services and libraries.
This architecture can perhaps can best be represented visually as outlined in this screenshot.
Each layer of the stack and the corresponding elements within each layer are tightly integrated and
carefully tuned to provide the optimal application, development and execution environment for mobile
devices.
The remainder of this course will work through the different layers of this Android stack and starting
the bottom with the Linux kernel.
So let's get started with the Linux kernel.
Linux kernel positioned at the bottom of Android software stack.
The Linux kernel provides a level of abstraction between the device hardware and upper layers of Android
software stack based on Linux version 2.6.
The kernel provides a preemptive multitasking, low level core system services such as memory process
and power management.
In addition to providing a network stack and device drivers for hardware such as device displays, WiFi
and audio.
The original Linux kernel was developed by in 1991 by Linus Torvalds and was combined with a set of
tools, utilities and compilers developed by Richard Stallman at the Free Software Foundation to create
a full operating system referred to as Genie or Linux.
The various Linux distributions have been derived from the basic underpinnings such as Ubuntu and Red
Hat Enterprise Linux.
The Kali Linux and the Ubuntu and other Linux based systems.
And it's important to note, however, that Android uses only the Linux kernel.
That said, it is worth noting that the Linux kernel was originally developed for use in traditional
computers in the form of desktops and servers.
In fact, Linux is now most widely deployed in mission critical enterprise server environments and it
is a testament to both the power of today's mobile devices and the efficiency and performance of the
Linux kernel that we find this software at the heart of the Android software stack.
In addition to a set of standard Java Kotlin Development libraries, this providing a support for such
general purpose tasks such as string handling, networking and file manipulation.
The Android development environment also includes the Android libraries.
These are a set of Java based libraries that are specific to Android development.
Examples of libraries in this category include the application framework libraries in addition to those
that facilitate user interface building, graphics, drawing and database access.
And on the screen you are seeing some of the most used libraries in Android.
The Android runtime.
Core libraries, as outlined in the preceding section, are Java and Kotlin based and provide the primary
APIs for developers writing Android application.
And it's important to note that, however, that the core libraries do not perform much of the actual
work and are in fact essentially Java and Kotlin wrappers around a set of C and C plus plus based libraries.
So when making a calls, for example, the Android OpenGL library to drive 3D graphics on the device
display and the library actually ultimately makes a call to the OpenGL s C plus plus library, which
in turn works with the underlying Linux kernel to perform the driving tasks.
The C plus plus libraries are included to fulfill a wide and diverse range of functions, including
2D and 3D graphics drawing secure sockets, layer, SSL communication, SQLite database management,
audio and video playback bitmap and vector font rendering display subsystem and graphics layer management
and an implementation of the standard C System library.
This means the lib C here.
So in practice, the typical Android application developer will access these libraries solely through
Java or Kotlin based Android core library APIs.
In the event that direct access to these libraries is needed, this can be achieved using the Android
Native Development kit in the UK.
So the purpose of which is to call the native methods of Non-java or Kotlin programming languages such
as C and C plus plus from within the Java and Kotlin code using the Java Native interface G and I.
And lastly, we have left to discuss the application framework in Android architecture.
The application framework is a set of services that collectively form the environment in which applications
and other applications run and are merged.
This framework implements the concepts that Android applications are constructed from a reusable, interchangeable
and replaceable components, and this concept is taken a step further in that an application is also
able to publish its capabilities along with any corresponding data so that they can be found and reused
by other applications.
So they are following.
The Android framework includes, for example, activity manager, which you can see on the screen here.
So the applications here located at the top of the Android software stack are the applications.
So these comprise both the native applications provided with the particular Android implementations,
for example, web browser and the email applications and the third party applications installed by the
user after processing the device.
A good Android Development Knowledge Foundation requires an understanding of the overall architecture
of Android.
Android is implemented in the form of software stack architecture, consisting of a Linux kernel, a
runtime environment and corresponding libraries, an application framework and a set of applications.
So applications are predominantly written in Java or Kotlin and compiled down to bytecode format within
the Android studio build environment.
When an application is subsequently installed on a device, this byte code is compiled down by the Android
runtime art to the native format used by the CPU.
The key goals of the Android architecture are performance and efficiency, so both in application execution
and the implementation of reuse in application design.