OverrideAndroid

Github OAuth Client Library - Android

2018-05-04T05:59:00.000-07:00

The Github_OAuth library helps to easily add a Github's OAuth implementation flow to your Android application.

It will open a new Dialog Fragment with webview and user token will be returned on callback.

Find more about GitHub's OAuth implementation

Let’s go through a sample application that authenticate using Github. complete source code of this library and sample application is available on Github.

Setup

Using Gradle

The Github-OAuth library is pushed to jcenter, so you need to add the following dependency to your app's build.gradle.

As a module

If you can't include it as gradle dependency, you can also download this GitHub repo and copy the library folder to your project.

Usage

Obtaining GithubAuthenticator instance

Obtaining an access token via the GithubAuthenticator

Authenticate will open a new Dialog Fragment with webview and user token will be returned on callback

Enable logs

Scope can also be defined (optional)

Available scopes are from developer page

Picture-in-Picture: Working in Android Oreo

2018-01-02T09:06:00.000-08:00

From release of the Android O, which saw some exciting new additions for us to get our hands on!

One of the most noticeable user-facing changes is the introduction of a picture in picture (PIP) option – similar to an Apple iPad feature added in iOS 9 – which should make multitasking easier in some circumstances. PIP is a special type of multi-window mode mostly used for video playback. PIP mode is already available for Android TV; Android O makes the feature available on other Android devices.

Let’s take a look at this exciting new feature and how we can implement it into our Android applications!

To learn more about Picture-in-Picture I created a playground project to have a play with the new features. You can check this out for yourself here!

What is Picture-In-Picture?

Picture-in-Picture (PiP) allows you to keep videos open as they play on top of of another screen. This wouldn’t be the same as the multi-window feature which allows users to keep two apps open simultaneously, but instead is likely to be more similar to the way YouTube videos play in a small player at the bottom right corner of the screen after you minimize them which allows you to continue scrolling through YouTube and looking at other videos. The change here would be that users will have the ability to do the same type of thing but while in other apps as well.

Implementing Picture-in-Picture

Implementing Picture-in-Picture into our applications is a simple process. There’s only several steps allow us to display PiP-windows to our users!

picture-in-picture support

The first step, is allow your activity to support PiP. Set android:supportsPictureInPicture tag to true:

Enter Picture In Picture Mode

To enter picture-in-picture mode, an activity must call enterPictureInPictureMode(). The other thing to keep in mind is that you need specials parameters to enter to PiP mode from your activity:

You need to set an aspect ratio to PiP parameters builder. The aspect ratio is used when the activity is in PiP mode. To do that, you have to pass the width and height of your video view. Then, you can call to enterPictureInPictureMode passing the PiP parameters built.

Handling UI during picture-in-picture

When the activity enters or exits picture-in-picture mode the system calls Activity.onPictureInPictureModeChanged() or Fragment.onPictureInPictureModeChanged().

References

How to Use Kotlin in Your Android Projects

2017-05-09T21:00:00.001-07:00

One great news of moving to Kotlin is, do not need to start from a new project. You could add it to your existing Java Android project. The language is interoperable with Java. So you could use steps below either for a new or existing project.

Setting up Your Environment

By default, Android Studio has no idea what to do with Kotlin, so the first step is to install the Kotlin plugin and configure Kotlin in your project.

Installing the Kotlin Plugin

Launch Android Studio and install the kotlin plugin.

In Android Studio's quick start menu, select Configure >> Plugins.

click on Install JetBrains plugin…

Search for and select Kotlin from the list and click Install.

When the installation completes, restart Android Studio to activate the plugins.

Configuring Your Project to Use Kotlin

Now IDE can understand and run Kotlin code, but need to configure kotlin for every project.

Create a new project in Android Studio from File >> New Project by filling the required details.

Select Tools from the Android Studio toolbar, followed by Kotlin and Configure Kotlin in Project.

On the Configure Kotlin in Project popup, select the plugin version you want to use and click OK.

The Configure Kotlin in Project option makes a number of changes to your project’s build.gradle files, so let’s take a closer look at how these files have changed. Open your project-level build.gradle file. it should look something like this:

Now, let’s take a look at your module-level build.gradle file:

Click on Sync Now to build the project.

Convert Any Java File to Kotlin

One of the feature of kotlin plugin is that we can convert a java classes to kotlin classes.

Let's convert MainActivity file into a Kotlin source file by invoking the Kotlin plugin’s Convert Java File to Kotlin File action.

