Mayowa Adegeye

AnimatedVectorDrawable XML Bundles

2016-12-01T00:00:00+01:00

Creating AnimatedVectorDrawables on Android requires you to create three xml resources that represents each of the following animated-vector , objectAnimator and vector. The <vector /> is the actual file that represents the vector drawable. The <objectAnimator /> defines the animation to apply to different parts of the vector and the <animated-vector /> is used to link the vector drawable and the animation together.

As an example, to create an animated vector drawable that transforms a play icon to stop icon, the following xml files will be created. The Vector drawable:

    <!-- res/drawable/ic_play.xml -->

    <?xml version="1.0" encoding="utf-8"?>
    <vector xmlns:android="http://schemas.android.com/apk/res/android"
        android:width="48dp"
        android:height="48dp"
        android:viewportWidth="48"
        android:viewportHeight="48">

        <path
            android:name="play"
            android:pathData="M 20 15 L 32 24 L 20 33 Z"
            android:fillColor="@android:color/white"/>
    </vector>

Then an animator that defines the transformation on the pathData property of the vector and morphs it into the stop icon.

    <!-- res/animator/animates_play_to_stop.xml -->

    <?xml version="1.0" encoding="utf-8"?>
    <set xmlns:android="http://schemas.android.com/apk/res/android">
        <objectAnimator
            android:duration="300"
            android:interpolator="@android:anim/accelerate_decelerate_interpolator"
            android:propertyName="pathData"
            android:valueFrom="M 20 15 L 32 24 L 32 24 L 20 33 Z"
            android:valueTo="M 16 16 L 32 16 L 32 32 L 16 32 Z"
            android:valueType="pathType"/>
    </set>

Finally, we create the AnimatedVectorDrawable xml file links the animation to the vector:

    <!-- res/drawable/animated_drawable_play_to_stop.xml -->

    <animated-vector xmlns:android="http://schemas.android.com/apk/res/android"
        android:drawable="@drawable/ic_play">

        <target
            android:animation="@animator/animate_play_to_stop"
            android:name="play" />
    </animated-vector>

At IO 2016, Google announced a new xml bundle format that enables creating AnimatedVectorDrawables using a single xml file. The XML bundle format requires build tools version 24 and above to work, and also requires adding the aapt namespace to your xml declaration. For example, the three xml files for the AnimatedVectorDrawable above can be written in a single xml file as shown below:

    <!-- res/drawable/animated_drawable_play_to_stop.xml -->

    <?xml version="1.0" encoding="utf-8"?>
    <animated-vector xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        xmlns:appt="http://schemas.android.com/aapt"
        tools:ignore="MissingPrefix">

        <appt:attr name = "android:drawable">
            <vector xmlns:android="http://schemas.android.com/apk/res/android"
                android:width="48dp"
                android:height="48dp"
                android:viewportWidth="48"
                android:viewportHeight="48">

                <path
                    android:name="play"
                    android:pathData="M 20 15 L 32 24 L 20 33 Z"
                    android:fillColor="@android:color/white"/>
            </vector>
        </appt:attr>

        <target
            android:name="play">
            <appt:attr name="android:animation">
                <objectAnimator
                    android:duration="300"
                    android:interpolator="@android:anim/accelerate_decelerate_interpolator"
                    android:propertyName="pathData"
                    android:valueFrom="M 20 15 L 32 24 L 32 24 L 20 33 Z"
                    android:valueTo="M 16 16 L 32 16 L 32 32 L 16 32 Z"
                    android:valueType="pathType"/>
            </appt:attr>
        </target>

</animated-vector>

The keys things to note in this new format are:

Inclusion of the appt namespace inside the <animated-vector .. opening xml tag:

        <animated-vector xmlns:android="http://schemas.android.com/apk/res/android"
            xmlns:appt="http://schemas.android.com/aapt">

