Android on Piotr Wittchen

Creating a fat AAR

Tue, 02 Oct 2018 00:01:31 +0000

I recently wrote a new library called NeuroSky Android SDK. It’s used for writing Android apps using signals of the brain waves received from the NeuroSky MindWave Mobile headsets. Probably I’ll write a separate article about it because it’s quite interesting topic. This library uses ThinkGear library, which is distributed by the NeuroSky as a *.jar file, so I couldn’t use it as a Gradle or Maven dependency in my project and I had to put this *.jar file into the lib directory and link it in the build.gradle file. Moreover, I wanted to create a library, which can be added to the project as a single Gradle dependency without messing around with additional *.jar files or custom configuration. Due to this fact, I decided to create a fat *.aar file and deploy it to the Maven Central repository. For those who are not familar with Android, *.aar is an Android version or *.jar file, which can be used as library in the project. I didn’t want to reinvent the wheel, so I searched for the different solutions. Unfortunatey, a few of them didn’t work, but luckilly I’ve found what I wanted. It’s fat AAR Gradle Plugin developed by Mobbeel company.

Writing my first library in Kotlin

Sun, 19 Aug 2018 10:24:19 +0000

Introduction

Recently, I decided to create a tiny Android library called RxBattery, which is monitoring battery state of the device with RxJava and RxKotlin. I created a few Java and Android libraries already and this time I decided to use Kotlin programming language instead of Java to learn something new and write something more complicated than “Hello World” app. Here are my observations.

Build System

I used Gradle to build the project. It’s popular for JVM and Android apps nowadays and works fine with Kotlin. I just needed to add Kotlin Gradle Plugin and Kotlin STD Lib to the /library/build.gradle file to the classpath dependencies in buildscript section. I also needed to define sourceSets to allow IntelliJ and Android Studio recognize directories with sources.

Solving problems with AVD and KVM on Linux

Thu, 16 Aug 2018 22:01:06 +0000

I installed Android SDK and Android Studio on my new ThinkPad T470s with Ubuntu Linux 18.04.1 LTS. As usual, I wanted to create a new Android phone emulator called AVD (Android Virtual Device). I was able to create a new device, but unfortunately I encoutered problems. After opening AVD window, I saw the error message…

/dev/kvm is not found

KVM (Kernel-based Virtual Machine) is a full virtualization solution for Linux on x86 hardware containing virtualization extensions (Intel VT or AMD-V). In order to enable KVM, I needed to restart the computer and enter the BIOS by pressing F1 key before the system boot. Next, I entered Security tab and enabled Intel Virtualization Technology and Intel VT-d Feature. Now, I could press F10 to save, exit nad restart the computer. Unfortunately, that wasn’t the end of the story. I saw another error message…

Releasing ReactiveNetwork v. 1.0.0 (paying the technical debt)

Sun, 24 Jun 2018 23:39:18 +0000

Today, I’ve released next version of my most popular open-source project - ReactiveNetwork. I’ve released version 0.12.4 for RxJava1.x and version 1.0.0 for RxJava2.x. Please note, RxJava1.x is no longer officially supported and I’m going to follow the same approach in my RxJava-based projects. It’s not the first release of this project, but I’m breaking the API and removing existing methods, so I decided to stick to proper versioning standard. I didn’t always do it properly in the past, but it’s never too late.

Debugging Google Pixel 2

Wed, 20 Jun 2018 23:05:56 +0000

I recently destroyed my good old Nexus 6 phone. It’s still working, but display screen is broken. Due to this fact, I’ve had an excuse to buy new Pixel 2 phone. It’s pretty expansive, but its quality is really good. As usual, I wanted to debug an app on this device and encountered problem related to device permissions.

Once I connected the phone, to my laptop and typed adb devices, I’ve seen the following message:

Introducing ReactiveBus

Sun, 11 Mar 2018 20:02:45 +0000

Today, I’ve released my another tiny project. It’s a very simple implementation of Event Bus with RxJava 2 under the hood. This library is compatible with Java 1.7 or higher. I didn’t use Java 1.8 or 1.9 because I wanted to make it compatible with Android apps.

You can use it as follows:

Bus bus = ReactiveBus.create();

Disposable observer = bus.receive().subscribe(new Consumer<Event>() {
    @Override public void accept(Event event) {
      // handle event here
    }
  });

Once, we created Event Bus object and our observer (or more precisely: disposable subscriber), we can start sending events:

DroidCon Poland 2017 - Is your app really connected?

Sat, 02 Dec 2017 01:39:00 +0000

Yesterday, I gave a presentation about connectivity in the Android apps during the DroidCon Poland 2017 Conference in Kraków.

Below, you can see slides from this presentation.

View slides on SpeakerDeck

There’s also tweet related to this presentation from DroidCon Kraków:

Piotr Wittchen tells us about how we can we keep the track of network 🌎 or Internet connectivity changes in our app 📱🆘🙂 pic.twitter.com/7YGGzNJeb2
— droidcon Kraków (@droidconkr) December 2, 2017

I hope, you enjoyed it. Any kind of feedback is welcome (in the comments below this article or via e-mail). Don’t forget to check ReactiveNetwork library I mentioned during the presentation.

Simple reactive HTTP client and server with RxJava, Vert.x and Android

Thu, 09 Nov 2017 22:30:00 +0000

During Hack Your Career event at the Silesian University of Technology, I’ve prepared a presentation titled Reactive Programming - Efficient Server Applications with a colleague from work. Arek told about theory of Reactive Programming, shown basic concepts, data types and a few examples in the code. During my part of the presentation, I’ve wrote a very simple server and client in Java (9 on the server, 7 on the client) with Vert.x (Core and Rx), RxJava 2, OkHttp 3, Android and RxAndroid. Presentation was targeted mainly to the university students with no experience with reactive programming, but it was an open event and anyone could attend it. Below, we can see a very simple code snippet showing how to create a reactive HTTP server with Vert.x. We can create a stream of requests, make Flowable out of it, apply any kind of RxJava 2 operator including backpressure handling and subscribe the stream. Moreover, we can also reactively start the server with rxListen(int port) method. This is just a basic example, where will be sending request to the only one endpoint. In the case, when we want to handle more endpoints, we can use vertx-web library and design REST API.