Select your MainActivity file, and then select Code from Android Studio’s menu bar, followed by Convert Java File to Kotlin File.

Your newly-converted MainActivity should look something like this:

Notice that the file's extension has changed from .java to .kt.

Using Kotlin Android Extensions

The Kotlin Android Extensions plugin allow you to use the widgets in the layout XML directly in activity without calling the findViewById method.

Add org.jetbrains.kotlin:kotlin-android-extensions as a build script dependency in app module's build.gradle.

Create a Kotlin class, KotlinActivity, that extends Activity and override its onCreate method.

To create a Kotlin file, right your app/src/main/ directory and select New >> Kotlin Activity.

In the layout XML file, define a TextView with an id of messageTextview.

Now, instead of calling findViewById to get a reference to the TextView, you can import it using the following code snippet:

import kotlinx.android.synthetic.another_activity.myMessage

If you had more widgets in your layout, you can import all of them using the following code snippet:

import kotlinx.android.synthetic.another_activity.*

Now access TextView using its id messageTextview.

messageTextview.setText("Hello")

In this tutorial, you have learned how to use Kotlin in your Android projects after installing the Kotlin plugin and the Kotlin Android Extensions plugin for Android Studio. As Kotlin and Java classes are largely interoperable, if you are still learning Kotlin, it is best to introduce it in your Android projects gradually.

Kotlin: Do more with less code

2017-04-30T02:27:00.001-07:00

Java is the most widely used language for Android development, but that doesn’t mean it is always the best choice.The biggest problem with Java is that it is old, verbose, not a “modern language” and don’t forget the infamous NullPointerException.

Java 8, bringing some modern flavors to the language but Android certainly doesn’t use all the features of Java 8 and we are still stuck in the old Java 7 and 6.That's where Kotlin comes in: This relatively new open source language, based on the Java Virtual Machine (JVM), is gaining traction with Android software engineers.

What is Kotlin?

Kotlin is a statically-typed programming language(sometimes referred to as Swift for Android) that runs on the JVM, developed by the JetBrains team, and is now in its 1.1 version. What makes it useful in Android development is that it compiles to JVM bytecode. It is fully compatible with Java, and Kotlin code can be simply converted to Java code and vice versa (there is a plugin from JetBrains). That means Kotlin can use any framework, library etc. written in Java.

Why Kotlin

Java 8 solved some language issues and corrected even more with Java 10. In order to get much of a benefit from the corrections made in these two releases, you have to set the minimum SDK to Android 24 just to use Java 8, which isn’t an option for many developers. For almost everybody, Java 10 isn’t even on the radar.

Kotlin aims to fill that gap of a missing modern language for the Android platform. Kotlin has heap of features, here covering just the important ones to get you started.

No More NullPointerExceptions

One of the most common reasons for crashes in our apps have been the NullPointerExceptions.

Kotlin comes with null-safety system which helps in catching null(s) during compile time.

By default every variable is treated as non-null unless we tell to compiler that it’s a null variable using an special operator “?” at the end of the variable type.

Suppose you have a String variable and you are trying to assign a null value to it:

Using this null variable in further code will also give compile-time error unless handled using not null condition.

The compiler is smart enough to understand that we are using an object which can be null-able hence it shows compile time error.

Write Less Code, Be Happy- Lambda Expressions

A lambda expression represents an anonymous function. Lambdas are a great way of reducing the amount of code needed to perform some tasks that come up all the time in Android development.

Java 8 has introduced native lambda expressions, and these are now supported in Android Nougat. Although this feature isn’t something that’s unique to Kotlin, it’s still worth taking a look at them. Plus, if you’re working on a project that contains both Kotlin and Java code, then you can now use lambda expressions across your entire project!

Adding a click listener to a button. In Java 7 and earlier, this would typically require the following code:

However, Kotlin lambda functions allow you to set a click listener using a single line of code:

Smart Casting

Smart casting is one of the interesting feature of Kotlin compiler. The Compiler does smart casting on our behalf. It even handles the negative scenario like if the “view” is not an “TextView”.

Great IDE and Tooling Support

Kotlin is a JetBrains product, the ones who specialize in creating some of the best and most used IDEs in the world.

There is a plugin that you can install in Android Studio to get Kotlin working in your project.

All IDE features work perfectly in Kotlin. You can mix and match Kotlin and Java code in the same project and everything still works great. The IDE support is really great with Kotlin where other JVM based languages don’t even come close.

About the Syntax

In order to understand the features of Kotlin. We will have a look at the basic syntax in Kotlin. You can refer the syntax in detail from the official website.