The android:drawable atttibute of the <animated-vector has been removed and now you put the vector xml directly within this tag:

        <appt:attr name = "android:drawable">
             <!-- vector graphics xml -->
        </appt:attr>

Finally, within each of the <tagret.. tags, you can either directly specify the objectAnimator wihtin an <appt:attr name="android:animation>, or reference an external animation located in res/animator/...

    <!-- directly specify the animation -->
    <tagret android:name="play">
        <appt:attr name="android:animation">
            <objectAnimator
                ....... />
        </appt:attr>
   </target>

   <!-- referenceing an external object animator -->
   <tagret android:name="play"
        android:animation="@animator/animate_play_to_stop"/>

You can add the tools:ignore="MissingPrefix" to suppress lint warnings because the bundle format is not yet recognized by lint.

References

Nick Butcher Google Plus Post on New XML Bundle format

AnimatedVectorDrawables Bundle

Android support Annotations

2016-08-22T00:00:00+01:00

In this blog post, we are going to be talking about the Android Support Annotations Library and why we should care about it.

Version 19.1 of the support library included a new annotations package which contains a number of useful annotations that can be added to your code, to help catch bugs. These annotations will help Android studio to check your code for possible errors and report them to you. As of version 22.2 of the support library, this annotations package has been enriched with an additional 13 annotations.

Adding the Library to your project

The annotations library are not included in an Android project by default, as they are shipped as a separate library. If you’re using appcompat library however, you already have access to the annotations, because appcompat itself depends on it.

In any case, to have access to the support library annotations in your android project, add this line to your module level build.gradle file.

compile 'com.android.support:support-annotations:<latest-library-version>'

These annotations are grouped together based on similarities in their usage and functionality and based on these grouping, we have the following classes of annotations in the support annotations library:

Nullness Annotations
Resource Annotations
Thread Annotations
Value Constraints Annotations
Others are: Permissions Annotations, CheckResults Annotations and CallSuper Annotations.

Nullness Annotations

@Nullable and @NonNull annotations can be used to check the nullness of a variable, parameter or method return value. @NonNull annotation means that the value of the variable, parameter or method return value cannot be null. Android studio generates a warning if this is violated. For example:

    //pass a null argument to a method annotated as @NonNull
    doubleNumber(null);

    public int doubleNumber(@NonNull int num) {
        return num * 2;
    }

@Nullable means a variable is allowed to take a null value and if used with a method, it means the method can return a null value. Null check should be done on variables or return values whenever @Nullable annotation is used.

Resource Annotations

Since resources are passed around in Android as integers, a code expecting a string resource id can be passed an int pointing to a drawable and the compiler will accept it. Resource type annotations allows type checking to be done in situations like this. By annotating an int parameter with @StringRes for examples, ensures that passing anything other than a R.string ref will be flagged by the IDE.

    public void setButtonText(@StringRes int id) {
         //set text on some button
    }

    //this will be flagged by the IDE
    setButtonText(R.drawable.icon);

Each of the android resource type has a corresponding resource type annotation. Some other examples are @DrawableRes, @ColorRes, @InterpolatorRes and so on. The general rule is, if there is a resource of type “Foo”, the corresponding resource type annotation is “FooRes”.

Lastly, there is a special resource annotation called @AnyRes which is used when the specific type of resource is not known but it must be a resource type.

Thread Annotations

Thread annotations checks if a method is called from a specific type of thread. Supported thread annotations are:

@UiThread
@MainThread
@WorkerThread
@BinderThread

@MainThread and @UiThread annotations are interchangeable and method calls from either thread type are allowed for these annotations.

A class can be annotated with a thread annotation if all methods in that class are called from the same thread. A good example of the usage of thread annotations is in AsyncTask

    @WorkerThread
    protected abstract Result doInBackground(Params... params);

    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }

An error will be flagged if the onProgressUpdate method is called from a thread other than the main thread.

Value Constraints Annotations