Integrating ErrorProne and NullAway with an Android project

Fri, 15 Sep 2017 18:39:00 +0000

Recently, with the remote help of guys from Uber in California, I integrated NullAway and ErrorProne with the one of my open-source Android projects.

What is NullAway?

Basically, it’s a tool to help eliminate NullPointerExceptions (NPEs) in your Java code. It detects situations where NPE could occur at the compile time. Let’s have a look at the following code:

static void log(Object x) {
    System.out.println(x.toString());
}
static void foo() {
    log(null);
}

NullAway will find out that we’re passing null and we’ll get appropriate error message:

Introducing ReactiveAirplaneMode

Tue, 15 Aug 2017 19:28:00 +0000

I’m continuing Rxfication of the Android. Recently I released brand new library called ReactiveAirplaneMode. As you may guess, it allows listening Airplane mode on Android device with RxJava observables. A usual I’ve hidden all implementation details, BroadcastReceivers and rest of the Android related stuff behind RxJava abstraction layer, so API is really simple. Just take a look on that:

ReactiveAirplaneMode.create()
    .observe(context)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(isOn -> textView.setText(String.format("Airplane mode on: %s", isOn.toString())));

In the code above subscriber will be notified only when airplane mode changes. If you want to read airplane mode and then listen to it, you can use the following method:

Releasing ReactiveNetwork v. 0.11.0

Sun, 06 Aug 2017 06:38:00 +0000

In the latest release of ReactiveNetwork library, I focused on Walled Garden AKA Great Firewall support during checking Internet connectivity. There are countries with limited Internet access like China and in such cases, pinging commonly known host like www.google.com may have different results than in other countries because it may be blocked. We may get false positive results because users will generally have an access to the Internet, but they don’t have access only to several websites. To solve that problem, I created WalledGardenInternetObservingStrategy and made it default strategy for checking Internet connectivity inside the library. Of course, you can still use SocketInternetObservingStrategy if you want to. Detailed release notes are as follows: RxJava1.x

Releasing ReactiveNetwork v. 0.10.0

Thu, 20 Jul 2017 20:02:00 +0000

I’ve recently released ReactiveNetwork library v. 0.10.0 for RxJava1.x and RxJava2.x. ReactiveNetwork is an Android library listening network connection state and Internet connectivity with RxJava Observables, which I’m developing for approximately 2 years now. In this version, I’ve done a few bug fixes and added new features for RxJava2.x version. Below, you can find the release notes: Release for RxJava1.x

bumped RxJava1 version to 1.3.0
bumped test dependencies
created Code of Conduct
updated Kotlin version in sample apps
added retrolambda to the sample Java app - issue #163
fixed behavior of network observing in disconnected state - issue #159

Release for RxJava2.x

Release of prefser v. 2.1.0 with RxJava2 support

Mon, 19 Jun 2017 16:56:00 +0000

I’ve recently released new version of prefser library for Android. In case you don’t know, it’s a wrapper for Android SharedPreferences with object serialization and RxJava Observables. This version has the new artifact, which has codebase migrated to RxJava2.x. As usual, I kept backward compatibility with RxJava1.x. You can find more details about the project at https://github.com/pwittchen/prefser. If you want to use it in your mobile project, you need the following dependencies in the build.gradle file:

Releasing Prefser v. 2.0.7

Sun, 28 May 2017 20:48:00 +0000

I’ve recently released new version of Prefser. It’s a wrapper for Android SharedPreferences with object serialization and RxJava Observables. The new version number is 2.0.7. In this release, I performed mostly internal work not related to the external library API. Nevertheless, it’s important for the library development in the future. The following things were done:

updated dependencies
updated Gradle configuration
migrated unit tests to Robolectric
started executing unit tests on Travis CI
added integration with codecov.io and coverage report
extracted code related to accessors from the Prefser class (refactoring library internals)

Organizational work is done and now I’m ready for migration to RxJava2 in this project on a separate branch. I want to keep backward compatibility with RxJava1 as in my other projects. This update is planned for version 2.1.0. Stay tuned!

ReactiveNetwork - release v. 0.9.0 with RxJava2.x support

Tue, 11 Apr 2017 06:04:00 +0000

This time, I upgraded my another reactive Android open-source project called ReactiveNetwork to RxJava2.x. Many thanks goes to @tushar-acharya who performed initial migration to the newer version of RxJava. During migration, I’ve also created new package rx2 to avoid potential import conflicts during migration inside Android apps. Besides migration, I’ve updated sample apps, documentation & JavaDocs on Github pages. You can still use RxJava1.x version and it’s available on the branch with that name. To use brand new ReactiveNetwork compatible with RxJava2.x, add the following dependency to your build.gradle file:

ReactiveBeacons - release of v. 0.6.0 with support for RxJava2

Mon, 03 Apr 2017 18:20:00 +0000

Thanks to @BugsBunnyBR I released new version of ReactiveBeacons library with the RxJava2.x support. It’s an Android library scanning BLE (Bluetooth Low Energy) beacons nearby with RxJava Observables. I also kept backward compatibility with RxJava1.x. Different versions of the libraries are located on the separate git branches. It’s a similar approach to original RxJava project. I have separate builds on Travis CI, separate artifacts and JavaDocs. Such approach generates more overhead, but in such case, RxJava1.x can be kept in a maintenance mode and RxJava2.x can be a subject of the future development. What has been done in this version?

Handling different Android versions with strategy pattern

Sun, 26 Mar 2017 22:39:00 +0000

When we’re developing Android apps, we have to remember that different users have different versions of the Android OS. Unfortunately, not all of them has the newest version of the system and some of them have older devices with older systems. Some of these devices may be even unsupported because e.g. Google supports their devices like Nexus and Pixel for only 2 years. When we want to reach as many users as possible and make the app available for almost everyone, we have to handle different Android versions. One of the solutions for that problem is strategy design pattern (it’s also called Policy in Domain-Driven Design). I’m developing an Android open-source library called ReactiveNetwork, which is used for monitoring connectivity with the network in the system. Network monitoring strategies vary between different versions of Android and I wanted to choose an appropriate strategy for appropriate Android version. To do so, I’ve created NetworkObservingStrategy interface:

