What's New in Android 4.4

Slide 1

Slide 1 text

No content

Slide 2

Slide 2 text

Chet Haase, Android Framework engineer (Graphics & animations) Romain Guy, ex-Android Framework engineer

Slide 3

Slide 3 text

& Chet Haase Romain Guy Chet Haase, Android Framework engineer (Graphics & animations) Romain Guy, ex-Android Framework engineer

Slide 4

Slide 4 text

A few weeks ago, Google announced the release of Android 4.4 KitKat.

Slide 5

Slide 5 text

What’s New Today we’re going to talk about what’s new in Android. We won’t be able to cover everything but we’d like to highlight some of the most exciting new features for developers and users alike.

Slide 6

Slide 6 text

Today we’re going to talk about what’s new in Android. We won’t be able to cover everything but we’d like to highlight some of the most exciting new features for developers and users alike.

Slide 7

Slide 7 text

The ﬁrst device to run with Android 4.4 KitKat is the newly released Google Nexus 5. It’s not the focus of our talk but here is some info about the specs: 1080p display, 2 GB of RAM, 4-core 2.3 Ghz Snapdragon 800, Adreno 330 GPU, optical image stabilization…

Slide 8

Slide 8 text

In September 2013, we announced a total of 1 billion activated Android devices. One year ago, in September 2012, there were 500 million Android devices.

Slide 9

Slide 9 text

1,000,000,000 devices activated In September 2013, we announced a total of 1 billion activated Android devices. One year ago, in September 2012, there were 500 million Android devices.

Slide 10

Slide 10 text

Device activations Here is a brief recap of the total number of activated Android devices since mid-2011.

Slide 11

Slide 11 text

May 11 Oct 11 Jan 12 Feb 12 Jun 12 Sep 12 Mar 13 Sep 13 100 190 250 300 400 500 750 1,000 Device activations Here is a brief recap of the total number of activated Android devices since mid-2011.

Slide 12

Slide 12 text

JellyBean is now on >50% of Android devices and ICS 20%. Honeycomb barely registers at 0.1%.

Slide 13

Slide 13 text

HC GB 26% Froyo < 2% JB 52% ICS 20% JellyBean is now on >50% of Android devices and ICS 20%. Honeycomb barely registers at 0.1%.

Slide 14

Slide 14 text

API 8-13 28% API 15-18 72% This means 72% of devices run API level 15 (ICS) or higher.

Slide 15

Slide 15 text

Documents 1

Slide 16

Slide 16 text

Storage Access Framework The new storage API makes it easy for users to browse and open local & cloud-based documents. An advanced setting even allows to browse the entire ﬁle system.

Slide 17

Slide 17 text

private static final int READ_REQUEST_CODE = 1; public void performFileSearch() { Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT); intent.addCategory(Intent.CATEGORY_OPENABLE); intent.setType("image/*"); startActivityForResult(intent, READ_REQUEST_CODE); } You can display the standard UI by using the OPEN_DOCUMENT or CREATE_DOCUMENT intents. The standard UI will show content from all registered document providers.

Slide 18

Slide 18 text

public class MyDocsProvider extends DocumentsProvider { @Override public Cursor queryRoots(String[] projection); @Override public Cursor queryChildDocuments(String parentDocId, String[] projection, String sortOrder); @Override public Cursor queryDocument(String documentId, String[] projection); @Override public ParcelFileDescriptor openDocument( String documentId, String mode, CancellationSignal signal); } To implement a new document provider you only need to implement these 4 methods. They let you manage the browsing, reading and writing of any local or remote data that can be represented as ﬁles/documents.

Slide 19

Slide 19 text

You need to register your document provider by using the DOCUMENTS_PROVIDER intent ﬁlter and requesting the MANAGE_DOCUMENTS permission.

Slide 20

Slide 20 text

Printing New printing APIs can be used to add printing capabilities to almost any kind of content. In particular, you can print anything you can render to a Canvas.

Slide 21

Slide 21 text

PdfDocument document = new PdfDocument(); PageInfo pageInfo = new PageInfo.Builder( new Rect(0, 0, 100, 100), 1).create(); Page page = document.startPage(pageInfo); View content = getContentView(); content.draw(page.getCanvas()); document.finishPage(page); document.writeTo(getOutputStream()); document.close(); Android uses PDF as its native printing format, this means you can generate PDF documents from any app that can draw onto a Canvas.

