Make more money with subscriptions on Google Play

Posted by George Audi, Tom Grinsted and Larry Yang, Google Play

The subscription business model is one of the best ways to make more regular, reliable, and recurring revenue on Android and Google Play. In fact, both developers and users love subscription apps so much that we�ve seen a 10X growth in consumer spend over the past three years and double the number of active subscribers in the past year. Thousands of developers are offering subscriptions through Google Play and are already seeing success with our billing platform. That�s why we�ve been working hard to help you take advantage of this opportunity and give you greater insights into your business and Android users.

New features to help your subscriptions business
thrive

You've got a high-performing product with fantastic features and compelling
content, but your business can't succeed without acquiring new users. In
addition to free trials, intro pricing, flexible billing periods, and more, we
recently launched the ability to pay for subscriptions with Google Play
balance. Although people have already been using gift cards to pay for
Play content in over 20 countries, the use of gift cards to pay for
subscriptions in regions where cash is a popular form of payment, such as Latin
America, has resulted in as high as a 15% increase in subscription spend.

But it's not just about acquiring new customers, it's about retaining the ones
you have. That's why we are introducing account hold, where we
work with you to block access to your content or service if a user's form of
payment fails. This directly links a payment failure to the user losing access
to your content and/or premium features, which is enough to get them to go and
choose a new form of payment. When Keepsafe�the developer of href="https://play.google.com/store/apps/details?id=com.kii.safe&hl=en">Keepsafe
Photo Vault, a photo locker for private pictures and videos with over 50M
downloads�integrated account hold, their renewal rate on Android increased by
25%. We have over a dozen developers in early access today, and we will be
announcing public availability at the end of June.

We know data is vital to running your business, so we're excited to announce a
new subscriptions dashboard in the Play Console, and a new
report on Android app subscribers.

The dashboard brings together subscription data like new subscribers, cancellations, and total subscribers. It also displays daily and 30-day rolling revenue data, and highlights your top-performing products. This will give visibility into your subscription products and users and will help guide your business decisions.

Insights to help you grow your subscriptions
business

In addition to products and features, understanding people's needs is core to
building a successful subscription business. We talked to 2,000 Android app
subscribers in the US and UK and asked them how and why they use the apps they
do. The results shared in 'href="http://services.google.com/fh/files/misc/subscription_apps_on_google_play.pdf">Subscription
apps on Google Play: User insights to help developers win' report
highlight some of the opportunities for you to grow your subscriptions user
base, set pricing strategies and learn to keep your users engaged, including:

• Use free trials to acquire users. 78% of users start with a
  free version of an app, and many cite a discount or end of a free trial as a
  reason to pay.
  
• Keep your content appealing and updated to get and keep users
  paying. It's the most important driver in converting users from free to
  paid users, as well as keeping users engaged and retained.

• There is a huge opportunity to make money from
  subscriptions. While pricing elasticity varies by category, few users
  cite price as a reason to churn from a paid subscription and 64% either budget
  on a per app basis or not at all (as opposed to budgeting across all app
  subscriptions).

To find out more about your growing your subscription business with Google Play,
watch
our I/O session, download
the research report (PDF), and get started with subscriptions
with Google Play In-app Billing.






How useful did you find this blogpost?

?
?
?
?
?

Android Wear: New complications tools and watch friendly UI library

Posted by Hoi Lam, Lead Developer Advocate, Android Wear

Android Wear 2.0 gives users more informative watch faces and provides developers with new ways to build useful apps. These new opportunities have been well received by users and developers alike. To help developers take advantage of these new features, we have released a suite of complication API tools, to make it easier for developers to add complication support to their watch faces, and a new Wear UI library, to help developers build watch friendly user interfaces.

New Complications API tools for Watch Face developers

Complications are bite-sized pieces of information displayed directly on the watch face. They can also be great shortcuts into your favorite apps. We introduced the Complications API last year to enable watch faces to receive data from any app that the user selects, and display the data to the user in a way that is stylistically coherent. Today, we are introducing four new tools to make it easier for watch face developers to integrate with the Complications API:

• TextRenderer - Auto-sizes text to fit in bounds defined by watch face makers.


• ComplicationDrawable - A full rendering solution for complications, that handles all the styling for you, and adjusts the layout to fit the space you specify


• Easy watch face settings sample - Adoptable sample code that makes it easier to build complication settings with a rich and usable experience.


• Complication test suite - A sample data provider to help check that your watch face can handle all the combinations of fields that can make up complication data.

It's never been easier to integrate complications into your watch faces.

New Wear UI Library for Wear developers

We have provided Android view components for building watch friendly user interfaces since the launch of Android Wear 1.0. Developers have told us that they would like to see these components open sourced. So, starting at Google I/O, we are open sourcing some components and providing some Android Wear UI components in the Android Support Library. This brings a number of advantages, including more consistent APIs with the rest of the Support Library, more frequent releases, and better responsiveness to developer feedback. We will:

• Migrate Wearable Support classes - Migrate and update Android Wear specific view components, such as WearableRecyclerView, from android.support.wearable.view in Wearable Support to android.support.wear.widget in the Android Support Library. This new package is available as open source. In terms of developer impact, we expect the migration process to be simple, with minor API name changes to bring consistency with the existing Android Support Library.


• Merge some Android Wear functionality to Android - Some Android Wear components have a lot of overlap with Android, e.g. CircledImageView and DelayedConfirmationView. We will merge the Android Wear specific functionality with the Android counterparts under android.support.v4.widget.


• Deprecate outdated user interface patterns - Two user interface patterns are deprecated with Android Wear 2.0: the Card pattern and the Multi-directional layout. As a result, we have deprecated all supporting classes, such as GridViewPager and CardFragment. Please refer to the class reference docs for their replacements.