Variables

The way to define a variable is with the “val” or “var” keyword. The type will be inferred from the Context:

You can specify the type explicitly:

Did you notice there is no new keyword near ArrayList() ?. Because there is no new keyword in Kotlin.

Functions

Structure of the function:

Start with “fun” keyword
The parameter names are written before the type
The return type is written at the end of the function

The above function can be Kotlin-ized even more:

Did you notice there are no semicolons(;) ?. Kotlin is semicolon free language :)

To learn more about Kotlin, I recommend browsing the Kotlin reference. The Getting Started section will help you get up to speed with this new language.

In the next tutorial, you will learn how to use the Kotlin plugin and the Kotlin Android Extensions plugin for Android Studio.

Introduction to Spring Animation

2017-04-20T09:04:00.000-07:00

When writing an application, it's important to consider exactly what your graphical demands will be. Varying graphical tasks are best accomplished with varying techniques. Android provides a variety of powerful APIs for applying animation to UI elements and drawing custom 2D and 3D graphics.

Dynamic-animation is a new module introduced in revision 25.3.0 of the Android Support Library. It provides a small set of classes for making realistic Physics-based Animations.

What is Physics-based Animation

Physics-based animation uses the fundamentals of physics to build animations. An animation is driven by force. The animation comes to rest when the force reaches equilibrium. The new set of animation APIs embeds physics to render a more natural-looking and flexible animation.

Spring Animation

Spring Animation is one of the animation API provided by the Dynamic-animation module. Physics-based animations are driven by force. Spring force, is one such force that guides interactivity and motion. In a spring-based animation, the value and the velocity are calculated based on the spring force that are applied on each frame.

To demonstrate, I am creating a simple app that animate a view with spring-based animation. Complete source code for the examples used in this tutorial is available on github.

Let’s start by creating a new project.

Creating New Project

Create a new project in Android Studio from File > New Project. When it prompts you to select the default activity, select Empty Activity and proceed.

Update Build Configuration

In order to use the physics-based support library, you must modify your app project's classpath dependencies within your development environment.

To add a support library to your application project:

Open the build.gradle file of your application.
Add the support library to the dependencies section.

Making a Spring Animation

Let’s start with how every Spring Animation is made.

Create a SpringAnimation object for your View with a specified ViewProperty
Create a SpringForce object and set your desired parameters
Apply the created SpringForce to your SpringAnimation.
Start the animation

Creating the Layout

So quickly create a layout with a ImageView placed center of the screen.

Create a SpringAnimation object

Open your MainActivity.java and create a method that returns SpringAnimation with SpringForce object and set your desired parameters. The method look like this:

Now create SpringAnimation objects for the ImageView.

Damping ratio The damping ratio describes a gradual reduction in a spring oscillation. By using the damping ratio, you can define how rapidly the oscillations decay from one bounce to the next.

Stiffness Stiffness defines the spring constant, which measures the strength of the spring. A stiff spring applies more force to the object that is attached when the spring is not at the rest position.

Drag the view. Springs back to its original position

Now we are going to drag the view around the screen and when it release the view springs back to its original position.

That's it :)

Android Debug Database: A Library for Debugging Android Databases and Shared Preferences

2017-04-12T10:26:00.000-07:00

Android comes with a powerful built-in database called SQLite, but it doesn't come with the best set of debugging tools. When it comes to debugging databases in an android application, it is very difficult to see what’s happening inside the database. The same is true with Shared Preferences. In fact, unless you have a rooted device, you can't even get the SQLite tables off your device without jumping through some hoops.

Android Debug Database

Android Debug Database is a powerful library for debugging SQLite databases and Shared Preferences in Android applications. It allows you to view databases and shared preferences directly in your browser in a very simple way.

By using the Android Debug Database we can do the following:

See all the databases.
See all the data in the shared preferences used in your application.
Run any sql query on the given database to update and delete your data.
Directly edit the database values.
Directly edit shared preferences.
Delete database rows and shared preferences.
Search in your data.
Sort data.
Download database.

Android Debug Database Library in your application

Let’s take a look how we can implement it into our Android applications and debug the SQLite databases and shared preferences.
Complete source code for the examples used in this tutorial is available on github.

Creating New Project

We’ll start by creating new project in Android Studio and do the basic setup required.Create a new project in Android Studio from File > New Project and fill the project details.

Update Build Configuration

Open build.gradle located under app module and add android debug database dependency.

Create SQLite Database Handler Class

Create a new class in your project src directory and name it as DatabaseHandler.java ( Right Click on src/package > New > Class)

Now extend your DatabaseHandler.java class from SQLiteOpenHelper.

Insert Records

Update MainAcitvity.java file to create the instance of DatabaseHandler.java class and add some rows.

Store Data Using Shared Preferences

Another way of storing data of an application is called Shared Preferences. Shared Preferences allow you to save and retrieve data in the form of key,value pair.

Create a Shared Preference instance and store some values.

Debugging Databases and Shared Preferences

Now we can debug the database and shared preference used in the app with the help of a web interface.

To do that do the following steps:

Your Android phone and laptop should be connected to the same Network.
If you are using it over usb, run adb forward tcp:8080 tcp:8080

Start the application, you will see in the logcat an entry like follows :

Android Default Emulator: run adb forward tcp:8080 tcp:8080 and open http://localhost:8080

If you want use different port other than 8080. In the app build.gradle file under buildTypes do the following change :

Seeing Sqlite Database

Editing Values

Run Sql Query

Seeing Shared Preference

Exploring Android O: Autosizing TextViews

2017-04-05T11:46:00.000-07:00

With the release of first developer preview of Android O, Google come with a solution to auto-size text in a TextView similar to the way the iOS SDK allows to select “fit text to box”.

Let’s take a look at this exciting new feature and how we can implement it into our Android applications!

Autosizing TextViews

Android O allows to instruct a TextView to let the size of the text expand or contract automatically to fill its layout based on the TextView's characteristics and boundaries. This setting makes it easier to optimize the text size on different screens with dynamic content.

Creating New Project

We’ll start by creating new project in Android Studio and do the basic setup required.Create a new project in Android Studio from File > New Project and fill the project details. While creating the project, select the API O: Android 7+(O preview) as Minimum SDK.

Update Build Configuration

Open build.gradle located under app module and Update compileSdkVersion, buildToolsVersion, targetSdkVersion, and the Support Library version with the following versions:

Textview Autosizing in XML

There are two ways to set up TextView Autosizing in XML. By using Granularity and Preset Sizes.

Granularity

By using granularity, we can specify a range of minimum and maximum text sizes and a dimension that specifies the size of each step. The TextView can uniformly scale, in a range between the given minimum and maximum size attributes. Each increment takes on the step size specified in the granularity attribute.

autoSizeText: attribute to instruct the TextView to auto-size. The valid values are none, which is a default value, and uniform.
autoSizeMinTextSize: The minimum text size constraint to be used when auto-sizing text
autoSizeMaxTextSize: The maximum text size constraint to be used when auto-sizing text
autoSizeStepGranularity: attributes to set the autosizing dimensions in the layout XML file.The default is 1px. Overwrites autoSizePresetSizes if set.

Another method to define these attributes is to use the Properties window. Selected the Design tab at the bottom of the window and open the Properties window.

Preset Sizes

Preset sizes are used to, autosize the TextView from a list of predefined sizes. autoSizePresetSizes attribute in the layout XML file is used to instruct the TextView to auto-size from a size array.

You can create a array file by the following steps

Right-click the values folder and go to New > Values resource file.
Give file name: arrays

You can also define these attributes in the Properties window in Android Studio.

Using Textview Autosizing programmatically

You can set up autosizing programmatically by using the following methods:

To set up the autosizing by using granularity, Call the setAutoSizeTextTypeUniformWithConfiguration(int autoSizeMinTextSize, int autoSizeMaxTextSize, int autoSizeStepGranularity, int unit) method. You can use any TypedValue dimension unit for maximum, minimum, and granularity values.

To set up the autosizing by using preset sizes, Call the setAutoSizeTextTypeUniformWithPresetSizes(int[] presetSizes, int unit) method. You can provide an array of sizes and any TypedValue dimension unit for the size.

Exploring Android O: Fonts in XML

2017-03-30T10:17:00.000-07:00

Google just released a few information about the next version of Android, which arrives later this year and is known for now as Android O.

With the first developer preview, we saw some exciting stuff that will have a big impact for developers and the apps they can make. New ways to use custom fonts and icons, a better way to deliver professional-level audio and awesome ways to connect with others for things like head-to-head gaming or local social applications.

One of the features of this announcement includes Fonts in XML — in this article we’re going to take a look at exactly what this and how we can make use of them within our applications!

Get started with Android O SDK

Android O Developer Preview, a program that gives you everything you need to make your apps compatible and build for the next version of Android.

Install Android Studio 2.4

To access the O Developer Preview, you must first update to Android Studio 2.4. Only Android Studio 2.4 includes support for all the new developer features available with Android O. So you need to get the canary version of Android Studio 2.4 to begin using the Android O SDK.

Install SDK and tools

Launch Android Studio 2.4 and open the SDK Manager by clicking Tools > Android > SDK Manager.

In the SDK Platforms tab, check Show Package Details. Below Android O Preview check the Android SDK Platform O.

Switch to the SDK Tools tab and check all items that have updates available. This should include the following that are required:

Android SDK Build-Tools 26.0.0 (rc1 or higher)
Android SDK Platform-Tools 26.0.0 (rc1 or higher)
Android Emulator 26.0.0
Support Repository

Click OK to install all the selected SDK packages.

Setup Device running Android O

Download the Android O system image for the Android Emulator. It's listed in the SDK Manager under Android O Preview as Google APIs Intel x86 Atom System Image.

Working With Fonts

Android O introduces a new feature, Fonts in XML, which lets you use fonts as resources. This means, there is no need to bundle fonts as assets. Fonts are compiled in R file and are automatically available in the system as a resource.

Creating New Project

We’ll start by creating new project in Android Studio and do the basic setup required.Create a new project in Android Studio from File > New Project and fill the project details. While creating the project, I have selected the Empty Activity as default activity.

Update Build Configuration

Open build.gradle located under app module and Update compileSdkVersion, buildToolsVersion, targetSdkVersion, and the Support Library version with the following versions:

Add Fonts As Resources

You can access the font resources with the help of a new resource type, font.To add fonts as resources do the following steps:

Right-click the res folder and go to New > Android resource directory.
Give Directory name: font
In the Resource type list, select font, and then click OK.

Next step is to add fonts in the font folder. Google Fonts are beautiful web fonts that can be used without restrictions. You can download and install Google Fonts for free.

Before adding font files to font folder rename files according to the naming conventions:

Resource name should contains be a-z,0-9,_
Resource name should start with a-z,_

Below is the project structure after adding the fonts to the font resource folder:

Double-click a font file to preview the file's fonts in the editor.

Using fonts in XML layouts

To attach fonts to the TextView or in styles, use the fontFamily attribute.

Open activity_main.xml file and add a TextView to the layout. Then use the fontFamily attribute to access the font file.

Another method to set the font is to use the Properties window. Selected the Design tab at the bottom of the window and open the Properties window.

The Android Studio layout preview, shown in the rightmost pane allows you to preview the font set in the TextView.

Using fonts programmatically

You can retrieve fonts by using the getFont(int) method, where you need to pass the resource identifier of the font that you want to retrieve. This method returns a Typeface object.

Getting started with Android Fingerprint Authentication

2017-03-23T11:37:00.000-07:00

With the release of Android 6.0 Marshmallow, Google has introduced best way to authenticate the User- That is Fingerprint Authentication.With this API, Google has created a native approach for fingerprint authentication across all Android devices. Developers can now authenticate their users on an app-by-app basis for everything from mobile purchases to app sign-in screens and more with just the tap of a finger.

Why fingerprint authentication?

let’s look at some of the ways in which fingerprint authentication can improve the user experience:

It’s a quick and convenient way of authenticating the user’s identity.
You can’t forget a fingerprint!
No more struggling with mobile keyboards.
No more annoying password recovery or reset.
our fingerprint is unique and impossible to guess.

Creating the Fingerprint Authentication Project

Imagine you are developing an app that requires to perform some critical operation like, payment. You want to be sure that your user is authenticated prior wiring any kind of money, right?

Let’s go through a sample application that authenticate the user by fingerprint.

Complete source code for the examples used in this tutorial is available on github.

Creating New Project

Open Android Studio and create a new project. You can use the settings of your choice, but set your project’s SDK version to Android 6.0 (API 23) or higher.

Updating the Manifest

Fingerprint authentication requires that the app request the USE_FINGERPRINT permission within the project manifest file.

Creating user interface

Create the fingerprint icon with the help of “Android Image Assets”. To do so, Right click on the drawable folder and Create a New ⇒ Image Asset named ic_action_fingerprint.

You can download fingerprint icons from here and paste in res folder.

Now we have all our resources, let’s create our UI:

Checking the Security Settings

Now time to implement the fingerprint authentication part of our app.As a first step we’re going to check that:

The device features a fingerprint sensor.
The user has protected their lockscreen.
The user has registered at least one fingerprint on their device.

