Android Runtime: Execution Environments

Loading...

Do curso por Vanderbilt University

Android App Components - Services, Local IPC, and Content Providers

161 classificações

Explore Related Videos

At Coursera, you will find the best lectures in the world. Here are some of our personalized recommendations for you

Vanderbilt University

Android App Components - Services, Local IPC, and Content Providers

161 classificações

Curso 3 de 5 em Specialization Android App Development

This 4 week MOOC builds upon the core Android app components and concurrency frameworks covered in Course 2 by focusing on started and bound services, local inter-process communication (IPC), and content providers. Case study apps will be examined from multiple perspectives to learn how to program these app components using Android's material design paradigm. Students will work incrementally on a hands-on project involving a material design-based RSS reader app. Each week you will add additional capabilities to the project, based on material covered in the lecture videos. You'll spend roughly 4 hours per week watching video lectures, taking quizzes, and programming assignments with Java and Android.

Na lição

MOOC Overview

This module provides an introduction to the contents of the MOOC and summarizes effective learning strategies. Learning objectives are presented in the Module Introduction video lecture.

An Introduction to Key Concepts3:54

Android Hardware Abstraction Layer (HAL)4:26

Android Runtime: Execution Environments5:23

Android Runtime: Core and Native Libraries9:51

Conheça os instrutores

Dr. Douglas C. Schmidt
Professor of Computer Science and Associate Chair of the Computer Science and Engineering Program
Electrical Engineering and Computer Science

[MUSIC]

Welcome to Part 2 in our lesson on Infrastructure Middleware,

where we focus on Android's Runtime execution environment.

After completing this part of the lesson, you'll understand the role of

the execution environment in Android's Runtime layer and

you'll also know the two execution environments

that have been part of Android's Runtime which are known as ART and Dalvik.

Apps rarely access ART or Dalvik directly, but it's still useful to understand what

they do so you'll be a more effective full-stack developer.

Start with an overview of the Android Runtime's Execution Environment.

Android's Runtime layer is largely used to execute Java apps on mobile devices

such as tablets, smart phones, or wearables.

These apps can now also run in the Chrome browser on laptops and desktops.

Android's Runtime layer contains an execution environment

that resides atop the Linux kernel.

This environment executes app byte code and/or native byte code

typically inside a Linux process.

The code itself is generated from Java source files by the javac compiler.

The execution environment is created when a process starts and

is destroyed whenever the process exits.

A process can run apps or system services.

The execution environment enhances portability and productivity by shielding

higher layers of Android, as well as application developers,

from low-level details of the underlying hardware.

This hardware can include different instruction sets such as Intel x86,

ARM, or various types of emulators.

Android apps typically run in their own process and

their own instance of the execution environment.

It is possible in some rare circumstances, however,

to have apps share the same process address space.

Let's now talk about the evolution of the Android Execution Environment,

which has changed over time.

Android apps are typically written in Java, but

they don't run in a standard Java Virtual Machine or JVM.

Originally, the Dalvik virtual machine, or DVM,

was used to interpret so-called Dalvik bytecode.

This Dalvik bytecode uses a register machine model.

In contrast, the Java platform uses a stack machine model.

These two types of bytecode, Dalvik bytecode and

Java bytecode, are not directly compatible.

Therefore, Android originally defined a utility program called dx that

transforms Java bytecode in class files into .dex-formatted bytecode.

Dalvik was later enhanced to add support for Just-in-time, or JIT compilation.

A JIT optimizes bytecode dynamically while a program is running.

During the past several years Dalvik has been phased out and replaced with

an improved execution environment called the Android Runtime, or ART.

There's a number of enhancements in ART.

For example, it provides an ahead-of-time compiler which

is used to compile .dex files into native code when an app is installed.

Needless to say, native code execution time is substantially faster than

interpreted bytecode.

It also provides better support for garbage collection.

It has fewer garbage collection pauses and

also the ability to execute garbage collection in parallel

with other computations taking place in an application.

It also provides a Just-in-time compiler

that further optimizes ART's ahead-of-time compiled code at runtime.

Irrespective of whether ART or Dalvik is used,

Android's execution environments implement core Java concurrency features.

For example, they implement the threading and

synchronization mechanisms defined in the Java programming language specification.

Such as threads that run computations concurrently,

as well as built-in monitor objects that provide synchronization mechanisms by

the synchronized statement and synchronized method constructs,

as well as notification features via the wait, notify, and notify all methods.

My website contains many more digital learning resources related to Android and

Java concurrency, so I recommend you check it out.

Note that Android's concurrency features also involve capabilities at

multiple levels.

There are kernel threads, there are Android virtual machine threads,

there are POSIX threads, there's Java threads, and

there's also higher-level Android concurrency frameworks.

There's also support in Android for multi-core hardware.

It's now widely available for many mobile devices.

This concludes the end of Part 2 of our lesson on Infrastructure Middleware,

which focused on the Android Runtime Execution Environment.

[MUSIC]

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2019 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play