In the first wave of these changes, we migrated the WearableRecyclerView, BoxInsetLayout and SwipeDismissFrameLayout classes to the new Android Wear UI Library. We expect the migration process to continue during 2017, and developers will have until mid-2018 to migrate to the new UI components. For additional information, see Using the Wear UI Library.

Get started and give us feedback!

To get started with these new tools, simply update the Android Support Library in Android Studio and update your gradle build files to import the new support libraries. In addition to the documentation links above, check out the Google I/O session - Android Wear UI development best practice - where lead engineers for these tools will be on-hand to explain the technical details.

We will continue to update these tools over the next few months, based on your feedback. The sooner we hear from you, the more we can include, so don't be shy! Let us do some of the heavy lifting for your Android Wear apps and watch faces.

What�s next for Google payment and loyalty experiences

Posted by Pali Bhat, VP of Payment Products

Thousands of apps and millions of stores accept Android Pay, a simpler and more
secure mobile payment experience. Android Pay is now available in 10 markets,
with more coming soon, including Brazil, Canada, Russia, Spain and Taiwan. And
in addition to our already announced href="https://blog.google/topics/shopping-payments/android-pay-partners-visa-checkout-and-masterpass/">Visa
and Mastercard partnerships, we'll soon enable a streamlined mobile checkout
experience for PayPal users.

The newest ways to pay with Google

Yesterday, we announced the Google Payment API, which lets people pay in app or
online with any verified credit or debit card saved to their Google Account, via
products like Google Play, Chrome and YouTube.

Paying with Google in the Wish app

For users, the option to pay with Google means breezing through checkout without
needing to remember and type multiple lines of payment details. You simply
choose your preferred card, enter a security code or authenticate with your
Android device, and check out.

Developers who adopt this API can enable an easy-to-use checkout experience for
their customers. Sign up for href="https://www.google.com/payments/solutions">early access to the new
Google Payment API.

In the upcoming months, we'll also enable people in the U.S. to send or receive
payments via the Google Assistant. On your Google Home or Android device, it's
as simple as saying "Ok Google, send $10 to Jane for pizza." All you need is a
debit card linked to your Google account.

Pay friends on Google Assistant

Connect with customers before, during and after purchase

We're also announcing new ways for merchants to engage and reward customers
before they walk into the store and after they've left.

The Card Linked Offers API drives customer loyalty by providing a new channel to
deliver targeted offers, and Panera Bread is one of the first merchants who will
roll out this new capability nationally. MyPanera members who save their loyalty
card to Android Pay can discover offers and learn about new menu items, surfaced
by Android Pay when they are at the store. The offer is redeemed when you use
your MyPanera account at checkout.

Card Linked Offers for Panera Bread in the Android Pay app

We're also making it easier for Android Pay users to add loyalty programs. For
example, Walgreens Balance Rewards� members who manually apply their loyalty
account with a phone number and use Android Pay will receive a notification on
their phone that easily enables them to link that loyalty card to Android Pay
for future visits. This experience is powered by our smart tap technology, which
Walgreens has fully deployed across their 8,000+ U.S. stores.

There's more�we're collaborating with href="https://www.clover.com/">Clover, a First Data company, to expand our
smart tap technology beyond national retailers to businesses of all sizes. With
the upcoming integration of smart tap in href="https://www.clover.com/developers">Clover's developer APIs, you'll be
able to build Android apps for loyalty, coupon and gift card redemption and new
features, such as order ahead and tap for pick up.

Visit href="http://developers.google.com/payments">developers.google.com/payments
for the latest on all of our Google Payment, Loyalty and Offers APIs.

Android and Architecture

Android and Architecture

The Android operating system provides a strong foundation for building apps that run well on a wide range of devices and form factors. That being said, we've listened to developer feedback; Issues like complex lifecycles and the lack of a recommended app architecture make it challenging to write robust apps.





 We need to make it easier�and more fun�to write robust apps, empowering developers to focus on areas where they can innovate. Today we're announcing a guide to Android app architecture along with a preview of Architecture Components. Rather than reinventing the wheel, we're also recognizing the work done by popular Android libraries.

Opinions not Prescriptions

We know that there's more than one way to write Android applications.  What we're providing is a set of guidelines that can help you architect an Android application to work best with the unique ways that Android interacts. The Android framework has well-defined APIs to handle contact points with the OS, such as Activities, but these are entry points into your application, not building blocks for your application architecture; Framework components don't force you to separate your data model from your UI components, or provide a clear way to persist data independent of the lifecycle.

Building Blocks

Android Architecture components work together to implement a sane app architecture, while they individually address developer pain points. The first set of these components helps you:

• Automatically manage your activity and fragment lifecycles to avoid memory and resource leaks


• Persist Java data objects to an SQLite database

Lifecycle Components

New lifecycle-aware components provide constructs to tie core components of your applications to lifecycle events, removing explicit dependency paths.



A typical Android observation model would be to start observation in onStart() and stop observation in onStop().  This sounds simple enough, but often times you'll have several asynchronous calls happening at once, all managing the lifecycles of their component.  It's easy to miss an edge case.  The lifecycle components can help.

Lifecycle, LifecycleOwner, and LifecycleObserver

The core class for all of this is Lifecycle. It uses an enumeration for the current lifecycle state along with an enumeration for lifecycle events to track the lifecycle status for its associated component.

Lifecycle States and Events

LifecycleOwner
is an interface that returns a Lifecycle object from the getLifecycle()
method, while LifecycleObserver
is a class that can monitor the component's lifecycle events by adding
annotations to its methods. Putting this all together, we can create
lifecycle-aware components that can both monitor lifecycle events and query the
current lifecycle state.

public class MyObserver implements LifecycleObserver {
  public MyObserver(Lifecycle lifecycle) {
    // Starts lifecycle observation
    lifecycle.addObserver(this);
   ...
  }
  public void startFragmentTransaction() {
     // Queries lifecycle state
     if (lifecycle.getState.isAtLeast(STARTED)) {
        // perform transaction
     }
  }
  