Slide 22

Slide 22 text

PrintHelper bitmapPrinter = new PrintHelper(getActivity()); bitmapPrinter.setScaleMode(PrintHelper.SCALE_MODE_FIT); Bitmap bitmap = BitmapFactory.decodeResource( getResources(), R.drawable.my_bitmap); bitmapPrinter.printBitmap("Untitled Image", bitmap); The PDF API is powerful but if you want to print properly paginated bitmaps, it is recommended you use helper classes.

Slide 23

Slide 23 text

User interface 2

Slide 24

Slide 24 text

Translucent system UI Android 4.4 allows applications to draw behind the status bar and the navigation bar.

Slide 25

Slide 25 text

Theme.Holo.NoActionBar.TranslucentDecor Theme.Holo.Light.NoActionBar.TranslucentDecor There are two new themes you can use to request the new translucent system UI.

Slide 26

Slide 26 text

If you request translucent sys bars, make sure to use ﬁtsSystemWindows for the portion of your layout that should not be covered by the system UI.

Slide 27

Slide 27 text

Immersive mode We have a new immersive full-screen mode that hides the system UI even while the user interacts with the application. This was previously only possible for passive content such as videos. This is a great new API for content-rich applications that many of you have been asking for. To bring back the system UI, swipe from the top or bottom edges.

Slide 28

Slide 28 text

private void hideSystemUI() { mDecorView.setSystemUiVisibility( View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE); } Hiding the system UI is easy with the new SYSTEM_UI_FLAG_IMMERSIVE ﬂag.

Slide 29

Slide 29 text

private void showSystemUI() { mDecorView.setSystemUiVisibility( View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN); } To show the UI again, no new ﬂag is necessary. These two methods can be used to toggle the system UI dynamically.

Slide 30

Slide 30 text

@Override public void onWindowFocusChanged(boolean hasFocus) { super.onWindowFocusChanged(hasFocus); if (hasFocus) { mDecorView.setSystemUiVisibility( View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY); } } Alternatively you can create a persistent immersive experience that will automatically re-hide the system UI after a short delay or if the user interacts with the middle of the screen.

Slide 31

Slide 31 text

Fullscreen & hide navigation Here are a few guidelines to help you choose the most appropriate mode. If your app needs a “lean back” experience – often found in video players – use the FULLSCREEN and HIDE_NAVIGATION ﬂags

Slide 32

Slide 32 text

Immersive, fullscreen & hide navigation If your app is a content reader (books, magazines, articles, etc…) use the IMMERSIVE, FULLSCREEN and HIDE_NAVIGATION ﬂags

Slide 33

Slide 33 text

Immersive sticky, fullscreen & hide navigation If your app is a game or a drawing app – an app that requires a lot of interaction – use the IMMERSIVE_STICKY, FULLSCREEN and HIDE_NAVIGATION ﬂags

Slide 34

Slide 34 text

New WebView Android 4.4 introduces a completely new backend for WebView, based on the Chromium Open Source project that powers Chrome. This new WebView improved HTML 5 support, remote debugging, etc.

Slide 35

Slide 35 text

Android 4.4 introduces a completely new backend for WebView, based on the Chromium Open Source project that powers Chrome. This new WebView improved HTML 5 support, remote debugging, etc.

Slide 36

Slide 36 text

WebView webView = (WebView) findViewById(R.id.html_content); // Enable remote debugging webView.setWebContentsDebuggingEnabled(BuildConfig.DEBUG); Remote debugging is one of the best new features of the new WebView. First, you must enable debugging on the WebView instance you want to inspect.

Slide 37

Slide 37 text

Connect your device over USB to a computer running Chrome and visit chrome://inspect to start debugging your WebView.

Slide 38

Slide 38 text

chrome://inspect Connect your device over USB to a computer running Chrome and visit chrome://inspect to start debugging your WebView.

Slide 39

Slide 39 text

Connect your device over USB to a computer running Chrome and visit chrome://inspect to start debugging your WebView.

Slide 40

Slide 40 text

Scenes & transitions

