Our first set of talks has been chosen. Check back next week for the full list.
Welcome to Droidcon NYC from touchlab founder and president, Kevin Galligan.
Opening remarks from New York Citys own CTO Minerva Tantoco.
Android is the most popular operating system in the world and growing rapidly.
Emerging markets are where most of the mobile growth over the next decade will occur, but there are too few solutions that specifically target (or even consider) their needs. Building solutions that serve all of your customers will become increasingly more important.
We will explore emerging use cases, technical challenges, and social challenges you will encounter when serving these markets. You will walk away with guidelines to write globally inclusive applications in order to make a broader global impact.
How will you impact the next billion?
Android 5.0 was one of the more exciting releases ever - especially with the introduction of the Material design. The specifications describe a beautiful UI, that can be a challenging for developers to implement, particularly if they must support backwards compatibility.
It just became easier with the release of the 'Android Design Support Library' (and the previously released 'AppCompat Library'). Developers now have the tools that make it simple to create Material compliant apps - that will work and look great on almost all devices (even ones running 2.1).
In this presentation I will highlight some important components of these libraries, and demonstrate how to use them effectively.
It is just the beginning for Material design - come learn about the important tools that make it easy to be part of the revolution.
In just a few few weeks, we reduced by 94% the OutOfMemoryError crashes in the Square Register Android app. We built http://squ.re/leakcanary to automatically detect memory leaks and make it very easy to fix them. This talk will cover the principles as well as the underlying implementation details. We'll dig into a few interesting examples and lessons learned.
If you're attending the conference to start your Android journey, this talk is for you. I'll introduce you to the tools and the basic programming concepts. I'll create some simple Android apps and run them on real phones.
This isn't a hands-on session. But if you work on some examples during the conference, I'll be available to help you get past any hurdles that you encounter.
Prerequisite: Reading knowledge of an object-oriented programming language such as Java.
One of the hardest things about with Android is working with images.
In their uncompressed form, they take up vast quantities of memory. Even the best-written apps routinely suffer crashes and slowdowns due to the demands of images and animations.
This talk will show you how Facebook cut its image load time by two thirds, while reducing crashes and improving scroll speed. It will also cover how you can use these same techniques with the new open-source library, Fresco (http://frescolib.org)
I will cover some poorly documented features in the Android SDK and NDK that Fresco takes advantage of, including some Android source code walkthroughs.
Material design offers a breadth of tools and paradigms to help us build beautifully animated applications. But few of us have actually been trained in the art of animation. Without a common animation language to express your ideas, priority on these details can fall to the wayside. That potentially means more confusion and less engagement among your users.
The solution: Android engineers need to become animators. We cover basic principles of Animation, how these can be applied to the Android platform, and how to work with designers (or on your own) to mock them up.
The Android app ecosystem is an international phenomenon. Developers need better tools now, more than ever, and the number of third-party SDKs is also growing to meet the developer's needs. Unfortunately, many of these SDKs are poorly developed and extremely difficult to use. In fact, at Twitter on the Fabric team, we've detected a significant percentage of issues caused by third-party SDKs.
Fabric, formerly Crashlytics, is well-known for its focus on SDK quality, and has been deployed on billions of devices. In this session, attendees will learn the skills to develop and distribute SDKs for Android. We’ll cover an overview of Fabric, deep dive into technical decisions we made, and present the learnings on developing an SDK for stability, testability, performance, overall footprint size, and, most importantly, exceptional ease of implementation. Over the course of the session, we'll develop a simple but well-architected SDK and uncover and explain many of the challenges we encountered when building SDKs at Twitter. Topics include device feature detection, supporting multiple application types (from Widgets to Services to Foreground GUI applications), API design, deploying artifacts, and coding patterns to support developer customization. We'll conclude with advanced topics, from less-known but very useful tricks to minimizing impact on application start-up time to reducing memory footprint and persistent CPU use.
Do you test? It’s okay if you don’t - historically the tools had not been stellar. But they have gotten much better, and I am going to show you my favorite, instrumentation testing with Espresso.
In this talk you will learn:
* The basic structure of an Espresso test (Matcher, ViewAction, ViewAssertion)
* Combining matchers such as withParent, isAssignableFrom to pinpoint your view
* onData and RecyclerViewActions to test ListView and RecyclerView
* Custom ViewAction and ViewAssertion
* Using Dagger and Mockito to write repeatable tests
By the end of the talk you will be itching to write some tests yourself!
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 cameras 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 cameras 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.
VectorDrawable was a hugely important introduction in Lollipop and could be available to those who cannot minSdkVersion="21" if/when the compat library is released.
Mark Allison, GDE for Android, writer of https://blog.stylingandroid.com will provide an overview of VectorDrawable and provide some easy to understand examples of how powerful they can be.
This talk will be aimed at experienced Android developers but will be understandable to those who are unfamiliar with SVG.
Retrofit has been simplifying HTTP calls for years and this new version is no different. In addition to fixing some long-standing annoyances, there are a handful of new features which make it more powerful than ever.
This talk will focus on how the new APIs in Retrofit aid in making HTTP calls as simple as possible for your app. The integration with OkHttp and Okio APIs will be covered to ensure a full understanding of the HTTP stack. Common use-cases and design patterns through more advanced functionality will end the talk.
No prior Retrofit, OkHttp, or Okio exposure needed. The content may quickly cover or skip some introductory aspects in order to allow focus on more actionable and useful content.
Targeted audience : Intermediate Android developers and CI administrators.
How the new Genymotion command line tool and the Gradle plugin can help you run your automated tests? Integrate your virtual devices into your CI server, create the devices automatically, start them, run your tests, grab the logs then trash everything: every test should be done on a brand new device!
During this session, we will show you how to define your devices through the command line tool or in your Gradle script, when to run your test scripts, how to grab your logs and clean the place. We will also explain how to integrate those features into your preferred CI tool and make the best of it.
Then close your eyes, press the button, relax, the robots will do the work for
Java 8 was released last year adding lambdas, streams, and many other language improvements. Java 9 is already in the works, but with over half of Android devices stuck using Java 6 will we ever get to use a modern language?
Introducing Kotlin: a statically typed JVM language backed by JetBrains. With features like lambdas, class extensions, and null-safety, it aims to be concise, expressive, and highly interoperable. In this presentation we will learn how powerful Kotlin can be when added to your Android tool belt.
What To Do About Fragments? Fragments are a regular subject of controversy in the Android community. They're big and unwieldy, difficult to test, and complicate a controller lifecycle that wasn't particularly simple in the first place. In this talk, Bill will come clean on why he continues to choose to emphasize fragments to beginners.
RecyclerView is a popular new item among developers for the flexibility that it provides in displaying collection views. At the heart of this flexible new API lies the ability for the developer to define that placement of child views in the collection using an external layout manager. Google has provided a good number of built-in managers for simple cases, but what if you want to go beyond that?
In this session we will explore the features of layout managers provided by the framework for displaying items in lists and grids. We will then dive into the API for building your own layout manager to gain full control over how RecyclerView displays views for your collection.
With a great variety of tools for optimizing your Android apps, it's easy to get lost and find it hard to even start working on the problem. In this talk, I'll cover how to approach a performance issue by picking the right tool for the job, analyzing the data and track down the culprit. I'll show case studies using Systrace, Traceview, Hierarchy Viewer, Allocation Tracker, Eclipse MAT and others, demonstrating variety of problems that many apps suffer from, and how to solve them.
I'll also cover how to find problems with the app's layouts, which directly affects its performance:
- Overdraw - what is it, how the framework helps to avoid it and what can we do to reduce it.
- Bad behaving layouts - Find them and reconstruct them to bring the same result with less performance hit.
- Custom views - how can they hurt us and what can we do about that.
Besides tracking existing problems, we'll talk about how to write better performing apps in the first place:
- Hardware acceleration is not a silver bullet. In order maximize its potential, we need to know how to properly leverage hardware acceleration for every app's unique UI.
- Bitmap hacks to optimize the use of bitmaps in the app. Using an image loading library is not always enough, and there could be a better way to optimize the bitmap usage for your app.
- General and less popular tips that many don't know about and should.
I'll share some of my "war stories" in the talk, to give some real-life examples, and showcase how can anyone start optimizing their apps the next day.
Mobile Payments is one of the most exciting and constantly evolving spaces right now and as Android developers we have a wide array of opportunities. Apple Pay helped make contactless payments mainstream and from now on it's going to be an exciting race to see how this landscape evolves. Starting with Android 4.4, developers have the ability to send contactless payments over Near Field Communication (NFC) using Host Card Emulation (HCE). Learn how to make contactless payments work in a mobile wallet implementation and the challenges associated with it. This will include code samples, hands on demonstrations and lessons learned.
Fragments suck. State is hard. Android is hostile. How can you write a crashfree, bug free app on such a buggy, fragmented OS? In the spirit of Jack Sparrow, I’ve come up with some guidelines for making Android development less of a headache. Talk would basically be about how we’ve adapted and used each of these in the Electric Objects companion app.
- There is a one to one correspondence between a wireframe screen and an Activity.
- Every Activity has it's own layout file.
- Reusable View code belongs in a View class.
- Fragments are not simple. Don't use fragments.
- Embrace state machines.
- Corollary: Every Activity is a State Machine.
- Override on configuration changed at your own peril (aka never)
- Retain nothing but state (and hardware adapters)
In 2014, Google unveiled its bold, colorful plan to make unified interfaces a reality for web and mobile platforms. Material design, founded on the principle that interface elements should behave as predictably as physical objects, has been well-received by designers and adopted faster than any of Google's previous guidelines.
But even as developers and designers adopt and evangelize the new design language, there's still the nagging question of just how branding fits into the picture. Designing for the user while keeping your brand in focus is more important than ever, so how can brands strike the right balance?
This talk will unpack the question of branding in material design, examining current practices, what it means to "go material" and how to effectively and appropriately brand your product while fostering a cohesive, delightful user experience.
Touch is pretty simple, right? You set an onClickListener and you are all set! But then... what happens when you want to drag stuff? What happens when you want to add gestures? How do you manage multiple views fighting for the focus? What is this pointer index thing? How do you animate a view after a fling and keep it natural? What is a touch slop?
In this talk, we will take a good look at what happens under the hood when your fingers touch the screen and how you can use this to create interesting ways to interact with your app!
One of the many new features in Lollipop, Camera 2 is a new API for image and video capture and processing. For developers, Camera 2 presents both a vastly improved, better structured API for development and an opportunity to create more sophisticated and professional image and video applications.
In this talk we will discuss the transition from the first Camera API to Camera API 2, look at how Camera 2's pipeline works, run through an example of setting up a camera and capturing images, and talk about the new data and capabilities that can be leveraged to build fully featured camera applications.
We'll use unity to create cutting edge 3D and VR apps. If time allows - I'll go over some advances in data visualization and some early adopter technologies that are disrupting the luxury consumer electronics space.
Hear what it's like to cover Android news from some of the best journalists out there. At this panel you'll get the inside scoop on what it's like day to day, learn the right way to pitch an Android journalist (even if you're an indie developer) and find out how they get all the secret info first (well, maybe not the secret info stuff).
SQLite was revolutionary when it launched in 2000 but developing mobile apps in 2015 is a very different beast than it was 15 years ago, and our notion of what a “phone” or “app” is has changed drastically.
Realm has benefited from the last decade of innovation in order to create a new mobile-first database that is faster than SQLite and easier to use.
This talk will take a deep dive into the underlying ideas and architecture behind Realm and lessons learned while building a new database API for Android.
While "Build -> Generate Signed APK" in Android Studio can get an app onto the Play Store, it is probably not a solution that scales well. Manual processes like clicking export are prone to human error, requiring developers to copy keys from machine to machine, share secret passwords with potentially untrustworthy individuals, and remember to run tests before pushing code. Fortunately, there's an answer to these problems with Continuous Integration (CI) tools, like Jenkins. In this session, Stephen will show you how to set up a cloud-hosted Jenkins instance, hook it up to your source code, and get building. To wrap things up, Stephen will share some tips and tricks for managing things like versionName and versionCode, deploying to the Play Store, saving APK's and more.
In-app purchases comprise a large share of in-game revenue today but are driven by paying power users (a.k.a ‘whales’) which typically make up less than five percent of the total user base. Ads can supplement monetization for the remaining ninety-five percent of non-paying users, but concerns around cannibalization and user experience for the whales prevents developers from implementing ads. As the gaming industry moves toward a hybrid of monetization models, targeting users across platforms becomes key. How do you show the right screen to the right user at the right time?
You’ve got an app idea, a few jars of cold-brew and a weekend to build your MVP. How do you stay focused on the idea and not the implementation details? How do you put a prototype in users’ hands early, so you can avoid over-investing in bad designs?
In this active coding session, you’ll learn how Cordova prototypes can keep your team focused on meaningful questions during the concept & design phase. You’ll learn how to:
1. Configure your dev environment for speed
2. Iterate on your app’s UI and logic quickly without breaking !@#$
3. Make it look good – so good – using Material design patterns
4. Beta test your app on user’s personal device
The TextView seems to be a fairly innocent and easy to use widget when building out UI for Android. However, when your app is targeting multiple locales, changing things like line spacing and line spacing multiplier can cause major issues. Join me as we talk through how text is rendered on a screen to some common pitfalls of developing with the TextView in multiple languages.
android:contentDescription="Making your application accessible is easier than ever. In this talk I will go through accessibility best practices, as well as case studies of various hurdles that app developers have overcome while trying to make their apps accessible. If you've never had a chance to look into accessibility, I hope this talk will convince you that it's more than just a feature to be backlogged."
I'll talk about how we at Facebook generate fast deterministic screenshots for Android views, with particular focus on how we do this for the hundreds of different configurations of Android feed stories.
I'll talk about how we use this both for iterating fast on user interfaces, and for catching regressions.
We'll also open source our screenshot tools. This will be similar to what Facebook has already open-sourced for iOS .
Thinking about monetizing your app on the Play Store but not sure where to start? Android documentation driving you crazy? This talk pieces together all the information in one place and will take you through all the steps required to implement an in-app billing solution on Android for multiple product types.
There are two kinds of payments available to developers: One time payments and Recurring payments. At the end of this talk, you will learn how to
set up the payment workflow on Google Play Developer Console and your app
integrate in-app billing files
test the workflow for both one-time and recurring payments
- manage the backend using Google Play Developer Api
Styles and themes are a core part of the Android system. That said: they can be rather difficult to use. Setting up styles improperly can hurt more than it can help, and there have been plenty of sleepless nights caused by theming woes.
This talk will present a system for using styles and themes without going crazy.
On Android, many applications rely on the Java Reflection API. For instance, all data driven apps get data from the network, save data in your local cache files / databases. And most of the libraries used to simplify those tasks will use reflection in their core.
Unfortunately, Reflection is slow on Android due to limitations of Dalvik and Art. The usual workaround is to write annotation processors and replace Reflection by generated code. But, it comes with a price : all the robust and mature libs from Java can't be reused and must be rewritten, often in a degraded, simpler version. And the annotation processor API is quite tricky, leaving this work to a handful of expert coders.
In this talk, we will demonstrate a new approach using the Reflection No Reflection (RNЯ). This new technology provides a much faster access to reflection data, while maintaining compatibility with the Reflection API. Using this technique, any library can swap out use of the Reflection API with this interface-compatible implementation to achieve greater performance.
It also comes with an additional benefit : if you create annotation processors based libs, you can now get rid of annotation processing API when writing an annotation processor : you will be able to use reflection of classes...Yes, before they are even compiled !
Android is the most popular mobile operating system on the planet. It powers more than 80% of smartphones worldwide and shipped on over 1 billion devices in 2014. However, the hidden story here is that Android forks now account for over 20% of the global Android ecosystem and 41% of new devices shipped. 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. In this session we will begin by looking at the Android Open Source Project (AOSP) and how it helps shape the current development environment. We will explore popular forks of Android including Cyanogen, FireOS (Amazon), MIUI (Xiaomi), and others. We will also examine the role of Google Play Services (Google’s fork of Android). Finally we will evaluate the opportunities that alternate app stores present and discuss strategies for developers who wish to reach a wider audience with their applications.
Would you like to start contributing towards open source projects but don’t know where to start? Or have your own project idea but don’t even know where to begin? Based on my experience creating Awesome Material, an open source library based on my earlier Android Bootstrap project which helps developers incorporate Material Design, Bootstrap, and Font Awesome into their apps.
This talk will walk you through with my real world examples:
* How to come up with an awesome open source project idea
* Creating a new Android Studio library project
* How to use it locally inside a sample app
* Considerations for creating your own API’s
* Publishing to jCenter to make it super easy for people to access as a gradle import.
Many people are intimidated by localization (l10n) and internationalization (i18n) but they don’t have to be—Android provides many tools out of the box to aide you in global domination. Learn how to provide alternate resources for different locales, how to be flexible in your layout design, and what to do when the built-in tools aren’t quite enough, like defining custom date formats. We will also cover a Gradle integration with Smartling, a paid service, which allows updating translations to be as easy as a push and a pull.
Chat about the droidcon app and tools. Sneak beers into code lab, maybe. This is a best efforts session.
A round-up of some of the latest new tools and frameworks that help you make amazing, beautiful, and very material Android UIs.
Material design's "paper" stresses the beautiful typography of print journalism -- but how? This talk will work directly through translating paper designs to Android's TextView, starting with styles, Spans, and Typefaces and finally diving deep into FontMetrics and custom text drawing. Forget about Roboto -- let's go down the rabbit hole.
Annotations and Annotation Processors are all the rage in Android Development these days. There are annotations to help you:
- Avoid the boilerplate of Parcelable or ContentProviders
- Generate bindings for your views
- Implementing deeplinking
- Even find bugs in your code!
This talk will showcase some existing annotations (like the support-annotations library) and annotation processors (such as butterknife, deeplinkdispatch, autoparcel). Afterwards, I’ll show you how to write your own.
The upcoming Android M release changes the way permissions are granted and handled in the system, with the goal of a more fluid experience and more refined user control. While this is a good thing, it also puts a larger burden on app developers creating new apps as well as authors of legacy apps. This talk will take a look at the basics of permissions, the impact to the user and the impact to you, the developer.
Augmented Reality is a popular technique that developers have been using to show extra information on top of the real-world view using mobile devices, i'm sure you've seen apps where you point the camera at a market and 3D image pops out, this its what this is about.
In this session i will show you the basics of AR, how to integrate it in your projects and how to add ibeacons to the equation using open sourced libraries.
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.
Nearly every Android developer has heard of the Lint and Checkstyle tools - however few use either to its full power, if at all. In addition to maintaining a consistent code style, we will see how to enforce architecture conventions and even prevent wrong usage of both internal and your own APIs.
For example, you have a fancy BaseFragment which should be extended by all your Fragments, or you have a custom logger which should be used instead of android.util.Log. Both of these are perfect use cases for custom Lint checks. This session will show you how to configure Checkstyle and Lint to your liking, and how to use their APIs to create custom checks, as well as how to include both in your Gradle-based project.
Default Gradle build scripts produced by Android IDEs are deceptively simple. However, this simplicity is often misleading as Gradle scripts have the potential for much more intricate behaviors than XML property file build systems. This complexity gap between the simple and the possible often causes roadblocks when an Android developer actually needs to do anything unique during a build. This class will help bridge that complexity gap by diving under the hood to explore how both simple and complicated build scripts actually work.
You will learn when and where lines of your build scripts are actually getting executed and what conditions prevent them from changing the state of your build. You'll also learn how you can create reusable code in a multi-app build environment. Finally, you'll hear important tips to make sure your Android Gradle scripts work well within the plugin ecosystem. All these lessons come straight from Jake's experiences developing the Crashlytics plugin for Gradle, which has been used in production by top Android app developers for almost two years. We'll cover advanced Gradle topics, but introduce them in a way that is accessible to newer users.
This talk will tour one of the most understated resources in the Android developer arsenal: the support tools.
Learn how to enrich your methods and classes using annotations, so that Lint and Android Studio will be able to spot errors for you. Or use IntelliJ annotations to define contracts, and let the IDE warn you of potential issues before you even run your code once. Take advantage of the tools namespace to bend even the most cryptic XML resource to your will.
Android M adds a long-awaited feature: user-managed permissions. While some Android permissions you request will be granted to you at install time, others will require you to specifically ask the user at runtime. The user can not only reject your request then, but she can change her mind and revoke the permission at any time in the future.
In this code lab, we will walk through how adjust your app to take the runtime permission model into account: when to ask for permission, how to determine if you have permission, how to gracefully degrade when the answer is "no", and so on. Attendees can follow along and modify the same sample project that the presenter will use for demonstrations, or attendees can experiment with their own code. Steps in the code lab will include:
- Converting a traditional Android project to be able to build with the M Developer Preview
- Detecting if you have all of your requested runtime permissions
- Asking the user for those runtime permissions when needed, including explaining why you need them
- Indicating to the user what portions of your UI still need permissions
- Testing relevant scenarios, including handling the user revoking already-granted permissions
If you wish to participate in the hands-on work, you will need a copy of Android Studio and the M Developer Preview (version 2) installed on your notebook. You will also need to be hooked up to the conference WiFi or otherwise have Internet access.
When you notice FPS glitches in your app, how do you find and fix them? This talk will discuss various options for measuring FPS, and some of the work Facebook’s Android Newsfeed team is doing to improve interaction smoothness. This includes some of the automated solutions Facebook uses to blame janky frames both in the wild and in automated tests.
UI boilerplate is a thing of the past! The Data Binding support library was one of Google's big announcements at I/O 2015. Now that Data Binding is graduating from Release Candidate status, it's a better time than ever to start using it in your projects.
Data Binding takes some of the best boilerplate-obliterating features from open source libraries you love like Butter Knife, AndroidAnnotations, Transfuse, and RoboBindings. However, Google's implementation of Data Binding goes a step further as they have the power to define the platform and change layout rules.
In this talk, we'll go over the history of the Data Binding project at Google, have a crash course on usage, and then look at some more advanced techniques like two-way binding and MVVM architecture. You won't want to miss it!
As a Developer Advocate at Google, I am exposed to a large number of various Android apps. I want to bring together several rules of thumb to make your Android app better, while avoiding the common pitfalls.
* Deprecated APIs
* System/OS abuse
* Memory Leaks
* Consistent App structure
* Method count
* 3rd party libs
Voice actions enable users to interact with mobile apps using natural speech patterns, enabling hands-free behaviors in situations where the user is multi-tasking or otherwise occupied. Consistent support for voice actions across Android devices (phones, tablets, Wear) makes them a perfect enabler for ubiquitous computing experiences where actions are auto-magically handled by the right app, in the right context, across all devices potentially owned by that user.
While voice actions focus simply on triggering the relevant app, the Voice Interaction API (announced in Android M Preview) allows the app to engage with the user in a follow-up dialog to further clarify actions (e.g., confirmation) or narrow it down (e.g., select from alternatives).
In this talk we’ll look at support for Voice Actions and the Voice Interaction API in Android, explore different usage contexts and walk through code snippets that show how we can leverage them in our own applications
What happens when your mobile device does not have a network connection? That device will have no content, no experience and that amazing application will simply not work. This two-part class will be around the implementation story of creating offline and online applications on Android Mobile. Couchbase Mobile is a thin client library that will help you with your Android projects in creating a local data layer for offline, and will provide fast sync capabilities when there is available network connectivity.
This class will present the instructor's personal journey with NoSQL database modeling and what we can do with the technology. The session will go through how to create data object model relations and how to design for performance in difficult areas with no signal.
The implementation, hands-on part will include best practices around what to store locally and how to sync data to the cloud. We will go over code and taking your mobile application offline.
Note: Android Studio should be install. We will walk through doing integration and code. We will go through samples and examples of the technology. Knowledge of Android development and basic databases is needed.
After the introduction of Material Design and Android Lollipop, animations and great design finally got the attention they deserve. New concepts have been introduced and finally a guideline exists. But Material Design goes way further than just elevations, cards and beautiful colors. Animations now are a big factor and play an important role in applications, a role that is not only related to a wow factor, but actually animations are a big friend of the User Experience of an App.
We will go through transition animations that helps the user understand how your app works and how to guide him in the easiest way possible and I'll show some do and donts of navigation and animation made by some popular apps. We'll also talk some UX points so you can plan better how the user will navigate through your app. After that, you will never think about animation in the same way again!
This talk is an evolution of my well received talk at Droidcon Montreal, this time, following the request of many people, I'll have some example codes and some application demos to show how to achieve some animations in code.
The main thread is where your app code runs by default.
- What should you do on the main thread.
- What should you NOT do on the main thread.
- Handlers and Loopers
- How the main thread affects your instrumentation tests.
The story of scaling Android Engineering at SoundCloud. We grew our team from two developers to 8 in little more than a year. This talk presents the processes and technologies that helped us as well as things we’re striving to get right.
Some things needed to evolve: the app architecture, branching strategy, code review policy and release process.
Other values supported us: unit/acceptance testing, pairing, continuous integration, end-to-end development and reactive programming.
This would be a revised an updated version of a talk originally presented at Droidcon London: https://speakerdeck.com/jdamcd/android-engineering-for-scale
If you're new to VR, a detailed overview of the basics will get you up to speed along with a tutorial and code walkthrough featuring the latest Cardboard APIs as well as the Project Tango APIs which will enable real time positional tracking using depth maps. We will also review the different types of controller inputs and how to integrate and support IoT devices with VR.
The Cash team at Square moves fast. Really fast. Learn about the tools that we use to eliminate external dependencies and move as fast as possible. In this talk, I’ll show you how to:
• Quickly verify all of the states of your app by eliminating the server.
• Build and test a server-supported feature before the server is ready.
• Add shortcuts to accelerate your edit-verify cycle.
• Make it easy to submit bug reports with screenshots & full context.
This talk will be an introduction to the ideas behind functional reactive programming and how you can move away from traditional synchronous state management with variables to asynchronous streams of data instead. You will learn how Rx (Reactive Extensions) Observables simplify concurrent code and let you write asynchronous, message based Android apps, in ways that are more elegant and a bit less error prone than traditional Android mechanisms.
We will also take a look at some Higher-order functions such as map(), flatmap(), filter(), zip() and reduce() as well as some other Rx operators that enable you to write simple, expressive and concise code to process Observables and solve problems in many common Android scenarios. These powerful yet easy to use abstractions will let you write asynchronous code in a very straightforward, declarative fashion; making the task of writing great Android apps a lot easier.
The Cloud is the perfect extension for mobile applications. Mobile apps don’t exist in a vacuum, you never know if you’ll have 10 or 100,000 users, and sooner or later you’ll need to save user data in the cloud, perform operations server-side for enhanced scalability, or monitor data feeds to push notifications to your mobile users. Microsoft Azure provides the best infrastructure for mobile developers across all platforms thanks to cross-platform storage, authentication and push notification services, all residing in the cloud. This session explores how you can build cloud-enabled cross-platform applications for iOS, Android and Windows 10 and Azure App Services for mobile, with demos focusing on the Android Java developer. You’ll learn how to authenticate users via Microsoft, Google, Facebook or Twitter credentials, store data remotely in NoSQL tables and blob storage, and even how to send push notifications to all vendor platforms (including GCM), all through live Android demos. Whether you’re a weekend warrior building consumer apps, a savvy entrepreneur building the next revolution, or a corporate mobile developer building apps for the enterprise, the cloud is the perfect companion for your mobile apps. Come learn how easy it is to harness its power.
Do you want to learn how to make Android games? Should you use Animations API, SurfaceView or OpenGL? Come learn from the experts who have been making interactive educational games for the past few years. This talk focuses on game animation - how to create robust animations by customizing SurfaceView:
* Continuous rendering on separate thread
* Update state, render using state, repeat till done
* Handling user input with SurfaceView
* How to build animations such as rocket burst and page flip
* Supporting multiple screen sizes and aspect ratios
Throughout the talk we will discuss problems we encountered and lessons we learnt. By the end of the talk you should understand the basics of game-making with animation.
In this lab we'll build a complete, collaborative app for Android. By using Firebase as the backend for our app, you can do this for free without spinning up our own server.
Frank will live-code the example on-screen as you follow along with the written, step-by-step tutorial.
Google engineers will also be available to help you with problems you may encounter and to answer your questions
Requirements: Android Studio
We're not going to spend much time talking about tech's diversity issues, if you're not yet aware of the problem there are lots of places for you to go educate yourself on it (and seriously, you should). This panel is a group of awesome folks who have made decisions to do things within their control to try to affect the situation. They're going to tell their stories briefly and then we're going to turn the attention away form the stage and to the audience.
Our goal in this session is to help empower you to start doing something, tiny, huge or in-between, today.
What if you could get your UI tests to run as fast as your unit tests?
- you would write more tests
- you would feel happy writing the tests
- your managers would be pleased with you not goofing around with that new testing framework around the corner
Using patterns of yore (like Martin Fowler's supervising controller, effective use of presenters and view model state) we're going to tackle everyday-real-annoying impediments to UI testing. We'll address what parts of the UI need testing and effective ways of testing them.
The objective of the talk is to prove to the world that the title of this talk is not an oxymoron.
An Android app is a forest of trees: views, contexts, navigation, and model. These hierarchical structures are distinct but often entangled, making apps complex, hard to build, and harder to understand.
This talk will focus on how Square has cleared the forest, teasing the trees apart to build simple, testable, maintainable apps. It will cover the techniques we use to work with each tree individually and to manage their interactions to minimize complexity. Throughout, there will be discussion of how these techniques relate to libraries like Dagger, Mortar, Flow, Transitions, and others.
Do you really want to amaze your friends and delight your users? Try adding a View directly to the WindowManager. Pretty cool stuff, right? Now, run your UI in a sticky Service. Maybe you are on your way to making the next floating web browser, huh?
Not so fast. This fun technique has some unexpected pitfalls. What happens when you want to translate your Views in the WindowManager? What happens when you want to apply some alpha animations pre-Lollipop? What about scaling? While building these cool features into IFTTT's DO Button app, I quickly found some unexpected behaviors.
This talk will cover first the basics of making this uniquely Android experience and then drill into the tactics for maneuvering the quirks of the trade. I will explain the strategies I used in maintaining consistent behavior from API level 15 (4.0.4) to 21 (5.0) and how you can save your sanity while still impressing your friends with these "floating" Views.
The Chromecast SDK offers a great opportunity to build apps for your TV.
In this session we explore how to get started with chromecast, understand it's architecture and how to build chromecast sender and receiver apps.
You have spent months building an awesome mobile app and now it's finally live. But how can you grow your user base? This class will walk you through building a simple sharing feature from scratch in minutes. With the help of use cases, we will also go through tips for improving your existing app invites, referrals and sharing features to help boost your app virality and grow your user base.
Requirements: Android Studio
The current solutions for mapping data to java objects come in many shapes and sizes, with JSON leading as the most familiar and “coolest” solution. Yes, JSON is very readable, convenient, and offers great support libraries like GSON and Jackson, but these options don’t always get the job done. Accessing and parsing serialized data is a common source of runtime inefficiency within applications, and this delay can crush your app’s overall user experience. How can you bypass this inefficiency? Google’s FlatBuffer library is the answer. FlatBuffers are similar to Google’s Protocol Buffers, but with one key differentiator: the ability to access serialized data without parsing or unpacking it first. Imagine a serialization process with no temporary objects, no additional allocation, and no copying. Join us for a deep dive into Google’s FlatBuffers library to learn more about the advantages of using FlatBuffers and what makes it different from other commonly used libraries.
The number of Android Libraries available is enormous and that number continues to grow day-by-day! But should you try to incorporate them all into your application? Do you really need to use EventBus, RxJava, and Custom Observables? How many different image libraries have you included? Hopefully you get the point, great Android apps only include what's needed to achieve the goals of the product, not enhance the resume of the developer.
In this talk learn four components essential to developing maintainable Android applications. What criteria should you use when choosing a library to include in your project? What simple changes can you adopt to improve your domain design? What tools are available to assist you in delivering high quality code? What can you start doing today to make your app more maintainable? Walk away with the tools you need to be a good Android citizen!
It's important to have support tools in place before you launch your application. However, it's sometimes the last thing that is considered (gotta build those features!).
Knowing which tools are the right ones for you, how they compare against each other, and which give the most value can be difficult.
During this talk we will review many tools that range from crash reporting, remote log management, analytic tracking, beta distribution, continuous integration, and much more.
Do you like clean, dry, reusable code? Sure, we all do. For some use cases the cleanest and most efficient way to build and maintain a feature is to get meta. Are you ready to level up your developer skills? Metaprogramming is working with code that works with your code. Aspects, annotations, bytecode manipulation, runtime wizardry. What is possible? What unique limitations and opportunities exist when working within Android code? This will be a practical guide to Android metaprogramming from a cross-platform native SDK and app developer.
You have spent months building an awesome mobile app and now it's finally live. But how can you grow your user base? This class will walk you through building a simple sharing feature from scratch in minutes. With the help of use cases, we will also go through tips for improving your existing app invites, referrals and sharing features to help boost your app virality and grow your user base.
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 class, 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.
Making Mobile Commerce Fun? Seriously? In this short talk I'll walk through ways merchants make mobile commerce not fun and tips, tricks and best practices you can use to make it fun and engaging. Come to this talk if you are interested in Mobile E-commerce, payments or anything related to making payments or shopping fun on your Android device
With Couchbase Lite, you can enable peer-to-peer 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’ll 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.