  // Annotated methods called when the associated lifecycle goes through these events
  @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
  public void onResume() {
  }
  @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
  public void onPause() {
  }
}
MyObserver observer = new MyObserver(aLifecycleOwner.getLifecycle());

LiveData

LiveData
is an observable lifecycle-aware data holder class. Your UI code subscribes to
changes in the underlying data, tied into a LifecycleOwner,
and LiveData
makes sure the observer:

• Gets updates to the data while the Lifecycle is in an active state (STARTED
  or RESUMED)
  


• Is removed when the LifecycleOwner
  is destroyed
  


• Gets up-to-date data when the LifecycleOwner
  restarts due to a configuration change or is restarted from the back
  stack

This helps to eliminate many pathways for memory leaks, and reduces crashes by
avoiding updates to stopped activities.


LiveData
can be observed by many listeners, each tied to a lifecycle owner such as a
Fragment or Activity.

ViewModel

ViewModel
is a helper class that contains UI data for an Activity or Fragment that serves
to separate view data ownership from UI controller logic. A ViewModel is
retained as long as the scope of its Activity/Fragment is alive, including when
the Activity/Fragmentis destroyed and recreated due to a configuration change;
This allows ViewModel to make UI data available to the recreated activity or
fragment instance. Wrapping UI data stored within the ViewModel with LiveData
provides the data an observable lifecycle-aware home. LiveData handles the
notification side of things while the ViewModel makes sure that the data is
retained appropriately.

Data
Persistence

The Android Architecture Components also simplify data persistence with the Room
library. Room provides an object-mapping abstraction layer that allows fluent
database access while harnessing the full power of SQLite.

The core framework
provides built-in support for working with raw SQL content. Although these APIs
are powerful, they are fairly low-level and require a great deal of time and
effort to use:

• There is no compile-time verification of raw SQL queries.
  


• As your schema changes, you need to update the affected SQL queries
  manually. This process can be time consuming and error prone.
  


• You need to write lots of boilerplate code to convert between SQL queries
  and Java data objects.
  

Room takes care of these concerns for you while providing an abstraction layer
over SQLite.

Database,
Entity,
and DAO

There are three major components in Room:

• Entity
  represents the data for a single database row, constructed using an annotated
  Java data object. Each Entity is persisted into its own table.
  


• DAO
  (Data Access Object) defines the methods that access the database, using
  annotations to bind SQL to each method.
  


• Database
  is a holder class that uses annotations to define the list of entities and
  database version. The class content defines the list of DAOs. It's also the main
  access point for the underlying database connection.

To use Room, you annotate the Java data objects you wish to persist as entities,
create a database containing these entities, and define a DAO class with the SQL
to access and modify the database.

@Entity
public class User {
    @PrimaryKey
    private int uid;
    private String name;
    // Getters and Setters - required for Room
    public int getUid() { return uid; }
    public String getName() { return name; }
    public void setUid(int uid) { this.uid = uid; }
    public void setName(String name) { this.name = name; }
}


@Dao
public interface UserDao {
    @Query("SELECT * FROM user")
    List getAll();
    @Insert
    void insertAll(User... users);
}

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
}

Guide to App Architecture 

Architecture Components are designed to be standalone, but they're most effective when they're incorporated into an effective app architecture. Today we're launching a Guide to App Architecture that shows how to build a robust, modular, and testable app using Architecture Components. The Guide has three main goals:

•  Defining principles that apply to Android app development. 


• Describing an app architecture that works with those principles. 


• Showing how to implement that architecture using Architecture Components. 

 We recommend all developers who have had to deal with these problems read the Guide; Even if you're happy with your existing app architecture, the Guide will have useful principles and insights.

Just the Beginning 

We're planning to continue being opinionated, and to continue to introduce new Architecture Components to make it easier for Android developers to make informed choices when architecting their applications. We encourage you to try the preview and provide feedback on what we're doing, because we're all in this together to make robust Android app development easier and more fun.

To learn more about Android Architecture, check out:

• Lifecycle-aware codelab 


• Persistence codelab 


• Guide to App Architecture

Google I/O 2017: Empowering developers to build the best experiences across platforms

By Jason Titus, Vice President, Developer Product Group


It's great to be in our backyard again for Google I/O to connect with developers
around the world. The 7,200 attendees at Shoreline Amphitheatre, millions of
viewers on the livestream, and
thousand of developers at local I/O Extended events across 80+
countries heard about our efforts to make the lives of developers easier --
allowing them to focus on the problems they're trying to solve by minimizing the
pain points of building a product.


Earlier this morning, our CEO Sundar Pichai talked
about our various billion-user platforms. Whether it's Android or Chrome or the
mobile Web, our success would not have been possible without the developer
community. And during our Developer
Keynote, we covered our heavy investments in tools and services for
developers who build on our platforms every day.


We have a lot to cover over the next three days. Let's take a closer look at the
major developer news at I/O so far:

Platforms that connect developers to billions of users around the
world

• Android
  O Developer Preview 2 � Get a look at the next release of Android O focused
  on fluid experiences that make Android even more useful, and our efforts to
  optimize battery life, startup time, graphic rendering time, and stability.
  Early adopters can opt in to the Android O Beta Program at android.com/beta and run Android O now.
  


• Project
  Treble � Last week, we also introduced a new Android framework designed to
  help reduce the time and effort it takes device makers to upgrade a phone to a
  new version of Android, starting with Android O.
  


• Android
  Go � We're optimizing Android to run smoothly on entry-level devices,
  starting with the O release. We're also designing Google apps to use less
  memory, storage space, and mobile data, including apps such as YouTube Go,
  Chrome, and Gboard.
  