Slide 41

Slide 41 text

Scenes // 1. From scratch Scene(ViewGroup); Scene.setEnterAction(Runnable);

Slide 42

Slide 42 text

Scenes // 2. From a layout resource Scene.getSceneForLayout(sceneRoot, R.layout.someId, context);

Slide 43

Slide 43 text

Scenes // 3. From existing ViewGroup Scene(ViewGroup, ViewGroup);

Slide 44

Slide 44 text

Transitions // 1. Individual transitions new ChangeBounds(); new Fade();

Slide 45

Slide 45 text

Transitions // 2. Transition groups TransitionSet set = new TransitionSet(); set.addTransition(new ChangeBounds()) .addTransition(new Fade());

Slide 46

Slide 46 text

Transitions // 3. From XML

Slide 47

Slide 47 text

Custom transitions void captureStartValues(TransitionValues); void captureEndValues(TransitionValues); Animator createAnimator(ViewGroup, TransitionValues, TransitionValues);

Slide 48

Slide 48 text

TransitionManager // Inflate from XML tm = TransitionInflater.inflateTransitionManager( R.transition.mgr, root);

Slide 49

Slide 49 text

TransitionManager // Build transition sequences manually TransitionManager tm = TransitionManager(); tm.setTransition(Scene, Transition); tm.setTransition(Scene, Transition, Transition);

Slide 50

Slide 50 text

TransitionManager // Different ways to trigger transitions Scene.enter(); TransitionManager.go(Scene); TransitionManager.go(Scene, Transition); tm.transitionTo(Scene, Transition);

Slide 51

Slide 51 text

The easy way TransitionManager.beginDelayedTransition(ViewGroup);

Slide 52

Slide 52 text

3 Accessibility & I18N

Slide 53

Slide 53 text

Closed captioning are now controlled by system-wide settings, found under Accessibility. Apps can access and adjust these settings using the new CaptioningManager.

Slide 54

Slide 54 text

// Add local source for English subtitles mVideoView.addSubtitleSource( getResources().openRawResource(R.raw.subs_en_vtt), MediaFormat.createSubtitleFormat("text/vtt", Locale.ENGLISH.getLanguage())); // Add local source for French subtitles. mVideoView.addSubtitleSource( getResources().openRawResource(R.raw.subs_fr_vtt), MediaFormat.createSubtitleFormat("text/vtt", Locale.FRENCH.getLanguage())); When you use a VideoView you can now simply pass the captions in WebVTT format. VideoView will take care of rendering the captions according to the user’s preferences.

Slide 55

Slide 55 text

CaptioningManager manager = (CaptioningManager) context.getSystemService(Context.CAPTIONING_SERVICE); manager.addCaptioningChangeListener(this); CaptioningManager.CaptionStyle style = manager.getUserStyle(); Typeface t = style.getTypeface(); The captioning manager lets you listen to preferences changes and access the style chosen by the user, including the typeface, background color, etc.

Slide 56

Slide 56 text

Drawables auto-mirroring In RTL mode drawables sometimes have to be mirrored (arrows for instance.) Until now it required the app to embed two versions of each asset, one going in the drawable-rtl/ resource directory. Mirroring is now handled automatically.

Slide 57

Slide 57 text

Here is an example of auto-mirroring taken from Android’s framework resources.

Slide 58

Slide 58 text

Drawable d = resources.getDrawable(R.drawable.spinner); d.setAutoMirrored(true); You can also of course set the auto-mirror property from code.

Slide 59

Slide 59 text

Supporting RTL locales is important to reach out as many users as possible but it can be difficult to test your application – and use the system – in Arabic or Hebrew. A new developer option lets you force RTL mode with your favorite locale to test your apps.

Slide 60

Slide 60 text

Performance 4

Slide 61

Slide 61 text

Re-usable bitmaps

Slide 62

Slide 62 text

// Create a 1 MB bitmap, 1 px high, 8 bits per pixel Bitmap b = Bitmap.createBitmap(1024 * 1024, 1, Bitmap.Config.ALPHA_8); // Use it as a 256x256 32 bits per pixel bitmap b.reconfigure(256, 256, Bitmap.Config.ARGB_8888); // Returns 256x256x4 = ~262 kB int size = b.getByteCount(); // Returns 1024x1024x1 = 1 MB int realSize = b.getAllocatedByteCount(); There is now a distinction between a bitmap’s backing store and its configuration. You can for instance allocate a bitmap that’s larger than what you need. As long as it can hold enough data, you can reconfigure it however you please by changing the width, height and configuration.