Android design inspirations

Sun, 19 Mar 2017 19:51:00 +0000

When we are planning to create our next Android app, besides the codebase, it’s also good to plan its design, UI, and UX. Before doing that, we can take a look at some inspirations and work of other people to gather a few UI design patterns, inspirations, and ideas. Good resource of such inspirations is Android Niceties website. As the authors write, this website is a collection of screenshots encompassing some of the most beautiful looking Android apps. You can also take a look at [https://pl.pinterest.com/explore/android-ui/](http://android-ui tag on Pinterest). Do you know any other similar resources? Share them in comments :-).

Unit test coverage report with Travis CI for Robolectric on Android

Sun, 19 Mar 2017 19:32:00 +0000

Introduction

Some time ago, I’ve written an article about Test coverage report for Android application. It got some interest (many comments below article and many visits according to Google Analytics), so I decided to refresh this topic. Previously, I’ve written instrumentation unit tests, which needed to be executed on a real device or an emulator. It’s a good approach when you want to test functionalities strongly connected with the device. E.g. when you want to test operations on a real SQLite database or something like that. Nevertheless, this approach has huge disadvantages. It’s hard to run tests on the Continous Integration server because we need to have the emulator or device up & connected all the time and also tests need to interact properly with the device to get passed what is not so easy. In most cases, mocking part of the application’s behavior is enough. In that case, we can easily run tests on a CI server and have deterministic test results. In order to do that, we can use Robolectric.

ReactiveNetwork - release of v. 0.2.0

Thu, 11 Feb 2016 19:19:00 +0000

I’ve recently released new version of ReactiveNetwork library for Android. Here are the fresh release notes for version 0.2.0:

added possibility to observe WiFi signal level with observeWifiSignalLevel(context, numLevels) and observeWifiSignalLevel(context) method
created WifiSignalLevel enum
added internet check to parameters of getConnectivityStatus(context, checkInternet) method
made getConnectivityStatus(context, checkInternet) method public
changed String variable status in ConnectivityStatus enum to description and made it public
changed output of the toString() method in ConnectivityStatus to keep consistency with another enum
made ReactiveNetwork class non-final
bumped Kotlin version in sample app to 1.0.0-rc-1036
increased immutability of code of the library
updated sample apps and documentation

Thanks to @llp and his Pull Request, we are able to observe WiFi signal level AKA RSSI now!

Reactive Live Coding during GDG DevFest 2015 in Poland

Sun, 29 Nov 2015 20:16:00 +0000

I was asked to be a speaker during GDG DevFest 2015 conference in Warsaw, Poland. Of course, I accepted this invitation and prepared presentation titled “Reactive Live Coding”. Presentation covered basics of Reactive Programming, RxJava and RxAndroid. Besides my talk I’ve done live coding to show how to use mentioned libraries and basics principles of Reactive Programming in real life. I had only 20 minutes for all of that, so my time-box was very limited. Being a speaker at conference was really interesting and challenging experience, which I haven’t had before. Moreover, I could meet a lot of interesting people and hear very inspiring talks covering different topics. You can check activity from conference by browsing #devfest15pl hashtag on Twitter and Facebook event. You can also check official website of the conference at devfest.pl. Slides from my presentation are available below.

New release of Kirai - elegant string formatting library for Java

Sun, 22 Nov 2015 20:34:00 +0000

I’ve recently released version 1.4.0 of Kirai library. Kirai means phrase in Swahili language. It’s string formatting library written in Java. It originally started as an Android library, but it evolved to pure Java library. It’s first possibilities were basic string formatting and text formatting for Android TextViews. Now, it allows to format strings for Java, Web, Android and even Unix Terminal! Have you ever wanted to have colorful and styled text in your mobile app, website or terminal app? Now you can with an elegant and fluent API! Moreover, I’ve added test coverage supported by codecov.io. It’s really nice service, which integrates with Travis CI and is free for open-source projects. It’s available for various programming languages and build systems. Check library source code and samples at: https://github.com/pwittchen/kirai.

Bunch of updates in my OSS for Android

Sun, 08 Nov 2015 16:53:00 +0000

Introduction

In the last days I prepared a bunch of updates in my open-source software for Android. Most of them are bug fixes and are related to increasing robustness of the projects as well as their overall quality. I also decided to play a little with Kotlin language from JetBrains, which seems to be reasonable choice for mobile applications running on Android. Nevertheless, writing an app in Kotlin requires some additional configuration and we should remember, it’s still in beta version. If you are interested in Kotlin programming for Android, take a look at Getting started with Android and Kotlin guide from official Kotlin website. You can also take a look at one of my sample apps written in Kotlin and its configuration in Gradle.

Introducing ReactiveBeacons

Wed, 30 Sep 2015 19:49:00 +0000

Recently, I’ve created yet another reactive library for Android. It’s called ReactiveBeacons and it’s responsible for observing BLE (Bluetooth Low Energy) beacons. Beacons are small devices, which became quite popular in the last years. They can be utilized in creating Contextual Awareness, Contextual Computing and Internet of Things. Beacons have lithium battery, are constantly turned on and emit signals via Bluetooth all the time. ReactiveBeacons library allows to transform these signals into Observable stream compatible with RxJava. Whenever new beacon is detected or RSSI (Received signal strength indication) changes, new immutable beacon data is emitted.

Introducing ReactiveSensors

Sat, 05 Sep 2015 20:03:00 +0000

Another month, another library. Recently, I’ve released yet another reactive library called ReactiveSensors. It’s an open-source Android library monitoring hardware sensors with RxJava Observables. Library is compatible with RxJava 1.0.+ and RxAndroid 1.0.+ and uses them under the hood.

Library is available at: https://github.com/pwittchen/ReactiveSensors.

In my opinion, hardware sensors are perfect case for applying RxJava, because in fact we’re constantly receiving a stream of events emitted by many sensors. With Reactive Programming approach we have plenty of possibilities and easy API for manipulating received sensor’s data.

Learning Android and being up to date

Sat, 22 Aug 2015 18:09:00 +0000

Recently a few people asked me, what are my methods for gathering knowledge and being up to date with all news connected with Android. I didn’t really think about that. I just grabbed all knowledge from a various places and then tried to use it in practice. I decided to sum everything up and create a collection of my knowledge resources. Of course, we are not able to use all of that every day, because it’s too much, but it’s good to know where we can find something interesting. Android is very dynamic mobile platform, which changes really fast. It’s hard to be up to date with all of new features and programming techniques. That’s why it’s worth to find places where we can gather interesting information. Below, I collected some resources, links and information, which I find useful for learning Android & Java and being up to date with Android development.

Introducing ReactiveNetwork

Mon, 10 Aug 2015 21:52:00 +0000

I’ve recently released ReactiveNetwork. It is an open-source Android library listening network connection state and change of the WiFi signal strength with RxJava Observables. It’s a successor of Network Events library rewritten with Reactive Programming approach.

Library is compatible with RxJava 1.0.+ and RxAndroid 1.0.+ and uses them under the hood. Min Android SDK version is 9. JavaDoc can be found at: http://pwittchen.github.io/ReactiveNetwork. Repository is available at: https://github.com/pwittchen/ReactiveNetwork.

This library is much simpler and easier to use than NetworkEvents. Even code-base is much smaller, but we have to remember that it utilizes powerful RxJava and RxAndroid. RxJava hase huge API and gives a lot of possibilities. That’s why I was able to obtain desired result with fewer lines of code.

Releasing prefser 2.0.0

Thu, 06 Aug 2015 22:34:00 +0000

I’ve recently released Prefser library v. 2.0.0. Prefser is a wrapper for Android SharedPreferences with object serialization and RxJava Observables. This update couldn’t be done without help of awesome open-source community and people who reported new issues and created pull requests. Thanks for that! A lot of issues related to RxJava was fixed. Moreover, now we can store and retrieve lists of objects of any type with Prefser. Examples of library usage can be found in README.md file and in unit tests covering 96% of the code. Below, you can find release notes for this version of the library:

Releasing NetworkEvents 2.0.0

Fri, 31 Jul 2015 09:28:00 +0000

I’ve recently released NetworkEvents library v. 2.0.0. It’s an Android library listening network connection state and change of the Wifi signal strength. It has a few significant changes in the API and new features, which people were requesting on GitHub. Moreover, codebase was slightly refactored and updated. I’m going to keep major.minor.patch convention AKA semantic versioning now:

major - new feature or update - backward incompatible
minor - new feature - backward compatible
patch - bug-fix - backward compatible

A few changes are backward incompatible, so I’ve increased major number. Below, you can find list of changes. As you can see, there is a lot of stuff. That’s why I’ve made the most important changes bold.

Releasing Weather Icon View v. 1.0.0 for Android

Tue, 21 Jul 2015 17:34:00 +0000

Today I released Weather Icon View library v. 1.0.0 It’s very simple and easy to use Android library, which allows you to use Weather Icons created by Erik Flowers in your mobile applications. This library was already available on GitHub as I wrote in one of my previous posts, but today it was released to Maven Central Repository and you can use it as Maven or Gradle dependency. I was encouraged to make this project more available by the open-source community and people who find it useful as I could read in the issue reported on the repository website. Thanks for that. You can find more details, usage examples and sample app in the repository of the project at: https://github.com/pwittchen/WeatherIconView.

Releasing prefser v. 1.0.5

Thu, 18 Jun 2015 20:46:00 +0000

I am happy to announce that I released version 1.0.5 of Prefser Android library. Prefser is a wrapper for Android SharedPreferences with object serialization and RxJava Observables. What has been done in this version:

Removed final keyword from Prefser class in order to allow class mocking thanks to @plackemacher
Removed unused imports from Prefser class
Added test coverage report generation
Increased test coverage to 100%
Added abstraction for JsonConverter and default GsonConverter
Added getAndObserve(...) method
Emiting current value right on subscription to Observable with getAndObserve(...) method, which is idea provided by @semanticer. Thanks!
Added GitHub pages with generated JavaDoc documentation on gh-pages branch available at: http://pwittchen.github.io/prefser

Moreover you can browse auto-generated reports:

Test coverage report for Android application

Wed, 03 Jun 2015 18:22:00 +0000

Update: see newer article about Unit test coverage report with Travis CI for Robolectric on Android. For a long time, I wasn’t able to find the right way to generate test coverage reports for Android instrumentation unit tests created with AndroidJUnit4 runner. In the past I’ve found many solutions, but none of them was working or they were compatible only with Robolectric, which I currently don’t use. Other developers also stopped using it for the new projects. E.g. Sqlbrite from Square is using AndroidJUnit4 runner as my projects do. Recently, I’ve found an interesting discussion on Reddit, where we can find information about enabling test coverage very easily without additional plugins, scripts and many lines of configuration. Moreover, Android SDK currently has built-in support for Emma Test Coverage, what we can read in official documentation. Basically, the only thing we need to do, is to apply jacoco-android plugin in build.gradle file:

Static code analysis in Android project

Thu, 26 Mar 2015 00:23:00 +0000

Overview

I’ve recently read great article telling how to improve quality and syntax of your Android code by Vincent Brison. It presents how to use tools like Checkstyle, Findbugs, PMD, and Android Lint for Static Code Analysis in Android project. Static Code Analysis allows us to keep consistency of the source code style and helps us to find errors, warnings, possible bugs, bottlenecks and ways to improve the projects. I highly recommend to use tools like those mentioned.

Mockito on Android

Sun, 15 Mar 2015 15:44:00 +0000

Overview

When we write unit tests for an Android application, sometimes there’s a necessity to mock some classes or interfaces. Instead of writing implementations dedicated for unit tests by hand, we can use Mockito library. We can read article about Mockito on Android on Square’s blog. Mockito can make our tests cleaner and better. It can be used both in classic Java projects and Android projects. It’s one of the most popular mocking framework in Java and if you’re a Java developer who writes unit tests and tries to apply TDD approach, you should be familiar with it.

Introducing prefser

Sun, 22 Feb 2015 22:39:00 +0000

I’ve recently released Prefser, which is a wrapper for Android SharedPreferences with object serialization and RxJava Observables. Prefser wraps SharedPreferences and thanks to Java Generics provides you simpler API than classic SharedPreferences with only two methods:

void put(String key, Object value);
<T> T get(String key, Class classOfT, T defaultValue);

Classic SharedPreferences allows you to store only primitive data types and set of strings. Thanks to Gson serialization, Prefser allows you to store:

Primitive data types (boolean, float, int, long, double)
Strings
Custom Objects
Lists
Arrays
Sets

In addition, Prefser transforms OnSharedPreferenceChangeListener into Observables from RxJava:

Unit Testing Support for Android Studio 1.1

Sun, 15 Feb 2015 12:53:00 +0000

As official Android website says:

Version 1.1 of Android Studio and the Android gradle plugin brings support for unit testing your code. This feature is still considered experimental, we encourage you to try it and file any bugs you find in our bug tracker.

It’s great news, because now we can write Unit Tests with JUnit 4.12 without any “hacks” or tricky configuration, which had to be done earlier. We can execute two kinds of tests:

NetworkEvents v. 1.0.2

Sun, 15 Feb 2015 00:16:00 +0000

I’ve recently released NetworkEvents v. 1.0.2. In case, you don’t know it, it’s an Android library listening network connection state and change of the Wifi signal strength. This version has small improvements:

Updated ping method in NetworkHelper class.
Detection of Internet access in WiFi network works faster and is more reliable.
Added example of usage of NetworkEvents with Dagger in example-dagger directory in the repository of the project.

Right now, we check Internet connection in a different way. Instead of sending HEAD or GET request to a specific website like www.google.com, we just ping 4.2.2.2 IP address. If you want to know why, read an article about 4.2.2.2: The Story Behind a DNS Legend.

Hello Kotlin!

Sat, 07 Feb 2015 18:59:00 +0000

I’ve recently played with Kotlin in order to create simple “Hello World” Android app using this new, fancy language from JetBrains. Kotlin is another programming language based on JVM, which can work with Java. It’s aim is to reduce code boilerplate and create projects faster. In my simple Android project, I’ve also used KotterKnife for injecting views. I’ve also added one simple ActivityUnitTestCase. Unfortunately, I couldn’t convert it into Kotlin, because I wasn’t allowed to call constructor of inherited class using super() method. You can read related StackOverflow thread in order to view more details. In order to use Kotlin, I followed instructions from article on JetBrains blog. I’ve also needed Kotlin plugin for Android Studio.

Introducing NetworkEvents

Sat, 31 Jan 2015 20:35:00 +0000

I have released NetworkEvents library for Android. It’s a wrapper for system Broadcast Receivers built with Otto library. It allows you to listen change of connectivity status (connected to WiFi network with or without Internet access, mobile network, off-line) and change of the WiFi signal strength very easily with @Subscribe annotation. The only thing you need to do, is to create Bus and NetworkEvents objects, register them in onResume() method and unregister them in onPause() method in your activity. After that, you can subscribe for the events you want to listen. Of course, remember to give your app appropriate permissions in AndroidManifest.xml file. In contrast to Broadcast Receivers available in Android SDK, NetworkEvents sends only one event per one occurrence of this event. Android Broadcast Receivers have a bug, which causes sending multiple Intents even if only one event occurred. This behavior may vary on different devices. Regardless of this fact, this bug was handled by NetworkEvents and you shouldn’t encounter that problem while using this library. Important facts:

Android resource converter

Sat, 17 Jan 2015 00:19:00 +0000

In international projects sometimes there’s a need to send resource files to the client in order to have translated strings. Client doesn’t have to understand XML notation and editing two or more files at the same time is inconvenient. It’s easier to send file which can be edited in MS Excel or Libre Office Calc. I’ve created Python scripts, which are able to convert Android xml resources with translations to a single *.csv file ready to open in software for common users. In addition, there’s another script, which can generate xml resource files with translations from *.csv file. Generating *.csv file from resources is easy:

Kirai - flavored Android string formatting library

Tue, 13 Jan 2015 19:12:00 +0000

Overview

Recently I’ve developed and realased to Maven Central Repository Kirai, which is flavored Android string formatting library. Kirai means phrase in Swahili language. Project is inspired by phrase, TaggerString and BabushkaText. Kirai has fluent API similar to phrase with additional formatting similar to TaggerString and allows to add formatted pieces of text like BabushkaText. Development including writing Unit Tests took me about 2 days. Deployment and release to Maven Central Repository took me about 2 days as well. It was my first deployment, so it wasn’t so easy, but people from Sonatype are helpful, problems were solved very quickly and release went quite smooth.

Detecting swipe gesture in mobile application

Thu, 25 Dec 2014 15:59:00 +0000

Introduction

Update: Swipe Detector project is now called swipe.

Some time ago, I needed to detect moment when user is swiping finger on the screen horizontally (from left to right or opposite) or when user swiped horizontally. I’ve decided to spend some time for analyzing [onTouch(MotionEvent event)](http://developer.android.com/reference/android/view/View.OnTouchListener.html#onTouch(android.view.View, android.view.MotionEvent)) and dispatchTouchEvent(MotionEvent event) method. We can read more about differences between triggering onTouch eventes on StackOverflow thread. Method like onTouch(MotionEvent event) allows to trigger any touch event, but it doesn’t allow to detect type of that event. Android API has GestureDetector class, which allows to detect long press and double tap events. There is also GestureDetector.OnGestureListener interface, which has the following methods:

Installing release and debug version of app on a single device

Thu, 25 Dec 2014 15:15:00 +0000

Introduction

During software development process developers and QAs may want to have installed release and debug version of the app on a single device, what can be very helpful when they want to develop and use application at the same time. Another advantage is the fact that debug and release version of the app may need different configuration. It this post I will show you an example in which we are changing application name and launcher icon, but we can also change different values during compilation in the same way (e.g. address of the webservice). Some time ago, I’ve created similar template, but it was using older version of Build Tools, Android SDK and Android Studio. I’ve created new template, with the newest version of Android Studio (1.0.2) and newest version of Build Tools (1.0.0), so in that case, build.gradle file is smaller and simpler, but does its work correctly.

Square is advocating against fragments

Sun, 12 Oct 2014 18:58:00 +0000

Recently, Square engineers confirmed my doubts I always had about fragments. I definitely knew that something was wrong with them, but Google introduced fragments into Android API, so I thought it must be okay for some reason and I tried to live with them feeling pain. Finally, concrete company have written an article criticizing Android Fragments and I totally agree with them. Read the article at: http://corner.squareup.com/2014/10/advocating-against-android-fragments.html.

Different build config for debug and release version of the Android app

Wed, 08 Oct 2014 17:52:00 +0000

Sometimes we may want to set different address of the back-end web service for debuggable and release version of our Android app. E.g. predefined static host and port for release version of the application and our local IP address and predefined port for debuggable version of the application. In second case, we can deploy back-end webservice on our local machine for testing purposes. We can customize all of that in build.gradle file. We can use variant.buildType.isDebuggable() instruction to check build type of the app. I described way of Updating Android XML resources before compilation via Gradle in one of my previous posts, so you can check it if you don’t understand replaceBackendAddressInResources(variant, host, port) method. After proper configuration, setting of the back-end url is straightforward. Please check the code between // configuration of the back-end address - begin and // configuration of the back-end address - end comments.

Weather Icons for Android applications

Thu, 02 Oct 2014 21:18:00 +0000

Some time ago I found Weather Icons project by Erik Flowers. It’s customized font with appropriate CSS, which allows you to use weather icons on the website. In addition, those icons can be customized. They can have different size or color. Moreover, they are compatible with the Bootstrap. I thought, that it would be nice, if I had something like that for Android applications. That’s why I created simple open-source project called Weather Icon View. It’s customized view for Android, which allows you to use weather icons in mobile apps in similar way as in web apps. When you add mentioned library to your project, you can use it in XML layout in the following way:

Micro-location based on WiFi Access Points

Sun, 21 Sep 2014 13:16:00 +0000

Introduction

Recently, I started working on quite interesting project. One of its elements is micro-location inside the building based on WiFi Access Points. Company’s buildings have a lot of Access Points in different locations like regular rooms, conference rooms, corridors, sports building and restaurant. Having pool of Access Points with their names, locations and MAC addresses (or more precisely: BSSID) it’s possible to create micro-location for Android mobile devices.

Overview

On the image below, you can see approximate location of WiFi Access Points in the F3 building of Future Processing company. Other buildings also have their own Access Points, but they weren’t taken into consideration during the initial experiment. Android gives us possibility to scan available WiFi Access Points and measure their signal strength. Appropriate BroadcastReceiver allows us to react on event of changing WiFi Access Points signal strength, what can be interpreted as movement of person having mobile device. When such event occurs, we can read list of available Access Points, measure their signal strength, detect Access Point with the strongest signal, map it to specific room location and start WiFi scan again in order to retrieve fresh list of the Access Points as soon as possible. We have to remember that WiFi scanning is an asynchronous operation, so we don’t know, when we receive the results. That’s why event-driven development is good approach in such case. We can use pure Android BroadcastReceiver or use Otto Event Bus to make our code annotation-based, fine-grained and clear.

Versioning Android applications

Sat, 13 Sep 2014 12:49:00 +0000

When we work in a team projects, our code constantly changes and being tested. Often some bugs occur in a specific version of application and no longer exists in next version of the project, because one programmer might fixed the bug according to the Boy Scout Rule and this is good. Nevertheless, sometimes we need to write documentation and check in which version bug occurred to be sure, that it was really fixed. In addition, QA Engineer needs to know, which version of the project he or she should check. That’s why we should introduce versioning system to our project. In Android Manifest we have versionCode and versionName. The versionCode is used for updates on Google Play Store and it has to be integer value. We should increment versionCode before releasing new version of the application for the users. The versionName available in Android Manifest is a string value and we can use it to store information, which we need in a current project. When we use Git as a Version Control System, we can put SHA value of a specific commit into our version name. In addition, we can add date and time of compilation to this variable. After that, our versionName contains very detailed information about current version of our application. Exemplary versionName will look in as follows: f935ea7-20140913144001. We can obtain that with proper configuration of build.gradle file containing buildTime() method and gitSha() method. Please, take a look at creation of versionName in 35th line of the build.gradle file presented below.

Updating Android XML resources before compilation via Gradle

Wed, 10 Sep 2014 21:22:00 +0000

Problem

In a team project, we encountered one of the common problems connected with mobile applications. Android application sends requests to backend web service and we don’t have backend web service deployed right now on a separate server, so every mobile developer is compiling and running backend web service on the local machine for testing purposes. In the beginning, url of backend url looked as follows:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="backend_url">192.168.1.1</string>
</resources>

Of course address varies on different machines.

EEG Analyzer - Android app

Mon, 01 Sep 2014 11:38:00 +0000

I recently published my side project connected with BCI and EEG technology in Google Play Store. EEG Analyzer reads electrical activity of the brain with EEG technology and blink strength with EMG sensor from NeuroSky MindWave Mobile device connected via Bluetooth to Android device. In order to use this application, you need to have NeuroSky MindWave Mobile device, which can be ordered from http://neurosky.com/ website. Direct link to the mentioned product: http://store.neurosky.com/products/brainwave-starter-kit Application has the following features:

Publishing Android application in Google Play store

Sun, 31 Aug 2014 14:44:00 +0000

Introduction

When you want to publish your Android application in Google Play Store, first you need to go to https://play.google.com/apps/publish/ website and create a Developer account. Its cost is $25. You can read more about that at: https://support.google.com/googleplay/android-developer/answer/113468?hl=en.

Problems with payments during registration

Remember that you need to have appropriate debit card in order to proceed with payments. E.g. I have debit card in PKO BP (Polish bank), which has two-stage authorization. Most of debit cards has two-stage authorization for the registration of the card in on-line payment system and next payments are verified only once. In my bank every payment is verified twice. It’s more secure, but due to this security policy I was not able to pay for my developer account at all! I decided to create another bank account for on-line payments in bank, which has one-stage authorization for regular payments. I’ve chosen mBank (another Polish bank). Finally, I was able to proceed with payments and create my developer account.

Stuff you should know about Android

Fri, 29 Aug 2014 16:29:00 +0000

Today I had talk at Future Processing about Android. It was part of company’s Java show & tell series. I wanted to make it interesting both for people without any experience with Android development and for people who already know something about this platform. Presentation was divided into three main parts:

Basics
Challenges
Techniques

Below, you can browse slides from the presentation.

View the presentation

Of course, slides does not show everything I prepared, but they are good summary of the talk. I hope you find it interesting and useful. Feel free to give me any feedback about the presentation (especially if you attended it in person. ;-)) !

NetworkEvents - Android library

Tue, 19 Aug 2014 14:59:00 +0000

Please note: This post is outdated. Check newest API on the GitHub.

Introduction

NetworkEvents is an Android library, which I’ve created recently for one of the projects. It uses Otto Event Bus to support event driven programming. We can use appropriate annotations and perform any action, when connectivity status changes. E.g. when device will go offline, connects to the mobile network, connects to the WiFi network, connects to the WiFi network with Internet access or connects to WiFi network without Internet access. Android API does not allow to determine whether specific WiFi Access Point is connected to the Internet, but this library does. In addition, we can monitor change of the signal strength of available WiFi Access Points in the same manner as connectivity status.

Brain-Computer Interface for mobile devices - Master Thesis presentation

Tue, 08 Jul 2014 20:03:00 +0000

Recently, I graduated from my university. Below, you can browse my Master Thesis presentation about Brain-Computer Interface for mobile devices. If you are interested in writing mobile Android applications communicating with NeuroSky MindWave Mobile device, you can check my EEG Reader project on GitHub, which can be treated as a basis for more advanced projects. During writing my Master Thesis, I created two another projects using similar concepts. Mentioned code may be a little bit outdated comparing to the newest Android trends, but feel free to fork and upgrade it.

Selected aspects of creating mobile Android applications

Mon, 07 Apr 2014 17:04:00 +0000

During the development of mobile applications, we should adjust our point of view to the specific projects we are working with. Applications for mobile devices are different than desktop or web applications. They have their own lifecycle, work on various devices with different screen resolutions. They have to work on devices with limited memory, clock rate of the CPU and battery life. In addition, these applications often have to be able to work without an Internet connection and their user interface has to be simple and well-designed due to smaller screen of a typical smartphone.

How to highlight and click on ListView item in Android programmatically?

Thu, 06 Mar 2014 21:43:00 +0000

There are many approaches concerning selecting items on Android’s ListView. Unfortunately most of them don’t work. I was struggling with this problem for some time and decided to publish my solution, which is actually quite easy.

The problem

I want to highlight item on a ListView programmatically (in a source code - without touching item on the screen). I also want to click on item of the ListView programmatically.

Solution

We have to create our own adapter. Let’s call it ContactsAdapter.

How to read contacts in Android device using ContentResolver?

Sun, 02 Mar 2014 22:23:00 +0000

With Content Providers we can access data stored by Android system applications. Popular example of using Content Provider is retrieving contact list from the smartphone. We can also access Calendar or create our own Content Provider. More information about that can be found in documentation of Android. If we want to access Content Provider, we can use Content Resolver in our application’s context.

In this example, we will access contact list. First of all, it’s good to create Contact entity class, which will be model of our data.

Avoiding OutOfMemory Error while loading large Bitmaps in Android UI

Sun, 23 Feb 2014 13:34:00 +0000

Sometimes we may encounter an error connected with loading too large Bitmaps into Android UI. In such cases, we may receive OutOfMemoryError in stack trace. In Android, we are working with limited memory and we shouldn’t load images with full resolution into UI. These images should be scaled down in order to save memory and increase performance of the application. It’s very well described in official Android documentation in section Loading Large Bitmaps Efficiently. It’s worth reading. We can deal with memory problem in three easy steps:

How to connect to Android device via TCP/IP?

Sat, 12 Oct 2013 12:48:00 +0000

While developing Android applications, we need to debug them on real devices. We also should be able to access debug output and execute Unix shell commands. In Android device (mobile phone or tablet), we can go to Settings and then to Developer options. Afterwards, we can enable USB Debugging. Now, we can connect our device via USB cable to the computer and we will be able to access it via Android Debug Bridge (ADB). USB connection is standard way of debugging application on real devices. We can also use TCP/IP connection and debug applications wireless. In order to do that, we need to go through the following steps:

Justifying block of text inside TextView in Android

Sat, 31 Aug 2013 22:14:00 +0000

Justifying text inside TextView in Android is not that simple as we may expect it to be. Unfortunately, Android does not have attribute for TextView, which supports justifying text. We can set alignment to the right or to the left, but we cannot simply justify text with generic attributes. In order to do that, we need to perform a few tricks. First of all, we need to create file named justified_textview.css and we need to put it into the assets/ directory of our project. We will use it later in our custom view. Source code of this CSS stylesheet is presented below:

Asynchronous loading and caching bitmaps with Volley

Mon, 26 Aug 2013 23:37:00 +0000

We can use Volley library from Google for very clean, simple and easy loading of the images from Internet. Volley uses LRU cache, so first of all, we need to create BitmapLruCache class extending LruCache class.

package com.github.volley.example.toolbox;

import com.android.volley.toolbox.ImageLoader.ImageCache;

import android.graphics.Bitmap;
import android.support.v4.util.LruCache;

public class BitmapLruCache extends LruCache<String, Bitmap> implements ImageCache {
    public BitmapLruCache(int maxSize) {
        super(maxSize);
    }

//    Fix thanks to Steven's comment: sizeOf method should not be overriden, 
//    when we are passing max image cache entries in another place of the code
//    @Override
//    protected int sizeOf(String key, Bitmap value) {
//        return value.getRowBytes() * value.getHeight();
//    }

    @Override
    public Bitmap getBitmap(String url) {
        return get(url);
    }

    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        put(url, bitmap);
    }
}