@IntRange, @FloatRange and @Size annotations are used to validate the values of passed parameters. @IntRange annotation validates that the parameter is within the specified range of integer values. The setAlpha method below for example, ensures that the alpha parameter value is between 0 and 255 inclusive.

    public void setAlpha(@IntRange(from=0, to=255) int alpha) {
        //set alpha
    }

@FloatRange likewise checks that a parameter value is within a specified range of floating point values. The @Size annotation on the other hand, is used to check the size of a collection or array, as well as the length of a string. @Size(min=1) annotation can be used to check that a collection is not empty and @Size(2) annotation checks that an array contains exactly two values.

CheckResult Annotations

This is used to ensure that the result of a method or its return value is actually used. It’s main purpose is to help with cases where users of the API may be confused and may think the method has a side effect. As explained in the support annotations documentation, a good example of this is the String.trim method, which may be confusing to new Java developers, thinking that the method call actually changes the string by removing whitespace. If the String.trim method is annotated with @CheckResult, the IDE will flag uses of String.trim where the caller does not do something with the result.

    @CheckResult
    public String trim(@NonNull String string) {
        //remove whitespace from string
    }

    String s = "hello world ";

    //this will make the IDE flag an error since the result from the @CheckResult
    //annotated method is not used
    s.trim();

Other support annotations worth looking at are @CallSuper, @Keep and @RequiresPermission. For a complete list check the android developer reference for support annotations.

Conclusion

Using support annotation makes helps to make obvious how the code works. It makes the code predictable and also makes it easy for other developers integrating your code or when you have to make changes to the code some times in the future.

References

Improve code Inspection with Annotations - Android developer doc

Support Annotation documentation

http://michaelevans.org/blog/2015/07/14/improving-your-code-with-android-support-annotations/

Bottom Sheets in Android

2016-06-29T00:00:00+01:00

Bottom Sheet is a material design component, that was added to design support library in version 23.2. Bottom sheet is a very simple window that displays from the bottom of the screen, and can be used to reveal more content to the user. Examples of bottom sheet can be seen in some of Google’s apps and widgets, such as the Place Picker from the Places API.

In this post, I will be showing how you can use bottom sheets in your apps.

Bottom sheet can be a structural part of a UI or a temporary modal. To achieve these, the design support library provides:

BottomSheetBehavior to be used with CoordinatorLayout
BottomSheetDialog which is a dialog with a bottom sheet behavior
BottomSheetDialogFragment which is an extension of DialogFragment, that creates a BottomSheetDialog instead of a standard dialog.

To get started with BottomSheet in your apps, add the support library dependecy to your build.gradle file:

    compile 'com.android.support:design:<latest-library-version>'

Creating a Persistent Bottom Sheet

To create a bottom sheet as part of your interface layout,

Create a layout with CoordinatorLayout as the root, then add the the view or layout for the bottom sheet, as a direct child of the CoordinatorLayout. The bottom sheet layout must have app:layout_behavior attribute, with value android.support.design.widget.BottomSheetBehavior.

For example:

