Fourth project for Udacity Android Developer Nanodegree Program, as Google scholarship.

I've used Gradle to build a joke-telling app that has both a free and paid version. This included factoring functionality into libraries as well as using build flavors to modularize the construction of each variant of the app. I also configured a Google Cloud Endpoints development server to supply the jokes.

The App displays a very simple UI with a button to ask for a joke. By clicking on it the service retrieves to you a joke.

Main screen

• Java
• Android Support Libraries (Google Mobile Ads)

• JDK 1.8
• Android SDK
• Android J (API 16)
• Latest Android SDK Tools and build tools.

Copyright 2018 Simone Armadoro

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

WARNING: Please note that this project was submitted by Simone Armadoro as part of the Udacity's Android Developer Nanodegree.

As part of Udacity Honor code, your submissions must be your own work, hence submitting this project as yours will cause you to break the Udacity Honor Code and the suspension of your account. I allow you to check the code as a reference, but if you submit it, it's your own responsibility if you get expelled.

Besides this notice, the above license applies and this license notice must be included in all works derived from this project.

Hereunder the readme over the forked project

In this project, you will create an app with multiple flavors that uses multiple libraries and Google Cloud Endpoints. The finished app will consist of four modules. A Java library that provides jokes, a Google Cloud Endpoints (GCE) project that serves those jokes, an Android Library containing an activity for displaying jokes, and an Android app that fetches jokes from the GCE module and passes them to the Android Library for display.

As Android projects grow in complexity, it becomes necessary to customize the behavior of the Gradle build tool, allowing automation of repetitive tasks. Particularly, factoring functionality into libraries and creating product flavors allow for much bigger projects with minimal added complexity.

You will learn the role of Gradle in building Android Apps and how to use Gradle to manage apps of increasing complexity. You'll learn to:

• Add free and paid flavors to an app, and set up your build to share code between them
• Factor reusable functionality into a Java library
• Factor reusable Android functionality into an Android library
• Configure a multi project build to compile your libraries and app
• Use the Gradle App Engine plugin to deploy a backend
• Configure an integration test suite that runs against the local App Engine development server

This is the starting point for the final project, which is provided to you in the course repository. It contains an activity with a banner ad and a button that purports to tell a joke, but actually just complains. The banner ad was set up following the instructions here:

https://developers.google.com/mobile-ads-sdk/docs/admob/android/quick-start

You may need to download the Google Repository from the Extras section of the Android SDK Manager.

You will also notice a folder called backend in the starter code. It will be used in step 3 below, and you do not need to worry about it for now.

When you can build an deploy this starter code to an emulator, you're ready to move on.

Your first task is to create a Java library that provides jokes. Create a new Gradle Java project either using the Android Studio wizard, or by hand. Then introduce a project dependency between your app and the new Java Library. If you need review, check out demo 4.01 from the course code.

Make the button display a toast showing a joke retrieved from your Java joke telling library.

Create an Android Library containing an Activity that will display a joke passed to it as an intent extra. Wire up project dependencies so that the button can now pass the joke from the Java Library to the Android Library.

For review on how to create an Android library, check out demo 4.03. For a refresher on intent extras, check out;

http://developer.android.com/guide/components/intents-filters.html

This next task will be pretty tricky. Instead of pulling jokes directly from our Java library, we'll set up a Google Cloud Endpoints development server, and pull our jokes from there.

The following tutorial explains how to add and use a Google Cloud Endpoints module in your project. The starter code already includes the module in the folder called backend. Therefore, you can skip the creation steps in the tutorial and start at section 1.1 Debugging the backend locally:

https://github.com/GoogleCloudPlatform/gradle-appengine-templates/tree/master/HelloEndpoints

Introduce a project dependency between your Java library and your GCE module, and modify the GCE starter code to pull jokes from your Java library. Create an Async task to retrieve jokes. Make the button kick off a task to retrieve a joke, then launch the activity from your Android Library to display it.

Add code to test that your Async task successfully retrieves a non-empty string. For a refresher on setting up Android tests, check out demo 4.09.

Add free and paid product flavors to your app. Remove the ad (and any dependencies you can) from the paid flavor.

For extra practice to make your project stand out, complete the following tasks.

Follow these instructions to add an interstitial ad to the free version. Display the ad after the user hits the button, but before the joke is shown.

https://developers.google.com/mobile-ads-sdk/docs/admob/android/interstitial

Add a loading indicator that is shown while the joke is being retrieved and disappears when the joke is ready. The following tutorial is a good place to start:

http://www.tutorialspoint.com/android/android_loading_spinner.htm

To tie it all together, create a Gradle task that:

1. Launches the GCE local development server
2. Runs all tests
3. Shuts the server down again

• Project contains a Java library for supplying jokes
• Project contains an Android library with an activity that displays jokes passed to it as intent extras.
• Project contains a Google Cloud Endpoints module that supplies jokes from the Java library. Project loads jokes from GCE module via an async task.
• Project contains connected tests to verify that the async task is indeed loading jokes.
• Project contains paid/free flavors. The paid flavor has no ads, and no unnecessary dependencies.

• App retrieves jokes from Google Cloud Endpoints module and displays them via an Activity from the Android Library.

Once you have a functioning project, consider adding more features to test your Gradle and Android skills. Here are a few suggestions:

• Make the free app variant display interstitial ads between the main activity and the joke-displaying activity.
• Have the app display a loading indicator while the joke is being fetched from the server.
• Write a Gradle task that starts the GCE dev server, runs all the Android tests, and shuts down the dev server.