Next, we need to create VolleyHelper class.

How to change Fragment layout on orientation change?

Thu, 15 Aug 2013 22:50:00 +0000

When we work with Activities in Android, defining different layouts for different screen orientations is easy. The only thing we need to do, is to create two *.xml files with the same name for layouts in two separate directories (res/layout/ and res/layout-land/). In Fragments it’s not that easy. In such case, we need to perform additional operations in order to achieve our goal. Fragment in Android is not re-inflated on configuration change, but we can recreate layout and repopulate view manually. We need to create two layouts for different orientations of the screen in the same way as for Activity:

First Google Glass Hackathon in Poland

Tue, 30 Jul 2013 18:46:00 +0000

Some time ago I participated in first Google Glass Hackathon in Poland, where I had possibility to test Google Glass, try it and write applications, which can be run on this cutting-edge device. It was very interesting experience. In addition, I took 2nd place with my team, what made me happy after leaving Warsaw late night. In a few hours, we created simple native application for Android platform, which can be used as a city guide with augmented reality, geolocation and image recognition. We called it Hereandhounds. You can see its source code at: https://github.com/pwittchen/Hereandhounds. You can read detailed report from that event at technical blog of Future Processing: http://www.future-processing.pl/blog/relacja-z-pierwszego-w-polsce-glass-hackathonu/. Unfortunately, its available only in Polish language right now.

Displaying image from the Internet inside the TextView

Tue, 19 Mar 2013 23:04:00 +0000

Sometimes, we have to work with legacy code and we have to change application’s behavior without modifying layouts, structure of the application and core components. Such situations can force us to do some tricks during development or maintenance process. For example, at the beginning, our app had to download data from the web service or RSS channel. This data consisted of the text, so we could use TextView in order to display such information. After some time, back-end developers decided to put there some HTML code including references to images. We want to display images in our mobile application without modifying existing structure, so we can create data of type Drawable inside the TextView. We can do it by creating an additional method getImageHTML() and using fromHtml method from Html class, which is default Android class. Below, you can see an example presenting approach described in this post.

Improper data type in Android TextView

Sun, 17 Mar 2013 18:57:00 +0000

Identifying the problem

One of the common mistakes done by Android programmers is using improper data type in TextView. Let’s have a look on a simple code snippet:

int area;
TextView sampleTextView = (TextView) findViewById(R.id.myTextViewInXml);
sampleTextView.setText(area + " km");

Here, we simply set a value of the text in an exemplary TextView and append string value " km" at the end. It can be used with SeekBar. For example, when we change value of the SeekBar, we can also update value of the text inside the TextView. Let’s have a look on another example:

Endless ListView in Android

Thu, 14 Feb 2013 15:34:00 +0000