<?xml version="1.0" encoding="utf-8"?>
<android.support.design.widget.CoordinatorLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   tools:context="com.mayojava.sample.bottomsheetdemo.MainActivity">

   <!-- main content layout-->
   <RelativeLayout
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:paddingBottom="@dimen/activity_vertical_margin"
       android:paddingLeft="@dimen/activity_horizontal_margin"
       android:paddingRight="@dimen/activity_horizontal_margin"
       android:paddingTop="@dimen/activity_vertical_margin">
       ......
   </RelativeLayout>

   <!-- bottom sheet layout -->
   <RelativeLayout
       android:id="@+id/linear_layout_bottom_sheet"
       android:layout_width="match_parent"
       android:layout_height="220dp"
       app:behavior_peekHeight="80dp"
       app:behavior_hideable="true"
       app:layout_behavior="@string/string_bottom_sheet_behavior"
       android:elevation="@dimen/z_bottom_sheet"
       android:background="@color/color_bottom_sheet">
       <TextView
           android:id="@+id/text_view_sheet_title"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:text="@string/text_pull_to_show_more"
           android:textSize="@dimen/text_size_medium"
           android:padding="@dimen/activity_vertical_margin"/>

       <TextView
           android:id="@+id/text_view_more_content"
           android:text="@string/text_more_contet_to_user"
           android:textSize="@dimen/text_size_big"
           android:textStyle="bold"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:layout_below="@+id/text_view_sheet_title"
           android:paddingLeft="@dimen/activity_vertical_margin"
           android:paddingRight="@dimen/activity_vertical_margin"/>

       <Button
           android:text="@string/text_click_me"
           android:layout_width="match_parent"
           android:layout_height="wrap_content"
           android:layout_alignParentLeft="true"
           android:layout_marginLeft="@dimen/activity_vertical_margin"
           android:layout_marginRight="@dimen/activity_vertical_margin"

           android:layout_marginTop="@dimen/activity_vertical_margin" android:layout_below="@+id/text_view_more_content"/>

   </RelativeLayout>

</android.support.design.widget.CoordinatorLayout>

For the bottom sheet to be displayable, we need a to create a BottomSheetBehavior. This can be done by calling BottomSheetBehavior.from(), passing a reference to the view with the bottom behavior attribute to the call. This should be done from the Activity that uses the bottom sheet.

LinearLayout bottomSheetLayout  
    = (LinearLayout) findViewById(R.id.layout_bottom_sheet);

//get bottom sheet behavior from bottom sheet view
BottomSheetBehavior bottomSheetBehavior = BottomSheetBehavior.from(mLayoutBottomSheet);

With a reference to the BottomSheetBehavior object, we can call the setState method, passing different behavior constants, that toggles the state of the bottom sheet.

BottomSheetBehavior.STATE_EXPANDED: Completely expands the bottom sheet.
BottomSheetBehavior.STATE_HIDE: Completely hides the bottom sheet.
BottomSheetBehavior.STATE_COLLAPSED: Sets the bottom sheet height with the value set on the peekHeight attribute.

    
//to expand the bottom sheet
mbottomSheetBehavior.setState(BottomSheetBehavior.STATE_EXPANDED);

//to collapse the bottom sheet
mbottomSheetBehavior.setState(BottomSheetBehavior.STATE_COLLAPSED);

peekHeight can be used to show a preview of the bottom sheet when the screen is displayed. It can be set in xml using the app:behavior_peekHeight attribute, or in code, by calling setPeekHeight on the BottomSheetBehavior object.

mbottomSheetBehavior.setPeekHeight(320);

A modal bottom sheet is a dialog with a bottom sheet behavior, and is not part of your view hierarchy. It can be used as alternative to menus, content choosers or simple dialogs in your application. It can also present deep-linked content from other apps.

To do this:

Create a class that extends BottomSheetDialogFragment, inflated with the layout that will be used as the content of the modal dialog.

layout_custom_bottom_sheet.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="@dimen/activity_vertical_margin"
    android:paddingRight="@dimen/activity_vertical_margin"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingTop="@dimen/activity_vertical_margin">

    <ImageView
        android:id="@+id/ic_image"
        android:src="@mipmap/ic_launcher"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginRight="@dimen/margin_normal"
        android:layout_marginTop="@dimen/activity_vertical_margin"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello bottom sheet"
        android:textSize="@dimen/text_size_medium"
        android:layout_marginTop="@dimen/activity_vertical_margin"
        android:layout_toRightOf="@+id/ic_image"
        android:layout_alignTop="@+id/ic_image"/>

    <TextView
        android:layout_marginTop="@dimen/activity_vertical_margin"
        android:layout_below="@+id/ic_image"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/text_lorem_ipsum"
        android:lineSpacingExtra="@dimen/margin_small"
        android:layout_marginBottom="@dimen/margin_normal"/>


</RelativeLayout>

