Java on Piotr Wittchen

Modifying mehtod's input parameters

Mon, 05 Aug 2019 18:27:30 +0000

During maintenance of the legacy projects, I sometimes see constructions like:

void appendFooter(Report report);

void populate(Data data);

I even saw something like this:

void populate(Source source, Target target);

What is wrong with these statements?

They’re using so called output argument. In the examples above, we’re passing a report or data variable, which usually are going to be global variables available in the scope of the whole class. These methods takes them as an argument and modify them. This idea comes from pre-OOP times and could be applied in programs written in C. Nevertheless, in Java, this technique should be avoided and is considered as a bad practice.

Get rid of the list null-checks

Sun, 28 Jul 2019 23:18:43 +0000

During development of the legacy Java applications, we still have to deal with null. It’s possible to avoid it completly when we’re designing application from the scratch, applying proper code constructions, static code analysis and we’re consistent during code reviews. Nevertheless in majority of the cases we will encounter null in daily projects. We may even expect them in the method inputs and we have to be prepared for it. With the functional programming in Java we can deal with them in quite elegant way, but I often see people are not using features available nowadays.

Zen of the Java library release process

Sat, 08 Jun 2019 10:58:10 +0000

In my previous article I published information about publishing JAR/AAR library to the Maven Central Repository. A few steps of that process were automated, but a few of them were still manual. I mean closing and release process which had to be done by manual clicking on the Sonatype website. Fortunately, it’s possible to automate it. In order to do that, I used gradle-nexus-staging-plugin developed by Codearte. Thanks to this plugin I could get rid of the remaining manual steps left in the release process.

Publishing a JAR/AAR to the Maven Central

Fri, 24 May 2019 19:18:27 +0000

Introduction

As a Java/JVM/Android developers we rely on the work of other people through frameworks and libraries. Many of them are open-source. Most of the developers are consumers of such projects. What if we would like to create our own library and distribute it to other developers? We can always create it and share a *.jar or *.aar file with others. Drawback of such solution is the fact that source of distribution may not be trusted. We also have problems with versioning. Consumers of the library have to constantly download and update their files. It’s much better to publish our library to Maven Central Repository and allow others to easily and seamlessly add it as an external dependency to pom.xml file (in case of Maven) or build.gradle file (in case of Gradle). In such case, dependency is managed by the appropriate build system and distributed via trusted source. This may be not easy for the first time that’s why I decided to collect information related to this topic in a single article. Let’s see how to do this.

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.

Separate execution of unit and integration tests in Gradle

Sat, 22 Sep 2018 16:51:47 +0000

During development process, we often write unit and integration tests. While unit tests verify corectness of the small pieces of code, integration tests verify software as a whole project and sometimes can treat it as a black box where concrete results are expected. During development of the REST API, we can write integration tests for such API with REST Assured. Integration tests are usually slower, because they need to start the server and sometimes do other stuff. That’s why it’s good to separate their execution from regular unit tests. On the CI server we can even have separate job for them.

Excluding generated code from JaCoCo report

Tue, 18 Sep 2018 20:07:30 +0000

I recently wrote a simple java app with Dagger 2 as a DI container and Gradle as a build system. I wanted to generate unit test coverage report for this app, so I used Jacoco.

In my build.gradle file I configured JaCoCo as follows:

plugins {
  id 'jacoco'
}

jacocoTestReport {
  reports {
    xml.enabled = true
    html.enabled = true
  }
}

Now, I could type:

./gradlew test jacocoTestReport

Report was generated in build/reports/jacoco/ directory. I noticed that report includes Java code generated by Dagger during the compilation. I didn’t want to include it in the report because it doesn’t really make any sense to write unit tests for generated code.

Testing exceptions

Tue, 04 Sep 2018 19:49:26 +0000

In Java, we can test exceptions via unit tests in a few different ways. In this article, I’ll present common methods of doing that. Nevertheless, I suppose we there are different methods as well.

First method is basically wrapping a method call with try-catch block, assigning an exception to a variable and performing appropriate assertion. In these examples, I’m using JUnit for unit tests and Truth for assertions.

@Test
public void shouldTestExceptionWithTryCatch() {
  Exception caughtException = null;

  try {
    throw new RuntimeExcetpion("message");
  } catch (final Exception e) {
    caughtException = e;
  }

  assertThat(caughtException).hasMessageThat().isEqualTo("message");
}

In the second method, we can define a type of the thrown exception within the @Test annotation. It’s useful approach when we don’t want to test exception details like message and we care only about the type.

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.

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.

Deployment of the Java code to AWS Lambda

Sun, 18 Mar 2018 16:50:02 +0000

Introduction

In the cloud computing era, companies start using services like Google Cloud Platform, Amazon Web Services or Microsoft Azure. We can hear about the term “Serverless”. It doesn’t mean that we don’t have any servers. It means that third-party services provide us server infsrastrucutre, monitoring and scaling capabilities, so we don’t have to care about that stuff by ourselves and we can focus on writing code. We have concepts like Backend as a Service (BaaS) and Funtion as a Service (FaaS). In BaaS we can configure whole backend infrastructure using third-party cloud services. In this case, we can have database, REST API and other services, which we need depending on our use case. In FaaS, we have just a tiny piece of code responsible for a single job, which we can take and deploy into the cloud. AWS Lambda is an example of FaaS and we’ll focus on it in this article.

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:

Automating generation of the on-line documentation for Java library

Sun, 11 Feb 2018 10:22:00 +0000

Introduction

In one of my open-source projects - ReactiveNetwork I have a documentation in README.md file and I have JavaDocs as well. This project is an Android library written in Java and built with Gradle. Moreover, I develop this project on two separate Git branches - one for RxJava1.x and another one for RxJava2.x. Similar convention is in the RxJava repository, so I followed it. After each release I publish documentation and JavaDocs on GitHub pages for both versions. It’s kind of boring and repeatable task, so I was wondering if there’s any way to automate it.

Quality Meetup no. 15 - Fixing a billion dollar mistake

Fri, 09 Feb 2018 00:46:00 +0000

On the 8th of February 2018, during Quality Meetup #15, I gave a presentation titled “Fixing a billion dollar mistake”. Tony Hoare introduced Null Reference w in ALGOL language in 1965. He calls this decision a “billion dollar mistake”. It was so easy to implement and probably it caused a loss of millions of dollars due to the mistakes done in the software over the 40 years. During the time, people came up with different ideas of solving that problem with software libraries, good programming practices, static code analysis and compile time code analysis. Moreover, we have new programming languages with null safety features. During the presentation I’ve shown how to deal with the null reference problem in the JVM projects no matter if it’s a greenfield solution or legacy code.

Creating a Docker container with Alpine Linux including Java 8 and 9

Wed, 27 Dec 2017 14:43:00 +0000

Recently, I’ve decided to refresh my knowledge regarding Docker and created an image with Alpine Linux and Java 9, which can be a useful base for the future projects. I used Alpine as a base image because it became quite popular in the Docker world due to its simplicity and the fact that it’s pretty lightweight when we compare it to containers based on other Linux distributions. Pure Alpine Docker container has about 4.144 MB, what is really impressing.

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.

JDD 2017 - Get ready for java.util.concurrent.Flow! - summary

Thu, 05 Oct 2017 16:19:00 +0000

Recently on the JDD 2017 conference, I gave a presentation regarding introduction to Reactive Streams standard in Java 9. I also talked about existing implementations of this standard with the strongest focus on RxJava2 and created simple Reactive Streams implementation in pure Java 9 during the presentation. Below, you can find slides from this talk.

View presentation on SpeakerDeck

Code snippets shown during this presentation are available at https://github.com/pwittchen/java-flow-experiments. I have done a tiny live coding session during this talk. Luckily, everything went fine, the code was compiled and executed without errors. Everything I’ve done during this presentation and additional exploratory unit tests could be found in this repository so you can check it out if you’re interested.

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:

New reactive data types in RxJava2

Wed, 31 May 2017 17:49:00 +0000

Introduction

I’m still exploring reactive programming world and RxJava library. Recently, I’ve migrated a few of my open-source libraries from RxJava1 to RxJava2 and written yet another project in RxJava2 from the beginning. Nevertheless, I’m still learning this library and its concept. It’s very wide topic. In RxJava1 we simply had one reactive data type called Observable. In RxJava2, we have more data types like Observable, Flowable, Single, Maybe & Completable. In this article, I’ll briefly explain their purpose and tell you when to use which. The general idea behind these types is code semantics. We should tell consumer of our code, what he or she can expect from our API. Introducing more reactive data types can increase readability and stability of our code base.

Introducing YaaS Java SDK

Sun, 28 May 2017 21:24:00 +0000

Introduction

In my company, there’s a concept of so-called “innovation day”. I have the possibility to “use” 1 innovation day per 2 development sprints. Last year, I used only 1 day due to the tight release schedule and a lot of work. Now, we are right after release, so I had time to take innovation day once again. I’ve decided to create YaaS Java SDK. If you don’t know what the YaaS is, check out my previous article about basic usage of YaaS proxy for the microservice. In a few words, it’s a proxy for the microservices with authorization & monitoring capabilities, which allows using other services available on the YaaS market. SDK created by me is really simple, was created in a short period of time and does not cover all features of the YaaS. This SDK allows performing authorized requests to the microservices hidden behind YaaS proxy. Tech stack used for this project is as follows:

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!

Joining lists of RxJava Observables

Mon, 15 May 2017 20:37:00 +0000

In RxJava we have a few operators for joining Observables. The most common are:

Take a look at the documentation in these links. It has interactive marble diagrams showing how the operators work on the streams. You can move marbles along the lines and see how the output stream changes. It really helps to understand how it works. Code snippets in this article are based on RxJava 2.1.0 with JUnit 4.12 and Google Truth 0.32 for unit tests. Let’s say, we have the following Observables:

Emitting different observables conditionally

Sun, 14 May 2017 21:44:00 +0000

Sometimes, we may need to emit different RxJava Observables depending on the specific condition dynamically. Moreover, it’s good to do it right without breaking a chain (stream of Observables). We want to combine different Observables together and do not want to nest one subscription inside another subscription because this will lead us to “subscription hell” similar to “callback hell”. Luckily RxJava has mechanisms to deal with such problems. In this article, I’m basing my examples on RxJava 2.1.0. Let’s say we have two Observables:

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.

An Opinionated Guide to Modern Java by Parallel Universe

Thu, 05 Nov 2015 08:27:00 +0000

Introduction

I recently read series of three articles titled An Opinionated Guide to Modern Java by Parallel Universe. It presents really interesting point of view and can be read even by non-Java developers due to its form. Non-Java developers can learn that Java can be fast, elegant and lightweight as much as other hipster technologies like Ruby, Go or Node.js. The main difference is the fact that Java is quite old and widely used technology what means it’s well tested, stable, solid, has great development and monitoring tools. Besides widely known projects, author of the articles presents some information about tools built by Parallel Universe, which are not commonly used and are less popular, but are also worth considering for modern development. E.g. he writes about so called Capsule project, which is intended to be a Docker alternative for Java and Quasar, which is interesting high level API for multi-threading with concept of actors, which is also available in Akka and Erlang. I recommend any Java and non-Java developer to read this series to learn new things and consolidate the knowledge.

Searching word in a string with KMP algorithm

Wed, 22 Jul 2015 13:03:00 +0000

Sometimes it’s good to revise some algorithms and try to implement them in order to get to know, how the built-in functions of high level programming languages actually works. One of the popular problems is string searching. We have many approaches to solve this problem. For example:

Naive string search algorithm
Rabin-Karp string search algorithm
Finite-state automaton based search
Knuth-Morris-Pratt algorithm
Boyer-Moore string search algorithm
Bitap algorithm

This time, I’ve decided to focus on Knuth-Morris-Pratt (KMP) algorithm. It’s quite easy to implement, when you understand it. In addition, its time complexity is quite good and can be defined as O(n). In this algorithm, we simply go through all letters in a given string and compare them with searched string. When position of searched string reaches length of searched string, we can assume, that our string was found. If two compared letters are different, we set position of searched string to zero and start new search from the next position after which we started searching process before. It’s quite good described on Wikipedia with some pseudo-code. You can also take a look at my code in Java available below, which I’ve written just for practice.

Get past the syntax - the real scare is in the semantics

Mon, 06 Jul 2015 15:37:00 +0000

Dr. Venkat Subramaniam presented an interesting point of view during his talk at Devoxx conference. Programmers, who start learning a new language, often complain about syntax. They focus on using available keywords and constructions instead of trying to understand their meaning and purpose. Programmers also have their own habits. That’s why Java has similar syntax to C and C++. Creators of Java designed new language with syntax, which was familiar to them, with significant improvements. Perception of the world is based on experience and things we get used to. The same rule applies to programming languages. Most software developers are familiar with imperative programming paradigm. They often focus on describing computation in terms of statements and changing program state. This approach leads us to necessity of creating a lot of temporary variables and boilerplate code. Let’s have a look at the following code snippet:

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:

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:

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.

How to switch java version on Linux

Sun, 02 Nov 2014 12:33:00 +0000

Sometimes we need to run specific program with a concrete version of JVM. We can also work with Java 7, but we want to try Java 8. In such cases, we can have installed both Java 7 and 8 on our system and easily switch between them. In order to show current java version, we can simply type: java -version in terminal. On my computer I received the following response:

Java Gradle Template

Fri, 17 Oct 2014 23:11:00 +0000

Some time ago, I had some troubles with configuring Java project with Gradle in IntelliJ IDEA CE. There is possibility to create new Gradle project in mentioned IDE, but for some reason it didn’t worked out-of-the box in my case on Ubuntu. I wanted to have pure, clean Java project with Gradle build system ready to open in IntelliJ IDEA. I found well configured simple project at: https://github.com/quinnliu/SampleGradleProject. Basing on that project, I created my simple template. I modified this project a little bit, added FEST assertions and wrote a few Unit Tests. In addition, I configured main class in build.gradle file in order to execute it via ./gradlew run command. My project template also has gradle wrapper, which is very convenient practice.

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.

Reading/writing generic Java objects to JSON files and vice versa

Wed, 27 Aug 2014 21:19:00 +0000

Overview

Recently, I have written small set of methods for a FileHelper using Jackson library in Android application, which allows to save generic Java objects and list of generic objects in JSON format to a file and read them back in the original form. In the beginning I had some problems with saving and reading data properly. I could save and read data (e.g. list of the objects), but their type was LinkedHashMap, which wasn’t the list of desired generic objects. After adjusting Jackson library, I finally achieved my goal. You can see helper class below.

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:

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:

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.