Create a method called checkFingerPrintSensor() on MainAcitivity.java file.

Accessing Android Keystore and Generate Encryption Key

We are going to create a method called generateKey() that generate an encryption key which is then stored securely on the device using the Android Keystore system.

The following task are going to do:

Gain access to the Android keystore, by generating a Keystore instance.
Initialize the KeyGenerator by Specify the operation(s) this key can be used for
Configure this key so that the user has to confirm their identity with a fingerprint each time they want to use it
Generate the key

Create the Android Cipher

The cipher that will be used to create the encrypted FingerprintManager.CryptoObject instance. This CryptoObject will, in turn, be used during the fingerprint authentication process.

The getInstance method of the Cipher class is called to obtain a Cipher instance which is subsequently configured with the properties required for fingerprint authentication. The previously generated key is then extracted from the Keystore container and used to initialize the Cipher instance.

Create method with name generateCipher() that return a cipher object.

Authenticating

We’re ready to authenticate.This is done by calling FingerprintManager’s authenticate(CryptoObject, CancellationSignal, int, AuthenticationCallback, Handler) method.

CryptoObject

The crypto object is passed to fingerprint manager to protect the integrity of the fingerprint authentication.There is a chance that third party can intercept the results returned by fingerprint scanner. Crypto object is used to encrypt the results returned by fingerprint scanner.

CancellationSignal

This gives us the ability to stop listening for fingerprints. In a typical implementation, this class's cancel() method will be called in the onPause() lifecycle method. This ensures we aren’t listening for fingerprints while the application isn’t available.

AuthenticationCallback

This is the listener for fingerprint events. Create an AuthenticationCallback object like below:

Finally the onCreate() method will look like this:

Updating user interface

Next step is to update the user interface with authentication success or failure.Just create two method to handle this.

Testing the project

Whenever you’re working on an Android app, you should test that app across a wide range of Android Virtual Devices (AVDs) plus at least one physical Android smartphone or tablet.

First, make sure your Android smartphone or tablet is configured to support fingerprint authentication by securing your lockscreen with a PIN, password or pattern and then registering at least one fingerprint on your device. Typically, you register a fingerprint by going to Settings ⇒ Security ⇒ Fingerprint and then following the onscreen instructions.

When it comes to testing Android’s fingerprint authentication on an AVD, there’s an immediate problem: an emulated Android device doesn’t have any physical hardware.The solution is to use the extended controls of the AVD.

Reactive Programming with RxBinding

2017-03-15T10:57:00.001-07:00

Developing a complex Android app that has lots of network connections, user interactions, and animations often means writing code that is full of nested callbacks. ReactiveX offers an alternative approach that is both clear and concise, to manage asynchronous tasks and events.

ReactiveX

ReactiveX is a combination of the best ideas from the Observer pattern, the Iterator pattern, and functional programming

RxJava

RxJava is a JVM implementation of ReactiveX, developed by NetFlix, and is very popular among Java developers.

What is Reactive Programming

Reactive programming is an asynchronous programming paradigm oriented around data streams and the propagation of change. This means that it should be possible to express static (e.g. arrays) or dynamic (e.g. event emitters) data streams with ease in the programming languages used, and that the underlying execution model will automatically propagate the changes through the data flow.

For example, in an imperative programming setting, a:=b+c would mean that a is being assigned the result of b+c in the instant the expression is evaluated, and later, the values of b and c can be changed with no effect on the value of a.

However, in reactive programming, the value of a would be automatically updated whenever the values of b and c change, without the program executing the sentence a:=b+c again.

Observable and Observer

There are two basic and very important items in reactive programming, Observables and Observers. Observables publish values, while Observers subscribe to Observables, watching them and reacting when an Observable publishes a value.

In simpler terms:

An Observable performs some action, and publishes the result.
An Observer waits and watches the Observable, and reacts whenever the Observable publishes results.

There are three different changes that can occur on an Observable that the Observer reacts to. These are:

Publishing a value
Throwing an error
Completed publishing all values

A class that implements the Observer interface must provide methods for each of the three changes above:

An onNext() method that the Observable calls whenever it wishes to publish a new value
An onError() method that’s called exactly once, when an error occurs on the Observable.
An onCompleted() method that’s called exactly once, when the Observable completes execution.

So an Observable that has an Observer subscribed to it will call the Observer’s onNext() zero or more times, as long as it has values to publish, and terminates by either calling onError() or onCompleted().

What are the RxBinding Libraries?