• Kotlin
  � Android is officially supporting the Kotlin programming language, in addition
  to the Java language and C++. Kotlin is a brilliantly designed, mature,
  production-ready language that we believe will make Android development faster
  and more fun.
  


• Android
  Studio 3.0 Canary � Our new preview includes three major features to
  accelerate development flow: a new suite of app performance profiling tools to
  quickly diagnose performance issues, support for the Kotlin programming
  language, and increased Gradle build speeds for large sized app projects.
  


• Mobile Web � AMP and Progressive Web
  Apps (PWAs) are re-defining
  modern mobile web development. AMP gets content in front of users fast and PWAs
  deliver app-focused experiences that are reliable, fast and engaging. We're
  seeing success stories
  from all around the world - travel company Wego has rolled out a
  successful AMP based PWA and Forbes has seen user
  engagement double since launching a PWA. If you're wondering how good your
  current web experience is, you can use Lighthouse - an
  automated tool for measuring web-page quality. Be sure to tune in this afternoon
  for the
  Mobile Web: State of the Union talk to hear more about building rich mobile
  web experiences.

Infrastructure and services to take mobile apps and the Web to the
next level

• Firebase
  � At last year's I/O, we expanded Firebase to a full mobile development platform
  with products to help you build your app and grow your business. Over a million
  developers now use Firebase, and we're doubling down on our efforts to simplify
  more every-day developer challenges. We're giving more insights to understand
  app performance through Firebase Performance Monitoring, introducing integration
  between Hosting and Cloud Functions, adding support for Phone Number
  Authentication, and continuing to improve Analytics in a number of ways. We've
  also started open
  sourcing our SDKs.
  


• Mobile web
  developer certifications � At I/O'16 we launched the Associate Android
  Developer Certification. This year, we're adding two new certifications for web
  developers: the Mobile
  Sites Certification and the Mobile Web
  Specialist Certification.

Powerful tools to acquire and engage new users; grow successful
businesses

• Google
  Play Console � We announced several powerful, new features and reports in
  the Play Console to help developers improve their app's performance, manage
  releases with confidence, reach a global audience, and grow their business. The
  Play Console also has a new name, to reflect its broadened business uses, and a
  fresh look to make it easier to get things done.
  


• Android
  Instant Apps � We opened Android Instant Apps, a new way to run Android apps
  without requiring installation, to all
  developers. Now anyone can build and publish an instant app. There are also
  more than 50 new experiences available for users to try out from a variety of
  brands, such as Jet, New York Times, Vimeo and Zillow.
  


• Payments, Monetization & Ads � We introduced a Google Payment API that
  enables developers to give their customers the ability to pay in apps and online
  with credit or debit cards saved to their Google Account. New AdMob integration
  with Google Analytics for Firebase helps them monetize efficiently and updates
  to Universal Apps Campaigns will help them grow their user base.

New interfaces to push the limits of what's possible

• Actions
  on Google for the Google Assistant � We brought Actions on Google to phones,
  introduced new features and functionality, improved our SDK and more. We also
  launched the Actions Console, a new developer console that helps developers work
  as a team, and collect data on app usage, performance and user discovery
  patterns. This new console is integrated with the Firebase and Google Cloud
  consoles.
  


• VR
  and AR at Google � We'll have more to share on the latest Daydream platform
  features and developer tools during our "VR and AR at Google" session tomorrow
  (May 18) at 9:30 AM PT in the Amphitheatre and on the livestream.

It's important to us that developers are successful. In addition to building
products that help solve developer challenges, we're on the ground in over 130
countries, growing and expanding the developer community through programs such
as Women Techmakers & Google
Developer Groups (GDGs).
We're also investing in training programs like Google Developers
Certification and courses through Udacity and other partners to help
developers deepen their technical capability. We're also excited to announce two
large multi-product developer events, Google Developer Days, which are planned
for Europe (September 2017 in Krakow, Poland) and India (December 2017 in
Bangalore, India). If you are interested to find out more, sign up for updates
on g.co/gdd2017.


During Google I/O, attendees and viewers have an opportunity to dive deep into
a number of these areas with 14 content tracks and 140+ breakout sessions --
covering Android to Assistant to VR -- and all livestreamed. We've also launched
over 70 codelabs to get
developers up and running with our latest APIs today.


Whether it's Android, Chrome, Play, VR/AR, the Cloud, and the Mobile Web � we're
constantly investing in the platforms that connect developers to billions of
users around the world. Thank you to the continued support and feedback from the
developer community.

Android Announces Support for Kotlin

By Mike Cleron, Director,
Android Platform

Today the Android team is excited to announce that we are officially adding
support for the Kotlin programming
language. Kotlin is a brilliantly designed, mature language that we believe will
make Android development faster and more fun. It has already been adopted by
several major developers � Expedia, Flipboard, Pinterest, Square, and others �
for their production apps. Kotlin also plays well with the Java programming
language; the effortless interoperation between the two languages has been a
large part of Kotlin's appeal.

The Kotlin plug-in is now bundled with Android Studio 3.0 and is available for
immediate download.
Kotlin was developed by JetBrains, the
same people who created IntelliJ,
so it is not surprising that the IDE support for Kotlin is outstanding.


In addition to the IDE support, we're announcing a collaboration with JetBrains
to move Kotlin into a non-profit foundation. (Kotlin is already open sourced
under Apache2.)

Say "Hello" to Kotlin

Kotlin will be very familiar to anyone who has used the Java programming
language.

package helloWorld

fun main(args: Array) {
   println("Hello World!")
}

At first glance, you will see comforting elements like curly braces, classes,
packages, functions and methods. But as you go deeper, you will discover that
although Kotlin is based on familiar concepts, it is a uniquely modern, elegant
and pragmatic riff on those models. In particular, Kotlin is highly expressive
with minimal syntactic friction between your thoughts and what you have to type
in order to express those thoughts. If when writing code you have asked yourself
questions that began "why do I have to �?" you will be pleased to learn that in
Kotlin the answer to many of those questions is "you don't!"