Some time ago, I had to implement Endless ListView in Android application. I checked different solutions, but some of them were overprogrammed or did not work well. Fortunately, I found simple solution, which solves the problem. Code snippet presenting mentioned approach, is placed below.

public class EndlessScrollListener implements OnScrollListener {

    private int visibleThreshold = 20;
    private int currentPage = 0;

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
    }

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
        if (scrollState == SCROLL_STATE_IDLE) {
            if (listView.getLastVisiblePosition() >= listView.getCount() - visibleThreshold) {
                currentPage++;
                downloadRecordsTask.setPage(currentPage);
                downloadRecordsTask.execute();
            }
        }
    }
}

In this solution, I simply implement OnScrollListener interface inside the activity, which is responsible for displaying the ListView (class presented above can be nested class in the proper activity class). In this case listView attribute represents ListView and downloadRecordsTask in an examplary AsyncTask. Of course, AsyncTask class should also have setPage method used for pagination. Records are loaded asynchronously to the listView, when user is not scrolling the list (SCROLL_STATE_IDLE). In my opinion, this solution is the simplest, the easiest to implement and works as we expect it to work. I have tested it in my project for over 1000 records and I have not encountered any problems during the testing process.

Custom background for ActionBar and SherlockActionBar

Fri, 01 Feb 2013 22:31:00 +0000

