RxJava is a powerful framework, but there are a lot of common issues developers run into when getting started with it. We'll go over a bunch of common mistakes and and best practices when it comes to working with RxJava. This talk assumes a beginner's knowledge of RxJava.
ClassyShark - a handy Android executables viewer, https://github.com/google/android-classyshark. I am Boris Farber, Developer Advocate at Google, focusing on Android data intensive apps. I want to show how using ClassyShark you can analyse and troubleshoot the most painful problems around runtime failures. 1. Obfuscation 2. Dependencies 3. Multidex 4. JNI & Native code
(for Will Bailey) Rebound is a library we developed at Facebook for bringing lifelike animation to Android. I'll be speaking about simple but powerful techniques that will help you build smooth, fluid, and lively interfaces on Android as well as showing some examples of how we use these techniques in Facebook products. Speaker info: Will is a Software Engineer at Facebook/Instagram who focuses on bringing delightful user experiences to Android. While leading the front end development efforts for Facebook Home, he developed a simple framework (Rebound) and philosophy for coordinating user interfaces with physics. He enjoys applying this approach in his day to day work and sharing his ideas with others through through open source
Our Code Lab will be a hands on workshop for getting your Android apps set up with the latest tooling from Fabric- whether that's crash reporting, easy beta distribution setup, analytics, ads, or our open source toolset fastlane, which helps you script some of the more time-consuming aspects of distributing and shipping your app.
The Android SDK has changed much since its first version. Every new version comes with many new APIs. However, there is no perfect API, some do too much under the hood, others couple your classes to the context, others have more lifecycle events than you have years in your life. The talk will show how to make your app scalable, your code clean, your performance optimized and your UI neat. The talk will show in a pragmatic way the pros and cons of using certain Android APIs, strategies and libraries.
While the 65k method limit on the Dex file format was once a problem that could be blissfully ignored, the current reality is that a very large number of developers have already hit this limit, and many others will hit it soon! Before (and even after) you take the MultiDex plunge, there are some significant performance consequences you should be aware of. This talk is all about MultiDex: what it is, why it’s necessary, how it works, what the real consequences are (with data), and some tricks you can use to get around these issues.
People often associate Android apps with less charming user interfaces. Yet with the correct set of frameworks and UI performance optimizations, we can create pleasant user experiences that are both aesthetically pleasing and highly performant. I’ll be discussing the immersive video viewer on Instagram as an example to demonstrate how Android apps can look and feel just as great (if not better) than their iOS counterparts. Speaker Info: Kevin is a Software Engineer at Facebook/Instagram who pursues smooth, interactive designs on Android. Recently he built the new video consumption experience on Instagram, hosting the best content from Halloween, New Year’s Eve, and other celebratory events for people to watch and have fun.
The Adobe Creative SDK lets you build applications that integrate with the Adobe Creative Cloud and leverage its power to benefit your users. The Creative SDK offers Creative Cloud content management, creative tools, connected workflows and more. In this session, learn how to integrate the Creative SDK’s Image Editor UI component to quickly and easily build powerful image editing into your Android app. Then learn about how you can continue on to save images from your app to the Creative Cloud with the Creative Cloud Files API, and let your users send their photos directly to Photoshop on the desktop with the Send To Desktop API.
For the past 3 years, Square Register Android has leveraged Dagger † to wire up Java objects. However, the app scope hierarchy and complexity increased and we started having bugs and crashes related to scoping errors. This talk will show how to structure an app around Dagger2 ‡ and present a strategy for incrementally migrating from Dagger1 to Dagger2.
The sync services framework is one of the best assets of the Android platform. It helps you keep your app’s data up to date while still being friendly on battery, and helps you build an app that can work better while offline. We’ll talk about when and where you might want to use the sync services. However, there are a lot of moving parts in the sync framework, and it looks a little scary up front. Fear not. We’ll dive into an open source example project to show how to use the sync services in a clean and testable way. We'll also cover over some pitfalls you might encounter while using sync services, and how to avoid them. Your users who commute via subway will thank you!
With more than 40,000 apps launching daily, it’s a challenge to stand out. Driving awareness and acquiring users is tough. It’s been shown that deep linking can improve new user retention and in-app conversions by up to 2X. This session will showcase how you can add deep linking to your latest app. We’ll also address deferred and contextual deep linking in theory and action, and best practices to use them. The class will close with specific types of features you can build on top of it to help drive quality new users.
In this talk, Ty will walk you through setting up and using Kotlin with Gradle to streamline your workflow for Android development by focusing on using Kotlin's advantages within the Gradle build toolchain. After a brief overview of some useful Kotlin features, we'll dive into how it can be used with Gradle to accelerate day to day Android Development, while using a consistent language throughout the entire development stack, all on a real world example, by building a Gradle plugin in Kotlin.
Firebase is Google's backend-as-a-service for developing native mobile apps. Frank introduces the main features of Firebase and then live-codes a complete, multi-user Android app from scratch. His promise: no snippets will be copied or auto-expanded. In return he may need your help catching typos and other coding mistakes.
This talk is a deep dive into code to demonstrate how Android developers can migrate and co-exist with Unity development for VR (and AR) apps (one to one comparisons as well as plugins). We'll walk through sample code for Cardboard, Tango and even non-Google sample code for additional VR and AR headsets.
XML layouts are a fundamental part of Android development at all levels. Getting started is straightforward but creating efficient layouts while still achieving a high-level of control takes some practice and a few tricks. In this session we will look at creating lean yet lovely layouts. We will discuss use cases and best practices for standard layouts, recognizing when a custom layout is for you, common mistakes and misconceptions, and some tricks and situational techniques.
Your Mobile apps can talk to other mobile apps all between each other without needing a server! Using bluetooth, mobile apps can exchange content amongst each other without requiring a server or network connections. With Couchbase Lite, you can enable Peer-to-peer (P2P) sync between two or more devices. Bring your laptops and code along with William who will show you how to build a peer-to-peer mobile photo-sharing app, step-by-step, from scratch. You will see how the core code for sending and receiving photos is barely 100 lines of code and contains zero code directly involved in network communication. Come learn about how to enable your mobile apps to have a better experience without needing a server. We will code together a sample app and demo how photo sharing with peer 2 peer technology can create apps of the future.
ItemTouchHelper was added to RecyclerView back in 22.2 and adds a lot of power to responding to touch events in RecyclerViews. Come not just to learn how to make your lists delight users but also to dig into how ItemTouchHelper really works in your RecyclerViews.
The Android Design Support Library is full of interesting widgets, but none are more powerful than the CoordinatorLayout. Billed as a “super-powered FrameLayout”, it provides a framework for building complex touch interactions and behaviors between related views. It builds on the nested scrolling behavior built into views starting with Android 5.0, and backported in the latest support library releases. CoordinatorLayout exposes these complex interactions in the form of Behaviors. We will be discussing how CoordinatorLayout uses Behaviors to accomplish its goals. You will also learn what behaviors are available from the support library…and how to create your own.
This talk will discuss the way Facebook approaches the analysis of the production performance of the Facebook Android app. We will cover some of our existing tools, as well as our newest production tracing system. Facebook faces extreme challenges in performance measurement and diagnostics - from the fast-moving code base, through the wide spectrum of devices, to the variable conditions that the app is used in. Developing within these constraints has led to solutions involving byte code instrumentation, databases for performance markers, as well as heavy automation, analysis, and monitoring. This talk will cover in some detail the end-to-end flow as a product engineer as well as our overall vision.
Arabic, Farsi, Hebrew, and Urdu are all very popular languages (Arabic, for example, is the 5th most spoken language in the world). As more and more Android developers begin targeting regions outside the US and Europe, supporting RTL becomes critical for capturing those audiences. This talk will discuss: - an overview of RTL languages - what Android gives you before and after api 17 - how the framework implements RTL in various ViewGroups - some tips and tricks for supporting RTL in your app
Design shouldn’t just adapt to screen size. Context isn’t all about adding more information. Mutative design is a new methodology that hopes to address the problems inherent in designing for averages. It looks to create interfaces and experiences that are born, live, and evolve according to a user's ongoing realities, providing a no-compromise design that accounts for every user, regardless of vision level, data access, physical ability, or even tech savvy. The first steps in thinking about and experimenting with this methodology were made with the introduction of Project Phoebe in December (hello.phoebe.xyz), and now it's time to take a look at Phoebe's latest steps. In this talk we'll unpack what it's like to actually use and live with a mutative interface, how mutations may be automatically selected for using aggregated information about various user states, and how to ensure users feel comfortable with an interface that may change and grow as they do.
Performance is always a concern when working with resource constrained environments like Android. In addition to that, developers also have to deal with another limited resource: time. It is quite common that adding new features or fixing bugs is way more relevant than ensuring application works smoothly. Just measuring the performance of certain view takes a good amount of time, so why not automate it? At Lyft we found that gathering data with every continuous integration build would help us to not only detect regressions but also to ensure a smooth ride for all our users.
In this talk, I will demonstrate how to write an Android TV app, using the Udemy TV app as an example. I will talk about how I used the Leanback library to create a TV playback app based on the main Udemy Android app, how I integrated with Android TV to create a search and discovery experience and how I reused the the existing code and other code resources to create the TV app.
Learn to build applications which respond to snaps, flicks, and other hand movements while the user’s phone is out of their hand. This session will cover implementation of the Presto library, which uses sensor data from Android Wear devices to build this new category of gesture UI. Participants will build a simple working gesture application and learn best practices for working with gesture. Details at http://presto.watch.
Come hear about the most important topics in Android. Hosted by Chet Haase, brought to you by the Speechless Live people: http://speechlesslive.com/
We’ve all heard of mobile SDKs. These off-the-shelf services that offer advertising, analytics, social and more. These SDKs are a great help in development process: they offer unique functionality, simplify the coding and save you precious time and money. But SDKs are not really your code. You work hard to ensure your app quality and your users’ safety and privacy in your own code, but can you be liable for these guests SDKs’ code as well? In this presentation, I’ll dive into the two major domains of risk introduced when using SDKs, and spice it up with a few real-life stories on SDKs and what can be done to reduce the risk of using them.
Periscope is a live streaming video app that makes watching broadcasts a truly interactive experience. Viewers can participate in a live broadcast by sending hearts and chats to the broadcaster. This talk will provide insight into how the Android team built this core user experience. You’ll learn what gives hearts their light, airy feel, how they flutter on the screen, and how chats animate on and off the screen. We’ll describe the why, what, and how behind them, and walk through actual code that powers these custom views and animations.
Have you ever mixed mentos and coke? That’s how the developers behind Redux talk about combining mutability with asynchronicity. On their own, either is great. But when combined, unexpected and catastrophic things can happen. Anyone who has dealt with stateful components has likely spent uncounted hours tracking down race conditions that cause a component to have the wrong appearance even when the right data appears to be sent. Such unpredictability is costly and disruptive to programmers, and causes the types of bugs that can delay progress on an otherwise ontrack project. Luckily, there’s a better way. The fast iteration of web has yielded several very promising paradigms to mitigate these problems by thoughtfully separating concerns. In this talk, we’ll explore ways we can borrow principles from React, Flux, Redux, and Cycle.js to bring the best of web data flow management to Android applications. This talk will provide an overview of relevant principles, include samples from apps in production, and discuss lessons learned 6 months after first deploying this data model into the wild.
Changing UI and updates based on user feedback is a never ending task. Running A/B tests to try UI variants is also a challenge. Options include releasing an app upgrade, bundling app with multiple layouts for A/B tests, using HTML, writing custom layout parser, and implementing custom markup language. We present an alternative to WebView - using precompiled layouts and native LayoutInflater. This is the fastest that you can get using built-in API. Similar to other alternatives, this alternative has its pros and cons. We present the scenarios where it can be useful. We also present the risks and their mitigation.
How Facebook improves its Android Apps on Emerging Markets devices and Slow and Intermittent networks Speaker: Alex Sourov, Android Emerging Markets team, Facebook
This is a follow up talk to Android Application Architecture IO'15 Session. (http://bit.ly/1KSLpAN). After a quick review, we'll go over a list of case studies and see how they can be implemented for better user experience and performance.
Using plain views in favor of activities and fragment has become a hot Android topic, but many wonder if this works for larger apps. One year ago we rebuilt the Lyft app to use only views, and while there are downsides, we are still glad we did. In this talk we will tell you why we switched, and show how to do it using Scoop framework we recently released. (https://github.com/lyft/scoop)
Android testing is hard! With new devices coming out every year, it’s very challenging to ensure the compatibility of your applications across all these form factors. In this talk, we’ll tell you how Cloud Test Lab helps developers address these issues. With a scalable infrastructure that allows you to run automated test on hundreds of devices with one click, a smart Robo that allows you to test your app launches without having to write complex scripts and clients that integrate into your workflow from the web, Android Studio and on your CI environment. We’ll also be hearing from the lead engineer on American Express Android team on how using Cloud Test Lab significantly reduced their infrastructure investment and allowed them to run tens of thousands of tests every day. He’ll be sharing some of the best practices on using Cloud Test Lab in order to get the most benefit in your project.
As a mobile codebase grows and evolves, it becomes increasingly difficult to make large changes with confidence and speed. Unintended side effects, strange lifecycles, memory leaks, error-cases, and poor code cohesion work together to quickly make a mess of many applications as they grow. This talk will cover some of the techniques Uber has used to allow for changes in a tightly integrated application with confidence, including tools like Dagger 2, static analysis, and annotation processing. We’ll show you how these techniques and tools reinforce each other by demonstrating some concrete anti-patterns that have scaled poorly in the past, as well as how you can combine these new techniques to prevent entire classes of issues in the future.
Today, Facebook serves over 1.39 billion mobile monthly active users. As Facebook mobile usage has grown significantly over the last years, we evolved from a small team of engineers developing our Android applications to dozens of product and infrastructure teams all thinking mobile first and contributing to the mobile codebases. We shifted our focus into developing methods that facilitate the distributed development across dozens of different teams so we can bring top notch features to our users fast. In this talk, we will talk about the general lifecycle for releasing features weekly on Android at Facebook and will describe different tools and architectural patterns we have found useful for ensuring code stability and encouraging code reuse across multiple teams.
Have you ever wanted to write your own special Lint check? Or maybe you've wondered just how Lint checks work? Come learn everything that you've ever wanted to know about Lint and more!
Material design on Android has ushered an age of delightful animations and meaningful transitions, leading to more engaging and sophisticated apps. But gestures, which tie touch mechanics to hidden actions, have been left behind, relegated to specific tasks, such as reordering or dismissing items in a list. The first half of the talk will cover the design of gestures, as well as the benefits of gestures over the usual tap-based interface. The main emphasis will be on examples of unique, but effective gestures, especially those unique to certain app categories. The traits of a good gesture will be examined, as well as various methods for hinting hidden gestures to users and ideas for adding gestures to existing interfaces. The second half of the talk will dive into implementing gestures using Backboard and Rebound, libraries that help tie user interaction to on-screen motion. Code examples from Tumblr gestures will be used to demonstrate the ease of developing a gesture-based interface, even in a production application. The talk will end with more experimental gestures as inspiration.
Several months ago, Google quietly introduced the experimental Jack and Jill compilers for Android apps. The compilers replace the existing Java and Dex compilers. They still translate Java source code to Dalvik bytecode, so at some level, it may seem like a small change. In this presentation, I'd like to discuss the implications for developers. How can you start using the compilers? What are the advantages? Are there any disadvantages? I'll also provide some insight in the underlying technology, such as the Gradle build process and the new Jayce bytecode representation, which may impact the Android ecosystem more profoundly.
Android powers more than 80% of smartphones worldwide and shipped on over 1 billion devices in 2014. However the hidden story in these numbers is that Android forks now account for over 20% of the global Android ecosystem and 41% of new devices. Early on “fragmentation" was an issue of screen size, display density, and platform version. The new “fragmentation” is forked versions of the OS and alternate app stores. This talk explores the Android Open Source Project (AOSP) and popular forks like Cyanogen, FireOS, and MIUI, as well as Google Play Services (Google’s fork of Android). We will introduce specific strategies to help developers reach a wider audience with their applications. This talk will address the following questions: 1. How does the Android Open Source Project (AOSP), Compatibility Test Suite (CTS), and Google Play Services help shape the global Android ecosystem? 2. Which forks of Android and which alternate app stores present the greatest opportunities for developers to reach a wider audience with their apps? 3. What are some strategies developers can use for building applications that are compatible with both Google and non-Google versions of Android?
Have you seen Cloud Spin? It's a demo that Google Cloud Developer Advocates (Ray Tsang, Bret McGowen, Francesc Campoy, and Kathy Kam) developed for the Google Cloud Platform Next event series. The demo, consists of 19 Nexus 6 phones were placed around a half-circle pointing inwards to take a picture of the subject at the same moment in time, to create a 180 degree animated GIF - see them at @googlecloudspin twitter! But wait, the Android phones introduces some unknown delays when taking a photo - how did we make all the cameras take pictures at the same time? What did we use to process and stitch the photos together? And most importantly, how did we pull it off in a matter of 3 weeks? Join this session to learn more about what we did behind the scenes, and how we leveraged open source technology, Google Cloud Platform, and Firebase to help us develop the demo rapidly.
This talk will give an overview of the 360 video format and dive into the technical details around 360 video capture, rendering, and playback in virtual reality. It will also cover some of the challenges and solutions to streaming 4k and even higher resolution 360 videos on slow networks. Pierre is an Android VR Engineer at Facebook who works on 360 Videos on Facebook for Android and Oculus Video for the Samsung GearVR.
As your app code gets larger and more complex, it makes sense to break your project out into smaller reusable components. But what’s the best way to do this? How can you clearly version your internal libraries? What kind of setup and maintenance can you expect? How much could it slow down development time? In this talk we’ll dive into the various ways you can manage internal library dependencies. We’ll chat about the current state of Android dependency management, Gradle multi-project builds, Git submodules, and creating a private maven repository in Artifactory. The speaker will share real-world examples, and the pros and cons of each approach.
This session takes a look at Android security from a developer rather than a hacker's perspective. Taken from the recently published book "Bulletproof Android," we look at how to protect your Android code, how to use secure authentication in your app, how to communicate securely with any backend server and how to safeguard that server against attack. Throughout the session, we'll use real-world examples from the many audits we've done over the years to show how other developers have tried and sometimes failed to secure their code.
When MediaPlayer and MediaRecorder is not flexible enough, what to do? In this talk usages of the media and related components in Android SDK (MediaCodec; AudioTrack; Surface; Renderscript; etc) will be discussed to show how to make apps with custom playback experiences (e.g. speed changes, queues, live streaming) and custom recordings with video effects.
Sluggish apps frustrate your users. Yet, it takes a great deal of time and expertise to diagnose your Android app's performance issues. In this talk, I'll first explain why you should care about your Android app's performance using both real-world data and anecdotes from developers of top apps. I'll then describe the best practices to make your app fluid -- an engineering process best captured by the "measure-analyze-optimize" mantra. Specially, I'll present (1) the key metrics for quantifying your app's performance and user experience and the rational behind selecting these metrics; (2) common performance issues uncovered in over 10K popular apps we've analyzed (using a technology we created at Columbia University) so that you can avoid these issues in your app; and (3) general strategies to fix performance issues in your app. One example issue we discovered is ClassLoader.getResourceAsStream() -- surprisingly, calling this method once can easily add one second slowdown to your app's startup! Throughout the talk, I'll share the best practices we've learned from some of the best Android developers out there, and the analytics we've obtained analyzing over 10K popular apps.
Testing an app on your perfect Nexus 5 device under perfect network conditions works great, but you're getting reports of strange behavior from the wild and weird crashes that you can't reproduce. This talk will walk through some of the more complex options on the Developer Options screen in the Android OS and discuss how a developer can use them to debug problems in their application. Topics covered include: showing surface updates to help you find layout loops in your app, showing layout bounds to get your views pixel perfect, and aggressively killing processes and activities to ensure that your app performs well under stress. We'll cover these options and more as we dive deep into debugging apps.
Have you ever wondered when you should use Handlers over AlarmManagers? What about Timers and TimerTasks? In this talk, we'll walk through several code examples demonstrating basic usages of these three classes, and then cover advantages and disadvantages of each approach. By the end, you'll feel comfortable tackling your own timing-related features!
Building the same components from scratch for your Android projects time after time just doesn’t make sense. This is why libraries are really powerful — we can use them to help us more easily build our creative projects. You should never roll your own when you’re building an Android application, but instead save yourself the headache by taking advantage of the hundreds of libraries available. And if you build something cool yourself, why not share it with the world? In this talk, we’ll look at what it takes to build an open-source Android library and share it with the world, learning from examples like android-async-http, a project that’s been downloaded millions of times and is used in apps like Instagram and Pinterest.
Android has always allowed to write custom transitions between activities, but they only became popular after the introduction of an official API in Lollipop. This is an In-depth presentation comparing these 2 different methods (pre and post lollipop), their strengths and weaknesses, explaining how they work and when to use them to achieve the most delightful transitions.
Managing memory & concurrency are one of the biggest challenges we face when it comes to writing testable & efficient apps. based on the experience of building Realm, We'll dig into some patterns & tricks used to control memory footprint & multithreading. Some of the topics this talks will cover are: - How to use the Java Reference API (WeakReference & ReferenceQueue) to work with the GC - Writing tests involving the GC - Working & testing code using the Handler/Looper api - Alternative asynchronous models (Messenger/ResultReceiver) - Threadpool customisation & pitfalls - Handler (mocking & testing, using IdleHandler)
ReactiveX, also known as Rx, is gaining more popularity in the Android community, as it offers a declarative way for developer to express their intent, which results in more readable, robust, and performant code in Rx world. Yahoo’s Video SDK is all about events: Network event, ads event, player event, error handling event, user event, and more. In most cases managing events could be very hard, especially when it has interdependencies among other object's state, and is a result of nested callbacks. In this talk, I will share on how we gain the benefits from Rx (with the implementation in RxJava), by refactoring the code with reactive paradigm when working in Yahoo Android Video SDK.
The purpose of this presentation is to share Facebook's insights on video playback on Android. Topics covered: - the metrics we use to quantify video playback user experience - the set of techniques we used to improve the metrics and the overall architecture we arrived at - and finally, high level learnings from this work spanning over a 1 year period
What happens when an Android engineer wants even more Android? Android phone in his pocket and Tablet on his desk. Android TV, Google Glass, and a Nexus Q too. But what if that wasn't enough? Can you have too much Android? Not this guy. What would he do? He would take his old Subaru and through sketchy means he can teach you about, get Android Auto into it, for less money than you might think. And then? Then he would start exploring the Android Auto SDK and writing code for his car. That engineer is me. I've talked in Hong Kong and Paris about Android and now I want to tell you my Android Auto story: the procurement, hardware installation, the code, all of it. I wrote a book about Google Glass software development and can tell you how Android Auto is like those early explorer days of Google Glass development. I've taken Android Auto to the highest peaks of Colorado and then snowboarded down them. Let me tell you my story and I bet if you have a phone in your pocket, watch on your wrist and tablet on your desk all running Android ... you'll want to go out and get Android Auto too, and write your own code for it.
When I started making a Cardboard App, I had a lot to learn. I didn't know much about OpenGL, things kept breaking when I changed little details... it was painful. Not being a very sensible person, I kept going, and I'd like to share with you some of the things I found out: - Look Ma, no Hands: Designing a good VR UX. - OpenGL: How to use as little of it as possible. - Fill the scene: How to programatically create and design fun and simple 3D models. - Shaders: Math is fun, or, How to impress your friends with parallel processing. - Avoiding Death by Build: Use 'Instant Run', scripting and live shader editing to get instant feedback.