Slide 63

Slide 63 text

// Create a 1 MB bitmap, 1 px high, 8 bits per pixel Bitmap b = Bitmap.createBitmap(1024 * 1024, 1, Bitmap.Config.ALPHA_8); // Re-use our scratch bitmap for decoding BitmapFactory.Options opts = new BitmapFactory.Options(); opts.inBitmap = b; // Resizing is now supported when re-using bitmaps opts.inSampleSize = 2; // Decode an input stream into our bitmap BitmapFactory.decodeStream(in, null, opts); This is of course particularly useful when decoding bitmaps from external resources. You can pre-allocate bitmaps large enough to hold your incoming data and never allocate new bitmaps.

Slide 64

Slide 64 text

Shared assets texture Android 4.4 now generates a single texture containing all the framework assets, shared by all processes. This saves a bit of memory in every process but it also helps batching and merging drawing operations to optimize applications automatically.

Slide 65

Slide 65 text

Re-ordering & merging This is an example of re-ordering & merging with Android 4.4 on Nexus 7 (2013). Note how checked and unchecked boxes are drawn together.

Slide 66

Slide 66 text

Software v-sync SurfaceFlinger in OpenGL ES 2.0 Asynchronous texture uploads Other notable graphics improvements. Software v-sync triggers redraws a little ahead of the hardware v-sync to reduce latency. Async texture uploads improve apps that uses a large number of glyphs (CJK, emojis, etc…)

Slide 67

Slide 67 text

RenderScript RenderScript is now part of the NDK. There is also a support library.

Slide 68

Slide 68 text

mRs = new RSC::RS(); mRs->init(RSC::RS_INIT_LOW_LATENCY | RSC::RS_INIT_SYNCHRONOUS); mRsElement = RSC::Element::A_8(mRs); mRsScript = RSC::ScriptIntrinsicBlur::create(mRs, mRsElement); RSC::sp t = RSC::Type::create(mRs, mRsElement, width, height, 0); RSC::sp ain = RSC::Allocation::createTyped(mRs, t, RS_ALLOCATION_MIPMAP_NONE, RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED, inImage); RSC::sp aout = RSC::Allocation::createTyped(mRs, t, RS_ALLOCATION_MIPMAP_NONE, RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED, outImage); mRsScript->setRadius(radius); mRsScript->setInput(ain); mRsScript->forEach(aout); This is how Android’s hardware renderer uses RenderScript intrinsics. This gives the renderer a 2-3x boost over native code when applying blurs to textures.

Slide 69

Slide 69 text

performTraversals draw getDL drawDisplayList systrace flush drawing commands systrace got even more useful in Android 4.4, with new tags (animations, inﬂation, etc.) and the ability to use it from monitor (DDMS). Let’s look at a demo, using Launcher.

Slide 70

Slide 70 text

Android 4.4 introduces a new overdraw debugging tool that shows you the amount of overdraw per window.

Slide 71

Slide 71 text

Project Svelte Project Svelte was an effort in Android 4.4 to reduce memory usage across the board (system & apps) to ensure KitKat can run well on devices with 512 MB of physical RAM.

Slide 72

Slide 72 text

Procstats

Slide 73

Slide 73 text

$ adb shell dumpsys procstats com.google.android.apps.maps COMMITTED STATS FROM 2013-11-05-18-04-58: * com.google.android.apps.maps / u0a60: TOTAL: 1.1% Service: 1.1% (Cached): 99% (98MB-98MB-99MB/96MB-97MB-97MB over 7) Run time Stats: Screen Off / Norm / +1h19m25s22ms Screen On / Norm / +10m43s963ms TOTAL: +1h30m8s985ms Start time: 2013-11-05 18:04:58 Total elapsed time: +5h9m53s44ms (complete) libdvm.so chromeview

Slide 74