When you want to set custom background for Android ActionBar or SherlockActionBar instead of playing with your styles or views, you can use the following simple code snippet.

@InjectResource(R.drawable.actionbar_custom_background)
private Drawable actionBarCustomBackground;

public void onCreate() {
  getSupportActionBar().setBackgroundDrawable(actionBarCustomBackground);
}

In this case, Drawable object is injected using RoboGuice library and set as a background for the ActionBar. In particular cases, you can use also getActionBar() method. In Drawable object you can store an image of 1 px width and it will be stretched for 100% of width of the ActionBar. I have tested the code snippet presented above for SherlockActionBar and it worked fine.

Custom fonts in Android

Thu, 31 Jan 2013 23:45:00 +0000

Using custom fonts in Android is quite simple, but requires to do some things programmatically and cannot be done using only XML file defining the view. Let’s have a look on an example. Here we have a simple Android view file:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:orientation="vertical"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent" >
      <TextView
      android:id="@+id/custom_font"
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:text="This is our custom font" />
</LinearLayout>

We want to use custom font for the TextView element with id: custom_font. Firstly, we have to put our font (in this example: Custom_Font.ttf) into the ./assets directory (create it if it doesn’t exist yet) in the main directory of the project. Then, we can use the following code:

Android and Maven

Thu, 24 Jan 2013 23:50:00 +0000

Overview

Etymology

Maven, a Yiddish word meaning accumulator of knowledge.

What is Maven?

Maven is a tool that can be used for building and managing any Java-based project with all its dependencies (libraries).

Maven’s objectives

Making build process easy
Providing uniform build system (Project Object Model)
Providing quality project information
Providing guidelines for best practices development
Allowing transparent migration to new features

Setting up Maven Android projects on MS Windows

Configuring environment

You need Eclipse Indigo or Juno installed

Fixing bug with dissappearing map overlay after zoom in Android

Mon, 21 Jan 2013 22:16:00 +0000

In Android 3.0 – HoneyComb (API 11) or higher occurs specific bug connected with map overlay. When we draw overlay on the map (e.g. routes, directions or polylines) after zooming to particular level, overlay disappear unexpectedly. We can fix this bug very easily by disabling hardware acceleration for drawing overlays. Below, you can see exemplary code snippet with map injected by RoboGuice and disabled hardware acceleration. Changing way of drawing overlays should fix the bug.