One of the benefits of using RxJava is the ability to compose asynchronous events in a more straightforward way. Complex UI interactions in Android can also be greatly simplified too, especially when there are multiple UI events that can trigger. To describe the interaction pattern with standard Android code, you would usually need to use a combination of both listeners, Handlers and AsyncTask. With RxJava and RxBinding, this logic can be greatly simplified and you can describe the interaction patterns between multiple UI components.

RxBinding is a set of libraries that allow you to react to user interface events via the RxJava paradigm. Let’s take a look at a few example.

This is how Android developers typically react to a text change for an EditText

Now the same thing, but written with RxBinding support:

In the example above, I use the RxTextView.textChanges() method to react only to the text change event. In traditional Android, we have to implement a full TextWatcher to accomplish this, wasting multiple lines of code because the beforeTextChanged event and afterTextChanged callbacks must also be implemented. This dead code simply pollutes the class and offers no additional value. With RxBinding I can achieve more control over what I want to react to in my application without the additional overhead in my codebase.

A Simple Example

For example, consider what you would need to create a simple registration form with two fields, username and email.

The registration form has these behaviours:

The initial state of both fields are blank.
If the field is valid according to the criteria, the text will be colored black.

Criteria for email is a valid email using simple regex check.
Valid user name if it’s more than 4 character in length.

If the field is not valid, the text will be colored RED.
The Register button is only active when both fields are valid.

If you used to create Android applications, you’d now how many handlers and anonymous classes you will write to track the state of the fields and to create the behaviour of the register button.

Setting Up RxBinding

To use RxAndroid in an Android Studio project, add it as a compile dependency in the app module’s build.gradle.

Creating an Observer and observables

As mentioned above we can create RxTextView.textChanges() observable to react to the text change event.We’d like to capture the text and print them in the ADB console.

When we run this app, we’ll get these output.

Transforming with Operators

Now, let’s implement the behaviour of the validity of each field. Map the text from each fields and verify.To achieve this we’ll define several Observables for each EditText. The condition of validity are

UserName should be more than 4 characters in length.
Email should match a simple regex validation.

Since RxBinding is applying RxJava paradigms to existing Android Views and Widgets, you can use RxJava operators to perform transformations on the stream of data that is emitted in real time.

The code is pretty straightforward.

This is the email pattern we’ll use for email validation. We’re using classes from java.util.regex package.
We create an Observable<Boolean> for the UserName and email.

Next we need to map the validity Observable to a color observable and subscribe to them to change the text Color.

The result is as expected.

Combining Observables

Lastly, we’d like to implement a use case where the Register button only enabled when both fields are enabled. For this we’ll need to combine two observables to one. To do that we use combineLatest method.When an item is emitted by either of two Observables, combine the latest item emitted by each Observable via a specified function and emit items based on the results of a function.

Code will look like this:

Filtering Observables

The items from userNameValid, emailValid and registerEnabled are emitted on each user input. This causes the subscribers are called everytime the user type in the fields.

We only want the subscriber only called when the validity changes. For this, we’d need to call distinctUntilChanged() method on our Observables. Thus, the code becomes:

As usual, the complete source code for the examples used in this tutorial is available on github. Feel free to check out and use however you see fit.

Introduction to Android Bottom Navigation View

2017-03-09T11:18:00.000-08:00

Bottom navigation with tabs has been quite a common primary navigation pattern over on iOS for a long time.It enables navigation through a series of hierarchical app screen. Android guidelines already included tabs too, but they were at the top of the screen, combined with swipeable pages, implemented with a ViewPager.

Google officially added Bottom Navigation to version 25 of the Design Support Library and released new versions of its Photos and Google+ app with this component as its main navigation.Let’s take a dive into how we can use it!

I made a really simple app, you can find it from GitHub

Usage

Bottom navigation provides quick navigation between top-level views of an app. It is primarily designed for use on mobile.

When to use

Bottom navigation should be used for:

Three to five top-level destinations of similar importance (alternative: a persistent navigation drawer accessible from anywhere in the app)

Destinations requiring direct access from anywhere in the app (alternative: tabs for only one or two destinations).

How to Use It

1. Add the design support library

The first step is to add the design support library to your app-level build.gradle file. Example is as shown below:

2. Add to your layout

Next we simply need to add the Bottom Navigation View widget to our desired layout file. Remember that this should be aligned with the bottom of the screen with all content displaying above it. We can add this view like so:

3. Populate Menu