Create an instance of the modal bottom sheet and show it with the show method, passing the FragmentManager and a string tag as parameters.

CustomBottomSheetDialog bottomSheetDialog = CustomBottomSheetDialog.getInstance();
bottomSheetDialog.show(getSupportFragmentManager(), "Custom Bottom Sheet");

The complete code for this tutorial can be found in this github repository.

Conclusion

Bottom sheets can be used to display unobtrusive dialogs, as well as provide users with context menus or pickers in a very subtle way.

References

Creating and sharing your own Android Library

2016-06-16T00:00:00+01:00

If you have ever thought of writing your own custom Android library for others to use or extend, and wonder how you could achieve that, then you can join me on this ride. In this post, I will be showing a step by step guide on how to create an Android library. I will also be showing you how to distribute your library through JitPack.

We will be creating a simple statistics library, that can be used to compute basic Arithmetic Mean, Median and Mode. To achieve this, we follow the steps below:

Create a new Android app that showcases the library
Create a new library module within the Android app
Write the code for your custom library
Add the library as a dependency to the project
Publish your library to Github
Setup to share your library with any other android project using Jitpack

Create a new Android project

Create a new Android project using the create new project wizard on Android studio. This project will be used to test your library and also for later showcasing it.

Create a new library module

Next is to create a new Android libraray module within the created Android app above.

Right-click the project new -> module then select Android Library.

Give your library a name on the next screen and click finish.

Once the project is done building, we should see our newly created module in the project.

Write library code

Our library for now will have just one class. CentralTendency.java. Create this file in the java folder under the library module.

// contains functions to computer Arithmetic mean, median and mode

public class CentralTendency {
    /**
     * Computes the arithmetic mean of a set of numbers
     * @param numbers
     * @return
     */
    public static Number arithmeticMean(Collection<? extends Number> numbers) {
        //check type of values
        Iterator<? extends Number> iterator = numbers.iterator();
        Number firstNumberInCollection = iterator.next();

        if (firstNumberInCollection instanceof Integer) {
            return computeMeanInt(numbers);
        } else if (firstNumberInCollection instanceof Long) {
            return computeMeanLong(numbers);
        }

        return computeMeanDouble(numbers);
    }

    ...............
    ...............

    /**
     * computes arithmetic mean for a set of Integer values
     *
     * @param numbers
     * @return
     */
    private static Number computeMeanInt(Collection<? extends Number> numbers) {
        double result = 0;
        Iterator<? extends  Number> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            result += iterator.next().intValue();
        }
        return result/numbers.size();
    }
}

Check this github repo for the complete code.

Add the library module as a dependency of the android project

Go to File -> Project Structure, click on the app module and select the Dependencies tab. Use the (+) icon at the bottom of the window to add a new module dependency. Select the newly created library.

Click the ok button when done. The dependency should be automatically added to the app module build.gradle file.

compile project(':statlib')

In the onCreate method of our MainActivity, we add the code to showcase this library.

ArrayList<Integer> numbers = new ArrayList<>();
Random r = new Random();

for (int i = 0; i < 15; i++) {
    numbers.add(r.nextInt(7)+1);
}

double mean = CentralTendency.arithmeticMean(numbers).doubleValue();
double median = CentralTendency.median(numbers);
ArrayList<Integer> mode = CentralTendency.mode(numbers);

Collections.sort(numbers);

String res = String.format("Numbers:\n\n%s\nMean: %.1f\nMedian: %.1f\nMode: %s\n",
                numbers, mean, median, mode);


textView.setText(res);

Publish your library to Github

Now that our app is ready, we need to upload to Github. Init a git repository in the project root, create a new remote git repository on Github and push all committed codes to the remote repo. If you are not familiar with git, you can learn about git here.

Jitpack is an easy to use package repository for Git. It allows you share your library with anyone by just adding the dependency of your library to their projects. We need to setup our library for Jitpack by adding some few lines to our gradle files.

Add the android-maven plugin. In the root build.grade file, add:

