Flying Bytes

How Google Shut Down My Android Play Store Account and Killed My Business

Mon, 07 Jul 2025 14:00:00 +0000

TL;DR: On May 29th, 2025, Google has shut down my Google Play Store developer account, thus blocking all of my apps and killing my business of publishing Android apps. They’ve given me no reason at all, and don’t allow me to take any action to re-activate my account. It seems like moving my apps to a new account, an idea that originated from the Google support itself, caused the termination.

In case Google’s reading this, my ticket numbers are 0-2181000039046 (new account) and 5-7732000037267 (old account).

Update August 2025: Someone mentioned that I should have deleted my old account by hand instead of letting it automatically block. However, since then I’ve been able to re-enable the old account and properly delete it. However, the new account is still blocked and Google support does not want to enable it. So that’s also not the issue I’m facing

Over the years, I’ve read in multiple blog posts like this, this, or that about Google shutting down other people’s developer accounts for arbitrary reasons.

I’ve never thought this arbitrary termination could happen to me as well. However, on May 29th, 2025, exactly this worst-case scenario began to unfold.

In this post, I want to present my frustrating conversations with the Google support about this incident and how Google declines any help to reactivate my account. The goal of this post is to show how easy it is to loose your business if you lay it in the hands of a third party like Google.

First, I’ll tell the main points of the story. Later, I will go into more detail and publish my conversations with the Google support.

Long story short

In case you didn’t know, Google insists to verify the legal name and address of every Play Store developer account since May 2024. Furthermore, if you monetize apps, this highly confidential information will be easily accessible for every user of the Play Store, even if you are not logged in. Hence, scraping and storing legal information is pretty easy in this case.

I’m fine with Google checking my legal information. However, I’m not fine making this sensitive information publicly available. Hence, I’ve decided to make all of monetized apps free s.t. my information is kept private. Furthermore, the Google support told me that I’d have to create a new developer account and move all apps there. This is because my old account contained monetized apps in the past, hence I’d have to make my legal information publicly available even if I don’t have monetized apps right now. The idea was to verify my new account and let my old and empty account suspend without any information provided. So far, so good.

On May 14th, 2025, my old account was suspended as this was the deadline for providing legal information. However, two weeks later, on May 29th, 2025, my new account with all apps was suspended as well.

This Reddit comment points out that moving my apps probably caused the termination of the new account. Google seems to automatically suspend accounts that are “connected” to suspended accounts. As my old account was suspended (which is fine for me), my connected new account was suspended as well (which is not fine for me). As I’ve not update any apps in my developer accounts in the days prior and not changed any settings, this seems to be the logical conclusion.

However, opening an appeal and pointing out that this transfer of apps was suggested by Google itself didn’t help to change Google’s opinion on the matter. As I can’t be 100% sure that the transfer is the actual cause of the termination (as Google doesn’t provide me the exact reason), there is nothing more I can’t do. My account is still suspended to this day.

Long story long

Explanation: In this part of the story, I will copy-paste parts of the email conversation between the Google support and me. The most important part of every email is surrounded by “**“-marks

I’m creating and publishing Android apps since 2015. In 2017, I’ve started monetizing them and making some money with them. Over the years, many of my apps gained traction, and some even got used in the context of university lectures. I’ve learned a lot by creating the business, working with the Google developer account and publishing a dozen apps.

At the beginning of 2025, I’ve had to make a decision. Either making it extremely easy for every Play Store user to see my legal address on every app page (even not logged in users like bots), or demonetizing all of my apps.

Thanks for your reply.

I understand that you are having some concerns in regards to the new
requirements related to the information that will be shown publicly on the
Play Store.

As part of the new expanded developer verification requirements, developers
will be required to provide certain information when creating Play Console
which helps us to verify your identity and making sure that we provide safe
and wonderful app experiences for our users and a great opportunity for all
our developers to be successful.

   - For individual accounts, below are the details that will be shown
   publicly:
      - Developer name
      - Legal name
      - Country (taken from legal address)
      - Developer email address

**Kindly note that, if you decide to monetize your app on Google Play then
Google will display your full address.**
In addition, there are certain countries or regions that may require you to
complete additional requirements to comply with regulatory authorities. For
further information, you may refer to this *Help center article*
<https://support.google.com/googleplay/android-developer/answer/6223646?hl=en&ref_topic=12798386&sjid=17803400505414581127-AP>
.

To learn more about developer verifications, please visit *Play Console
Requirements*
<https://support.google.com/googleplay/android-developer/answer/10788890?hl=en>
and the *Play Console Help Center*
<https://support.google.com/googleplay/android-developer/answer/13628312>.

Thanks for working with us through this process and please don't hesitate
to reply to this email if you need further assistance. If we do not hear
from you, we will consider the matter closed.

It also had to be the correct legal address, something like a postbox doesn’t work.

Thank you for your patience.

**Unfortunately you can't use a postbox address.**

Thanks for your understanding.

Regards,
...
Google Play Developer Support

The decision was pretty hard for me, but I’ve demonetized all of my apps to keep my address safe. For this to work, I’ve moved all of my apps to a new developer account of mine, as the Google support has told me.

Thank you for your reply.

In order to provide transparency to our users, and avoid potential
regulatory issues, Google Play now requires all organization developers and
all monetizing individual developers to provide a verified address that is
displayed in full to Google Play users.
**If you do not intend to monetize on Google Play, you can create a new
account and transfer your app there, and we will assist you in closing your
current account. Individual non-monetizing developer accounts only have
their legal name and country of residence publicly displayed, and not the
full address.**

Thanks for working with us through this process and please don't hesitate
to reply to this email if you need further assistance. If we do not hear
from you, we will consider the matter closed.

This way, no payment information was linked to my (new) developer account anymore, hence I didn’t have to publicly announce my real address everywhere. So far, so good. That’s the way Google wanted it to be, and I didn’t bother paying the extra 25 dollars for the second developer account. As mentioned, that’s the recommended way from Google to keep my apps and hide my address.

However, after two weeks, Google blocked both of my developer accounts without any particular reason. As this transfer was the only thing I did in this time, I guess the suspension is connected to my account migration, as this Reddit comment points out as well.

This is a notification that your Google Play Publisher account has been  
terminated.



Publishing Status
Status: Account Terminated

**Your Developer account remains terminated due to prior violations of the  
Developer Program Policies and Developer Distribution Agreement by this or  
associated, previously terminated Google Play Developer accounts.**

Please do not attempt to register a new developer account. Any new accounts  
will be closed, and your developer registration fee will not be refunded.

View policy status




Issue found: High Risk Behavior


We have identified a pattern of high risk or abuse associated with your  
Developer Account and are taking this action pursuant to the Policy  
Coverage policy.

About the Policy Coverage policy
We don't allow apps or app content that undermine user trust in the Google  
Play ecosystem. In assessing whether to include or remove apps from Google  
Play, we consider a number of factors including, but not limited to, a  
pattern of harmful behavior or high risk of abuse. We identify risk of  
abuse including, but not limited to, items such as app- and  
developer-specific complaints, news reporting, previous violation history,  
user feedback, and use of popular brands, characters, and other assets.


Submit an Appeal

Please read through this page to understand your policy violation. If you  
believe our decision may be incorrect, you can appeal. It may take up to 7  
days to receive a response, or longer in exceptional cases.
Please do not attempt to register a new developer account. We will not be  
restoring your account at this time.


Regards,
...
The Google Play Team

As the email suggests, I’ve submitted an appeal. I’ve asked the Google support team what happened. However, I’ve only got an answer that told me, again, that “strange” behaviour occurred within my account and thus it had to be terminated.

Thank you for your patience while I looked into your issue.

After reviewing your appeal, we're unable to reinstate your Google Play
Developer account.

We can confirm that we have identified a pattern of high risk or abuse
associated with your Developer Account and have taken this action pursuant
to Section 8.3 or 10.3 of Google Play’s Developer Distribution Agreement
<https://play.google.com/intl/en_us/about/developer-distribution-agreement.html>.
**As we previously explained, in order to prevent bad-faith developers from
gaming our systems and putting our users at risk in the process, we can’t
share the reasons we’ve concluded that your account is at high risk.**

Your Developer account remains terminated due to prior violations of the  
Developer
Program Policies <https://play.google.com/about/developer-content-policy/>
 and Developer Distribution Agreement
<https://play.google.com/intl/ALL_us/about/developer-distribution-agreement.html>  
by
this or associated, previously terminated Google Play Developer accounts.

Please do not attempt to register a new developer account. Any new accounts
will be closed, and your developer registration fee will not be refunded.

If you are located in the EU, you may have additional redress options.
Learn more about those potential options in the EU Out-of-Court Dispute
Resolution Help Center
<https://support.google.com/european-union-digital-services-act-redress-options/answer/13535501>.
Routing ID: ZLFS

Regards,
...
The Google Play Team

Asking again which actions I can do to re-activate my account, I’ve received the answer that Google can’t tell me what’s going on because I could start “gaming [Google’s] system”.

Thanks again for contacting the Google Play team.

**As we previously explained, in order to prevent bad-faith developers from
gaming our systems and putting our users at risk in the process, we can’t
share the reasons we’ve concluded that your account is at high risk.**

Your Developer account remains terminated due to prior violations of the  
Developer
Program Policies <https://play.google.com/about/developer-content-policy/>
 and Developer Distribution Agreement
<https://play.google.com/intl/ALL_us/about/developer-distribution-agreement.html>  
by
this or associated, previously terminated Google Play Developer accounts.

Please do not attempt to register a new developer account. Any new accounts
will be closed, and your developer registration fee will not be refunded.

Thank you for your understanding.

Regards,
...
The Google Play Team

Please visit the Google Play *Developer Policy Center*
<https://play.google.com/about/developer-content-policy/> and Google Play's  
*Academy
for App Success*
<https://www.google.com/url?q=https%3A%2F%2Fplayacademy.exceedlms.com%2Fstudent%2Fcatalog%3Futm_source%3Dshortlink%26utm_medium%3Dgco%26utm_campaign%3Dgeneric&sa=D&sntz=1&usg=AOvVaw3TU58z9sfaZs6auAAx9I4W>  
to
learn more about building policy compliant and high quality apps. You can
also visit the *Android Developers Blog*
<https://android-developers.googleblog.com/> for the latest Android and
Google Play news for app and game developers.

I find it especially rude that they end the conversation with a reference to the developer blog, with information that I’m forbidden to use anymore. Asking again and again, I got the same “gaming the system”-mail three times without any new information whatsoever.

I’ve never received a strike in the Play Store before, no bad reviews or whatsoever. I have the rights to the content and names of all of my apps. Still, Google decided that my account had to be terminated.

To conclude the post, I just want you to make sure that dependencies on third parties can be good and bad. If you depend on a very powerful third party (like Google) for things to work, it can also happen that things go sideways.

Use C Libraries in Kotlin Native Code (C Interop) for C Noobs

Sat, 10 Sep 2022 09:00:00 +0000

TL;DR: Calling C Code in Kotlin Native is very simple and much more intuitive then using the corresponding JVM-“Java Native Interface” (JNI). However, the sample code from JetBrains is IMHO too hard for C beginners, hence I wrote this blog post. If you just want to see the code, look at GitHub.

Hello everybody,

When I’m not developing some Android app, I enjoy learning more about the Kotlin Ecosystem as well. As some of you might know, there is not only the “normal” JVM Kotlin programming language, which compiles to bytecode which can be run on the Java Virtual Machine (JVM). There is also “Kotlin Native”, a dialect which compiles to bear-metal binary code and thus does not need a JVM to run. This can lead to potentially faster programs or completely new areas of application for Kotlin Code, like embedded devices which can’t handle a full-blown JVM.

Unfortunately, the one downside of Kotlin Native in comparison to “JVM-Kotlin” is the of loss of all Java/JVM-Libraries. The JVM is known for its rich ecosystem of libraries and frameworks. You lose all of that when using Kotlin Native as your program does not use the JVM at all. However, you still have another option left to add other people’s code: through C Libraries. Like on the JVM, there is a rich ecosystem of C-libs which one can use.

The big question is: How do you call C libraries from your Kotlin Native code?

There is already a tutorial by JetBrains which answers this question. However, I found it way too difficult for a C beginner like me. For example, I don’t know where header-files or shared objects are located on my computer, and I don’t know how linking C-libraries in general works. For you, my dear readers, I will fill these gaps in this blog post after researching this topic in more detail.

In the first part of this blog post, we will link an already existing C-library (VLC) into our Kotlin Native code and play some music with it. We learn more about the C-infrastructure, which files one needs to bind everything together, and how we can use the Gradle build system to call the C code in our Kotlin Code.

In the second part of this blog post, we will create our own small C-lib and execute it in our Kotlin Native code. Here, we learn more about C and its build-system in general.

This tutorial should work on Linux-, OSX/Mac-, and Windows-Systems.

Linking a C library into your Kotlin Native Code

Next, we will link the VLC-C-Library into our Kotlin Native code. It is a really easy and well documented library to play back music. Our goal is to play back some sound in our Kotlin Native Code through the C-library.

For the sake of completeness, I want to mention the JNI. If you have a background in JVM-development, you probably heard of the Java Native Interface (JNI). This is a protocol which allows you to call C code on the JVM. However, it is very cumbersome to use. For example, you have to write additional C-adapter to wrap the C-lib you want to use. With Kotlin Native, all of this is way easier and you don’t have to write any additional adapter-code. Gradle does all of this hard work for you under the hood.

We have four small steps to do

Create a new Kotlin Native Project
Download the VLC-Library
Link the VLC-Files to our Kotlin Native Project
Call the library to play back sound.

1. - Create a new Kotlin Native Project

To create a new Kotlin Native Project, just install IntelliJ, create a new Project, and there click on “Kotlin Multiplatform -> Native Application”. Let’s call it the “KotlinNativeCInteropProject”. Now finish initialization and build the project.

2. - Download the VLC-Library

Next, we will download the VLC files. I can’t just give you the files, because they depend on the architecture of your machine, hence you have to download them through the package manager of your OS (or build them yourself). Most of the time, the package is called something like libvlc, vlc-devel, or vlc-dev. Here are the command for the most common distributions:

Ubuntu/Linux Mint/Debian/…: sudo apt install libvlc-dev

Fedora/RHEL/CoreOS/…: sudo dnf install libvlc-devel

Arch Linux/Manjaro/…: sudo pacman -S libvlc

OSX/Mac: brew install –cask vlc

Windows: Unfortunately, you have to compile the code yourself from source.

With this, you download two files. The first one is the libvlc.so file. This is the “shared object”, which basically contains the actual code of the vlc-library. Under most distributions, it is either located under /lib or /lib64. If you look inside the shared object, you will see that it is binary file, so you can’t read it at all. The second file that was installed is vlc.h. This is the header-file, and it should be located at /usr/include or /usr/include/vlc. One can actually read this file, and it tells you which functions the shared object actually contains. In Kotlin terminology, the header is like an “interface” of the shared object “class”.

3. - Link the VLC-Files to our Kotlin Native Project

In the third step, we connect these two vlc-files to our Kotlin project. First of, in our Kotlin project, we create the folders nativeInterop/cinterop, where nativeInterop is on the same level as the already existing nativeMain folder. Note that the “I” in nativeInterop is uppercase, while the “i” in cinterop is lowercase (this is important).

In thecinterop-folder, we add a libvlc.def file, which contains the locations of the vlc-files. This file contains the following configurations:

compilerOpts = -I /usr/include
headers = vlc/vlc.h

linkerOpts = -L /lib64 -L /lib64/vlc  -L /lib -L /opt/local/lib -L /opt/local/lib/vlc -L /usr/local/opt/ -L /usr/local/opt/vlc -l vlc

The compilerOpts options tells Gradle where to search for header files (i.e. in the /usr/include folder). The headers option tells Gradle that we want to add the /usr/include/vlc/vlc.h header to our project. In the linkerOpts option, the -L parameters tell Gradle where to search for shared-object files. I added a lot of different folders so that this project runs on as many distributions as possible, but you can remove the unnecessary ones if you want to. The -l parameter in the end tells Gradle that we want to add the libvlc.so file to our project. As you can see, to add libX.so file to our project, the parameters has to be -l X.

If you work on Windows, you have to adapter the compilerOpts and linkerOpts to point to the folder of your vlc.h and libvlc.so file.

Afterwards, we have to tell Gradle that it should execute the libvlc.def-file and create Kotlin bindings for the C function which are part of the vlc-header. We do this by adding the following code in our build.gradle.kts file, and there in the already existing nativeTarget.apply block:

nativeTarget.apply {
      ...
      compilations.getByName("main") {
          cinterops {
              val libvlc by creating
          }
      }
      ...
}

After we sync the project, Gradle created Kotlin functions that match the functions in the vlc.h header file. This is an incredible improvement over the JNI, where we had to write these functions ourself.

4. Call the library to play back sound.

Now, everything is combined and we can use the vlc-library in our project. As Gradle created functions with the same function names as the ones in the vlc-header file, we can easily adapt the libvlc example code to play back sound for our project. Add the following code to your Main.kt file:

import libvlc.*
import platform.posix.sleep

fun main(args: Array<String>) {
    val SOUND_FILE = "sound.mp3"

    val inst = libvlc_new(0, null)

    val m = libvlc_media_new_path(inst, SOUND_FILE)

    val mp = libvlc_media_player_new_from_media(m)

    libvlc_media_release(m)

    libvlc_media_player_play(mp)
    sleep(10)
}

You can put any sound.mp3 file in the root-“KotlinNativeCInteropProject” folder of your project, or adapt the SOUND_FILE variable as needed. For example, you could use this file. Our code will play back ten seconds of sounds due to the sleep(10) command.

Hooray, you used C code in your Kotlin project! You can find the final project on GitHub.

If your IDE can’t find the libvlc_...-functions, or can’t import libvlc.*, then nevertheless try to execute the code by clicking the run arrow next to the main-function. If this does not work, try to re-sync the Gradle file. For me, it worked by adding a useless character to the build.gradle.kts file, then syncing (thus creating an error), then removing the character again and re-syncing the project. 99% of the time, this solved the import-issue.

Next, we want to take a short detour and create our own C-library and call it from the Kotlin project.

Create and Call your own C Library from Kotlin Native Code

Now, we want to create a small C library called helloworld. It contains a function hello() that prints Hello World! and returns 42. Afterwards we want to call this function from our Kotlin code.

Create a C library

As you know from the first part of this blog post, we need a shared object and a header file to call C code from our Kotlin project. The header is relatively easy, as it is human readable.

Create the file helloworld.h and insert the following code:

#include <stdio.h>
int hello();

We need to import the stdio.h header to call printf() in the C code afterwards. Next, copy this file to the other header files in the /usr/include/ folder.

Next, we need to create a shared object file which contains the actual code. First, we need to create a helloworld.c file with the following content:

#include <stdio.h>
int hello() {
  printf("hello world!\n");
  return 42;
}

As you can see, the function hello prints “Hello World!” to the console and returns 42.

Next, we need to compile this C file to a shared object. We do this with the following command:

gcc -shared -o libhelloworld.so helloworld.c

The command should be rather self-explanatory. We copy the libhelloworld.so file to /lib.

Afterwards, we do the same things as for the vlc-library. First of, in the cinterop folder of our Kotlin project, we create a new libhelloworld.def file with the following content:

compilerOpts = -I /usr/include
headers = helloworld.h

linkerOpts = -L /lib64 -L /lib64/vlc  -L /lib -L /opt/local/lib -L /opt/local/lib/vlc -L /usr/local/opt/ -L /usr/local/opt/vlc -l helloworld

Next, we add the following line to the build.gradle.kts:

nativeTarget.apply {
      ...
      compilations.getByName("main") {
          cinterops {
              val libvlc by creating
              val libhelloworld by creating //Add this line
          }
      }
      ...
}

Then sync the project and add the following lines to your Main.kt:

import libhelloworld.*

fun main(args: Array<String>) {
    val x = hello() //should be 42
    println("Return value was $x")
}

Now, your C should work, congratulations! Again, if it does not compile, try to re-sync the Gradle-file. You can find the final project on GitHub.

Conclusion

That’s it for today!

You have seen the necessary steps to include C code in your Kotlin Native project. Additionally, you have seen how to create a C library yourself.

Please leave an email if this post helped you or if you have any questions regarding this blog post.

Thanks for reading and have a nice day,

Niklas

Enable Kotlin Context Receivers in an Android Project

Mon, 13 Jun 2022 18:00:00 +0000

Hello everybody,

As some of you know, Context Receivers are a new, unstable feature added in Kotlin 1.6.20. I find them really interesting, as they are a syntactical generalization of extension functions (although extension functions and context receiver are used in different semantic cases, see this video for an explanation).

As I went along trying out Context Receivers, I found it rather difficult to enable them for toying around. Unfortunately, I am missing the usual step-by-step tutorial by JetBrains. They only tell us that we have to add a compile flag, but this does not help much. And most blog posts skip this step as well. Even Stack Overflow does not help this time! This blog post should help everyone who has the same problem enabling Context Receivers without wasting as much time as I did searching for the necessary actions.

Of course, all of this could change dramatically when the feature becomes stable over time. This guide is from June 2022, and I use Android Studio Chipmunk as my IDE.

0. Add Context Receiver to Code

Before we enable Context Receivers, we add the following class somewhere in our app:

context(Unit)
class Test()

To make this compile, we have to do the following two actions:

1. Update Kotlin Language Features

To fix the “Expecting a top level declaration” compile error, first, we have to enable the language features of Kotlin 1.6.20 (or higher). We do this by updating the used Kotlin version inside the build.gradle file of the project folder:

plugins {
    ...
    id 'org.jetbrains.kotlin.android' version '1.6.20' apply false #Or anything higher than 1.7.0
}

This fixes the error.

2. Enable Context Receivers

To fix the “The feature ‘context receivers’ is experimental and should be enabled explicitly” compile error, we have to set the following compile flag inside the build.gradle file of the app module folder:

android {
  kotlinOptions {
    ...
    freeCompilerArgs += "-Xcontext-receivers"
  }
}

Now, the code compiles. Congratulations!

Conclusion

That’s it for today!

You have seen the necessary steps to enable Context Receivers in any Android app.

Unfortunately, Android Studio (Chipmunk) still shows a syntax error when using Context Receivers. However, the code still compiles and works. Do you know any way to remove this error? If so, please present it in the comment section below.

Please leave a comment if this post helped you or if you have any questions regarding this blog post.

Thanks for reading and have a nice day,

Niklas

Setting up LibGDX, Kotlin and Admob (with Android)

Sun, 22 Mar 2020 19:00:00 +0000

Hello everybody,

As regular readers of my blog know, I love functional programming. And I love Android app programming, and I hope you do too.
While programming my latest Android game Jewel Trop, I had several problems adding ads which I couldn’t solve immediately. For example, libGDX genereates three different build.gradle files, so good luck finding the right one for your dependencies.
For some of these problems I couldn’t find direct help in the Internet, so I decided to share this step-by-step guide to walk you through all of solutions and save you some time.
If you don’t care about the details and just about the code, then go straight to my GitHub project where I added all the code combined in an unchanged libGDX Project.

Without further ado, let’s do this!

Adding Android Admob/Firebase-Ads Dependency

To add support for Admob Ads in your app, open the android/build.gradle file (in your android folder) and add the following new dependency block at the very end of the file:

...
}

eclipse.project.name = appName + "-android"

dependencies {
implementation 'com.google.firebase:firebase-ads:19.0.1'
}

Enabling Android X

After you try to compile your app now, an unpleasant error will be displayed:

This project uses AndroidX dependencies, but the 'android.useAndroidX' property is not enabled. Set this property to true in the gradle.properties file and retry.
The following AndroidX dependencies are detected: androidx.versionedparcelable:versionedparcelable:1.0.0, androidx.slidingpanelayout:slidingpanelayout:1.0.0, androidx.fragment:fragment:1.0.0, androidx.core:core:1.0.0, androidx.customview:customview:1.0.0, androidx.swiperefreshlayout:swiperefreshlayout:1.0.0, androidx.interpolator:interpolator:1.0.0, androidx.loader:loader:1.0.0, androidx.drawerlayout:drawerlayout:1.0.0, androidx.viewpager:viewpager:1.0.0, androidx.collection:collection:1.0.0, androidx.localbroadcastmanager:localbroadcastmanager:1.0.0, androidx.lifecycle:lifecycle-common:2.0.0, androidx.arch.core:core-common:2.0.0, androidx.annotation:annotation:1.0.0, androidx.legacy:legacy-support-core-ui:1.0.0, androidx.lifecycle:lifecycle-livedata:2.0.0, androidx.lifecycle:lifecycle-viewmodel:2.0.0, androidx.browser:browser:1.0.0, androidx.lifecycle:lifecycle-livedata-core:2.0.0, androidx.arch.core:core-runtime:2.0.0, androidx.legacy:legacy-support-core-utils:1.0.0, androidx.documentfile:documentfile:1.0.0, androidx.cursoradapter:cursoradapter:1.0.0, androidx.lifecycle:lifecycle-runtime:2.0.0, androidx.coordinatorlayout:coordinatorlayout:1.0.0, androidx.asynclayoutinflater:asynclayoutinflater:1.0.0, androidx.print:print:1.0.0

To solve this issue, open the gradle.properties file in your root folder and add the following line to enable Android X:

org.gradle.daemon=true
org.gradle.jvmargs=-Xms128m -Xmx1500m
org.gradle.configureondemand=false
android.useAndroidX=true

Adding an AdView to your Project

Now you can add the Admob app ID in your android/AndroidManifest.xml file and an AdView to your AndroidLauncher. The minimal example for this is:

android/AndroidManifest.xml:

      </activity>
      <meta-data
            android:name="com.google.android.gms.ads.APPLICATION_ID"
            android:value="ca-app-pub-3940256099942544~3347511713" />
     </application>
 
 </manifest>

android/…/AndroidLauncher.java:

...
 public class AndroidLauncher extends AndroidApplication {
        @Override
        protected void onCreate (Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                AndroidApplicationConfiguration config = new AndroidApplicationConfiguration();
                AdView a = new AdView(this);
                initialize(new MyGdxGame(), config);
      }
...

Increase Minimum Android SDK Version

Compiling now gives you the following error message:

Manifest merger failed : uses-sdk:minSdkVersion 14 cannot be smaller than version 16 declared in library [com.google.firebase:firebase-ads:19.0.1] .../firebase-ads-19.0.1/AndroidManifest.xml as the library might be using APIs not available in 14
	Suggestion: use a compatible library with a minSdk of at most 14,
		or increase this project's minSdk version to at least 16,
		or use tools:overrideLibrary="com.google.firebase.firebase_ads" to force usage (may lead to runtime failures)

So we need to increase the minimal Android Version 16 (Android 4.1 Jelly Bean). This can be done easily in the android/build.gradle file:

     defaultConfig {
        applicationId "com.mygdx.game"
        minSdkVersion 16 //From 14
        targetSdkVersion 29
        ...

If your app compiles without any errors by now, congratulations. But for all the developers who have errors while using other big dependencies other then Admob, don’t worry, I’ve got you covered with multiple DEX files.

Too Many Classes / Multidex

The last problem on our journey is appears when we try to compile now:

Cannot fit requested classes in a single dex file (# methods: 93902 > 65536)

With all of our dependencies (in my case the amazing functional programming library Arrow) we just have too many classes in our app for one DEX file.

The solution is to add support for multiple DEX files in our app. Therefore, we add and enable the multi dex dependency in our android/build.gradle file:

...
 defaultConfig {
        applicationId "com.mygdx.game"
        minSdkVersion 16
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"
        multiDexEnabled true
    }
...

and

dependencies {
    implementation 'com.google.firebase:firebase-ads:19.0.1'
    implementation 'com.android.support:multidex:1.0.3'
}

once re-compiled, we get the following (and last) error message:

More than one file was found with OS independent path 'androidsupportmultidexversion.txt'

Because this txt file is there more than once, we have to exclude it in the android/build.gradle file:

...
packagingOptions {
    exclude 'META-INF/robovm/ios/robovm.xml'
    exclude 'androidsupportmultidexversion.txt'
}
...

As you will notice, your app will now compile without any error and your good to go. Congratulations, you’ve done it!

Conclusion

That’s it for today!

We have fixed all nasty problems towards showing ads in your own libGDX game. We enabled Android X and manifest merging for the ad dependency and multiple DEX files for all our other dependencies.
You can find all of the code combined in a vanilla libGDX Project on GitHub.

From here on, you can follow the wonderful guide by libGDX itself on how to display ads in your app or the great guide by Cansu Yeksan Aktaş.

Please leave a comment if this post helped you or if you have any questions regarding this blog post.

Thanks for reading and have a nice day,

Niklas

Learn IntelliJ Shortcuts with the IntelliJTutor

Fri, 06 Apr 2018 12:00:00 +0000

Whether it is CLion, PyCharm or IntelliJ, many people use some Jetbrain IDE in their daily life. These IDEs have many great features, work on all distributions and just make your work easier. However, most people don’t use the full potential these programs allow. Many developers don’t use any shortcuts at all, but just use their mouse or touchpad to click buttons inside the IDE.

In my eyes, that’s a real bummer. You can get much more done by using some shortcuts in your day to day work. Moving your fingers to your pointing device just slows you down. Keeping your hands on the keyboard and pressing shortcuts is much faster and more precise than moving the cursor on the screen.

To help you getting started with shortcuts, I created a project called IntelliJTutor. The tutorial is very self explanatory and you shouldn’t have any problem using it. Nevertheless, if you have any concerns with it, just create an issue or pull request on GitHub or write a command below this post.

The name and the project are an homage to the Vimtutor. When I started learning Vim with all of it shortcuts, it was so great to have the Vimtutor to guide me through the most basic commands to control Vim.

As I have to work a lot with IntelliJ and Android Studio these days, I thought it would be nice to have a tutor for these IDEs too. The shortcuts I mention in the tutorial work for WebStorm, CLion and all the other Jetbrain IDEs as well.

If you want to take a look at the tutor, you can find it here.

What do you think about this project? Is it a good start for learning shortcuts or do you find it frustrating? Please share your opinion in the comment section.

Thank you for reading and have a nice day,

Niklas

How to Set Up Wallabag on Uberspace

Sat, 11 Nov 2017 12:00:00 +0000

Today, I want to show you how to set up your own Wallabag instance on an Uberspace server.

Set Up Composer

First of all, we will need Composer for using Wallabag. You can find the guide I used for this here:

mkdir /var/www/virtual/$USER/wallabag
cd /var/www/virtual/$USER/wallabag
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('SHA384', 'composer-setup.php') === '544e09ee996cdf60ece3804abc52599c22b1f40f4323403c44d44fdfdd586475ca9813a858088ffbc1f233e9b180f061') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Set Up Wallabag

We will use this guide for installing Wallabag on our server. For that, let’s concentrate on the shared hosting part here:

wget https://wllbg.org/latest-v2-package && tar xvf latest-v2-package -C /var/www/virtual/$USER/wallabag --strip-components=1
cd /var/www/virtual/$USER/wallabag
php bin/console wallabag:install --env=prod #Remember the username + password

You can shut down this Wallabag instance, because it uses port 8000, which Uberspace doesn’t open for the outside world.

Adapt Wallabag for Uberspace

Now, we’re going to set up our domain and after that, we want to start Wallabag, but with a different port:

uberspace-add-domain -d "*.$USER.$HOSTNAME" -w
uberspace-add-port -p both -f #Remember the number of the port.
php bin/console server:start 0.0.0.0:PORTNUMBER -e prod

Finally, you have access to your Wallabag server from anywhere under $USER.$HOSTNAME:PORTNUMBER. You can login with the username and password you used when you set up Wallabag (default is Wallabag/Wallabag).

Thanks for reading and have a nice day, please leave some feedback too!

Niklas

An Ode to Android

Mon, 06 Nov 2017 12:00:00 +0000

Let’s face it: I’m an Android fanboy.

The Android Platform is one of my favorite, if not my most favorite, platform to develop for.

I want to tell you exactly why I think Google makes a good job regarding Android. Nevertheless, I also try to highlight some problems I have with Android, because be realistic: Nothing’s perfect.

The Development Environment

Back in the days, Android Development in Eclipse was such a paint. The IDE just wasn’t meant to be used for job of developing apps. Plugin Management was painful, the UI preview didn’t really work and everything crashed most of the time (at least for me).

However, Android Studio was developed to solve these problems. And it does so to an almost perfect degree. You can tell that Google keeps an eye on feedback and integrates every new tool nicely into the IDE (Kotlin, Espresso Test Recorder, …). The development of the app’s UI is just as fast and smooth as the creation of business logic. It just feels right doing all of this. Developing Android Apps is such a pleasure nowadays.

The Language

I like Java very much. In my opinion, static typing makes much more sense in big applications than dynamic typing. But I also like the design decisions behind the syntax. The functional programming techniques, which were introduced in Java 8, are also implemented nicely into Java’s ecosystem. If you want to learn more about them, check out my other posts.

Every time I read or work with Android Code, the language doesn’t get in my way. It just makes sense and is easy to understand.

The Bug Bounty System

Breaking other peoples code is a real pleasure for me ;) . Getting inside a developer’s mind and exploiting common code habits can can keep me busy for a whole weekend. And bug bounty reports are by far the most fascinating blog posts for me.

However, this task is even more rewarding now, because Google expanded it’s bug bounty program onto some Android Apps last month. Now, you can make real money reporting issues you found and learn so much about the Android system while searching bugs.

The Testing Environment

As a developer who cares a lot about testing, I want to make sure that every released app of mine works as intended. I don’t want to release buggy software. Android makes it so easy to do achieve this goal. Espresso and Robolectric are so intuitive and they just work. And if you also use Kotlin in your projects, it’s easy to make your tests even more readable with extension functions.

It just feels right to write tests. This is so important in an environment where few people practice TDD and just rely on luck to find bugs.

Contributing

When I’m working on a new project, it’s always easy to get started. The amazing work Google does at documenting Android features is one of the best reasons for that.

What’s more, every time I have a problem, there is someone in an IRC chat or part of an email list who can give me a quick answer. When I develop for other platforms, I haven’t felt this invited in their communities.

But of course, not everything’s good about Android. There are still problems that this platform has and which simply annoy me as a developer.

New year = New Android Version

Let’s be clear: It’s awesome when a platform develops over time. But maybe Google should give us the time to really embrace new features.

Not even a quarter of the Android users use Android N at this time. Still, there is Oreo coming out right now.

However, you can’t use all of the new features and upgrade the minimum SDK Version of your app. This is because most of the users don’t buy a new phone with the latest Android version every year. Also, phone manufactures usually don’t provide new Android versions for their older phones. And not everybody wants to use a custom OS on their device.

Google should just give the developers and users more time to adapt to a new Android Version.

Conclusion

To sum everything up: The Android platform is an superb platform for developers. Google provides an awesome IDE and documentation which doesn’t leave anyone behind. The community is amazing as well.

Still, the system’s not perfect. Google should slow down the release cycle so that the developers and users can adapt better to every new Android version.

What’s your opinion on all of this? Which parts of the Android ecosystem do you love or hate? Please write a comment and check out my other blog posts too!

Thanks for reading and have a nice day,

Niklas

An Introduction to Functional Programming in Java 8: Part 4 - Splitter

Fri, 10 Mar 2017 12:00:00 +0000

Hello everybody,

In the last parts, we’ve learned about the most basic ways to program functional in Java. We used functions as Objects, Streams and so much more.

Today, we want to create a useful example with them. You will train the paradigms of the last parts and learn how the optimize the run time of your program.

Example: Split a Stream by a specific filter

You might have stumbled over a problem like this before: You have a collection of objects and want to split them by a specific filter. After that, you want to perform some action with all elements who passed the test and another action with the ones that didn’t passed the test.

The Basic (and Slow) Approach

public <T> void splitAndPerform(Collection<T> items, Predicate<T> splitBy, Consumer<T> passed, Consumer<T> notPassed) {
    items.stream()
        .filter(splitBy)
        .forEach(passed);

    items.stream()
        .filter(splitBy.negate())
        .forEach(notPassed);
}

This approach works, but it is pretty slow. The run time for splitting alone is O(2n), because we go through the whole collection 2 times: Ones to get all the items that passed the test and ones to get all the items that didn’t passed it.

But what if we would create a splitter on our own? It’d sort all items in the collection, depending on whether or not they pass the test, into one List or the other. This would lower the run time to split the collection to O(n), because you just have to call filter once, not twice.

So let’s do this.

The Better Approach

1. Split the Collection

The first step to building our splitter is to, you guessed it, split it.

In our splitBy() function, we want to take a Predeciate<T> as a parameter and return a new Splitter object, which is basically an object which consists of two Lists. One List consists of all the objects that passed the test, and the other one of all the objects that didn’t pass the test.

public class Splitter<T> {

    private List<T> passed;
    private List<T> notPassed;

    private Splitter(List<T> passed, List<T> notPassed) {
        this.passed = passed;
        this.notPassed = notPassed;
    }

    public static <T> Splitter<T> splitBy(Collection<T> items,Predicate<T> test) {
        List<T> passed = new LinkedList<T>();
        List<T> notPassed = new LinkedList<T>();

        items.stream()
                .forEach(item -> {
                    if(test.test(item)){
                        passed.add(item);
                        return;
                    }
                    notPassed.add(item);
                });

        return new Splitter<T>(passed, notPassed);
    }

}

As you can see, we used the factory method pattern to make the creation of the Splitter nicer.

Now that we can create a Splitter object, we want to give it some functionality.

2. Work With the Split Lists

We want to work with the Lists in the same way that we can work with Streams. But we don’t want to recreate every function that a Stream has for our two lists. That’s where a nice design pattern comes in handy. I heard about it in this talk and it’s a very cool way to use lambdas. We basically create two new functions, called workOnPassedItems and workOnNotPassedItems. They take a Consumer<Stream<T>>. Therefore, we can create a lambda and work inside it with a normal looking stream. This method will then be applied onto the List of passed and not passed items.

public class Splitter<T> {

    //...

    public Splitter<T> workWithPassed(Consumer<Stream<T>> func) {
        func.accept(passed.stream());
        return this;
    }

    public Splitter<T> workWithNotPassed(Consumer<Stream<T>> func) {
        func.accept(notPassed.stream());
        return this;
    }

}

We used the cascade design pattern to make the use of multiple methods nicer. You will see it in the example down below.

And that’s basically our Splitter! Now, we can try out some examples on how to use it.

Example 1: Showing numbers, but squaring all odd numbers

In this very first example we want to operate over a list of numbers. For each even number, we just want to print this number out. But for every odd number, we want to square them before we print them out.

So first off, we want to split the list into even and odd numbers. After that, we can work on the lists as already told.

public void workOnNumbers() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

    Splitter.splitBy(numbers, num -> num%2 == 0)
            .workWithPassed(passed ->
                    passed.forEach(even -> System.out.println("" + even + " -> " + even)))
            .workWithNotPassed(notPassed ->
                    notPassed.map(odd -> odd * odd)
                            .forEach(odd -> System.out.println("" + Math.sqrt(odd) + " -> " + odd)
            ));
}

Example 2: Sending all Winners a Confirmation and all Losers a Cancellation

Now, we have a List of Candidates. All of these people have a method called hasWon(), which gives back a boolean. We want to split the List into Winners and Losers. After that, we want to send all Winners a confirmation that they won, and all losers a cancellation that they lost. So let’s do this!

public void sendEmails(List<Candidates> candidates) {
    Splitter.splitBy(candidates, Candidates::hasWon)
            .workWithPassed(winners ->
                    winners.forEach(winner -> Email.send(winner.getEmail(), "You won!"))
    )
    .workWithNotPassed(losers ->
            losers.forEach(loser -> Email.send(loser.getEmail(), "You lost, sorry!"))
    );
}

Update: On Using partitioningBy

After the post’s out for a day now, a lot of you have given feedback. And I really appreciate it! You told me about ways to make the Splitter class better.

One of the discussed things is the use of Stream.collect(Collectors.partitioningBy(Predicate<T> test)). And I totally agree that it could be useful in our scenario.

It partitions the Stream depending on a test function. So for us, the map would look something like this: {true: passed, false: notPassed}. After that, we just take the two lists out of the map and go on.

So as Philboyd_Studge mentioned on Reddit, the new splitBy method could look something like this:

public static <T> Splitter<T> splitBy(Collection<T> items,Predicate<T> test) {

        Map<Boolean, List<T>> map = items.stream()
                .collect(Collectors.partitioningBy(test));

        return new Splitter<T>(map.get(true), map.get(false));
}

And I have to admit that this takes out a lot of noise. It just looks nicer than the splitBy method above. So thank you for that!

So what’s the Splitter’s Right to Exist?

The Splitter’s purpose is to demonstrate how you can work with functions as objects. Its purpose is not to replace some methods in the JDK.

It’s a class for learning and playing around. If you want to tweak around, just do it. Please leave a comment on what you have learned or where you have optimized the class, so that others can learn from it too.

In addition, we learned about design patterns. Some of you even told me that they learned new design patterns in this blog post.

The patterns help to make the syntax nicer. When you split your collection in two parts, it’s nicer to use the cascade pattern in the Splitter than to handle a Map.

Conclusion

That’s it for today!

We have learned how to create our first useful class with the help of Streams. We also optimized the run time of our program with it. Therefore, we have trained our knowledge about design patterns like the factory method and the cascade pattern.

Lastly, we have tried out our splitter with some examples.

Next time, we will talk about RxJava. It’s a framework that uses the observer pattern for asynchronous tasks and builds upon functional programming.

Are there any things that your splitter should do too? Please let me know in the comments. I’d love to hear your feedback too!

Thanks for reading and have a nice day,

Niklas

An Introduction to Functional Programming in Java 8: Part 3 - Streams

Sat, 18 Feb 2017 12:00:00 +0000

Hello everybody,

In the last part, we’ve learned about the Optional type and how to use it correctly.

Today, we will learn about Streams, which you use as an functional alternative of working with Collections. Some method were already seen when we used Optionals, so be sure to check out the part about Optionals.

Where do we use Streams?

You might ask what’s wrong with the current way to store multiple objects? Why shouldn’t you use Lists, Sets and so on anymore?

I want to point out: Nothing is wrong with them. But when you want to work functional (what you hopefully want after the last parts of this blog), you should consider using them. The standard workflow is to convert your data structure into a Stream. Then you want to work on them in a functional manner and in the end, you transform them back into the data structure of your choice.

And that’s the reason we will learn to transform the most common data structures into streams.

Why do we use Streams?

Streams are a wonderful new way to work with data collections. They were introduced in Java 8. One of the many reasons you should use them is the Cascade pattern that Streams use. This basically means that almost every Stream method returns the Stream again, so you can continue to work with it. In the next sections, you will see how this works and that it makes the code nicer.

Streams are also immutable. So every time you manipulate it, you create a new Stream.

Another nice thing about them is that they respect the properties of fP. If you convert a Data Structure into a Stream and work on it, the original data structure won’t be changed. So no side effects here!

How to Convert Data Structures into Streams

Convert Multiple Objects into a Stream

If you want to make a Stream out of some objects, you can use the method Stream.of()

public void convertObjects() {
    Stream<String> objectStream = Stream.of("Hello", "World");
}

Converting Collections (Lists, Sets, …) and Arrays

Luckily, Oracle has thought through the implementation of Streams in Java 8. Every Class that implements java.util.Collection<T> has a new method called stream() which converts the collection into a Stream. Also Arrays can be converted easily with Arrays.stream(array). It’s as easy as it get’s.

public void convertStuff() {
    String[] array = {"apple", "banana"};
    Set<String> emptySet = new HashSet<>();
    List<Integer> emptyList = new LinkedList<>();

    Stream<String> arrayStream = Arrays.stream(array);
    Stream<String> setStream = emptySet.stream();
    Stream<Integer> listStream = emptyList.stream();
}

However, normally you won’t store a Stream in an object. You just work with them and convert them back into your desired data structure.

Working with Streams

As I already said, Streams are the way to work with data structures functional. And now we will learn about the most common methods to use.

As a side note: In the next sections, I will use T as the type of the objects in the Stream.

Methods we already know

You can use some methods we already heard about when we learned about Optionals also with Streams.

map

This works pretty straight forward. Instead of manipulating one item, which might be in the Optional, we manipulate all items in a stream. So if you have a function that squares a number, you can use map to use this function over multiple numbers without writing a new function for lists.

public void showMap() {
    Stream.of(1, 2, 3)
        .map(num -> num * num)
        .forEach(System.out::println); // 1 4 9
}

flatMap

Like with Optionals, we use flatMap to going e.g from a Stream<List<Integer>> to Stream<Integer>. If you want to know more about look into part 2.

Here, we want to concat multiple Lists into one big List.

public void showFlatMapLists() {
    List<Integer> numbers1 = Arrays.asList(1, 2, 3);
    List<Integer> numbers2 = Arrays.asList(4, 5, 6);

    Stream.of(numbers1, numbers2) //Stream<List<Integer>>
        .flatMap(List::stream)  //Stream<Integer>
        .forEach(System.out::println); // 1 2 3 4 5 6
}

And in these examples, we already saw another Stream method, forEach(), which I will describe now.

Common Stream methods

forEach

The forEach method is like the ifPresent method from Optionals, so you use it when you have side effects. As already shown, you use it to e.g. print all objects in a stream. forEach is one of the few Stream methods that doesn’t return the Stream, so you use it as the last method of a Stream and only once.

You should be careful when using forEach, because it causes side effects which we don’t won’t to have. So think twice if you could replace it with another method without side effects.

public void showForEach() {
    Stream.of(0, 1, 2, 3)
        .forEach(System.out::println); // 0 1 2 3
}

filter

Filter is a really basic method. It takes a ‘test’ function that takes a value and returns boolean. So it test every object in the Stream. If it passes the test, it will stay in the Stream or otherwise, it will be taken out.

This ‘test’ function has the type Function<T, Boolean>. In the JavaDoc, you will see that the test function really is of the type Predicate<T>. But this is just a short form for every function that takes one parameter and returns a boolean.

public void showFilter() {
    Stream.of(0, 1, 2, 3)
        .filter(num -> num < 2)
        .forEach(System.out::println); // 0 1
}

Functions that can make your life way easier when creating ‘test’ functions are Predicate.negate() and Objects.nonNull().

The first one basically negates the test. Every object which doesn’t pass the original test will pass the negated test and vice versa.

The second one can be used as a method reference to get rid of every null object in the Stream. This will help you to prevent NullPointerExeptions when e.g. mapping functions.

public void negateFilter() {
    Predicate<Integer> small = num -> num < 2;

    Stream.of(0, 1, 2, 3)
        .filter(small.negate()) // Now every big number passes
        .forEach(System.out::println); // 2 3
}

public void filterNull() {
    Stream.of(0, 1, null, 3)
        .filter(Objects::nonNull)
        .map(num -> num * 2) // without filter, you would've got a NullPointerExeception
        .forEach(System.out::println); // 0 2 6
}

collect

As I already said, you want to transform your stream back into another data structure. And that is what you use Collect for. And most of the times, you convert it into a List or a Set.

public void showCollect() {
    List<Integer> filtered = Stream.of(0, 1, 2, 3)
        .filter(num -> num < 2)
        .collect(Collectors.toList());
}

But you can use collect for much more. For example, you can join Strings. Therefore, you don’t have the nasty delimiter in the end of the string.

public void showJoining() {
    String sentence = Stream.of("Who", "are", "you?")
        .collect(Collectors.joining(" "));

    System.out.println(sentence); // Who are you?

}

Shortcuts

These are methods which you could mostly emulate by using map, filter and collect, but these shortcut method are meant to be used because they declutter your code.

reduce

Reduce is a very cool function.

It takes a start parameter of type T and a Function of type BiFunction<T, T, T>. If you have a BiFunction where all types are the same, BinaryOperator<T> is a shortcut for that.

It basically stores all objects in the stream to one object. You can concat all Strings into one String, sum all numbers and so on. There, your start parameters would be the empty String or zero. This function helps a lot to make your code more readable if you know how to use it.

public void showReduceSum() {
    Integer sum = Stream.of(1, 2, 3)
        .reduce(0, Integer::sum);

    System.out.println(sum); // 6
}

Now I will give a little bit more information how reduce works. Here, it sums

the first number with

the sum of the second and

the sum of the third and start parameter.

As you can see, this produces a long chain of functions. In the end, we have sum(1, sum(2, sum(3, 0))). And this will be computed from right to left, or from the inside out. This is also the reason we need a start parameter, because otherwise the chain would’nt have a point where it could end.

sorted

You can also use Streams to sort your data structure.

The class type of the objects in the Stream doesn’t even have to implement Comperable<T>, because you can write your own Comperator<T>. This is basically a BiFunction<T, T, int>, but Comperator is a shortcut for all BiFunctions that take 2 arguments of the same type and return an int.

And this int, like in the compareTo() function, shows us if the first object is “smaller” than the first one (int < 0), is as big as the second (int == 0), or is bigger than the second one (int > 0). The sorted function of the Stream will interpret these ints and will sort the elements with the help of them.

public void showSort() {
    Stream.of(3, 2, 4, 0)
        .sorted((c1, c2) -> c1 - c2)
        .forEach(System.out::println); // 0 2 3 4
}

Other Kinds of Streams

There are also special types of Streams which only contains numbers. With these new Streams you also have a new set of methods.

Here, I will introduce IntStream and Sum, but there are also LongStream, DoubleStream,… . You can read more about them in the JavaDoc.

To convert a normal Stream into an IntStream, you have to use mapToInt. It does exactly the same as the normal map, but you get a IntStream back. Of course, you have to give the mapToInt function another function which will return an int.

In the example, I will show you how to sum numbers without reduce, but with an IntStream.

public void sumWithIntStream() {
    Integer sum = Stream.of(0, 1, 2, 3)
        .mapToInt(num -> num)
        .sum();
}

Use Streams for Tests

Tests can also be used to test your methods. I will use the method anyMatch here, but count, max and so on can help you too.

If something goes wrong in your program, use peek to log data. It’s like forEach, but also returns the stream. As always, look into the JavaDoc to find other cool methods.

anyMatch is a little bit like filter, but it tells you if anything passes the filter. You can use this in assertTrue() tests, where you just want to look if at least one object has a specific property.

In the next example, I will test if a specific name was stored in the DB.

@Test
public void testIfNameIsStored() {
    String testName = "Albert Einstein";

    Datebase names = new Datebase();
    names.drop();

    db.put(testName);
    assertTrue(db.getData()
        .stream()
        .anyMatch(name -> name.equals(testName)));
}

Shortcuts of Shortcuts

And after I showed you some shortcut methods, I want to tell you that there are many, many more. There are even shortcuts of shortcuts! One Example would be max, which combines sorted and findFirst.

If you are interested in other helpful methods, look into the JavaDoc. I’m sure you are prepared to understand it and find the methods that you need. Always remember: If your code looks ugly, there’s a better method to use ;).

A Bigger Example

In this example, we want to send a message to every user whose birthday’s today.

The User Class

A user is defined by their username and birthday. The birthdays will be in the format “day.month.year”, but we won’t do much checking for this in today’s example.

public class User {

    private String username;
    private String birthday;

    public User(String username, String birthday) {
        this.username = username;
        this.birthday = birthday;
    }

    public String getUsername() {
        return username;
    }

    public String getBirthday() {
        return birthday;
    }

}

To store all users, we will use a List here. In a real program, you might want to switch to a DB.

public class MainClass {

    public static void main() {
        List<User> users = new LinkedList<>();

        User birthdayChild = new User("peter", "20.02.1990");
        User otherUser = new User("kid", "23.02.2008");
        User birthdayChild2 = new User("bruce", "20.02.1980");

        users.addAll(Arrays.asList(birthdayChild, otherUser, birthdayChild2));

        greetAllBirthdayChildren(users);
    }

    private static void greetAllBirthdayChildren(List<User> users) {
        // Next Section
    }

}

The Greeting

Now, we want to greet the birthday children.

So first off, we have to filter out all Users whose birthday is today. After this, we have to message them. So let’s do this.

I won’t implement sendMessage(String message, User receiver) here, but it just sends a message to a given user.

public static void greetAllBirthdayChildren(List<User> users) {
    String today = "20.02"; //Just to make the example easier. In production, you would use LocalDateTime or so.
    users.stream()
        .filter(user -> user.getBirthday().startsWith(today))
        .forEach(user -> sendMessage("Happy birthday, ".concat(user.getUsername()).concat("!"), user));
}

private static void sendMessage(String message, User receiver) {
    //...
}

And now we can send greetings to the users. How nice and easy was that?!

Parallelism

Streams can also be executed parallel. By default, every Stream isn’t parallel, but you can use .parallelStream() with Streams to make them parallel.

Although it can be cool to use this to make your program faster, you should be careful with it. As shown on this Site, things like sorting can be messed up by parallelism.

So be prepared to run into nasty bugs with parallel Streams, although it can make your program significantly faster.

Conclusion

That’s it for today!

We have learned a lot about Streams in Java. We learned how to convert a data structure into a Stream, how to work with a Stream and how to convert your Stream back into a data structure.

I have introduced the most common methods and when you should use them.

In the end, we tested our knowledge with a bigger example where we greeted all birthday children.

In the next part of this series, we will have a big example where we are going to use Streams. But I won’t tell you the example yet, so be surprised.

Are there any Stream methods that you miss in the post? Please let me know in the comments. I’d love to hear your feedback too!

Thanks for reading and have a nice day,

Niklas

An Introduction to Functional Programming in Java 8: Part 2 - Optionals

Sat, 04 Feb 2017 12:00:00 +0000

Hello everybody,

After we’ve made our first big steps into functional programming in the last post, we will talk about Optionals in today’s part.

Why do we need Optionals?

Hand on heart, you also think that null is annoying, don’t you? For every argument which can be null, you have to check whether it is null or not.

if(argument == null) {
    throw new NullPointerException();
}

These lines suck! This is a boilerplate that bloats up your code and can be easily forgotten. So how can we fix that?

Introducing Optionals

In Java 8, java.util.Optional<T> was introduced to handle objects which might not exist better. It is a container object that can hold another object. The Generic T is the type of the object you want to contain.

Integer i = 5;
Optional<Integer> optinalI = Optional.of(i);

The Optional class doesn’t have any public constructor. To create an optional, you have to use Optional.of(object) or Optional.ofNullable(object). You use the first one if the object is never, ever null. The second one is used for nullable objects.

How do optionals work?

Options have two states. They either hold an object or they hold null. If they hold an object, optionals are called present, if they hold null, they are called empty. If they are not empty, you can get the object in the optional by using Optional.get(). But be careful, because a get() on an empty optional will cause a NoSuchElementException. You can check if a optional is present by calling the method Optional.isPresent()

Example: Playing with Optionals

public void playingWithOptionals() {
    String s = "Hello World!";
    String nullString = null;

    Optional<String> optionalS1 = Optional.of(s); // Will work
    Optional<String> optionalS2 = Optional.ofNullable(s); // Will work too
    Optional<String> optionalNull1 = Optional.of(nullString); // -> NullPointerException
    Optional<String> optionalNull2 = Optional.ofNullable(nullString); // Will work

    System.out.println(optionalS1.get()); // prints "Hello World!"
    System.out.println(optionalNull2.get()); // -> NoSuchElementException
    if(!optionalNull2.isPresent()) {
        System.out.println("Is empty"); // Will be printed
    }
}

Common problems when using Optionals

1. Working with Optional and null

public void workWithFirstStringInDB() {
    DBConnection dB = new DBConnection();
    Optional<String> first = dB.getFirstString();

    if(first != null) {
        String value = first.get(); 
        //... 
    }
}

This is just the wrong use of an Optional! If you get an Optional (In the example you get one from the DB), you don’t have to look whether the object is null or not! If there’s no string in the DB, it will return Optional.empty(), not null! If you got an empty Optional from the DB, there would also be a NoSuchElementException in this example.

2. Using isPresent() and get()

2.1. Doing something when the value is present

public void workWithFirstStringInDB() {
    DBConnection dB = new DBConnection();
    Optional<String> first = dB.getFirstString();

    if(first.isPresent()) {
        String value = first.get(); 
        //... 
    }
}

As I already said, you should always be 100% sure if an Optional is present before you use Optional.get(). You wouldn’t get a NoSuchElementException anymore in the updated function. But you shouldn’t check a optional with the isPresent() + get() combo! Because if you do it like that, you could have used null in the first place. You would replace first.isPresent() with first != null and you have the same result. But how can we replace this annoying if-block with the help of Optionals?

public void workWithFirstStringInDB() {
    DBConnection dB = new DBConnection();
    Optional<String> first = dB.getFirstString();

    first.ifPresent(value -> /*...*/);
}

The Optional.ifPresent() method is our new best friend to replace the if. It takes a Function, so a Lambda or method reference, and applies it only when the value is present. If you don’t remember how to use method references or Lambdas, you should read the last part of this series again.

You use ifPresent() when you want to do something that produces a side effect. Storing something in the DB and IO are two common examples for side effects. If you don’t need side effects, you shouldn’t use ifPresent(), but map(), which is part of the next section.

2.2. Returning a Modified Version of the Value

public Integer doubleValueOrZero(Optional<Integer> value) {
    if(value.isPresent()) {
       return value.get() * 2;
    }

    return 0;
}

In this method, we want to double the value of an optional, if it is present. Otherwise, we return zero. The given example works, but it isn’t the functional way of solving this problem. To make this a lot nicer, we have two function that are coming to help us. The first one’s Optional.map(Function<T, R> mapper) and the second one’s Optional.orElse(T other). map takes a function, applies it on the value and returns the result of the function, wrapped in an Optional again. If the Optional is empty, it will return an empty Optional again. orElse returns the value of the Optional it is called on. If there is no value, it returns the value you gave orElse(object) as a parameter. With that in mind, we can make this function a one liner.

public Integer doubleValueOrZero(Optional<Integer> value) {
    return value.map(i -> i * 2).orElse(0);
}

Using flatMap()

There is another really cool method that you can use with Optionals. It’s called flatMap().

When you use map on a method that returns an Optional, you basically get an Optional<Optional<T>>. But you don’t want two containers abound your object! But you also don’t want to rewrite the method nor do you want to call get() or orElse() two times to get the value.

This is the reason there is flatMap. It flattens the Optional<Optional<T>> to Optional<T>. In our example, we want to divide 2 Integers. But if we divide by zero, we return Optional.empty(). So if we use map and divide, we have a object of type Optional<Optional<Double>>. That’s the reason we use flatMap here.

public void showFlatMap() {
    Optional<Double> two = Optional.of(2.0);
    Optional<Double> zero = Optional.of(0.0);
    two.flatMap(num -> divide(1.0, num)).orElse(0.0); // 0.5
    zero.flatMap(num -> divide(1.0, num)).orElse(0.0); // 0.0
}

public Optional<Double> divide(Double first, Double second) {
    if(second == 0.0) {
       return Optional.empty();
    }

    return Optional.of(first / second);
}

When Should you use Nullable Objects and when Optionals?

You can find a lot of books, talks and discussions about the question: Should you use null or Optional in some particular case. And both have their right to be used. In the linked talk, you will find a nice rule which you can apply in most of the cases. Use Optionals when “there is a clear need to represent ‘no result’ or where null is likely to cause errors.”.

So you shouldn’t use Optionals like this:

public String defaultIfOptional(String string) {
    return Optional.ofNullable(string).orElse("default");
}

Because a null check is much easier to read.

public String defaultIfOptional(String string) {
    return (string != null) ? string : "default";
}

You should use Optionals just as a return value from a function. It’s not a good idea to create new ones to make a cool method chain like in the example above. Most of the times, null is enough.

Conclusion

That’s it for today! We have played with the Optional class. It’s a container class for other classes which is either present or not present(empty). We have removed some common code smell that comes with Optionals and used functions as objects again. We also discussed when you should use null and when Optionals.

In the next part, we will use Streams as a new way to handle a Collection of Objects.

Thanks for reading and have a nice day,

Niklas