For example, perhaps you have asked why you need to type in a bunch of
boilerplate getters and setters as well as overriding equals(),
hashCode() and toString() when implementing a simple
class. Here is a typical example from the Java programming language (in a
microscopic font for brevity).

public class Customer {
   private String name;
   private String email;
   private String company;

   public Customer(String name) {
       this(name, "", "");
   }

   public Customer(String name, String email) {
       this(name, email, "");

   }

   public Customer(String name, String email, String company) {
       this.name = name;
       this.email = email;
       this.company = company;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getEmail() {
       return email;
   }

   public void setEmail(String email) {
       this.email = email;
   }

   public String getCompany() {
       return company;
   }

   public void setCompany(String company) {
       this.company = company;
   }

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;

       Customer customer = (Customer) o;

       if (name != null ? !name.equals(customer.name) : customer.name != null) return false;
       if (email != null ? !email.equals(customer.email) : customer.email != null) return false;
       return company != null ? company.equals(customer.company) : customer.company == null;
   }

   @Override
   public int hashCode() {
       int result = name != null ? name.hashCode() : 0;
       result = 31 * result + (email != null ? email.hashCode() : 0);
       result = 31 * result + (company != null ? company.hashCode() : 0);
       return result;
   }

   @Override
   public String toString() {
       return "Customer{" +
               "name='" + name + '\'' +
               ", email='" + email + '\'' +
               ", company='" + company + '\'' +
               '}';
   }
}

In Kotlin, you don't have to type any of that. This single line is equivalent to
the entire class above.

data class Customer(var name: String, var email: String = "",
                    var company: String = "")

History and Reference

Kotlin has been around for quite a while; it was announced back in 2011 and the
first preview was released in 2012. Kotlin 1.0 was released in 2016, at which
point JetBrains committed to maintaining backwards compatibility for stable
features from 1.0 forward.



You can find excellent training material and references at https://kotlinlang.org/. The Android team has
found the Kotlin
Koans tutorial to be especially helpful as a quick way to get started
writing some Kotlin snippets. These tutorials range from the simple to the
sublime as the material progresses from the basics to more sophisticated Kotlin
idioms.

Why Kotlin?

Why did the Android team decide to support Kotlin? Most importantly, it was
because we think Kotlin is a great language that will make writing Android apps
easier and more enjoyable.



Kotlin is also a great match for the existing Android ecosystem. It is 100%
compatible with the Java programming language. You can add as little or as much
Kotlin into your existing codebase as you want and mix the two languages freely
within the same project. Calling out to Kotlin code from code written in the
Java programming language Just Works�. Going the other direction usually works
without any developer effort too via some automatically applied translation
conventions (for example, things like property getters and setters are created
for you). With the help of a few Kotlin annotations, you can also customize how
the translation is performed.



Finally, many, many developers have told us they love the Kotlin language. (Many
of our own developers on the Android team have also been saying similar things.)
There is already an enthusiastic
community
of Kotlin developers
for Android, and the Android team has been routinely peppered with questions
about Kotlin at public events. The Android community has spoken, and we
listened.

A Quick Tour

To help you get a sense of where all of the excitement around Kotlin is coming
from, here is a quick, very-much-not-comprehensive tour of some of the
particularly appealing aspects of Kotlin:



Nullable


The Kotlin compiler enforces that variables that can hold null values are
explicitly declared � thus no more NullPointerExceptions at runtime!

var neverNull: String = "something"
var mightBeNull: String? = null // "?" indicates this can be null

if (neverNull.length > 0) {   // This is OK
    �
}

if (mightBeNull.length > 0) { // Compiler catches this error for you
    �
}

Named parameters and default arguments


We've all seen methods that have too many parameters to keep track of. For
example:

fun orderPizza(size: Size, pepperoni: Boolean, mushrooms: Boolean,
               ham: Boolean, pineapple: Boolean, pickles: Boolean,
               sausage: Boolean, peppers: Boolean, onion: Boolean)
{
    ...
}

// Wait� did I just order pickles on my pizza?
// Why do we even have that option?
orderPizza(Size.LARGE, true, false, false, false, true,
           false, true, false)

Compare that to a similar scenario using named parameters and default arguments:

fun orderPizza(size: Size,
               pepperoni: Boolean = false,
               mushrooms: Boolean = false,
               ham: Boolean = false,
               pineapple: Boolean = false,
               pickles: Boolean = false,
               sausage: Boolean = false,
               peppers: Boolean = false,
               onion: Boolean = false)
{
    ...
}

orderPizza(Size.LARGE, ham = true, mushrooms = true)

In addition to helping to avoid tragic pizza outcomes, this is much easier to
read. It also reduces the number of variants of overloaded functions you need to
write.



When statement


Kotlin has a variation of a switch statement that allows matching on arbitrary
expressions.

// Please don't put this in your app!
when {
    password.equals("password") -> println("Insecure password!")
    password.length < 4 -> println("Too short!")
    else -> {
        println("Secure password!")
    }
}

Smart Casts


Why should you have to cast something to a class right after you just tested
that it is an instance of that class? In Kotlin, you don't have to do that
anymore.

if (obj is String) {
    // Compiler casts obj to a String for you.
    // (Would work with && instead of nested ifs too.)
    if (obj.length > 0) {
        �
    }
}

This generalizes to the when statement as well:

// Assume reasonable implementations of Cat and Dog
when (obj) {
   is Cat -> obj.meow(...)
   is Dog -> obj.woof(...)
   else -> {
        �
   }
}

Extension functions


Kotlin lets you essentially retcon
new methods onto an existing type. If you, like many people, wish that the
String class had a toPigLatin method, you can now add it yourself
without having to create a new helper class to wrap String or going through the
trouble of serving on a language committee:

// The "String." prefix indicates that this method should
// extend the existing String class
fun String.toPigLatin() : String {
    ...
}

val plainOldString : String = "some text"

// Can now call toPigLatin as if were a method on String
println(plainOldString.toPigLatin())

// Or:
println("some text".toPigLatin())

Destructuring Declarations


We have already seen how easy it is to define a simple data class:

data class Order(val itemCode: String, val quantity: Int,
                 val price: Float)

A function that uses one of these classes as the return type is very close to
supporting multiple return values:

fun getOrder(...): Order {
    ...
    return Order(itemCode, quantity, price);
}

To get all the way there, you can use the destructuring declaration syntax. The
following statement takes the Order object, extracts its three
properties, and then assigns them to the three variables what,
howMany and howMuch � all courtesy of the Kotlin
compiler, which also infers the correct types for you.

val (what, howMany, howMuch) = getOrder(...)

Lambdas


Kotin has an extremely concise syntax for lambdas that makes is easy to express
powerful functional programming paradigms. Here's a simple example that uses a
lambda to test that everything in a collection is a String:

fun allStrings(collection: Collection)=
    collection.all { it is String }

That lambda syntax is building block of one of Kotlin's coolest features: the
ability to create builders that use JSON-like syntax that also happens to be
syntactically valid Kotlin. This example is adapted from an extended discussion
here,
but you can get the flavor of what it possible with this snippet:

fun generatePage(withEmphasis : Boolean) {
    val result =
        html {
            head {
                title { +"Kotlin Builders" }
            }
            body {
                h1 { +"Kotlin Builders" }
                p {
                    +"This is "
                    if (withEmphasis) b { +"really " }
                    +"interesting"
                    a(href = "https://goo.gl/rHwJio") { +"More here" }
                }
            }
        }
    println(result)
}

There are a couple of interesting things going on here. First, this shows how
expressive Kotlin's functional syntax can be: in this example,
"html", "head", "body, etc. are all just
functions written in Kotlin and the stuff in curly braces that follows are
functional parameters. (This snippet uses functions with names that match HTML
tags to build a representation of a web page, but of course you can use this
pattern to build any complex data structure with whatever names you want.) The
second interesting thing is the "withEmphasis" conditional. This
may look like we are mixing code (if (withEmphasis) �) with data
(all the HTML-esque tags), but the "data" here is actually just more code. Since
it is all really just code, this lets you build complex data structures using a
declarative syntax while also having inline access to the full capabilities of
the Kotlin language.

Getting Started

If you want to get started with Kotlin, you can start playing with code online
immediately here. Just hit the green
triangle to compile and run.



To try Kotlin in your app, follow these steps:

1. Download
   Android Studio 3.0
   


2. Open one of your existing ".java" files
   


3. Invoke "Code > Convert Java File to Kotlin File"

The IDE will then walk you through adding Kotlin dependencies into your project,
and then convert the code to functionally equivalent Kotlin code. (The IDE will
also offer to touch up all of the call sites to the converted class when
suitable to be more idiomatic Kotlin such as when static methods are moved to
companion objects.)



You can also find a lot more information on how to start using
Kotlin on developer.android.com.

Android Studio 3.0 Canary 1

By Jamal Eason, Product
Manager, Android




Just in time for Google I/O 2017, we're providing a sneak peak of Android Studio
3.0 - available to download today on our
canary release channel. Android Studio's our official IDE, purpose-built for
Android, and we keep increasing our investment. The feature set in Android
Studio is focused on accelerating your app development flow and providing the
latest tools built for the Android platform.




To accelerate your development flow, Android Studio 3.0 includes three major
features: a new suite of app performance profiling tools to quickly diagnose
performance issues, support for the Kotlin programming language, and increased
Gradle build speeds for large sized app projects. Android Studio 3.0 also
tightly integrates with Android platform development with these additional key
features: support for Instant App development, inclusion of the Google Play
Store in the Android O emulator system images, and new wizards for Android O
development. Overall, this first canary release of Android Studio 3.0 has 20+
new features.




We have been quietly iterating on many of these features as part of the Android Studio 2.4
Canaries. Today we are renumbering the release to Android Studio 3.0 after
recognizing that we added many significant features, and that we had to
introduce a rare breaking change in the Android Gradle Plugin to improve
scalability and build times. If you want to target Android O, create an Instant App, start developing with the Kotlin language or use the latest in Android app
performance tools to improve your app quality then you should download Android
Studio 3.0 Canary 1 today.

Android DevByte - What�s New in Android Studio 3.0 Canary 1

Check out the the list below organized into key developer flow for the details of the new features in this first canary release of Android Studio 3.0.

Develop

• Kotlin Programming Language - By popular
  request, Android Studio 3.0 now includes support for Kotlin. With this new language support, you
  can seamlessly add Kotlin code next to your existing Android app code and have
  access to all the great development tools found in Android Studio. You can
  choose to add Kotlin to your project using the built-in conversion tool found
  under Code ? Convert Java File to Kotlin File,
  or you choose to create a Kotlin enabled project with the New Project Wizard.
  Lean more about Kotlin language support in Android and Android Studio.

Kotlin Language Conversion in Android Studio

• Java 8 Language features - We are
  continuing to evolve the support for Java 8 language features and APIs. With the
  recent deprecation
  of the Jack toolchain and migration to the javac based toolchain, you have
  access to features such as Instant Run for projects using the Java 8 language
  features in Android Studio. To update your project to support the new Java 8
  Language toolchain, simply update your Source and Target
  compatibility levels to 1.8 in the Project Structure dialog. Learn
  more.

Update Project Structure Dialogue for Java 8 Language