buildscript {
 dependencies {
  classpath 'com.github.dcendents:android-maven-gradle-plugin:1.3'

In the library module build.gradle file, add the following below the first apply plugin line:

apply plugin: 'com.github.dcendents.android-maven'  

group='com.github.YourUsername'

Create a Github release or add a TAG In the project root, run the command below to create v1.0 tag for newly created library:

git tag -a v1.0 -m “statlib version 1.0”
git push origin v1.0

Ensure that you have Gradle Wrapper in your repository. If you don’t then create it using the command gradle wrapper and commit it. When this is done, run this command in the project root:

./gradlew install

This will install this library in the local maven repository ($HOME/.m2/repository).

If the build is successful and the project has also been uploded to Github, go to this jitpack url:

//Replace User with your Github username, and Repo with your library repo name

https://jitpack.io/#User/Repo

On the website, select the release you would like to share by clicking the Get It button next to the list of releases of your repository.

Add a README file

Automatically, Github looks for a file names README.md in the root of your project and displays it below. At minimum, the README file should contain the following:

A badge with the status of your library repository.
A line describing how your library can be added to an android project.
Sample code showing how to use the library.
Finally, the library license usage. Check out this link for sample open source licensing.

References

https://jitpack.io/docs/

Using Java 8 Lambda expressions in Android

2016-06-06T00:00:00+01:00

What are Lambda expressions

Lambda Expressions are one of the most important features added to Java 8. Prior to Lambda Expressions, implementing functional interfaces i.e interfaces with only one abstract method has been done using syntax that may seem cumbersome and unclear. In cases like this, what we are trying to do is pass a functionality as an argument to a method, such as what happens when a button is clicked. Lambda expressions enables you to do just that, in a way that is much more compact and clear. In android for example, lambdas can replace anonymous inner class when providing event listeners.

Syntax of Lambda Expressions

A lambda expression consist of the following:

A comma separated list of formal parameters enclosed in parentheses. The data types of the parameters in a lambda expression can be omitted. Also the parenthesis can be omitted if there is only one parameter. For example:

TextView textView = (TextView) findViewById(R.id.text_view);
textView.setOnLongClickListener(v -> System.out.println("Long Click"));

The arrow token ->
A body which contains a single expression or a statement block. If a single expression is specified, the java runtime evaluates the expression and then return its value. To specify a statement block, enclose statements in curly braces "{}"

Lambda Expressions in Android

To use Lambda Expressions and other Java 8 features in Android, you need to use the new Jack toolchain. Open your module level build.gradle file and add the following:

android {
  ...
  defaultConfig {
    ...
    jackOptions {
      enabled true
    }
  }
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

sync your build.gradle file and if you are having any issue with build tools, you may need to update buildToolsVersion in your build.gradle file to "24rc4" or just download the latest Android SDK Build-tools from the SDK Manager, under the Tools (Preview channel).

Example

Adding a click listener to a button

without lambda expression

Button button = (Button)findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Toast.makeText(this, "Button clicked", Toast.LENGTH_LONG).show();
    }
});

with lambda expressions It is as simple as:

Button button = (Button)findViewById(R.id.button);
button.setOnClickListener(v -> Toast.makeText(this, "Button clicked", Toast.LENGTH_LONG).show());

As we can see above, using lambda expressions makes implementing a functional interface clearer and compact. Standard functional interfaces can be found in the java.util.function package [included in Java 8]. These interfaces can be used as target types for lambda expressions and method references.

Another way to have Java 8 features in your Android app is using the RetroLambda plugin. You can check out the RetroLambda github repo here.

References

https://developer.android.com/preview/j8-jack.html#configuration https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Android UI Instrumentation test with Espresso [Tutorial]

2016-06-03T00:00:00+01:00

This tutorial describes how to write instrumentation tests for your Android application. It covers the usage of Espresso to write UI tests and how to run these tests via Android studio.

Why testing?