We can add content to the bottom navigation view by specifying a menu resource file. First, create a menu file and then populate it by using the following attribute of BottomNavigationView.

4. Styles

The bottom navigation view also can be customized with several different options, including

app:itemBackground, app:itemIcontint, and app:ItemTextColor:

If you add this to your app and run it on your device, you’ll see a shiny new bottom navigation view like below:

5. Handling Enabled/Disabled state

We can easily handle the display of both enabled and disabled menu items.

First, we need to create a selector file for our enabled / disabled colors like following.

app:itemIcontint="@drawable/nav_item_color_state"

app:ItemTextColor="@drawable/nav_item_color_state"

Disabled and Enabled states will then be displayed reflecting the stated look and feel from the selector file:

6.listen to tab selection events

To listen for click events on the BottomNavigationView, we just need to call setOnNavigationItemSelectedListener()

Example of how to do this is:

When we receive click events for the items, we can simply react accordingly. In my sample I simply change the text on the textview that is being displayed on the screen.

OverrideAndroid

Github OAuth Client Library - Android

Setup

Using Gradle

As a module

Usage

Obtaining GithubAuthenticator instance

Obtaining an access token via the GithubAuthenticator

Enable logs

Scope can also be defined (optional)

Picture-in-Picture: Working in Android Oreo

What is Picture-In-Picture?

Implementing Picture-in-Picture

picture-in-picture support

Enter Picture In Picture Mode

Handling UI during picture-in-picture

References

How to Use Kotlin in Your Android Projects

One great news of moving to Kotlin is, do not need to start from a new project. You could add it to your existing Java Android project. The language is interoperable with Java. So you could use steps below either for a new or existing project.

Setting up Your Environment

By default, Android Studio has no idea what to do with Kotlin, so the first step is to install the Kotlin plugin and configure Kotlin in your project.

Installing the Kotlin Plugin

Launch Android Studio and install the kotlin plugin. In Android Studio's quick start menu, select Configure >> Plugins. click on Install JetBrains plugin… Search for and select Kotlin from the list and click Install. When the installation completes, restart Android Studio to activate the plugins.

Configuring Your Project to Use Kotlin

Convert Any Java File to Kotlin

Using Kotlin Android Extensions

Kotlin: Do more with less code

What is Kotlin?

Why Kotlin

No More NullPointerExceptions

Write Less Code, Be Happy- Lambda Expressions

Smart Casting

Great IDE and Tooling Support

About the Syntax

Variables

Functions

To learn more about Kotlin, I recommend browsing the Kotlin reference. The Getting Started section will help you get up to speed with this new language. In the next tutorial, you will learn how to use the Kotlin plugin and the Kotlin Android Extensions plugin for Android Studio.

Introduction to Spring Animation

What is Physics-based Animation

Spring Animation

Creating New Project

Update Build Configuration

Making a Spring Animation

Creating the Layout

Create a SpringAnimation object

Damping ratio The damping ratio describes a gradual reduction in a spring oscillation. By using the damping ratio, you can define how rapidly the oscillations decay from one bounce to the next.

Stiffness Stiffness defines the spring constant, which measures the strength of the spring. A stiff spring applies more force to the object that is attached when the spring is not at the rest position.

Drag the view. Springs back to its original position

That's it :)

Android Debug Database: A Library for Debugging Android Databases and Shared Preferences

Android Debug Database

Android Debug Database Library in your application

Creating New Project

Update Build Configuration

Create SQLite Database Handler Class

Insert Records

Store Data Using Shared Preferences

Debugging Databases and Shared Preferences

Seeing Sqlite Database

Editing Values

Run Sql Query

Seeing Shared Preference

Exploring Android O: Autosizing TextViews

Autosizing TextViews

Creating New Project

Update Build Configuration

Textview Autosizing in XML

Granularity

Preset Sizes

Using Textview Autosizing programmatically

Exploring Android O: Fonts in XML

Get started with Android O SDK

Install Android Studio 2.4

Install SDK and tools

Setup Device running Android O

Working With Fonts

Creating New Project

Update Build Configuration

Add Fonts As Resources

Using fonts programmatically

To learn more about Kotlin, I recommend browsing the Kotlin reference. The Getting Started section will help you get up to speed with this new language.

In the next tutorial, you will learn how to use the Kotlin plugin and the Kotlin Android Extensions plugin for Android Studio.

Three to five top-level destinations of similar importance (alternative: a persistent navigation drawer accessible from anywhere in the app)

Destinations requiring direct access from anywhere in the app (alternative: tabs for only one or two destinations).