Many mobile apps today suffer from “app-nesia” — the affliction that causes an app to forget
who you are. Have you ever re-installed an app only to discover you have to re-create all your
carefully crafted preferences? This is typically because the user’s app data lives only on the
device.
By connecting your apps to a backend platform, you can solve this issue, but it can be
challenging. Whether it’s building basic plumbing, or just trying to load and save data in a
network & battery-efficient way, spending time dealing with the backend can take
precious time away from building an awesome app. So, we’re introducing two new features to
help make your life easier.
Google Cloud Save
Google Cloud Save allows you to easily load and save user data to the cloud without needing to
code up the backend. This is handy for situations where you want to save user state and have
that state synchronized to multiple devices, or survive an app reinstall.
We handle all the backend logic as well as the synchronization services on the client. The
synchronization services work in the background, providing offline support for the data, and
minimizing impact on the battery. All you need to do is tell us when and what to save, and you
do this with just 4 simple methods:
.save(client, List<Entity>)
.delete(client, Query)
.query(client, Query)
.requestSync(client)
All data is written locally first, then automatically synchronized in the
background. The save, delete and query methods provide your basic CRUD operations while the
requestSync method allows you to force a synchronization at any time.
On the backend the data is stored in Google Cloud Datastore
which means you can access the raw data directly from a Google App Engine or Google Compute Engine
instance using the existing Datastore API.
Changes on the server will even be automatically synced back to client devices.
Importantly, this per-user data belongs to you, the developer, and stored in your own Google
Cloud Datastore database.
Google Cloud Save is currently in private beta and will be available for general use soon. If
you’re interested in participating in the private beta, you can sign up here!
Cloud Tools for Android Studio
To simplify the process of adding an App Engine backend to your app, Android Studio now
provides three App Engine backend module templates which you can add to your
app:
App Engine with Google Cloud Messaging - Push notification
wireup
When you choose one of these template types your project is updated with a new Gradle module
containing your new App Engine backend. All of the required dependencies/permissions will be
automatically set up for you.
Built-in rich editing support for Google Cloud Endpoints
Once you have added the backend module to your Android application, you can use Google Cloud Endpoints
to streamline the communication between your backend and your Android app. Cloud Endpoints
automatically generates strongly-typed, mobile optimized client libraries from simple Java
server-side API annotations, automates Java object marshalling to and from JSON, and provides
built-in OAuth 2.0 support.
On deployment, this annotated Endpoints API definition class generates a RESTful API. You can
explore this generated API (and even make calls to it) by navigating to Endpoints API explorer as shown in
the image below:
To simplify calling this generated API from your Android app, Android Studio will
automatically set up your project to include all compile dependencies and permissions required
to consume Cloud Endpoints, and will re-generate strongly-typed client libraries if your
backend changes. This means that you can start calling the client libraries from your Android
app immediately after defining the server-side Endpoints API. The underlying work-horses: Gradle, and Gradle plug-in for App Engine
Under the hood, Gradle is used to build both your app and your App Engine backend. In fact,
when you add an App Engine backend to your Android app, the open-source App Engine plug-in
for Gradle is automatically downloaded by Android Studio, and common App Engine
tasks become available as Gradle targets. This allows you to use the same build system across
your IDE, command-line or continuous integration environments.
Checkout more details on the new Cloud Endpoints features in Android
Studio on the Android Developer Blog.