Writing and maintaining a good test suite containing different types of tests requires a good amount of time and discipline on the part of the developer. However, the benefits that comes with doing this includes the following:

Helps to ensure the correctness of the app features.
Helps to implement new features with confidence that the new changes will not break existing working code.
Facilitates building of app features in modules and iterations especially when tests are first written [TDD], then codes are written to validate the test.

Categories of Android unit tests

Local unit tests: These are tests that runs on the JVM. They do not require any native Android library to run. They are found in app/src/test/java folder in the Project perspective. Unit test should amount to about 60-70% of the test code base.
Integration test: Tests more than one individual module working together that implements a complete functional part of an app. Integration test are located in the app/src/androidTest/java folder and requires the Android system to run. Should amount to about 20% of the test code base.

Espresso is a testing framework contained in the Android Testing Support Library. It provides APIs to simulate user interactions and write functional UI tests.

Espresso tests are written based on what user might do while interacting with your app. Basically, you:

Locate the desired UI element
Interact with the UI element or check its state.

Android Instrumentation tests are located in the app/src/androidTest/java folder and this is the location where you will be writing your tests.

Espresso tests are composed of three major components which are:

ViewMatchers: These are collection of objects used to find the desired view in the current view hierarchy. They are passed to the onView method to locate and return the desired UI element.
ViewActions: They are used to perform actions such click on views. They are passed to the ViewInteraction.perform() method.
ViewAssertions: They are used to assert the state of the currently selected view. They can be passed to the ViewInteraction.check() method.

For Example:

onView(withId(R.id.my_view))            // withId(R.id.my_view) - ViewMatcher
    .perform(click())                  // click() - ViewAction
    .check(matches(isDisplayed()));   //matches(isDisplayed()) - ViewAssertion

Setting up Espresso in your project

Download the latest Android Support Repository via the SDK Manager or Android Studio
Open your app’s build.gradle file, the one located in app/build.gradle and add the following lines inside dependencies:

// Android JUnit Runner
androidTestCompile 'com.android.support.test:runner:0.5'
// JUnit4 Rules
androidTestCompile 'com.android.support.test:rules:0.5'
// Espresso core
androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'

To that same build.gradle file, under android.defaultConfig, add the following:

testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

Sample build.gradle file

apply plugin: 'com.android.application'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        applicationId "com.android.sample.espressouitestsample"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    // App's dependencies, including test
    compile 'com.android.support:support-annotations:22.2.0'

    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile 'com.android.support.test:rules:0.5'

    //Espresso core
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.2'
}

Set up your device for Espresso tests

To ensure that espresso works as expected on your test device or emulator, turn off animations on your device. Navigate to Settings -> Developer Options and turn all the following off under Drawing

Window animation scale
Transition animation scale
Animator duration scale

A sample app showing a SignUp and Login screen will be used to demonstrate the basic concepts of Espresso. To follow through with the snippets in the following section, please clone this git repository. git clone git@github.com:mayojava/espressoUIIntegrationTest.git

Now let’s dive in

The sample code has a main screen with a Login and SignUp button. The first test we will be looking at, is to check that the SignUp screen shows up when the SignUp button is clicked. In the androidTest folder, open the app/src/androidTest/java/.../mainscreen/MainScreenTest.java file. The first thing to notice here are the annotations:

@RunWith(AndroidJUnit4.class): Tags the class as an Android JUnit4 class. Espresso unit test should be written as a JUnit 4 test class.
@LargeTest: Qualifies a test to run in >2s execution time, makes use of all platform resources, including external communications. Other test qualifiers are @SmallTest and @MediumTest.
@Rule: ActivityTestRule and ServiceTestRule are JUnit rules part of the Android Testing Support Library and they provide more flexibility and reduce the boilerplate code required in tests. These rules provides functional testing of a single activity or service respectively.
@Test: Each functionality to be tested must be annotated with this. The activity under test will be launched before each of the test annotated with @Test.