Slide 74 text

ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE); if (activityManager.isLowRamDevice()) { // Modify memory use behavior }

Slide 75

Slide 75 text

Connectivity & media 5

Slide 76

Slide 76 text

Bluetooth HID over GATT (HOGP) IR blasters NFC host card emulation Low-power sensors Step detection and counting sensors

Slide 77

Slide 77 text

Adaptive playback Support for adaptive video playback is now available with the MediaCodec APIs, enabling seamless change in resolution during playback onto a Surface. You can feed the decoder input frames of a new resolution and the resolution of the output buffers change without a signiﬁcant gap.

Slide 78

Slide 78 text

Loudness enhancer The LoudnessEnhancer is a new subclass of AudioEffect that allows you to increase the audible volume of your MediaPlayer or AudioTrack. This can be especially useful in conjunction to increase the volume of spoken audio tracks while other media is currently playing.

Slide 79

Slide 79 text

private void setupImageReader() { mReader = ImageReader.newInstance(width, height, 2); mReader.setOnImageAvailableListener(this, mHandler); playVideo(mReader.getSurface()); } @Override public void onImageAvailable(ImageReader reader) { Image image = reader.acquireLatestImage(); for (Image.Plane plane : image.getPlanes()) { processImageData(plane.getBuffer(), image.getWidth(), image.getHeight()); } } The new ImageReader API provides you direct access to image buffers as they are rendered into a Surface. The Image object provides direct access to the image's timestamp, format, dimensions, and pixel data.

Slide 80

Slide 80 text

android:sdk $ adb shell screenrecord 㾑 /sdcard/my_app.mp4 android:sdk $ adb pull /sdcard/my_app.mp4 Android 4.4 adds a long awaited feature: screen recording. The screenrecord command can record a video of your device for a duration of up to 3 minutes.

Slide 81

Slide 81 text

You can also invoke the screen recording command from Android Studio. The record button can be found in the “Android DDMS” panel (Alt-6).

Slide 82

Slide 82 text

You can also invoke the screen recording command from Android Studio. The record button can be found in the “Android DDMS” panel (Alt-6).

Slide 83

Slide 83 text

And more! 6

Slide 84

Slide 84 text

SELinux set to “enforcing” Improved cryptographic algorithms Per-user VPN on multi-user devices

Slide 85

Slide 85 text

Map> drawables = new HashMap<>(); Android 4.4 supports new language features such as the diamond operator. The compiler can infer the type of the right-hand side expression for us. This feature is retro-compatible.

Slide 86

Slide 86 text

String command = getCommand(); switch (command) { case "start": start(); break; case "stop": stop(); break; } It is not possible to use String types in switch statements. This makes the code a lot more readable than a series of if (mystring.equals(“astring”)). This feature is retro-compatible.

Slide 87

Slide 87 text

try (PrintWriter out = new PrintWriter("data.out")) { for (String line : getData()) { out.println(line); } } catch (IOException e) { // Do something smart } Automatic resource management will take care of calling close() for you. No more try/catch for IOException around close() calls in your ﬁnally statement! Auto resource management works on classes that implement AutoCloseable, present in API level 19 only.

Slide 88

Slide 88 text

try { readFile(); } catch (FileNotFoundException | IOException e) { // Do something useful } If several exceptions are thrown in a block of code and needs to be handled the same way, you can now catch them all with a single catch without catching a base class. This feature is retro-compatible.

Slide 89

Slide 89 text

New runtime Android 4.4 offers the option to switch to a new runtime, called ART, for development purposes only. ART is included so you can test your application but Dalvik should remain the default runtime for normal use.

Slide 90

Slide 90 text

To enable ART, go to Developer options, and click the “Select runtime” entry. After selecting ART you will need to reboot the device.

Slide 91

Slide 91 text

Android 4.4 DevBytes goo.gl/2bpmDA DevBytes is a series of videos that dive deeper in some of the features presented here. They are a great resource and highly recommended if you want to learn more about the new Android 4.4 APIs.

Slide 92

Slide 92 text

More info developer.android.com/about/versions/android-4.4.html developer.android.com/about/versions/kitkat.html

Slide 93

Slide 93 text

More info Romain’s Tips & Tricks www.curious-creature.org Chet’s Tips & Tricks graphics-geek.blogspot.com