• Layout Editor - With this Android Studio
  release, you will find additional enhancements to the Layout Editor. We have
  updated the component tree with better drag-and-drop view insertions, and a new
  error panel. In coordination with an update to ConstraintLayout,
  the Layout Editor also supports creating view Barriers, creating Groups, and
  enhances Chain Creation. Learn
  more.

Layout Editor Component Tree & Warning Panel

• Adaptive Icon Wizard - Android O
  introduces adaptive launcher icons, which can display in different shapes across
  different Android devices. The new Adaptive Launcher Icon wizard creates the new
  and legacy launcher icon assets and provides previews of how your adaptive icon
  will look on different launcher screen icon masks. Create a new asset by
  right-clicking on the /res folder in your project then navigate
  to ? New ? Image Asset ? Launcher
  Icons (Adaptive and Legacy) Learn
  more.

Adaptive Icon Wizard

• XML Fonts & Downloadable Fonts - Adding
  custom fonts to your app (available when targeting Android O) is now even easier
  with the XML fonts preview and font selection tools in Android Studio. You can
  can also create a downloadable font resource for your app. Using downloadable
  fonts allows you to use a custom font in your app while avoiding the need to
  bundle in a font resource into your APK. To use downloadable fonts, ensure that
  you device or emulator is running Google Play Services v11.2.63 or higher. Learn
  more.

Downloadable Fonts Resource Picker

XML Fonts Preview

• Android Things Support - With Android
  Studio 3.0, you can start developing on Android Things with a new set of
  templates in the New Project wizard and the New Module wizard. Android Things
  allows you to extend your Android development knowledge into the Internet of
  Things (IoT) device category. Learn more.

Android Things New Module Wizard 

• IntelliJ Platform Update: Android Studio 3.0 Canary 1
  includes the IntelliJ 2017.1 release, which has features such as Java 8 language
  refactoring, parameter hints, semantic highlighting, draggable breakpoints,
  enhanced version control search, and more. Learn
  more.

Build

• Instant App Support - With Android Studio
  3.0, you can create Instant
  Apps in your project. Instant Apps are lightweight Android apps that your
  users can immediately run without installation. To support this, Android Studio
  introduces two new module types: instant app and feature. Combined with a new
  "Modularize" refactoring action and the App
  Links Assistant, Android Studio can help you extend your app into an Instant
  App. To use you can use the New Module Wizard or right-click on a class and
  navigate to: Refactor ? Modularize Learn more.

Instant App Module Wizard

• Build Speed Improvements - We are
  continuing to invest in making build speeds faster. For this release, we focused
  on improving speed for projects that have many modules. To achieve these speed
  improvements and to support future enhancements, we have made breaking API
  changes to the Android Gradle plugin used by Android Studio. If you
  depended on APIs provided by the previous plugin you should validate
  compatibility with the new plugin and migrate applicable APIs. To test, update
  the plugin version in your
build.gradle file. Learn more.

build.gradle




dependencies {
   classpath 'com.android.tools.build:gradle:3.0.0-alpha1'
}

• Google's Maven Repository - Also, by
  popular request, we are now distributing the Android Support Library maven
  dependencies outside of the Android SDK Manager in a brand new Maven repository.
  For those developing with a Continuous Integration (CI) system, this should make
  Maven dependency management easier. Used in combination with the latest command
  line SDK
  Manager tool and Gradle,
  CI builds should be easier to manage with Google's Maven Repository. To use the
  the new Maven location, add the following url to your app module's
  build.gradle file. Learn more.

build.gradle

repositories {
   maven {
       url "https://maven.google.com"
   }
}

Test & Debug

• Google Play System Images - Along with the
  update to the Android O Beta release, we updated the Android Emulator O system
  images to include the Google Play Store. Bundling in the Google Play store
  allows you to do end-to-end testing of apps with Google Play, and provides a
  convenient way to keep Google Play services up-to-date in your Android Virtual
  Device (AVD). Just as Google Play services updates on physical devices, you can
  trigger the same updates on your AVDs.

Google Play Store in Android Emulator

Update Google Play Services in Android Emulator

To ensure app security and a consistent experience with physical devices, the
emulator system images with the Google Play store included are signed with a
release key. This means you will not be able to get elevated privileges. If you
require elevated privileges (root) to aid with your app troubleshooting, you can
use the Android Open Source Project (AOSP) emulator system images that do not
include Google apps or services. To get started, make sure you are using Android
Emulator v26.1+, the latest system images API 24+ and then create a new AVD with
a Google Play icon next to the device definition. Learn more.

Android Virtual Device Manager with Google Play Store Support 

• OpenGL ES 3.0 Support in Android Emulator - As a part of our ongoing investment in making your development experience fast, the latest version of the Android Emulator has OpenGL ES 3.0 support for Android O system images along with significant improvements in OpenGL ES 2.0 graphics performance for older emulator system images. Most modern graphics cards on all operating systems support OpenGL ES 2.0 acceleration. To use OpenGL ES 3.0 with the Android Emulator, your development machine needs a host GPU graphics card that supports OpenGL 3.2 or higher on Microsoft� Windows� or Linux (with Apple MacOS� support coming in the future). Learn more.

OpenGL ES 3.0 in Android Emulator

• App Bug Reporter in Android Emulator - To
  help in documenting bugs in your app, we have added an easier way to generate a
  bug report with all the necessary configuration settings and space to capture
  your repro steps. Additionally, if you want to share a specific emulator bug
  with the Android team, we have also added a link to quickly generate a bug on
  the Android Issue Tracker. To use this feature, navigate to the Emulator
  Tool Bar ? Extended Controls ? Help ?
  Emulator Help ? File a Bug. Learn
  more.

App Bug Reporting in Android Emulator

• Proxy Support in Android - For those who
  need to use a HTTP proxy to access the Internet, we have added a user interface
  to manage the proxy settings used by the emulator. By default, the Android
  Emulator will now use the settings from Android Studio, but you can override
  these settings for your network setup. To configure navigation to the
  Extended Controls ? Settings ?
  Proxy.

Android Emulator Proxy Settings

• Android Wear Rotary Controls in Android Emulator -
  The Android Emulator now supports rotary controls for the Android Wear
  2.0 emulator system image. It is now easier to test your apps that target
  Android Wear devices that include rotary input scrolling. To enable, create an
  Emulator AVD that targets Android Wear, and the Rotary Input panel should appear
  under Extended controls. Learn
  more.

Rotary input in Android Emulator

• APK Debugging - For those of you who just
  want to debug an APK without building your project in Android Studio, the
  Android Studio 3.0 release now has the ability to debug an arbitrary APK. This
  functionally is especially helpful for those who develop your Android C++ code
  in another development environment, but want to debug and analyze the APK in the
  context of Android Studio. As long as you have a debuggable version of your APK,
  you can use the new APK Debugging features to analyze, profile & debug the APK.
  Moreover, if you have access to the sources of your APK, you can link the source
  to the APK debugging flow for a higher fidelity debugging process. Get started
  by simply selecting Profile or debug APK from the Android
  Studio Welcome Screen or File ? Profile or debug APK. Learn More.

Profile or Debug an APK

APK Debugging

• Layout Inspector - You will find that the
  Layout Inspector has a few additional enhancements in Android Studio 3.0 that
  make it easier to debug issues in your app layouts. A couple of the enhancements
  include better grouping of properties into common categories, as well as search
  functionality in both the View Tree and Properties Panels. While an application
  is running, access the Layout Inspector via Tools ?
  Android ? Layout Inspector. Learn more.

Layout Inspector

• Device File Explorer - Ported from DDMS
  into Android Studio by popular demand, the new Device File Explorer allows you
  to view the file and directory structure of your Android device or emulator. As
  you are testing your app, you can now quickly preview and modify app data files
  directly in Android Studio.

Device File Explorer

Optimize

• Android Profiler - Android Studio 3.0 includes a brand new suite of tools to help debug performance problems in your app. We completely rewrote the previous set of Android Monitor tools, and replaced them with the Android Profiler. Once you deploy your app to a running device or emulator, click on the Android Profiler tab and you will now have access to a real-time & unified view of the CPU, Memory, & Network activity for your app. Each of the performance events are mapped to the UI event timeline which highlights touch events, key presses, and activity changes so that you have more context on when and why a certain event happened.  Click on each timeline to dig into each performance aspect of your app. Learn more. 

Android Profiler - Combined timeline view.

• CPU Profiler - Unnecessary CPU processing
  and load spikes are symptoms of poor app performance. With the CPU Profiler,
  you can analyze the CPU thread usage of your app by triggering a sample or
  instrumented CPU trace. At this point, you can troubleshoot CPU performance
  issues using a variety of data views and filters built into the CPU Profiler. Learn more.

CPU Profiler

• Memory Profiler - Using memory
  inefficiently can lead to many device problems ranging from a janky UI to low
  memory events. The Memory Profiler combines the functionality of the previous
  Heap Viewer and Allocation Tracker in one rich interface to help debug memory
  usage problems in your app. You can diagnose a range of memory issues by
  analyzing memory allocations, heap dumps and more. Learn more.

Memory Profiler

• Network Profiler - Optimizing foreground
  and background network usage in your app can lead to a more performant app and
  lower app data usage. The network profiler allows you to monitor the network
  activity of your app, inspect the payload of each of your network requests, and
  link back to the line of source code that generated the network request.
  Currently, the network profiler works with HttpURLConnection,
  OkHttp, and Volley
  network libraries. The network profiler is an advanced analysis feature that can
  be enabled on Pre-Android O devices & emulators by selecting Enable Advanced
  Profiling in the Profiling Tab in the Run Configuration box. In addition to
  enabling network request and payload analysis, this checkbox enables event
  collection at the top level, memory object count, and memory garbage collection.
  For Android O-based devices and emulator, just deploy your app. Learn more.

Network Profiler

Network Profiler Setup for Pre- Android O Devices

• APK Analyzer Improvements - In Android
  Studio 3.0, we have added some additional enhancements to the APK Analyzer to
  help you further optimize the size of your APK. With this feature update, you
  can now analyze Instant App zip files & AARs, and view dex bytecode of classes &
  methods. You can also generate Proguard configuration rules and load Proguard
  mapping files in the dex viewer. Learn
  more.

APK Analyzer

To recap, Android Studio 3.0 Canary 1 includes these new major features: 

Develop Kotlin Language Java 8 Language Layout Editor Improvements Adaptive Icon Wizard XML Fonts & Downloadable Fonts Android Things Intellij Platform Update 2017.1 Build Instant App Support Build Speed Improvements Google's Maven Repo Change

Test & Debug Emulator Google Play System Images Emulator OpenGL ES 3.0 Support Emulator Proxy Support App Bug Reporter Android Wear Rotatory APK Debugging Layout Inspector Device File Explorer Optimize CPU Profiler Memory Profiler Network Profiler APK Analyzer Improvements

Check out the release notes for more details.

Getting Started  

Download

If you are using a previous version of Android Studio, you can install Android
Studio 3.0 Canary 1 alongside
your stable version. You can download this update from the official Android
Studio Preview download
page. As mention in this blog, there are some breaking Gradle Plugin API
changes to support new features in the IDE. Therefore, you should also update
your Android Gradle plugin version to 3.0.0-alpha1 in your current project to
test and validate your app project setup.






We appreciate any feedback on things you like, issues or features you would like
to see. If you find a bug or issue, feel free to file an
issue. Connect with us -- the Android Studio development team - on our Google+ page or on Twitter.