To test that the Signup screen shows up when the Signup button is clicked, we do the following:

Locate the Signup button using the withId ViewMatcher.
Perform a click() action on the button.
Assert that the Signup screen is displayed.

The code for the steps above is shown in the snippets below:

    @Test
    public void clickSignUpButton_opensSignUpScreen() {
        //locate and click on the login button
        onView(withId(R.id.button_sign_up)).perform(click());

        //check if the sign up screen is displayed by asserting that the first name edittext is displayed
        onView(withId(R.id.edit_text_first_name)).check(matches(allOf(isDescendantOfA(withId(R.id.layout_sign_up)), isDisplayed())));
    }

Next open the SignUpScreenTest.java file under app/src/androidTest/java/.../signup/SignUpScreenTest.java. Here we want to test that on filling the signup form and clicking the Signup button, the Success screen is displayed with the signup success text, when the signup is complete.

The code for the test above, follow the following steps:

Locate each of the sign up form text fields using the withId ViewMatcher.
Perform typeText() action on each, to type in the text for that field.
Locate sign up button and perform the click() action on the button to submit the form.
On sign up completion, assert that the sign up success screen is displayed with the success text.

The code for the steps above is shown below:

@Test
public void clickSignUpButtonAfterFillingForm_showProgressAndSuccessScreen() {
    String first_name = "Firstname";
    String last_name = "lastname";
    String emailAddress = "firstname.lastname@g.com";
    String password = "password";

    //find the firstname edit text and type in the first name
    onView(withId(R.id.edit_text_first_name)).perform(typeText(first_name), closeSoftKeyboard());

    //find the lastname edit text and type in the last name
    onView(withId(R.id.edit_text_last_name)).perform(typeText(last_name), closeSoftKeyboard());

    //find the email address edit text and type in the email address
    onView(withId(R.id.edit_text_email)).perform(typeText(emailAddress), closeSoftKeyboard());

    //find the password edit text and type in the password
    onView(withId(R.id.edit_text_password)).perform(typeText(password), closeSoftKeyboard());

    //click the signup button
    onView(withId(R.id.button_sign_up)).perform(click());

    //check that we can see the success screen with success message
    String successString = InstrumentationRegistry.getTargetContext().getString(R.string.text_sign_up_successful);
    onView(withId(R.id.text_view_status_message)).check(matches(allOf(withText(successString), isDisplayed())));
}

For a list of possible ViewMatchers, ViewActions and ViewAssertions check out the Espresso Cheat Sheet

Running Espresso tests

To run a single test class, right click on the test class file and select the ‘Run [TestFileName]’ option.

To run many different tests at the same time, you will need to create a build configuration. This can be done easily in Android Studio by right clicking on the package name under androidTest /java/.. and select “Create Tests in [package name]” option.

Select the new run configuration from the run configuration menu and select run. Tests results are displayed in the run panel at the bottom of the screen.

References and further readings:

The sample code for this post can be found in this github repo.

Mayowa Adegeye

AnimatedVectorDrawable XML Bundles

References

Android support Annotations

Adding the Library to your project

Nullness Annotations

Resource Annotations

Thread Annotations

Value Constraints Annotations

CheckResult Annotations

Conclusion

References

Bottom Sheets in Android

Creating a Persistent Bottom Sheet

Creating a Modal Bottom Sheet

Conclusion

References

Creating and sharing your own Android Library

Create a new Android project

Create a new library module

Write library code

Add the library module as a dependency of the android project

Publish your library to Github

Setup and share your library through Jitpack

Add a README file

References

Using Java 8 Lambda expressions in Android

What are Lambda expressions

Syntax of Lambda Expressions

Lambda Expressions in Android

Example

References

Android UI Instrumentation test with Espresso [Tutorial]

Why testing?

Categories of Android unit tests

Setting up Espresso in your project

Sample build.gradle file

Set up your device for Espresso tests

Now let’s dive in

Running Espresso tests

References and further readings: