Android 5.0 Lollipop introduces material design principles, enhanced notifications, improved battery life through ART and JobScheduler, multiple network connections, new camera and audio APIs, expanded security features, and cross-device synchronization. It also provides multi-dex support to overcome the method limit, and improved performance through ART's ahead-of-time compilation compared to Dalvik's just-in-time compilation. Developer tools have also been enhanced to analyze battery usage statistics.
4. • Static design
• Battery drainage
• Over heating
• Lagging (it’s really slow after few months of usage)
• Decentralized - it lacks central Android body to
address the grievance of its users.
• Fragmentation
24. • Android apps are deployed in Dalvik bytecode, which is
portable, unlike native code. In order to be able to run the
app on a device, the code has to be compiled to machine
code.
• older versions of Android use Dalvik VM
• based on JIT (just in time) compilation
• each time you run an app, the part of the code
required for its execution is going to be translated
(compiled) to machine code at that moment
• it has a smaller memory footprint and uses less
physical space on the device.
25. • Android 5.0 runs exclusively on the ART runtime,
which offers ahead-of-time (AOT) compilation
• The whole code of the app will be pre-
compiled during install (once)
27. • With no need for JIT compilation, the code should
execute much faster
• it doesn't hit the CPU as hard as just-in-time code
compiling on Dalvik (also, results in less battery
drain)
29. • the generated machine code requires more space
than the existing bytecode
• the code is pre-compiled at install time, so the
installation process takes a bit longer
• larger memory footprint at execution time (fewer
apps run concurrently)
31. • increased speed in CPU floating operations by
approx. 20%
• increased speed in RAM operations by approx. 10%
• increased speed in storage operations by approx.
10%
• CPU integer operations - slight advantage goes to
Dalvik
• Install times on my Nexus 4, for one of our larger
projects, jumped from ~17 s to ~25 s.
(tested on Kitkat 4.4.4, should be even faster now)
34. 1. Scheduling jobs
• Android 5.0 provides a new JobScheduler API that lets you
optimize battery life by defining jobs for the system to run
asynchronously (at a later time or under specified condition)
• The app has non-user-facing work that you can defer.
• The app has work you'd prefer to do when the unit is
plugged in.
• The app has a task that requires network access or a Wi-Fi
connection.
• The app has a number of tasks that you want to run as a
batch on a regular schedule.
35. • You can schedule the task to run under specific
conditions, such as:
• Start when the device is charging
• Start when the device is connected to an
unmetered network
• Start when the device is idle
• Finish before a certain deadline or with a
minimum delay
36. 2. Developer tools for battery usage
• The new dumpsys batterystats command generates interesting
statistical data about battery usage on a device, organized by unique
user ID (UID):
• History of battery related events
• Global statistics for the device
• Approximate power use per UID and system component
• Per-app mobile ms per packet
• System UID aggregated statistics
• App UID aggregated statistics
38. • since the release of Android 4.4
KitKat, WebView has been
based on Chromium (it has the
same rendering and Javascript
engine as Chrome for Android)
• WebView is now unbundled from
the system and will be regularly
updated through Google Play.
• every mobile device with
Android 5 or later should have
not only the same but the latest
browsing engine in the WebView
40. • Android 5.0 provides new multi-networking APIs
that let your app dynamically scan for available
networks with specific capabilities, and establish a
connection to them
• useful when your app requires a specialized network, such
as an SUPL, MMS, or carrier-billing network, or if you want to
send data using a particular type of transport protocol.
42. • Android 5.0 introduces the new
android.hardware.camera2 API to facilitate fine-
grain photo capture and image processing
• Use the new notification and media APIs to ensure
that the system UI knows about your media
playback and can extract and show album art.
• Controlling media playback across a UI and a
service is now a lot easier
• ability for apps to browse the media content library
of another app
44. • encryption is automatically turned on to help
protect data on lost or stolen devices
• Android Smart Lock - secure your phone or tablet
by pairing it with a trusted device like your
wearable or even your car
46. • ability to pair up different devices (tablet + Android
wear + smartphone + Android TV) in one system
• applications are optimised for every device
• songs, photos, apps, and even recent searches
from one of your Android devices can be
immediately enjoyed across all of your Android
devices
50. • Dalvik VM has one major limitation which we didn’t
discuss yet:
APK HAS UPPER LIMIT OF
65,536 METHODS!
51. • ART natively supports loading multiple .dex files
from application APK files.
• ART performs pre-compilation at application install
time which scans for classes(..N).dex files and
compiles them into a single .oat file for execution
by the Android device
• Android build tools construct a primary dex
(classes.dex) and supporting (classes2.dex,
classes3.dex) as needed. The build system will
then package them into an APK file for distribution.
53. • BLE Peripheral Mode - Android devices can now function in
Bluetooth Low Energy (BLE) peripheral mod
• Managed provisioning and unified view of apps
• OpenGL ES 3.1 and Android Extension Pack
• 64-bit support
• Print preview and page range support
• better integration with OK Google
• Concurrent documents in Overview
• Android Work
55. • Android Studio 1.0 RC 1 has been released to
Canary channel
• Material design has already been integrated to
Android Support Library
• Google Play Services Granular Dependency
Management - you’ll be able to depend only on the
parts of Google Play services that you use by
utilizing separate libraries for each API.