Emanuele Papa RSS Feed

Test GitHub Actions workflows on a branch before merging

Emanuele Papa — Mon, 29 Dec 2025 00:00:00 GMT

If you’re developing a new GitHub Actions workflow, you may want to test it on a feature branch before merging it into your default branch. Unfortunately, GitHub Actions has a limitation: workflows that only exist on a branch and use workflow_dispatch cannot be triggered until GitHub has “seen” them at least once.

In this guide, we’ll walk through a simple and reliable workaround to test GitHub Actions workflows on a branch using a temporary push trigger and the GitHub CLI.

📝 Prerequisites

Before starting, make sure you have:

A GitHub repository with Actions enabled
A feature branch where you’re developing the workflow
GitHub CLI (gh) installed and authenticated
Basic familiarity with GitHub Actions YAML syntax

🛠️ Step-by-step: Testing a GitHub Actions workflow on a branch

1. Create a skeleton workflow triggered by `push`

On your feature branch, create a new workflow file under .github/workflows/, starting with a minimal trigger using push:

on:
  push:

At this stage, the job can be incomplete or just a placeholder. The important part is that the workflow runs at least once. Push the branch to GitHub so the workflow is executed.

💡 You can cancel the job immediately if you don’t want it to finish.

2. Let GitHub register the workflow

Once the workflow has run a single time, GitHub internally registers it. This is a key step: without it, GitHub won’t allow manual triggers from branches. After the first run, you no longer need the push trigger.

3. Replace `push` with `workflow_dispatch`

Now update the workflow to use workflow_dispatch:

on:
  workflow_dispatch:

Push the updated workflow to the same branch. Even though the workflow no longer triggers automatically, GitHub still recognizes it.

4. Trigger the workflow using GitHub CLI

You can now manually run the workflow directly from your branch using the GitHub CLI:

gh workflow run <workflow-file-name>.yaml -r <branch-name>

This allows you to:

Test the workflow repeatedly
Iterate quickly without touching the default branch

5. Continue developing and testing

As long as the workflow file remains in the branch, you can keep triggering it via gh until it’s fully tested and ready to be merged. No additional push runs are required.

✅ Conclusion

Testing GitHub Actions workflows on feature branches can be tricky due to current platform limitations. By temporarily enabling a push trigger, letting the workflow run once, and then switching to workflow_dispatch, you can safely and effectively test your workflow without polluting your default branch. Until GitHub provides better native support for branch-only manual workflows, this workaround is one of the cleanest and most practical solutions available.

You can read more in this GitHub discussion.

Happy automating 🚀

How to change Proxmox IP address when moving to a different network

Emanuele Papa — Wed, 11 Jun 2025 00:00:00 GMT

If you’ve migrated your Proxmox server to a different network, you might find yourself unable to access the web interface or SSH due to an outdated IP configuration. In this guide, we’ll see the necessary steps to update the IP address and restore connectivity to your Proxmox VE node.

📝 Prerequisites

Before starting, ensure you have:

Physical or console access to your Proxmox server
Root privileges
Knowledge of your new network configuration (IP address, subnet mask, gateway, DNS servers)

🛠️ Step-by-Step: Changing Proxmox IP address

1. Access the server via console

If the old IP no longer works due to the network change, you’ll need to access your server physically or through a remote management console provided by your hosting provider.

2. Update the Network Configuration File

Proxmox stores its static network settings in the /etc/network/interfaces file. Open it with your preferred text editor like:

nano /etc/network/interfaces

Look for a section similar to this:

auto vmbr0
iface vmbr0 inet static
    address 192.168.1.100/24
    gateway 192.168.1.1
    bridge-ports eth0
    bridge-stp off
    bridge-fd 0

Update the address and gateway values to match the new network configuration. For example:

address 192.168.100.50/24
gateway 192.168.100.1

Save and exit.

3. Update `/etc/hosts`

To avoid hostname resolution issues, update your /etc/hosts file:

nano /etc/hosts

Find and modify the line referencing the old IP:

192.168.1.100 proxmox.yourdomain.local pve

Change it to the new IP:

192.168.100.50 proxmox.yourdomain.local pve

4. Check DNS Settings

If you’re using custom DNS servers, make sure they are updated:

nano /etc/resolv.conf

For example:

# Option 1: If using public DNS servers
nameserver 1.1.1.1

# Option 2: If your DNS servers are on your gateway
nameserver 192.168.100.1

5. Restart Networking

You can either restart the networking service or reboot the entire system:

# Option 1: Restart networking
systemctl restart networking

# Option 2: Reboot
reboot

6. Verify the new configuration

Now, try accessing the Proxmox web interface using the new IP at https://192.168.100.50:8006

✅ Conclusion

Changing the IP address in Proxmox after moving to a different network is straightforward once you know where the settings live. Just be sure to update /etc/network/interfaces, /etc/hosts, /etc/resolv.conf and restart networking.
With these steps, your node should be up and reachable on the new network. Bear in mind, if your Proxmox server is part of a cluster, you might need to update additional files not covered in this blog post.

Block ads using DNS over TLS with AdGuard Home, Let's Encrypt, and Cloudflare for Android Devices

Emanuele Papa — Tue, 22 Oct 2024 00:00:00 GMT

DNS over TLS (DoT) is a security protocol that encrypts DNS queries, providing enhanced privacy and security. This guide will walk you through setting up AdGuard Home to serve DNS over TLS using your custom domain, secured with a Let’s Encrypt certificate. We’ll use Cloudflare for DNS management and integrate Home Assistant for automation. By the end, your Android devices will be able to use secure DNS queries to your AdGuard Home server. We will be focusing on Android devices but iOS devices can use it as well!

Prerequisites

Before starting, ensure you have:

A registered domain name.
An active Cloudflare account managing your domain.
A running instance of Home Assistant.
AdGuard Home installed and running.

Step 1: Create DNS Records in Cloudflare

To enable DNS over TLS, you’ll need to set up the necessary DNS records in Cloudflare.

Create an A Record:

Log in to your Cloudflare dashboard.
Navigate to the DNS settings of your domain.
Create a new A record with the following details:
- Name: dns
- IPv4 Address: Your server's public IP address (this will be updated automatically by the HomeAssistant Cloudflare integration, don’t worry!)
- TTL: Auto
- Proxy status: DNS only (unproxied).

Create a CNAME Record:

Still in DNS settings, create a CNAME record:
- Name: *.dns
- Target: dns.yourdomain.com
- TTL: Auto
- Proxy status: DNS only (unproxied).

These records ensure that both dns.yourdomain.com and any subdomains will direct traffic to your AdGuard Home instance. This is useful to be able to create clientname.dns.yourdomain.com to identify different clients by different hostnames.

Step 2: Configure Cloudflare Integration in Home Assistant

Home Assistant can automate updating your Cloudflare DNS records if your server’s IP address changes.

Create API Tokens in Cloudflare:

To interact with Cloudflare API we need two different tokens:

used in the Cloudflare HomeAssistant Integration to update the DNS record with our IP
used in the Let’s Encrypt HomeAssistant add-on to automate DNS challenges for domain validation

To generate those:

Go to My Profile > API Tokens in your Cloudflare account.
Click Create Token.
Use the Create Custom Token button and add the following permissions for your domain Zone:
- Zone:Zone:Read and Zone:DNS:Edit for Token 1
- Zone:DNS:Edit for Token 2
Copy the generated token.

Install and configure the Cloudflare Integration:

In Home Assistant, go to Settings > Integrations.
Search for Cloudflare and install the integration.
Set it to update the dns.yourdomain.com A record whenever your IP changes.

Note: it seems that it doesn’t run automatically as soon as it’s setup, so either you enter your current IP address in previous step, or you run the integration to update it for you using the service cloudflare.update_records. After that, it will run automatically every hour to update your IP.

Step 3: Obtain and Configure Let’s Encrypt Certificates

Next, secure your domain with a Let’s Encrypt SSL certificate to enable DNS over TLS.

Install the Let’s Encrypt Add-on in Home Assistant:

In Home Assistant, navigate to Supervisor > Add-on Store.
Find and install the Let’s Encrypt add-on.

Configure the Let’s Encrypt Add-on:

Set the domains to dns.yourdomain.com and *.dns.yourdomain.com.
Set the challenge to dns.
Enter your Cloudflare API token to automate DNS challenges.
Start the add-on to generate your certificates.

Set Up Automatic Certificate Renewal:

In Home Assistant, navigate to Settings > Automations and Scenes > Automations
Click on Create Automation
Use the following YAML and save the automation

alias: Start Let's Encrypt Add-on at Midnight
description: Start the Let's Encrypt add-on every day at midnight
mode: single
triggers:
  - at: "00:00:00"
    trigger: time
actions:
  - data:
      addon: core_letsencrypt
    action: hassio.addon_start

Step 4: Configure AdGuard Home for DNS over TLS

With the SSL certificate ready, you can now configure AdGuard Home to support DNS over TLS.

Go to AdGuard Home’s web interface.
Navigate to Settings > Encryption.
Set the Server Name to dns.yourdomain.com.
Use default certificate path as we didn’t change it in Let’s Encrypt add-on configuration
Ensure certificate chain is validated (green lights)
Save and Apply Settings

Your AdGuard Home server is now configured to serve DNS over TLS.

Step 5: Configure Android Devices for DNS over TLS

Different Android devices might have slightly different steps to setup DNS over TLS, but generally to use your new DNS over TLS setup on Android devices follow these steps:

Open Settings > Network & Internet.
Tap Private DNS.
Choose Private DNS provider hostname.
Enter dns.yourdomain.com or clientname.dns.yourdomain.com (if you want to use client names, go to Settings > Client Settings on AdGuard and add needed clients)

Your Android device will now use DNS over TLS with your AdGuard Home server, ensuring encrypted DNS queries. If your device says that your DNS over TLS server doesn’t exist, please check everything is configured above, or wait a bit of time to allow the DNS system to propate your configuration.

Conclusion

By following these steps, you’ve successfully configured AdGuard Home to provide DNS over TLS, secured with a Let’s Encrypt certificate and managed through Cloudflare. Your Android devices are now equipped to handle encrypted DNS queries, enhancing your privacy and security. This setup not only secures your DNS traffic but also allows for easy management and automation using Home Assistant.

Feel free to adjust the steps to fit your environment, and enjoy a more secure internet experience on your Android devices.

Synchronize AdGuard Home instances with Docker and Proxmox

Emanuele Papa — Tue, 23 Apr 2024 00:00:00 GMT

In today’s digital age, ensuring privacy and security on our networks has become increasingly important. AdGuard Home, a powerful network-wide ad blocking and privacy protection tool, has gained popularity for its effectiveness in achieving these goals. However, managing multiple instances of AdGuard Home across different devices in a homelab setup can be cumbersome. In this article, we’ll explore how I tackled this challenge by using the AdGuard Home Sync tool, simplifying the synchronization process and ensuring consistent filtering and configuration across all my devices.

What is AdGuard Home Sync

adguardhome-sync is a handy tool available on GitHub, designed to streamline the process of synchronizing configurations, whitelists, and blocklists across multiple AdGuard Home instances. By automating this synchronization, users can maintain uniform settings and preferences across their entire network effortlessly.

Installation steps

Here, I’m assuming you already have setup two (or more) instances of AdGuard Home. You can follow one of the option provided in the adguardhome-sync repository to setup AdGuard Home sync, but here we will setup it using docker in a proxmox environment, while having 1 AdGuard Home instance hosted by HomeAssistant, and another 1 hosted using docker.

Ensure both your AdGuard Home instances are up and running
Ensure you have a Proxmox home server set up and running
Use the Proxmox main shell to create an Alpine Docker LXC using this awesome script from tteck.
In the shell of the newly created container, move to /docker/adguard-sync
Now create a file adguardhome-sync.yaml and paste the following content, adjusting it where needed:

cron: '*/10 * * * *'
runOnStart: true
continueOnError: true
origin:
  url: '{ORIGIN_ADGUARD_HOME_INSTANCE_URL}'
  insecureSkipVerify: true
  username: {ORIGIN_ADGUARD_HOME_INSTANCE_USERNAME}
  password: {ORIGIN_ADGUARD_HOME_INSTANCE_PASSWORD}
replicas:
  - url: '{REPLICA_ADGUARD_HOME_INSTANCE_URL}'
    username: {REPLICA_ADGUARD_HOME_INSTANCE_USERNAME}
    password: {REPLICA_ADGUARD_HOME_INSTANCE_PASSWORD}
api:
  port: 8080
  username: {ADGUARD_HOME_SYNC_CONTROL_PANEL_USERNAME}
  password: {ADGUARD_HOME_SYNC_CONTROL_PANEL_PASSWORD}
  darkMode: true
features:
  generalSettings: true
  queryLogConfig: true
  statsConfig: true
  clientSettings: true
  services: true
  filters: true
  dhcp:
    serverConfig: true
    staticLeases: true
  dns:
    serverConfig: true
    accessLists: true
    rewrites: true

Now, run the following Docker command:

docker run -d \
  -p 80:8080 \
  -v /docker/adguard-sync/adguardhome-sync.yaml:/config/adguardhome-sync.yaml \
  --restart unless-stopped \
  --name=adguardhome-sync \
  ghcr.io/bakito/adguardhome-sync:latest

Once the container is up and running, your original AdGuard Home configuration will be replicated onto your replica instance every 10 minutes! You can also access the AdGuard Home sync web interface by navigating to http://<your-container-ip> in your web browser.
You are all set, but keep reading for more information!

AdGuard Home sync configuration

Most of the settings in the yaml files are self-explanatory: what you should now is that you can have more than 1 replica, and that you can disable the web interface of AdGuard Home sync if you don’t want it. I encourage you to read their readme to find all the info you might need.

How to get username/password of HomeAssistant AdGuard Home

To enable access to the HomeAssistant AdGuard Home instance you have to do several things:

Turn on its web interface in the Network section of the Add-On configuration
To improve the security of your architecture, create a new HomeAssistant user that can access HomeAssistant only from the local network. This will be the one you will use to setup {ORIGIN_ADGUARD_HOME_INSTANCE_USERNAME} in this case
The URL for {ORIGIN_ADGUARD_HOME_INSTANCE_URL} is the local address of your HomeAssistant instance

Thanks to brunty.me for providing this insights!

Understanding the Docker Run Command

docker run -d -> Run Docker in detached mode
-p 80:8080 -> Expose on port 80 of the host the port 8080 of the Docker container, so AdGuard Home sync web interface can be accessed
-v /docker/adguard-sync/adguardhome-sync.yaml:/config/adguardhome-sync.yaml -> serve the file at /docker/adguard-sync/adguardhome-sync.yaml on the host machine as /config/adguardhome-sync.yaml in the docker container
--restart always -> Always restart the container
--name=adguardhome-sync -> The name that will be assigned to the container
ghcr.io/bakito/adguardhome-sync:latest -> The Docker image to use to create the container

Maintenance

Your docker container will restart automatically in case of issues or reboot thanks to --restart always. To manually stop and restart it, you can use docker stop adguardhome-sync and docker restart adguardhome-sync.

Now stop replicating AdGuard Home settings manually and enjoy its protection! 🚀

Self-Hosting changedetection.io with Docker and Proxmox

Emanuele Papa — Fri, 01 Dec 2023 00:00:00 GMT

This time, let’s explore the process of deploying changedetection.io as a Docker instance on a Proxmox home server.

What’s changedetection.io

changedetection.io is a simple and free open source website change detection, website watcher, restock monitor and notification service.
It can detect website content changes and perform meaningful actions - trigger notifications via Discord, Email, Slack, Telegram, API calls and many more. We want to be able to check changes also on webpages that uses JavaScript to fill-in the content, so we need to install a WebDriver as well.

Installation steps

Ensure you have a Proxmox home server set up and running
Use the Proxmox main shell to create an Alpine Docker LXC using this awesome script from tteck. Customize the installation and set 4GB disk space.
In the shell of the newly created container, run the following Docker command to run Chrome WebDriver:

docker run -d \
  --name selenium \
  --restart always \
  -p 4444:4444 \
  --shm-size="2g" \
  selenium/standalone-chrome-debug:3.141.59

In the shell of the newly created container, run the following Docker command to run changedetection.io:

docker run -d \
  --name changedetectionio \
  --restart always \
  --link selenium \
  -p 80:5000 \
  -e WEBDRIVER_URL="http://selenium:4444/wd/hub" \
  -v /docker/changedetectionio/datastore:/datastore \
  dgtlmoon/changedetection.io

Once the containers are up and running, you can access the changedetection.io web interface by navigating to http://<your-container-ip> in your web browser.
You are all set!

Note: WEBDRIVER_URL is using selenium in the path which is the name of the container running the WebDriver. This works because Docker creates a network between containers.

I suggest you to read the changedetection.io wiki to explore all the features of changedetection.io and to learn how to setup notifications on your own instance!

Enjoy your own changedetection.io instance! 🚀

Self-Hosting Stirling-PDF with Docker and Proxmox

Emanuele Papa — Sat, 25 Nov 2023 00:00:00 GMT

Let’s explore the process of deploying Stirling-PDF as a Docker instance on a Proxmox home server.
Proxmox, coupled with an Alpine Docker LXC, provides a simple solution to isolate applications, making it an efficient choice for self-hosting.
This article aims to share my findings and guide you through the setup process.

What’s Stirling-PDF

Stirling-PDF is a powerful locally hosted web based PDF manipulation tool that allows you to perform various operations on PDF files, such as splitting merging, converting, reorganizing, adding images, rotating, compressing, and more.

Installation steps

Ensure you have a Proxmox home server set up and running
Use the Proxmox main shell to create an Alpine Docker LXC using this awesome script from tteck. (Assign at least 4GB of disk space if you plan to install the full version of Stirling-PDF)
In the shell of the newly created container, run the following Docker command:

docker run -d \
-p 80:8080 \
-v /docker/stirlingpdf/ocrdata:/usr/share/tesseract-ocr/4.00/tessdata \
-v /docker/stirlingpdf/configs:/configs \
-e DOCKER_ENABLE_SECURITY=true \
-e SECURITY_ENABLE_LOGIN=true \
--restart always \
--name stirling-pdf \
frooodle/s-pdf:latest

Once the container is up and running, you can access the Stirling-PDF web interface by navigating to http://<your-container-ip> in your web browser.
You are all set, but keep reading for more information!

Understanding the Docker Run Command

docker run -d -> Run Docker in detached mode
-p 80:8080 -> Expose on port 80 of the host the port 8080 of the Docker container, so Stirling-PDF can be accessed
-v /docker/stirlingpdf/ocrdata:/usr/share/tesseract-ocr/4.00/tessdata -> mounts the folder at /docker/stirlingpdf/ocrdata on the host machine to /usr/share/tesseract-ocr/4.00/tessdata in the docker container
-v /docker/stirlingpdf/configs:/configs -> Mount the folder at /docker/stirlingpdf/configs on the host machine to /configs in the docker container
-e DOCKER_ENABLE_SECURITY=true -> Tell docker to download security jar (required as true for auth login)
-e SECURITY_ENABLE_LOGIN=true -> Actually enable the authentication
--restart always -> Always restart the container
--name stirling-pdf -> The name that will be assigned to the container
frooodle/s-pdf:latest -> The Docker image to use to create the container

Security

Enabling DOCKER_ENABLE_SECURITY and SECURITY_ENABLE_LOGIN is crucial to enforce authentication in Stirling-PDF.
You can always customize security stuff by changing the settings.yaml file created inside /docker/stirlingpdf/configs instead of providing these environment variables.

OCR

If you need additional languages for OCR, using the LXC shell move to /docker/stirlingpdf/ocrdata and download the needed language file from tesseract-ocr/tessadata repository.
For example, run wget https://github.com/tesseract-ocr/tessdata/raw/main/ita.traineddata for the Italian language.

If you don’t need OCR or you run on low resources, depending on the feature you need, you might want to use a lightweight version, in that case change latest to latest-lite or latest-ultra-lite.
See here for a features overview.

Maintenance

Your docker container will restart automatically in case of issues or reboot thanks to --restart always. To manually stop and restart it, you can use docker stop stirling-pdf and docker restart stirling-pdf.

Enjoy your own Stirling-PDF instance! 🚀

Kotlin Multiplatform and Swift - Overcoming Interoperability Challenges for Multiplatform Development

Emanuele Papa — Sun, 16 Jul 2023 00:00:00 GMT

Kotlin Multiplatform Mobile (KMM) is a popular framework for developing multi-platform mobile applications with shared code between Android and iOS. However, one limitation of KMM is that it doesn’t allow direct use of Swift libraries: this is because Kotlin doesn’t have direct interoperability with the Swift language; instead, it relies on interoperability with Objective-C.

As a result, KMM doesn’t have built-in support for Swift-only libraries that don’t have an Objective-C API. This means that developers can’t use Swift libraries directly in a KMM project without first creating a bridging library that provides a Kotlin interface to the Swift code.

Creating a bridging library requires writing a separate library for each Swift library that needs to be used in the project: this can be time-consuming and requires knowledge of both Kotlin and Swift.

Using a Swift library with Dependency Injection and Koin

Imagine the classical situation where you want to use a third party service and they provide you a native Android SDK and a native iOS SDK (written in Swift). If you are going to develop two native apps, you face no issues, each platform implements and uses their respective SDK. If you are going to develop a KMM app, you end up having some issues due to the fact the iOS SDK is written in Swift.

Let’s see how we can use Koin to achieve Dependency Injection (DI) and incorporate a third-party iOS Swift SDK in a KMM project. Koin supports KMM development, making it the ideal choice for KMM projects.

Shared code

If you are going to use a library which already supports KMM, you are going to declare it as a dependency in the commonMain source set of the shared module build.gradle.kts file. This is not our case, we have a library for Android and a separate one for iOS.
For the sake of example, let’s imagine we have com.weather.sdk:1.0.0 for Android and WeatherSDK for iOS: they provide weather information given a city.

So what do we do?

Create a wrapper

To avoid scattering the use of the weather SDK throughout the project and allow for future flexibility to swap it out with another SDK, we create a wrapper interface for it. This approach provides a layer of abstraction that enables us to decouple the SDK implementation from the rest of the project, making it easier to maintain and modify in the future.

interface WeatherDataSource {
    suspend fun getWeather(cityName: String): WeatherInfo
}

Do not take care of the function signature, it’s just an example. Keep the focus on the fact we are creating an interface to decouple from the Weather SDK.

Now, we need to implement this interface both for Android and for iOS. The implementantions will use the respective Weather SDK to fetch data. Let’s start from Android first, which is easier.

Android setup

First, set the Android library as dependency in the androidMain source set.

val androidMain by getting {
    dependencies {
        implementation("com.weather.sdk:1.0.0")
    }
}

This makes us able to use com.weather.sdk into the androidMain source set.

Next step is to create the implementation for WeatherDataSource, so we create AndroidWeatherDataSource, where we use the weatherSdk class of Weather SDK to fetch weather information.
This is the link between our code and the third party SDK.

class AndroidWeatherDataSource(
    private val weatherSdk: WeatherSDK
): WeatherDataSource {
    suspend fun getWeather(cityName: String): WeatherInfo {
        //use weatherSdk to fetch weather information!
    }
}

Now, still in the androidMain source set, we create this function to init Koin:

/**
 * [context] is the Android app context
 * [appModules] is a list of modules defined in the app layer (e.g. viewModels)
 */
fun initKoin(context: Context, appModules: List<Module>) {
    startKoin {
        androidLogger()
        androidContext(context)
        modules(appModules + sharedModules + weatherModule)
    }
}

Koin will be setup using:

appModules: modules created in the app layer, e.g. for viewModels
sharedModules: modules created in the commonMain source set to be shared between platforms
weatherModule: module where we declare dependencies for com.weather.sdk

We will concentrate on weatherModule, let’s see its code:

val weatherModule = module {
    singleOf(::AndroidWeatherDataSource) bind WeatherDataSource::class
}

We declare AndroidWeatherDataSource as single instance for whenever we require WeatherDataSource.

Now, let’s move to iOS!

iOS setup

iOS setup it’s a little bit more cumbersome than the Android one, but let’s go step by step to see what’s needed.

Since the iOS library is written in Swift and doesn’t have Objective-C bindings, we can’t declare it in the iOSMain source set, we can’t cinterop it neither. The only way to use it is from the iOS project that AndroidStudio/KMMPlugin created for us.

First thing, as we did for Android, it’s to create the implementation for WeatherDataSource, so we create IOSWeatherDataSource:

import WeatherSDK
import shared

class IOSWeatherDataSource: WeatherDataSource {
    final let weatherSDK: WeatherSDK

    init(weatherSDK: WeatherSDK) {
        self.weatherSDK = weatherSDK
    }

    func getWeather(cityName: String) async throws -> WeatherInfo {
        //use weatherSdk to fetch weather information!
    }
}

Now, let’s go back to our shared module into iOSMain source set: here, as well as for Android, we need to create a function to init Koin. Right now, Koin API can’t be used in the iOS project, so we need both to create a function to init Koin and to expose all Koin dependencies to the iOS project.
To do so we create a class DependenciesProviderHelper:

class DependenciesProviderHelper : KoinComponent {

    /**
     * [weatherDataSource] is the iOS implementation to fetch weather information
     */
    initKoin(
        weatherDataSource: WeatherDataSource
    ) {
        val iosDependenciesModule = module {
            single {
                weatherDataSource
            } bind WeatherDataSource::class
        }
        startKoin {
            modules(iosDependenciesModule + sharedModules)
        }
    }

    //usecases
    val getWeatherInfoUseCase: GetWeatherInfoUseCase by inject()

}

Since it’s currently not possible to use Koin APIs from iOS, the initKoin() function can’t have a list of Koin Module like the Android one. However, we can still provide the real implementations of our dependencies and create a Koin module in the shared code. Then, we can use startKoin() with both the iOS dependencies and the shared modules.

Imagine then that this DataSource will be used in a Repository that will be used in a UseCase, here in DependenciesProviderHelper we also expose getWeatherInfoUseCase to be able to use it from the iOS project.

Start Koin!

Both the projects are now setup correctly, Dependency Injection is in place, real implementations have been created, we just miss one last thing: to finally start Koin!

On Android, you start Koin in your application class:

class MyApplication : Application() {
    
    override fun onCreate() {
        super.onCreate()
        initKoin(this@MyApplication, appModules)
    }

}

On iOS, you do the same:

@main
struct MyApplication: App {

    init() {
        let iosWeatherDataSource = //create iOSWeatherDataSource
        //DependenciesProviderHelper should be a singleton
        DependenciesProviderHelper().initKoin(
            weatherDataSource: iosWeatherDataSource
        )
    }

}

Instances injected by Koin

What instances does Koin provide in our code and how does it provide them, based on the code above? AndroidWeatherDataSource is defined as a single instance for WeatherDataSource on Android, which means that Koin will handle its instantiation and provide it whenever it is needed in our code. Because it is defined as single, the instance will remain the same throughout the lifecycle of our app. On iOS, the approach is similar, but Koin will not instantiate IOSWeatherDataSource on its own. Instead, we will need to instantiate it ourselves and provide the instance to startKoin() before Koin can manage it and provide it whenever it is needed.

Considerations

We have come to the end of how to use a Swift third-party library in a Kotlin Multiplatform project. While it’s still necessary to write two different native implementations (one for iOS and one for Android), these implementations are restricted in the DataSource level, while UseCases and Repositories can still be shared and written into the commonMain source set.

This means that the UseCases can use shared Repositories, and tests can be written to cover the UseCases and Repositories code just once. If there’s a bug in the DataSources, it will be spotted by these tests.

The shared code also provides the advantage of being able to implement functionality once, such as a cache in the Repository layer, instead of writing it twice for both platforms.

While there are limitations and challenges to using Swift third-party libraries in a Kotlin Multiplatform project, the benefits can make it a worthwhile investment for developers looking to build multiplatform apps.

Easily retrieve SHA fingerprints with Gradle signingReport task for Android development

Emanuele Papa — Wed, 22 Mar 2023 00:00:00 GMT

Signing applications with a digital certificate before releasing them to the public helps to protect the integrity and security of your app, as well as establish your identity as the developer.

In the world of Android development, the Gradle build tool provides a convenient way to manage the signing process for your apps: one useful feature of Gradle is the signingReport task, which allows you to generate a report that lists all of the signing configurations for your app.
This might become useful whenever you need to get the SHA-1 or SHA-256 of your signing key to authenticate against a service.

To use the this task, simply navigate to your project’s root directory in the terminal and run the following command:

./gradlew signingReport

The generated report includes information such as the signing configuration used for each variant, the location of the signing artifacts, and the SHA fingerprints of the signing certificates.

Another benefit of using this task is that it can help you identify any issues with your signing configuration: for example, if you see a variant listed in the report that is not properly signed, you can use the information provided in the report to troubleshoot the issue and get your app properly signed.

Boost your Internet speed setting up a 2.5Gbps Ethernet connection with iliad FTTH and a Macbook Pro M1

Emanuele Papa — Tue, 21 Mar 2023 00:00:00 GMT

Setting up a 2.5Gbps Ethernet network can significantly improve your Internet speed, allowing you to enjoy faster downloads and smoother streaming. In this blog post, I’ll share with you what steps I followed to set up a 2.5Gbps Internet connection with iliad FTTH (Open Fiber) and a Macbook Pro M1.

Let’s start, this is what you need:

A Macbook Pro M1 (this is my case, but other hardware can work as well)
A FTTH connection with iliad using their iliadbox which supports 2.5Gbps on a single Ethernet port
Cat-6a keystone to complete the Open Fiber termination box
2.5Gbps Ethernet adapter to have a 2.5Gbps port
Ethernet wall plate if you want to access the Ethernet in a different room than the one where your iliadbox is
Some meters of Ethernet cable. Cat-6a would be awesome but Cat-5e still perfectly does the job!

Now, let’s get started with the setup process.

Run a cable from the room where the iliadbox is to where you want to have another Ethernet wall plate
Mount the Ethernet wall plate on the wall and attach the Ethernet cable to it following the T568B standard
Attach the keystone to the termination box and attach the Ethernet cable to it following the T568B standard
Attach an Ethernet cable from the keystone to the iliadbox 2.5Gbps port
Attach an Ethernet cable from the wall plate to the 2.5Gbps Ethernet adapter
Attach the Ethernet adapter to the Macbook using a Thunderbolt/USB-C port

Once you’ve completed the above steps, it’s time to test your connection.
Disable the Wi-Fi on your Macbook and run a speed test to see if you’re getting the expected speed.

Congratulations, you’ve successfully set up a 2.5Gbps Internet connection with Iliad (Open Fiber) and a Macbook Pro M1!
Enjoy your faster internet speed and improved online experience 🚀

Kotlin Essentials - My experience reviewing the latest Marcin Moskala book

Emanuele Papa — Mon, 09 Jan 2023 00:00:00 GMT

The 6th of May 2022 was a typical day for me, as I was surfing the web and reading the latest tech news until a huge opportunity presented itself to me when I read an article saying Marcin Moskala was looking for someone to review his upcoming Kotlin book.

Almost immediately I decided to apply to be one of the reviewers!

As time passed, maybe I forgot about that moment until I received an email saying I was selected for the reviewing program! It was exciting news for me to be invited to serve as a reviewer for Marcin Moskala’s upcoming book on Kotlin. As a software developer with a strong interest in Kotlin and its capabilities, I was excited to have the opportunity to contribute my thoughts and feedback to the book.

So I spent most of my free time over the last few months reading every chapter of the book, discussing topics with other reviewers, paying attention to code samples, and again reading every chapter of the book.

One of the things that I particularly appreciated about the book was its clear and concise writing style. Marcin does an excellent job of explaining complex concepts in a way that is easy to understand. The book is also well-organized, with each chapter building upon the knowledge and skills developed in previous ones. This makes it easy for newcomers to follow along and absorb the material.

This book covers the essentials of Kotlin and those coming from other languages who wish to learn Kotlin would find this book extremely useful.

You can get it on Leanpub if you want a digital version or on Amazon if you prefer a paperback version!

The opportunity to review the book was a pleasure for me. I hope to have the chance to give my feedback on more publications in the near future.

Speaking about KMM at Commit University in November 2022

Emanuele Papa — Sun, 20 Nov 2022 00:00:00 GMT

A few days ago I gave a talk at Commit University in Florence, Italy.

I spoke about Kotlin Multiplatform Mobile (KMM) detailing some of the struggles that affect your developer experience while mixing Kotlin and Swift, and how to work around them.

I met a lot of new people interested in the topic and was fun to discuss it!

You can see a recording of the talk on YouTube. It was given in Italian, I’m sorry this time for the English followers. Anyway, you can see the slides on SpeakerDeck and the samples sourcecode.

Thank you to all the people I met and to the ones who attended my talk!

Solve ADB stuck on waiting for debugger

Emanuele Papa — Sun, 06 Nov 2022 00:00:00 GMT

While debugging an Android app you are used to seeing the Waiting for debugger dialog. This dialog is shown until the debugger attaches to the process of the app you want to debug, to let you debug it.

Sometimes, for various unknown and strange reasons, may happen that this dialog won’t go away, and so you are unable to continue your debugging session.

A solution could be to reboot your device/emulator and also kill/restart Android Studio. This is quite a heavy solution that makes you lose a lot of time.

You can avoid all these restarts just by running the following code in your terminal:

adb shell am clear-debug-app

Doing so should clear any broken reference that ADB might have with your app, so you can now launch a new debug session and you will see the infamous dialog to disappear!

Happy coding!

Speaking about KMM at droidcon Italy 2022

Emanuele Papa — Sun, 16 Oct 2022 00:00:00 GMT

A few days ago I took part in droidcon Italy as a speaker.

I spoke about Kotlin Multiplatform Mobile (KMM) detailing some of the struggles that affect your developer experience while mixing Kotlin and Swift, and how to work around them.
I’ve also participated in the KMM Roundtable where I and other cool developers spoke about our KMM experiences. It was fun and interesting at the same time!

You can see the slides on SpeakerDeck. Those of you who bought the ticket for the event can already see the recording of the talk, and so I want to share the samples sourcecode.
Edit(16/07/2023): finally the video of the talk has been published on YouTube, see it here!

Furthermore, JetBrains just announced that KMM just moved from Alpha to Beta, so give it a chance and try it if you haven’t already!

There was a lot of interest around KMM: to the ones who didn’t have a chance to talk with me, feel free to write me a message, I’ll be happy to discuss it!

Thank you to all the people I met and to the ones who attended my talk!

Meet me at droidcon Italy 2022

Emanuele Papa — Thu, 22 Sep 2022 00:00:00 GMT

A year has passed and it seems this blog was lost in time. It has been a year full of tasks to accomplish in my private life, so the time for side projects decreased and I didn’t have the time to keep the quality level I want for posts I publish, so practically all of them remained drafts. I hope I’ll resume publishing soon but in the meanwhile…

I’m happy to say that I’m very excited to be speaking at droidcon Italy 2022 in a few days!

Last year I talked about Flutter at droidcon London 2021, but then I moved to use Kotlin Multiplatform Mobile (KMM) daily.
So, this time, I will be speaking about what’s cool and what’s not about KMM. I do love KMM but you anyway need to know that having a silver bullet for cross-platform development isn’t so easy, so things might get difficult sometimes. I will share some tricks to create a better synergy between Android and iOS!

You can find the talk abstract here on the speakers page.

Please like and retweet the Twitter post.

Come and say hi, I’ll be happy to meet you!

Android image and video picker using ActivityResultContracts in Jetpack Compose

Emanuele Papa — Tue, 13 Sep 2022 00:00:00 GMT

Experimenting with Jetpack Compose you might have trouble doing old things in the new cool way.

One of these things is opening a media picker where the user can select an image or a video: imagine the use case of a Social Media app where you want your users to publish their content.

Let’s make it simple for now: you want your users to be able to select an image from their gallery.

Working with Jetpack Compose, you can just do the following:

val pickMediaActivityResultLauncher = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.GetContent()
) { uri: Uri? ->
    //use the received Uri
}

Button(onClick = {
    pickMediaActivityResultLauncher.launch("image/*")
}) {
    Text(text = "Pick media content")
}

Now, imagine you want your users to be able to publish a video. You can just change the MIME Type image/* to video/*, and keep the above code as it is. In the picker which will appear, the users can only select a video from their gallery.

Cool, but this is a Social Media app and users want to publish both pictures and videos, and you don’t want to have two different buttons for them to choose what to pick from their gallery. Unfortunately, the method launch() doesn’t accept a List of MIME Types as a parameter.

To solve this inconvenience, you can create a subclass of ActivityResultContracts.GetContent and set the Intent to handle both image/* and video/* MIME types.

class GetMediaActivityResultContract : ActivityResultContracts.GetContent() {

    override fun createIntent(context: Context, input: String): Intent {
        return super.createIntent(context, input).apply {
            // Force only images and videos to be selectable
            putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
        }
    }
}

Once you made this new custom ActivityResultContract you can just launch it like in the previous example:

val pickMediaActivityResultLauncher = rememberLauncherForActivityResult(
    contract = GetMediaActivityResultContract()
) { uri: Uri? ->
    //use the received Uri
}

Button(onClick = {
    pickMediaActivityResultLauncher.launch("*/*")
}) {
    Text(text = "Pick media content")
}

Pay attention, you can’t just pass an empty String to pickMediaActivityResultLauncher.launch() otherwise the system will raise an ActivityNotFoundException because it doesn’t know how to handle that Intent.
You can use the wildcard */* MIME Type to launch the Intent and then your users will be forced to choose only between an image or a video because those are the MIME types you specified in GetMediaActivityResultContract.

Bonus: starting from Android 11 (API Level 30) a built-in Photo picker was introduced. I suggest you to check it out and use this picker on devices running on newer APIs handling different Android versions in your code.

Flutter code generation with Paddinger at droidcon London 2021

Emanuele Papa — Thu, 02 Dec 2021 00:00:00 GMT

Speaking at droidcon London few weeks ago was a very cool experience, I met a lot of new people, old colleagues, friends, and I really enjoyed it!

I spoke about paddinger, a Flutter library I made to improve productivity while building UIs.

I want to share here the slides I used for the talk and the video for the ones who weren’t able to attend it!

Thank you to all the people I met and to the ones who attended my talk!

Let me know your thoughts!

Meet me at droidcon London 2021

Emanuele Papa — Tue, 19 Oct 2021 00:00:00 GMT

I’m happy to say that I’m very excited to be speaking at droidcon London in a few days!

I’ve been focused on Android since it was born and I’ll always be, but I also started experiencing multiplatform programming and so I wanted to share something I created for Flutter.
Actually, I’ve already exposed what’s the topic of my talk… I’m speaking about Paddinger

You can find the talk abstract here

Please like and retweet the twitter post

I’m really happy this is an in-person droidcon, so I can meet old friends and make new ones!

Come and say hi, I’ll be happy to meet you!

New website! emanuelepapa.dev and w3ma.com merge

Emanuele Papa — Thu, 07 Oct 2021 00:00:00 GMT

This is time for a big change!

In the past there were 2 projects running side by side:

emanuelepapa.dev, my resume website
w3ma.com, my tech blog

Right now, I decided to merge the 2 projects into one, hosted at emanuelepapa.dev

I absolutely love the new look and I’m really happy with the final result!

Furthermore, Wordpress was abandoned in favour of Gatsby and I’m happy with the new development/publish workflow.

I wish emanuelepapa.dev a great success! 🚀

Flutter Padding widgets generator with Paddinger

Emanuele Papa — Sun, 16 May 2021 00:00:00 GMT

Paddinger is a new package to help you deal with Flutter paddings and here you’ll discover how!

Have you ever been tired of writing Padding and EdgeInsets boilerplate everytime you need to add padding to a widget? I was, so I started looking for something to simplify this task. Furthermore, the necessary code to create declarative UIs can become very long and difficult to read, so, if there is a way to reduce it even by a few lines it’s something always worth to be considered.

I found out I was not the only one who was tired of this Padding boilerplate because, searching for a solution, I found someone else struggling with the same problem. One of the solution I found was Padder, which is available on Github and on pub.dev. It’s a cool set of widgets which can help you dealing with paddings.

Unfortunately, it was not what I was looking for, but having found valid proofs that there was a problem affecting someone else other than me, I decided to build what I needed on my own, and so Paddinger was born.

What is Paddinger

Paddinger is a code generator for Flutter: it builds Padding widgets for you based on the values you have in your design system. An example is worth a thousand words, so here it is. Assuming you have

const double PADDING_NORMAL = 8;

with Paddinger you will obtain a set of widgets like

NormalAllPadding
NormalLeftPadding
NormalTopPadding
NormalRightPadding
NormalBottomPadding
NormalHorizontalPadding
NormalVerticalPadding
NormalLeftTopPadding
NormalLeftBottomPadding
NormalRightTopPadding
NormalRightBottomPadding

just by annotating with @paddinger the constants you want the widgets to be generated for, like

@paddinger
const double PADDING_NORMAL = 8;

Then, you can use the generated widgets like every other one. Assuming you want to give a padding of 8 to a Text, instead of writing

Padding(
  padding: const EdgeInsets.all(PADDING_NORMAL),
  child: Text(
    'MyText',
  ),
)

you can just write

NormalAllPadding(
  child: Text(
    'MyText',
  ),
)

which imho is far easier to remember, to write, to read and IDE code completion will come to rescue!

How to use Paddinger in your project

First of all, add Paddinger as a dependency:

dependencies:
  paddinger_annotations: [latestVersionHere]

dev_dependencies:
  paddinger: [latestVersionHere]

Create a file where you will add all your PADDING_ constants, the file could be named paddings.dart.
Add your favourite material or cupertino import like:

// ignore: unused_import
import 'package:flutter/material.dart';

Add the part directive:

part 'paddings.g.dart';

Now run the code generation with flutter pub run build_runner build --delete-conflicting-outputs and your widgets will be generated and ready to be used!

You can have a look at the example in the Github repository or on pub.dev.

Happy Fluttering!

Clear all Android SharedPreferences

Emanuele Papa — Tue, 29 Dec 2020 00:00:00 GMT

It may happen you would need to clear your all of your SharedPreferences without knowing in advance their keys.

This can happen when you are writing tests: you don’t want your production code to publicly expose your SharedPreferences keys neither you need a clear() method, so you didn’t implement it. You may also need to clear third party SharedPreferences to which you don’t have direct access.

Without changing your production code there is something you can do:

access the app SharedPreferences folder
get the SharedPreferences Editor for each file
clear the SharedPreferences

You can use the following code, called in a @BeforeEach annotated method, to be sure each of your tests will run in a clean environment.

private fun clearAllSharedPreferences(context: Context) {
    val sharedPreferencesPath = File(context.filesDir.parentFile!!.absolutePath + File.separator + "shared_prefs")
    sharedPreferencesPath.listFiles()?.forEach { file ->
        context.getSharedPreferences(file.nameWithoutExtension, Context.MODE_PRIVATE).edit { clear() }
    }
}

Notes:

be sure to include androidx.core:core-ktx in your project to have that edit() method
if you are running your tests using Espresso you can access the app Context using InstrumentationRegistry.getInstrumentation().targetContext

Happy coding!

How to debug an Annotation Processor in Android Studio

Emanuele Papa — Sun, 05 Jul 2020 00:00:00 GMT

Writing an Annotation Processor in Java/Kotlin is a very interesting task and debugging comes very handy, but unfortunately it seems not so easy to start a debug session.

The following information are valid for Android Studio 3.6.3 and Kotlin 1.3.71. Gradle is the build tool used for the project.

First thing to do is setup a new Run/Debug Configuration in Android Studio:

Choose Run from the main menu
Choose Edit Configurations
Now click on the + symbol in the top left corner to add a new Configuration
Choose Remote from the list
Give it a friendly name (e.g. AnnotationProcessorDebugger)

Setup your breakpoints wherever you need them and then run this command from the terminal:

./gradlew --no-daemon -Dorg.gradle.debug=true :APP_MODULE_NAME:clean :APP_MODULE_NAME:compileDebugJavaWithJavac

Replace APP_MODULE_NAME with the name of the module having annotations which you want to debug. You will see the process will start and suddenly stop on > Starting Daemon waiting for you to do something.

Now, click on the Debug icon in the Toolbar (having selected the previously created AnnotationProcessorDebugger configuration) and the debugger will hit your breakpoints!

Additional info

The clean task seems to be necessary.

Unfortunately, sometimes these steps are not enough, or simply don’t work, the debugger won’t hit your breakpoints. I see somebody else solved the issue after adding the following line to their gradle.properties file.

kapt.use.worker.api=true

Add UEFI support to your AMD HD7970 to use Secure Boot

Emanuele Papa — Tue, 31 Dec 2019 00:00:00 GMT

Secure boot is a security standard developed by members of the PC industry to help make sure that a device boots using only software that is trusted by the Original Equipment Manufacturer (OEM). When the PC starts the installed software is being checked to see if its signature matches the one in the UEFI database and so is for the hardware: this case is about the BIOS of the Sapphire AMD HD7970 Vapor-X GHz Edition.

Its official BIOS doesn’t have UEFI support as GPU-Z shows:

Starting situation with no UEFI support

Looking online I couldn’t find any official information about Sapphire making BIOS updates neither making an update to support UEFI. So I started looking for unofficial solutions…

On TechPowerUp I found a database of all the users’ uploaded GPU BIOS and so I started looking into the Sapphire HD7970 list. Unfortunately, none of them was having UEFI support, but I saw there were versions more recent than mine! Then I started looking into other brand versions and I saw some Gigabyte BIOS having UEFI support and they should be official as they are available in the Gigabyte HD7970 support page. Nice work! Unfortunately, I’m not sure if it’s possible to flash a different brand BIOS even if the card model is the same, so I didn’t try this way.

I kept looking for unofficial solutions and eventually landed on a curious thread on overclock.net where a user says he is able to modify official BIOS to add UEFI support. After reading a lot of posts I found another interesting thread on Win-Raid.com where a user speaks about an automatic tool to add UEFI support to an original BIOS, whoa! No hex editing this time!

Want to read more about the GOP (Graphics Output Protocol) mentioned in that thread? Read it here on wikipedia.

So, next section is about what I did to successfully modify and flash the new BIOS! Do it at your own risk! It would be better if your VGA supports double BIOS so you can always revert your changes! Again, do it only if you know what you are doing and at your own risk, you could brick your card!

I downloaded the latest Sapphire HD7970 Vapor-X GHz Edition available on TechPowerUp which is version 015.037.000.000.000000 and can be found here. I flashed it with ATIFlash to be sure it worked, and here you can see the GPU-Z information.

Updated BIOS with no UEFI support

Then, I used the GOP Update tool to add UEFI support to this BIOS. The procedure worked flawlessly as shown by tool output here

************************* GOPupd 1.9.6.5 *************************


************************ Update EFI GOP ************************


***************** Drop VBIOS file on this .bat *****************


File Not Found
The system cannot find the file specified.
Dumping info from = official_037.rom


ID of ROM file    = 1002-6798

No EFI ROM found!

No EFI ROM found or error on decompression !!!

***************************************************************
***                Extracting with GOPupd...                ***
***************************************************************

---------------------------------------------------------------

***************************************************************
***                Processing with GOPupd...                ***
***************************************************************

GOP is not present!!!


Do you want to update GOP to latest available? Y for yes or N for no: y

  Fixing last-image-bit in PCI Structure of Legacy ROM!

  Using AMD byte for checksum!

  Fixing ID for EFI image. No checksum correction is needed.

  Removing unnecessary end padding.


File "official_037_updGOP.rom" with updated GOP 1.67.0.15.50 was written!

Then, the new official_037_updGOP.rom BIOS was flashed with ATIFlash and GPU-Z showed UEFI support! Tada!

Updated BIOS with UEFI support

I found no issues at all with the modified BIOS and I was also able to disable CSM (Compatibility Support Module, read more here) from my motherboard BIOS which didn’t let me do it before due to the VGA lack of UEFI support!

If you have a different AMD VGA (or NVIDIA one, check the supported ones) you might be able to follow the same steps to modify your official BIOS. If you have the same card I have, I’ve uploaded the firmware on TechPowerUp so you can download it here.

Sleep automation with Mi Band and Home Assistant

Emanuele Papa — Sat, 23 Nov 2019 00:00:00 GMT

Have you ever thought about using your Mi Band to help you automate stuff? Read this article and you will know how you can use your Mi Band sleep detection to trigger automations in your Home Assistant!

You will need:

Tasker
Notify & Fitness for Mi Band
A Mi Band
An automation which creates a webhook and then publishes your sleep status on a MQTT topic
A sensor based on the MQTT topic previously defined (it can be avoided for the purpose of this automation but I prefer to have it to keep track of the sleep status)
Tasker profiles which react to your sleep status

Create a sleep_status.yaml file in your packages directory with the following content.

Replace [YOUR_NAME] and [YOUR_WEBHOOK_ID].

homeassistant:

automation:
  - alias: [YOUR_NAME] Sleep Status
    initial_state: true
    trigger:
      - platform: webhook
      webhook_id: [YOUR_WEBHOOK_ID]
      condition: []
    action:
      - service: mqtt.publish
        data_template: 
          payload: "{\"sleepStatus\": \"{{trigger.json.sleepStatus}}\"}"
          topic: "sleepstatus/[YOUR_NAME]"

sensor:
  - platform: mqtt
    name: "[YOUR_NAME] Sleep Status"
    state_topic: "sleepstatus/[YOUR_NAME]"
    value_template: '{{ value_json["sleepStatus"] }}'

Take now your phone, open Tasker and setup the following profiles which will send your sleep status events (when you wake up and fall asleep) to your Home Assistant.

Replace [YOUR_HOME_ASSISTANT_DOMAIN_NAME] and [YOUR_WEBHOOK_ID]

<TaskerData sr="" dvi="1" tv="5.9.rc">
    <Profile sr="prof61" ve="2">
        <cdate>1574199690392</cdate>
        <clp>true</clp>
        <edate>1574529186304</edate>
        <flags>8</flags>
        <id>61</id>
        <mid0>63</mid0>
        <nme>MiBand Fell Asleep</nme>
        <Event sr="con0" ve="2">
            <code>599</code>
            <Str sr="arg0" ve="3">com.mc.miband.tasker.fellAsleep</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="0"/>
            <Str sr="arg3" ve="3"/>
            <Str sr="arg4" ve="3"/>
        </Event>
    </Profile>
    <Task sr="task63">
        <cdate>1574199712492</cdate>
        <edate>1574529096550</edate>
        <id>63</id>
        <nme>Send Asleep Payload</nme>
        <pri>6</pri>
        <Action sr="act0" ve="7">
            <code>339</code>
            <Bundle sr="arg0">
                <Vals sr="val">
                    <net.dinglisch.android.tasker.RELEVANT_VARIABLES>
                        <StringArray sr="">
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES0>%http_data
Data
Data that the server responded from the HTTP request.</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES0>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES1>%http_file_output
File Output
Will always contain the file's full path even if you specified a directory as the File to save.</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES1>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES2>%http_response_code
Response Code
The HTTP Code the server responded</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES2>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES3>%http_headers()
Response Headers
The HTTP Headers the server sent in the response. Each header is in the 'key:value' format</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES3>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES4>%http_response_length
Response Length
The size of the response in bytes</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES4>
                        </StringArray>
                    </net.dinglisch.android.tasker.RELEVANT_VARIABLES>
                    <net.dinglisch.android.tasker.RELEVANT_VARIABLES-type>[Ljava.lang.String;</net.dinglisch.android.tasker.RELEVANT_VARIABLES-type>
                </Vals>
            </Bundle>
            <Int sr="arg1" val="1"/>
            <Str sr="arg2" ve="3">https://[YOUR_HOME_ASSISTANT_DOMAIN_NAME]/api/webhook/[YOUR_WEBHOOK_ID]y</Str>
            <Str sr="arg3" ve="3">Content-Type:application/json</Str>
            <Str sr="arg4" ve="3"/>
            <Str sr="arg5" ve="3">{ "sleepStatus" : "Asleep" }</Str>
            <Str sr="arg6" ve="3"/>
            <Str sr="arg7" ve="3"/>
            <Int sr="arg8" val="30"/>
            <Int sr="arg9" val="0"/>
        </Action>
    </Task>
</TaskerData>

<TaskerData sr="" dvi="1" tv="5.9.rc">
    <Profile sr="prof66" ve="2">
        <cdate>1574200024388</cdate>
        <edate>1574529166065</edate>
        <flags>8</flags>
        <id>66</id>
        <mid0>65</mid0>
        <nme>MiBand WokeUp</nme>
        <Event sr="con0" ve="2">
            <code>599</code>
            <Str sr="arg0" ve="3">com.mc.miband.tasker.wokeUp</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="0"/>
            <Str sr="arg3" ve="3"/>
            <Str sr="arg4" ve="3"/>
        </Event>
    </Profile>
    <Task sr="task65">
        <cdate>1574199886906</cdate>
        <edate>1574529090100</edate>
        <id>65</id>
        <nme>Send Awake Payload</nme>
        <pri>6</pri>
        <Action sr="act0" ve="7">
            <code>339</code>
            <Bundle sr="arg0">
                <Vals sr="val">
                    <net.dinglisch.android.tasker.RELEVANT_VARIABLES>
                        <StringArray sr="">
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES0>%http_data
Data
Data that the server responded from the HTTP request.</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES0>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES1>%http_file_output
File Output
Will always contain the file's full path even if you specified a directory as the File to save.</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES1>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES2>%http_response_code
Response Code
The HTTP Code the server responded</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES2>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES3>%http_headers()
Response Headers
The HTTP Headers the server sent in the response. Each header is in the 'key:value' format</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES3>
                            <_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES4>%http_response_length
Response Length
The size of the response in bytes</_array_net.dinglisch.android.tasker.RELEVANT_VARIABLES4>
                        </StringArray>
                    </net.dinglisch.android.tasker.RELEVANT_VARIABLES>
                    <net.dinglisch.android.tasker.RELEVANT_VARIABLES-type>[Ljava.lang.String;</net.dinglisch.android.tasker.RELEVANT_VARIABLES-type>
                </Vals>
            </Bundle>
            <Int sr="arg1" val="1"/>
            <Str sr="arg2" ve="3">https://[YOUR_HOME_ASSISTANT_DOMAIN_NAME]/api/webhook/[YOUR_WEBHOOK_ID]</Str>
            <Str sr="arg3" ve="3">Content-Type:application/json</Str>
            <Str sr="arg4" ve="3"/>
            <Str sr="arg5" ve="3">{ "sleepStatus" : "Awake" }</Str>
            <Str sr="arg6" ve="3"/>
            <Str sr="arg7" ve="3"/>
            <Int sr="arg8" val="30"/>
            <Int sr="arg9" val="0"/>
        </Action>
    </Task>
</TaskerData>

Now, you can create a Node-RED flow which reacts to sensor.[YOUR_NAME]_sleep_status with Awake/Asleep value and executes your preferred stuff (e.g. turn off all the lights as soon as you fall asleep).

I have used my Mi Band 2 and it detects my sleep activity usually within 5 minutes so don’t use it for real-time automations.

Edit: it works on my Mi Band 4, too!

Let me know what automations you are going to create!

Light control using an Aqara Wireless Remote Switch with Home Assistant and Node-RED

Emanuele Papa — Fri, 04 Oct 2019 00:00:00 GMT

Home automation is nice, sending commands with your voice is very cool, but sometimes, especially at night, you might want to just use traditional methods like a wall switch. You can do it very easily without compromising your cool voice controls, and you can also customize the way it works to suit your needs!

Let’s start, this is what you need:

Home Assistant running wherever you like
Node-RED configured on your Home Assistant
Zigbee2mqtt configured on your Home Assistant
Aqara Wireless Remote Switch paired with Zigbee2mqtt

The Aqara Wireless Remote Switch is a switch you can place anywhere because it doesn’t need any wire, it works with a small battery which will last a very long time. To make the following configuration you need to use the double rocker one: it has a lot of different click interactions you can customize.

This is the configuration you can have using the Node-RED flow shown in this post:

Left click: turn on/off the lights (toggle)
Right click: switch between a predefined set of colors
Left long click: decrease brightness
Right long click: increase brightness

This Node-RED flow should be pretty straightforward, anyway, let’s have some more details.

The first node is an event state node that reacts to the changes of the Aqara Switch: it can have different values like left, right, left_long, right_long, etc. Home Assistant detects it as a sensor.

The second node is a switch used to take different actions based on the type of click done on the Aqara switch.

Left click scenario

A service call to toggle the lights, very easy!

Right click scenario

This is the most interesting part, the state machine node! It is used to create a finite state machine of the colors and transitions you want the lights to have. Unfortunately, I couldn’t find a way to make the state machine move to the next state based only on the current one, without taking care of the input value, so I managed to achieve it with a workaround!

After the state machine node there is a switch node which checks if the state machine already did its transition checking a value which is put into the payload object in the following function node. This function node also put the current state machine value as payload of the message, so the state machine can correctly move. In doing so, the second time the flow will go to another function node which generates the light settings based on the value the state machine now has. Then, the last node simply sets this configuration to the lights.

Left long click scenario

A current state node which gets the current brightness of the light followed by a function node which calculates the increased brightness value. In the function node you can customize the brightness interval and the minimum brightness you would like to reach. The last node is a service call which sets the new brightness to the light.

Right long click scenario

Same as the left long click scenario but this time the light brightness is increased, so the function node calculates the increased value the light will have. Customization for brightness interval and maximum brightness are available here as well.

Enjoy your wireless switch!

Wireless Switch flow

[
   {
      "id":"63038ca5.043d84",
      "type":"server-state-changed",
      "z":"ebd2b060.28c27",
      "name":"SmartSwitch1",
      "server":"b0807fb3.bda6d",
      "version":1,
      "entityidfilter":"sensor.smartswitch1_click",
      "entityidfiltertype":"exact",
      "outputinitially":false,
      "state_type":"str",
      "haltifstate":"",
      "halt_if_type":"str",
      "halt_if_compare":"is",
      "outputs":1,
      "output_only_on_state_change":true,
      "x":110,
      "y":160,
      "wires":[
         [
            "e4f033f6.02139"
         ]
      ]
   },
   {
      "id":"e4f033f6.02139",
      "type":"switch",
      "z":"ebd2b060.28c27",
      "name":"click is",
      "property":"payload",
      "propertyType":"msg",
      "rules":[
         {
            "t":"eq",
            "v":"left",
            "vt":"str"
         },
         {
            "t":"eq",
            "v":"right",
            "vt":"str"
         },
         {
            "t":"eq",
            "v":"left_long",
            "vt":"str"
         },
         {
            "t":"eq",
            "v":"right_long",
            "vt":"str"
         }
      ],
      "checkall":"true",
      "repair":false,
      "outputs":4,
      "x":290,
      "y":160,
      "wires":[
         [
            "c92d98e8.8de858"
         ],
         [
            "bbcdb78.3712348"
         ],
         [
            "752f2116.e5b66"
         ],
         [
            "a10c6932.4ae3a8"
         ]
      ]
   },
   {
      "id":"c92d98e8.8de858",
      "type":"api-call-service",
      "z":"ebd2b060.28c27",
      "name":"toggle living room lights",
      "server":"b0807fb3.bda6d",
      "version":1,
      "service_domain":"light",
      "service":"toggle",
      "entityId":"group.living_room_lights",
      "data":"",
      "dataType":"json",
      "mergecontext":"",
      "output_location":"",
      "output_location_type":"none",
      "mustacheAltTags":false,
      "x":530,
      "y":60,
      "wires":[
         [
            
         ]
      ]
   },
   {
      "id":"515a6b84.e21c54",
      "type":"api-call-service",
      "z":"ebd2b060.28c27",
      "name":"set brightness to living room lights",
      "server":"b0807fb3.bda6d",
      "version":1,
      "service_domain":"light",
      "service":"turn_on",
      "entityId":"group.living_room_lights",
      "data":"",
      "dataType":"json",
      "mergecontext":"",
      "output_location":"",
      "output_location_type":"none",
      "mustacheAltTags":false,
      "x":1200,
      "y":220,
      "wires":[
         [
            
         ]
      ]
   },
   {
      "id":"752f2116.e5b66",
      "type":"api-current-state",
      "z":"ebd2b060.28c27",
      "name":"",
      "server":"b0807fb3.bda6d",
      "version":1,
      "outputs":1,
      "halt_if":"",
      "halt_if_type":"str",
      "halt_if_compare":"is",
      "override_topic":false,
      "entity_id":"light.left_living_room",
      "state_type":"str",
      "state_location":"data",
      "override_payload":"msg",
      "entity_location":"data",
      "override_data":"msg",
      "blockInputOverrides":false,
      "x":560,
      "y":200,
      "wires":[
         [
            "91a6b4b5.c19558"
         ]
      ]
   },
   {
      "id":"ba574398.cc6a",
      "type":"function",
      "z":"ebd2b060.28c27",
      "name":"calculate increased brightness",
      "func":"const BRIGHTNESS_INTERVAL = 100;\nconst BRIGHTNESS_MAX = 255;\n\nlet brightness = msg.data.attributes.brightness;\nlet entityId = msg.data.entity_id;\nbrightness = brightness + BRIGHTNESS_INTERVAL\nif (brightness > BRIGHTNESS_MAX) {\n    brightness = BRIGHTNESS_MAX\n}\nmsg.payload = {\n    \"data\": {\n        \"brightness\":brightness\n        \n    }\n}\nreturn msg;",
      "outputs":1,
      "noerr":0,
      "x":870,
      "y":260,
      "wires":[
         [
            "515a6b84.e21c54"
         ]
      ]
   },
   {
      "id":"91a6b4b5.c19558",
      "type":"function",
      "z":"ebd2b060.28c27",
      "name":"calculate decreased brightness",
      "func":"const BRIGHTNESS_INTERVAL = 100;\nconst BRIGHTNESS_MIN = 1;\n\nlet brightness = msg.data.attributes.brightness;\nlet entityId = msg.data.entity_id;\nbrightness = brightness - BRIGHTNESS_INTERVAL\nif (brightness < BRIGHTNESS_MIN) {\n    brightness = BRIGHTNESS_MIN\n}\nmsg.payload = {\n    \"data\": {\n        \"brightness\":brightness\n        \n    }\n}\nreturn msg;",
      "outputs":1,
      "noerr":0,
      "x":870,
      "y":200,
      "wires":[
         [
            "515a6b84.e21c54"
         ]
      ]
   },
   {
      "id":"a10c6932.4ae3a8",
      "type":"api-current-state",
      "z":"ebd2b060.28c27",
      "name":"",
      "server":"b0807fb3.bda6d",
      "version":1,
      "outputs":1,
      "halt_if":"",
      "halt_if_type":"str",
      "halt_if_compare":"is",
      "override_topic":false,
      "entity_id":"light.left_living_room",
      "state_type":"str",
      "state_location":"data",
      "override_payload":"msg",
      "entity_location":"data",
      "override_data":"msg",
      "blockInputOverrides":false,
      "x":560,
      "y":260,
      "wires":[
         [
            "ba574398.cc6a"
         ]
      ]
   },
   {
      "id":"bbcdb78.3712348",
      "type":"state-machine",
      "z":"ebd2b060.28c27",
      "name":"bulb color state",
      "triggerProperty":"payload",
      "triggerPropertyType":"msg",
      "stateProperty":"topic",
      "statePropertyType":"msg",
      "outputStateChangeOnly":false,
      "throwException":false,
      "states":[
         "white",
         "yellow"
      ],
      "transitions":[
         {
            "name":"white",
            "from":"white",
            "to":"yellow"
         },
         {
            "name":"yellow",
            "from":"yellow",
            "to":"white"
         }
      ],
      "x":540,
      "y":140,
      "wires":[
         [
            "10c6a2fd.57b7dd"
         ]
      ]
   },
   {
      "id":"f1efc70d.5de9e8",
      "type":"api-call-service",
      "z":"ebd2b060.28c27",
      "name":"set color to living room lights",
      "server":"b0807fb3.bda6d",
      "version":1,
      "service_domain":"light",
      "service":"turn_on",
      "entityId":"group.living_room_lights",
      "data":"",
      "dataType":"json",
      "mergecontext":"",
      "output_location":"",
      "output_location_type":"none",
      "mustacheAltTags":false,
      "x":1340,
      "y":120,
      "wires":[
         [
            
         ]
      ]
   },
   {
      "id":"10c6a2fd.57b7dd",
      "type":"switch",
      "z":"ebd2b060.28c27",
      "name":"has state ben processed",
      "property":"data.attributes.state_machine_processed",
      "propertyType":"msg",
      "rules":[
         {
            "t":"true"
         },
         {
            "t":"else"
         }
      ],
      "checkall":"true",
      "repair":false,
      "outputs":2,
      "x":770,
      "y":140,
      "wires":[
         [
            "41cecb0c.bbfbe4"
         ],
         [
            "f4044d2d.8f0a6"
         ]
      ]
   },
   {
      "id":"f4044d2d.8f0a6",
      "type":"function",
      "z":"ebd2b060.28c27",
      "name":"set topic as payload",
      "func":"msg.payload = msg.topic\nmsg.data = {\n    \"attributes\": {\n        \"state_machine_processed\" : true\n    }\n}\nreturn msg;",
      "outputs":1,
      "noerr":0,
      "x":1040,
      "y":140,
      "wires":[
         [
            "bbcdb78.3712348"
         ]
      ]
   },
   {
      "id":"41cecb0c.bbfbe4",
      "type":"function",
      "z":"ebd2b060.28c27",
      "name":"create color data as payload",
      "func":"whitePayload = {\n    \"data\": {\n        \"kelvin\": 6000\n    }\n}\n\nyellowPayload = {\n    \"data\": {\n        \"kelvin\": 3000\n    }\n}\n\nlet payloadToUse;\nswitch(msg.topic) {\n    case \"white\": \n        payloadToUse = whitePayload;\n        break;\n    case \"yellow\":\n        payloadToUse = yellowPayload;\n        break;\n    default:\n    \n        break;\n}\n\nmsg.payload = payloadToUse;\nreturn msg;",
      "outputs":1,
      "noerr":0,
      "x":1060,
      "y":100,
      "wires":[
         [
            "f1efc70d.5de9e8"
         ]
      ]
   },
   {
      "id":"b0807fb3.bda6d",
      "type":"server",
      "z":"",
      "name":"Home Assistant"
   }
]

Enable the new Android Auto UI

Emanuele Papa — Sun, 25 Aug 2019 00:00:00 GMT

In the last few weeks the new Android Auto UI is being released by Google but it’s not yet available for everyone. There are some tricks you can use to force enable it before Google releases it to everyone.

One of these tricks is explained here on Reddit.

It works on my OP6 running Android Pie, but those commands need to be executed each time I want to use the new Android Auto UI, otherwise I see the old one.

To overcome this little issue I made a Tasker profile to automatically run those commands when the smartphone is connected to a power source, so they are executed before Android Auto starts.

Here the Tasker profile! Just import it in your Tasker and enjoy the new Android Auto UI!

<TaskerData sr="" dvi="1" tv="5.8.3">
    <Profile sr="prof21" ve="2">
        <cdate>1566724247086</cdate>
        <edate>1566724464417</edate>
        <id>21</id>
        <mid0>17</mid0>
        <mid1>17</mid1>
        <nme>On power change AA to new UI</nme>
        <State sr="con0" ve="2">
            <code>10</code>
            <Int sr="arg0" val="0"/>
        </State>
    </Profile>
    <Task sr="task17">
        <cdate>1566723956355</cdate>
        <edate>1566724006352</edate>
        <id>17</id>
        <nme>New AA UI</nme>
        <Action sr="act0" ve="7">
            <code>123</code>
            <Str sr="arg0" ve="3">sqlite3 /data/data/com.google.android.gms/databases/phenotype.db "INSERT OR REPLACE INTO Flags (packageName, version, flagType, partitionId, user, name, intVal, committed) VALUES ('com.google.android.projection.gearhead',45592854,0,0,'','Boardwalk__launch_experiment_id',15592854,1);"</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="1"/>
            <Str sr="arg3" ve="3"/>
            <Str sr="arg4" ve="3"/>
            <Str sr="arg5" ve="3"/>
        </Action>
        <Action sr="act1" ve="7">
            <code>123</code>
            <Str sr="arg0" ve="3">sqlite3 /data/data/com.google.android.gms/databases/phenotype.db "INSERT OR REPLACE INTO Flags (packageName, version, flagType, partitionId, user, name, boolVal, committed) VALUES ('com.google.android.projection.gearhead',45592854,0,0,'','Boardwalk__enabled',1,1);"</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="1"/>
            <Str sr="arg3" ve="3"/>
            <Str sr="arg4" ve="3"/>
            <Str sr="arg5" ve="3"/>
        </Action>
    </Task>
</TaskerData>

Make your washing machine smarter with Home Assistant

Emanuele Papa — Sat, 01 Jun 2019 00:00:00 GMT

Do you own an old washing machine and do you ever think about how to make your washing machine smarter? Would you have better information about the current washing cycle?

Well, you can do it today, you just need a couple of things:

a smart plug with energy monitoring feature
an Home Assistant instance running somewhere (e.g. on your Raspberry)

Smart plug integration

Each smart plug is different from another so you have to figure out how to integrate your into Home Assistant.

In my setup I used a TP-Link HS-110 and I integrated it into my Home Assistant as shown here.

After the successful integration you should have a new sensor which reports the current consumption, and this is the one you are going to use to monitor your washing machine!

Washing machine integration

The following snippet of code is an Home Assistant package, you can just copy-paste it into a whatever_you_want.yaml file into your packages directory; the only thing you need to do is to replace PUT_YOUR_ENERGY_CONSUMPTION_SENSOR_NAME_HERE with your current consumption sensor name!

homeassistant:
  customize_glob:
    "*washing_machine*":
      icon: mdi:washing-machine

input_text:
  washing_machine_enriched_status:
    name: 'Washing Machine Enriched Status'
    initial: "Off"
    
sensor:
  - platform: template
    sensors:
      washing_machine_status:
        friendly_name: 'Washing Machine Status'
        value_template:  >
          {% if states.sensor.PUT_YOUR_ENERGY_CONSUMPTION_SENSOR_NAME_HERE .state | float > 3.0 %}
            {{ "Running" }}
          {% elif states.sensor.PUT_YOUR_ENERGY_CONSUMPTION_SENSOR_NAME_HERE .state | float > 1 %}
            {{ "On" }}
          {% else %}
            {{ "Off" }}
          {% endif %}
      washing_machine_info:
        friendly_name: 'Washing Machine Info'
        entity_id: sensor.time
        value_template:  >
          {%- macro as_formatted_elapsed_time(now, other_date_time) %}
          {% set duration = as_timestamp(now) - as_timestamp(other_date_time) %}
          {% set seconds = (duration % 60) | int %}
          {% set minutes = ((duration / 60) | int) % 60 %}
          {% set hours = (duration / 3600) | int %}
          {{ [hours, "hours", minutes, "minutes", seconds, "seconds"] | join(' ') }}
          {%- endmacro %}
          {% if states.input_text.washing_machine_enriched_status.state == "Running" %}
            Washing machine running for: {{ as_formatted_elapsed_time(now(), states.input_text.washing_machine_enriched_status.last_changed)}}
          {% elif states.input_text.washing_machine_enriched_status.state == "On_After_Running" %}
            Clothes left in the washing machine for: {{ as_formatted_elapsed_time(now(), states.input_text.washing_machine_enriched_status.last_changed)}}
          {% elif states.input_text.washing_machine_enriched_status.state == "On_After_Off" %}
            {{ "Washing machine ready to start" }}
          {% else %}
            {{ "Washing machine is off" }}
          {% endif %}

automation:
  - id: '1556314846684'
    alias: Refresh Washing Machine Info
    initial_state: true
    trigger:
      platform: state
      entity_id: sensor.washing_machine_status
    action:
      - service: input_text.set_value
        data_template:
          entity_id: input_text.washing_machine_enriched_status
          value:  >
            {% if trigger.to_state.state == "Running" %}
              {{ "Running" }}
            {% elif trigger.to_state.state == "On" and trigger.from_state.state == "Running" %}
              {{ "On_After_Running" }}
            {% elif trigger.to_state.state == "On" and trigger.from_state.state == "Off" %}
              {{ "On_After_Off" }}
            {% else %}
              {{ "Off" }}
            {% endif %}

Detailed explanation

Let me explain a bit about what this package does:

Here we are just telling Home Assistant to use a washing machine icon for all the sensors containing the string washing_machine

homeassistant:
  customize_glob:
    "*washing_machine*":
      icon: mdi:washing-machine

Here we declare a sensor, washing_machine_status, to keep track of the status of the washing machine. There are three possible status: Running, On and Off. You would need to tune the watts value according to your washing machine to detect when it’s running or just turned on.

washing_machine_status:
        friendly_name: 'Washing Machine Status'
        value_template:  >
          {% if states.sensor.PUT_YOUR_ENERGY_CONSUMPTION_SENSOR_NAME_HERE .state | float > 3.0 %}
            {{ "Running" }}
          {% elif states.sensor.PUT_YOUR_ENERGY_CONSUMPTION_SENSOR_NAME_HERE .state | float > 1 %}
            {{ "On" }}
          {% else %}
            {{ "Off" }}
          {% endif %}

Here we setup an automation to store in an input_text (couldn’t find a better way) the enriched status of our washing machine: the enriched status is a status which keeps track of the previous one. So for example, if the washing machine was off and you turn it on, the status would be On, but the enriched status would be On_After_Off.

automation:
  - id: '1556314846684'
    alias: Refresh Washing Machine Info
    initial_state: true
    trigger:
      platform: state
      entity_id: sensor.washing_machine_status
    action:
      - service: input_text.set_value
        data_template:
          entity_id: input_text.washing_machine_enriched_status
          value:  >
            {% if trigger.to_state.state == "Running" %}
              {{ "Running" }}
            {% elif trigger.to_state.state == "On" and trigger.from_state.state == "Running" %}
              {{ "On_After_Running" }}
            {% elif trigger.to_state.state == "On" and trigger.from_state.state == "Off" %}
              {{ "On_After_Off" }}
            {% else %}
              {{ "Off" }}
            {% endif %}

This is just the simple declaration of the variable holding the enriched status of the washing machine.

input_text:
  washing_machine_enriched_status:
    name: 'Washing Machine Enriched Status'
    initial: "Off"

Here we declare another sensor, washing_machine_info, which will keep us informed of the washing machine’s current status and will also tell us more information (e.g. for how long the washing machine is running). The sensor will be updated every minute since it has a dependency on sensor.time: you can customize this behaviour adding another automation to refresh it faster or slower, but I think every minute is enough. as_formatted_elapsed_time is a macro used to display the elapsed time between two moments.

washing_machine_info:
    friendly_name: 'Washing Machine Info'
    entity_id: sensor.time
    value_template:  >
        {%- macro as_formatted_elapsed_time(now, other_date_time) %}
        {% set duration = as_timestamp(now) - as_timestamp(other_date_time) %}
        {% set seconds = (duration % 60) | int %}
        {% set minutes = ((duration / 60) | int) % 60 %}
        {% set hours = (duration / 3600) | int %}
        {{ [hours, "hours", minutes, "minutes", seconds, "seconds"] | join(' ') }}
        {%- endmacro %}
        {% if states.input_text.washing_machine_enriched_status.state == "Running" %}
          Washing machine running for: {{ as_formatted_elapsed_time(now(), states.input_text.washing_machine_enriched_status.last_changed)}}
        {% elif states.input_text.washing_machine_enriched_status.state == "On_After_Running" %}
          Clothes left in the washing machine for: {{ as_formatted_elapsed_time(now(), states.input_text.washing_machine_enriched_status.last_changed)}}
        {% elif states.input_text.washing_machine_enriched_status.state == "On_After_Off" %}
          {{ "Washing machine ready to start" }}
        {% else %}
            {{ "Washing machine is off" }}
        {% endif %}

Finally, you can just put your new sensor washing_machine_info into your UI and you will get very useful information about your washing machine, making it actually smarter.

Furthermore, you can use the statuses we collect here, and their time-based changes, to make other automations like send you a Telegram notification when the washing machine cycle ends, but at the moment that’s left to your imagination!

Build your smart car’s on-board computer!

Emanuele Papa — Sat, 14 Jul 2018 00:00:00 GMT

Reading this post you will be able to create your smart car’s on-board computer, for example you will be to able to ask your Google Assistant (from your device or from an Android Auto head unit) the temperature of your car’s coolant liquid! Woa!

What do you need:

an Android device (with Google Assistant or Android Auto since your going to use this in your car)
Torque
Tasker
Join
an IFTTT account
an OBD2 device

Such a long list of stuff!

Let’s start!

IFTTT and Tasker integration

Thanks to Join, a new app from joaomgcd, you can create a URL to push information to your devices in a very easy and powerful way! Read his well written tutorial here and you will be able to generate a URL to use in the Webhook that action of IFTTT.

As reference, I’d like to report the old way of doing this, so everyone can read it and understand how much Join has simplified and improved this process!

Tasker and Torque integration

Now, you will need to make Tasker able to read your car’s data using Torque. To accomplish this, open Torque and set it up to log your car’s data to a file on your sdcard (you can do it making changes in the Settings – Data Logging and Upload section).

Tasker will now be able to read your car’s data reading that log file using the following task which you could import into it.

<TaskerData sr="" dvi="1" tv="5.2.bf6">
    <Task sr="task43">
        <cdate>1432225457845</cdate>
        <edate>1531597970703</edate>
        <id>43</id>
        <nme>ReadCarEngineCoolantTemperature</nme>
        <pri>100</pri>
        <Action sr="act0" ve="7">
            <code>342</code>
            <Int sr="arg0" val="5"/>
            <Str sr="arg1" ve="3">/storage/emulated/0/torqueLogs/trackLog.csv</Str>
            <Str sr="arg2" ve="3">%TORQUE_LOG_EXISTS</Str>
            <Int sr="arg3" val="0"/>
        </Action>
        <Action sr="act1" ve="7">
            <code>123</code>
            <se>false</se>
            <Str sr="arg0" ve="3">tail -1 /storage/emulated/0/torqueLogs/trackLog.csv</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="0"/>
            <Str sr="arg3" ve="3">%OBDLOG</Str>
            <Str sr="arg4" ve="3"/>
            <Str sr="arg5" ve="3"/>
            <ConditionList sr="if">
                <Condition sr="c0" ve="3">
                    <lhs>%TORQUE_LOG_EXISTS</lhs>
                    <op>0</op>
                    <rhs>true</rhs>
                </Condition>
            </ConditionList>
        </Action>
        <Action sr="act2" ve="7">
            <code>590</code>
            <Str sr="arg0" ve="3">%OBDLOG</Str>
            <Str sr="arg1" ve="3">,</Str>
            <Int sr="arg2" val="0"/>
            <ConditionList sr="if">
                <Condition sr="c0" ve="3">
                    <lhs>%TORQUE_LOG_EXISTS</lhs>
                    <op>0</op>
                    <rhs>true</rhs>
                </Condition>
            </ConditionList>
        </Action>
        <Action sr="act3" ve="7">
            <code>547</code>
            <Str sr="arg0" ve="3">%EngineCoolantTemp</Str>
            <Str sr="arg1" ve="3">%OBDLOG2</Str>
            <Int sr="arg2" val="0"/>
            <Int sr="arg3" val="0"/>
            <Int sr="arg4" val="0"/>
            <ConditionList sr="if">
                <Condition sr="c0" ve="3">
                    <lhs>%TORQUE_LOG_EXISTS</lhs>
                    <op>0</op>
                    <rhs>true</rhs>
                </Condition>
            </ConditionList>
        </Action>
        <Action sr="act4" ve="7">
            <code>559</code>
            <Str sr="arg0" ve="3">Engine coolant temperature is %EngineCoolantTemp degrees</Str>
            <Str sr="arg1" ve="3">default:default</Str>
            <Int sr="arg2" val="3"/>
            <Int sr="arg3" val="5"/>
            <Int sr="arg4" val="5"/>
            <Int sr="arg5" val="1"/>
            <Int sr="arg6" val="0"/>
            <Int sr="arg7" val="0"/>
            <ConditionList sr="if">
                <Condition sr="c0" ve="3">
                    <lhs>%TORQUE_LOG_EXISTS</lhs>
                    <op>0</op>
                    <rhs>true</rhs>
                </Condition>
            </ConditionList>
        </Action>
        <Action sr="act5" ve="7">
            <code>559</code>
            <Str sr="arg0" ve="3">E C U connection not established!</Str>
            <Str sr="arg1" ve="3">default:default</Str>
            <Int sr="arg2" val="3"/>
            <Int sr="arg3" val="5"/>
            <Int sr="arg4" val="5"/>
            <Int sr="arg5" val="1"/>
            <Int sr="arg6" val="0"/>
            <Int sr="arg7" val="0"/>
            <ConditionList sr="if">
                <Condition sr="c0" ve="3">
                    <lhs>%TORQUE_LOG_EXISTS</lhs>
                    <op>0</op>
                    <rhs>false</rhs>
                </Condition>
            </ConditionList>
        </Action>
    </Task>
</TaskerData>

This task will check for that log file on your external memory and:

if it founds it, it make your speakers say the last engine coolant temperature read by Torque
if it doesn’t found it, it make your speakers say there is no connection between Torque and you car ECU (your OBD2 adapter).

Another task that you will need is one that deletes that log file when the Torque app closes, so the next time you ask Tasker to read that file your are sure the data is new, and if there is no file, a new connection with your car wasn’t established.

<TaskerData sr="" dvi="1" tv="5.2.bf6">
    <Task sr="task47">
        <cdate>1525023939110</cdate>
        <edate>1529001057169</edate>
        <id>47</id>
        <nme>DeleteTorqueLog</nme>
        <pri>100</pri>
        <Action sr="act0" ve="7">
            <code>406</code>
            <Str sr="arg0" ve="3">torqueLogs/trackLog.csv</Str>
            <Int sr="arg1" val="0"/>
            <Int sr="arg2" val="0"/>
        </Action>
    </Task>
</TaskerData>

Google Assistant and IFTTT and Tasker and Torque integration

Now the last part! We have all the pieces, let’s put them together!

Click on this and look for Google Assistant, then click on it. Select the Say a simple phrase trigger and write your custom question(s) and response; click then on Create trigger

Click now on that and look for Webhooks, then click on it. Select the Make a web request action and use the URL you generated as explained in the joaomgcd’s tutorial. Click on Create action, then on Finish and your recipe is ready!

Open your Google Assistant and say the phrase you just put in the IFTTT recipe, your device should say you’re not connected to the ECU, you got the push notification, that’s great!

Now go to your car, turn it on, make Torque pair with your OBD2 adapter…. when it’s ready ask Google Assistant again to read your engine coolant temperature and now you should hear it!

Wonderful, it works!!!

Further improvements of your smart car

The recipe on IFTTT and the task on Tasker could be improved by using parameters and so making you able to ask for and listen to different details of your car, which could now be called a smart car!

AndroidAutoAlerts – Simple alerts app for Android Auto

Emanuele Papa — Sun, 10 Sep 2017 00:00:00 GMT

AndroidAutoAlerts is a very simple app for Android Auto I have developed to test my Android Auto unit. Please read through the article to check it out!

What it does and how it works

As I said, the app is very simple and at the moment it has only one functionality: it will notify the driver if the speed limit is exceeded. Wow!

The driver can set the maximum speed limit through the app’s settings (you can also choose the name of your virtual assistant!)

Settings screen

Then, go back to the main screen and start the notification service. A service will run (and will keep running in the foreground using a system notification when you exit the app or attach your device to your Android Auto unit).

Main screen

Notification of active ForegroundService

So, now, using the speed taken from the GPS sensor, when the app catches you going faster a notification will be displayed on your Android Auto unit from your virtual assistant! Tap it and listen to what it has to say to you! Please slow down, you have exceeded your speed limit!!

Android Auto Head Unit notification

Where to get it

At the moment, the app is not following all of the Android Auto requirements (see them here) and Google only allows music and messaging Android Auto apps. For this reason I had to create the notification like a messaging app, like you are going to reply to it, even if you are not. Furthermore, I’m not going to publish it on Google Play at the moment (till apps of this kink will be accepted on it), but you can check its source code which I shared here on github.

Future development

Let’s wait for Google to accept other kinds of apps on the Android Auto platform and let’s hope this platform will become more and more interactive, full of useful apps (maybe some which can control car’s features, would be amazing!) and used by more and more people! I already love it, can’t live without it!

Using Spring Data to persist a Set of Enums in a Many-To-Many relationship

Emanuele Papa — Thu, 24 Aug 2017 00:00:00 GMT

Usually, when we write a Many-To-Many relationship it is between 2 entities. Sometimes, it could happen that we have an entity which has a field which is a set of enum. In this case, we need to approach the problem differently and Spring comes to help.

Let’s see an example where we have two classes: Person and Skill (e.g. swimming, running, etc).

Many-To-Many between entities example

The following code shows what the situation is when Person and Skill are both entities.

@Entity 
public class Person {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY) 
  private Long id;

  private String name;

  @ManyToMany(fetch = FetchType.LAZY) @JoinTable(name = "person_skill", joinColumns = {
    @JoinColumn(name = "person_id")
  }, inverseJoinColumns = {
    @JoinColumn(name = "skill_id")
  }) 
  private Set <Skill> skillSet;
}

@Entity 
public class Skill {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY) 
  private Long id;
  private String name;
}

To use this mapping, you would have 3 tables. You can create them with the following SQL code.

CREATE TABLE `person` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT, 
  `name` VARCHAR(45) NOT NULL, 
  PRIMARY KEY (`id`)
);

CREATE TABLE `skill` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT, 
  `name` VARCHAR(45) NOT NULL, 
  PRIMARY KEY (`id`)
);

CREATE TABLE `person_skill` (
  `person_id` BIGINT(20) NOT NULL, 
  `skill_id` BIGINT(20) NOT NULL, 
  PRIMARY KEY (`person_id`, `skill_id`), 
  INDEX `skill_fk_idx` (`skill_id` ASC), 
  CONSTRAINT `person_fk` FOREIGN KEY (`person_id`) REFERENCES `person` (`id`) ON DELETE CASCADE ON UPDATE CASCADE, 
  CONSTRAINT `skill_fk` FOREIGN KEY (`skill_id`) REFERENCES `skill` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
);

Many-To-Many between entity and enum example

The following code shows what the situation is when Person is an entity and Skill is an enum.

@Entity 
public class Person {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY) 
  private Long id;

  private String name;

  @ElementCollection(targetClass = Skill.class) 
  @CollectionTable(name = "person_skill", joinColumns = @JoinColumn(name = "person_id")) 
  @Enumerated(EnumType.STRING) 
  @Column(name = "skill_name") 
  private Set <Skill> skillSet;
}

public enum Skill {
  RUNNING,
  SWIMMING
}

To use this mapping, you would have only 2 tables, because Skill is not an entity and would not have its own table. You can create them with the following SQL code.

CREATE TABLE `person` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT, 
  `name` VARCHAR(45) NOT NULL, 
  PRIMARY KEY (`id`)
);

CREATE TABLE `person_skill` (
  `person_id` BIGINT(20) NOT NULL, 
  `skill_name` VARCHAR(45) NOT NULL, 
  PRIMARY KEY (`person_id`, `skill_name`), 
  CONSTRAINT `person_fk` FOREIGN KEY (`person_id`) REFERENCES `person` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
);

As you can see here, you don’t have the table skill because Skill is not an entity but only an enum; you only have to create the table which represents the relationship between Person and Skill.

Furthermore, since we added the annotation @Enumerated(EnumType.STRING), Spring Data will save the name of the entity in the database (look, we put a VARCHAR column). If you prefer, you could use EnumType.ORDINAL and Spring Data will save the ordinal value of the entity (1,2,3,etc..), so change the column to accept a numeric value.

That’s it!

MobaXterm - Enhanced SSH client for Windows

Emanuele Papa — Mon, 31 Jul 2017 00:00:00 GMT

I’ve always struggled myself each time I had to use SSH on Windows (yes, at least half of the time I use it, I like it). Just few months ago Windows released the Bash Ubuntu integration, which is very well integrated with the Windows environment and it’s a very cool feature, even if it is still a beta!

Anyway, since I was always looking for a better alternative than PuTTY, I finally found an alternative which is extremely worth to be mentioned, MobaXterm.

It has a very cool list of features and has both a free and a professional editions.

It is a lot more than only a featured SSH client, so, really, give it a look, it’s really worth it!

Thank you MobaXterm!

Android Contextual Action Bar

Emanuele Papa — Sun, 30 Jul 2017 00:00:00 GMT

In this post you will learn how to implement a Contextual Action Bar (CAB) which will be useful to do actions on multiple items you have selected in a RecyclerView.

The Contextual Action Mode represents a contextual mode of the user interface and focuses user interaction toward performing contextual actions. In the case of a RecyclerView which shows a list of item, Contextual Action Mode is triggered after a long press on one of this items: this causes the Contextual Action Bar to appear at the top of the screen so then the user can interact with its actions.

Let’s follow these steps!

Initial setup

First of all, create a RecyclerView and its adapter in the usual way you do it. Here in this example I will use a RecyclerView which shows Authentication items (it is a class I made for a project, it doesn’t matter for the purpose of the example, use whatever you want, and change the names accordingly).

Theme changes

Open your styles.xml file and add the following lines:

<!-- It should be true otherwise action mode will not overlay toolbar -->
<item name="windowActionModeOverlay">true</item>
<!-- For Custom Action Mode Background Color/Drawable -->
<item name="actionModeBackground">@color/colorAccent</item>

Comments should be self-explanatory.

We need a menu file which contains the available actions for that RecyclerView. Let’s create a file into the res/menu directory like the following:

<?xml version="1.0" encoding="utf-8"?>
<menu
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item android:id="@+id/action_delete" android:icon="@drawable/ic_delete_white_24dp" android:title="@string/action_delete" app:showAsAction="always" />
</menu>

We added a delete action that will be shown on the CAB.

Adapter changes

Our adapter we created in the first step needs to be able to keep trace of the elements we select. To do this, let’s modify our adapter and create a new field

private final SparseBooleanArray selectedItemsIds;

and initialize it in our constructor

selectedItemsIds = new SparseBooleanArray();

Now, let’s create an interface which will be useful for all the Adapters which need the CAB, and make our Adapter implements it. Please note this is a generic interface, so adapt it to the model you are displaying in your adapter.

public interface ActionModeAdapterCallbacks<T> {
    void toggleSelection(int position);
    void clearSelections();
    int getSelectedCount();
    List<T> getSelectedItems();
}

This is what the implementation should look like:

@Override public void toggleSelection(final int position) {
    if (selectedItemsIds.get(position)) {
        selectedItemsIds.delete(position);
    } else {
        selectedItemsIds.put(position, true);
    }
    notifyItemChanged(position);
}

@Override public void clearSelections() {
    selectedItemsIds.clear();
    notifyDataSetChanged();
}

@Override public int getSelectedCount() {
    return selectedItemsIds.size();
}

@Override public List < Authentication > getSelectedItems() {
    final List < Authentication > selectedItemList = new LinkedList < > ();
    for (int i = 0; i < selectedItemsIds.size(); i++) {
        selectedItemList.add(authenticationList.get(selectedItemsIds.keyAt(i)));
    }
    return selectedItemList;
}

Now, we also need the Adapter to change the view state when an item gets selected to show the user a visual feedback. To do this we can use a StateListDrawable and in the onBindViewHolder() method add this line.

holder.itemView.setActivated(selectedItemsIds.get(position));

Create a new xml file inside the res/drawable directory:

<?xml version="1.0" encoding="utf-8"?>
<selector
    xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@color/colorPrimaryDark" android:state_activated="true" />
    <item android:drawable="@android:color/transparent" />
</selector>

and assign it to the root view element of the layout file which represents your adapter’s row item:

android:background="@drawable/statelist_item_background"

Doing so, each time an item is selected or deselected, the adapter will change its color accordingly.

Fragment/Activity changes

Now, we need to make our Fragment/Activity class aware that we can trigger the Contextual Action Mode. To do so, let’s create an interface and call it ActionModeViewCallbacks.

public interface ActionModeViewCallbacks {
    void onListItemSelect(final int position);
    void onDestroyActionMode();
}

This interface has 2 methods:

onListItemSelect(final int position): to be used after a long click on an item to trigger the Action Mode (or after a single click on an item, if Action Mode was already triggered, to select this new item, too);
onDestroyActionMode(): reset actionMode variable to null;

Now, let’s create another interface which extends from this one:

public interface ListAuthenticationActionModeViewCallbacks extends ActionModeViewCallbacks {
    void onDeleteActionClicked();
}

This new interface has another method, onDeleteActionClicked(), which is where the presenter gets called (check MVP if you are not aware what MVP and a Presenter are) and asked to delete the items the user has selected (if you have more than a single action, you need to create more methods, each for any action you have).

This interface must be implemented by the Fragment/Activity which wants to use the Contextual Action Mode. The implementation looks like this:

@Override
public void onListItemSelect(final int position) {
    listAuthenticationAdapter.toggleSelection(position);

    final boolean hasCheckedItems = listAuthenticationAdapter.getSelectedCount() > 0;

    if (hasCheckedItems && actionMode == null) {
        // there are some selected items, start the actionMode
        actionMode = ((AppCompatActivity) getActivity()).startSupportActionMode(new ListAuthenticationToolbarActionModeCallback(this, this, listAuthenticationAdapter));
    } else if (!hasCheckedItems && actionMode != null) {
        // there no selected items, finish the actionMode
        actionMode.finish();
    }

    if (actionMode != null) {
        //set action mode title on item selection
        actionMode.setTitle(getString(R.string.cab_selected, listAuthenticationAdapter.getSelectedCount()));
    }

}

@Override
public void onDestroyActionMode() {
    actionMode = null;
}

@Override
public void onDeleteActionClicked() {
    presenter.delete(listAuthenticationAdapter.getSelectedItems());
}

where R.string.cab_selected is

<string name="cab_selected">%1$d selected</string>

In doing startSupportActionMode() we need to pass a ActionMode.Callback item that I haven’t explained yet. Let’s create another class which implements that interface.

public class ListAuthenticationToolbarActionModeCallback implements ActionMode.Callback {
    private final ActionModeViewCallbacks actionModeViewCallbacks;
    private final ListAuthenticationAdapter listAuthenticationAdapter;

    public ListAuthenticationToolbarActionModeCallback(final ActionModeViewCallbacks actionModeViewCallbacks, final ListAuthenticationAdapter listAuthenticationAdapter) {
        this.actionModeViewCallbacks = actionModeViewCallbacks;
        this.listAuthenticationAdapter = listAuthenticationAdapter;
    }

    @Override public boolean onCreateActionMode(final ActionMode mode, final Menu menu) {
        mode.getMenuInflater().inflate(R.menu.listauthentication, menu);
        return true;
    }

    @Override public boolean onPrepareActionMode(final ActionMode mode, final Menu menu) {
        menu.findItem(R.id.action_delete).setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
        return true;
    }

    @Override public boolean onActionItemClicked(final ActionMode mode, final MenuItem item) {
        switch (item.getItemId()) {
        case R.id.action_delete:
            actionModeViewCallbacks.onDeleteActionClicked();
            mode.finish();
            return true;
        }
        return false;
    }

    @Override public void onDestroyActionMode(final ActionMode mode) {
        actionModeViewCallbacks.onDestroyActionMode();
        listAuthenticationAdapter.clearSelections();
    }
}

Please have a look on the official documentation here to understand how ActionMode.Callback works.

Screenshots

The initial situation before *Action Mode* is triggered

The situation after *Action Mode* was triggered by long press an item

The final situation after the item "Auth 2" was deleted

Conclusions

Your Contextual Action Mode should work now! I suggest you to create different menu files, Fragment/ActivityToolbarActionModeCallback and Fragment/ActivityActionModeViewCallbacks to keep everything separated.

Please note: if you rotate the device, Contextual Action Mode is lost, you need to save its state and restore it. Another post will follow, hopefully soon!

Java concurrency explained with a few examples

Emanuele Papa — Sat, 06 May 2017 00:00:00 GMT

Sometimes we write very high level code, sometimes we don’t. I want to put here a link to a simple project which shows how to deal with concurrency in Java with a few examples.

The project is available on Github here

Goal of the project is to retrieve the details and the balance of a player and show them at the same time: until you have collected both of them you have to wait before showing the user the information.

There are two different packages: in the first, Futures and Callables are being used, in the other, Threads/Runnables and a CountDownLatch are.

Futures and Callables are the best option when you need to run a task which has a return value. I also made it in a different way using Threads/Runnables, a CountDownLatch and some listeners but these classes are usually used when you have tasks which won’t return any value.

Use the two Main classes to run the examples. Have fun!

AWS S3 custom policy

Emanuele Papa — Sun, 19 Feb 2017 00:00:00 GMT

Do you want to restrict access on S3 only to some users? Do you want to restrict the bucket they can access? Do you want to restrict the actions they can do? Let’s create an AWS S3 custom policy!

Login to your AWS console, go to the IAM console, choose Policies from the left side menu, then click on Create Policy.

Here you can create a new policy in 3 different ways, but what we will do today is following the first one, so click on Copy an AWS Managed Policy. In the next screen select AmazonS3FullAccess. Now, choose a policy name and description. Then, let’s write the policy document.

What I wanted to achieve was these:

user A which could access only the development bucket;
user B which could access only the production bucket.

So I created 2 policies, one for each user, that look like the following:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":"s3:*",
         "Resource":"arn:aws:s3:::bucketname*"
      }
   ]
}

Look at the * at the end of the bucket’s name. It is mandatory otherwise you won’t have permission the execute the listing operation and many other operations would fail due to this.

Another way was to create the policy this way:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":"s3:ListBucket",
         "Resource":"arn:aws:s3:::bucketname"
      },
      {
         "Effect":"Allow",
         "Action":"s3:*",
         "Resource":"arn:aws:s3:::bucketname/*"
      }
   ]
}

I write it only for completeness but I find the first way more compact to write and to read.

Please note you can add more attributes to the Statement object to restrict even further the permissions.

Now, after you have successfully created a policy, assuming you have already created a IAM user from the IAM console, go to that user’s info and attach the policy to it using the Permissions tab.

Do you want to test your new user and policy work as expected? Let’s assume you have created these settings:

User A can access only the development bucket; User B can access only the production bucket.

This is what should happen:

User A tries to access the development bucket: permission granted; User A tries to access the production bucket: permission denied; User B tries to access the development bucket: permission denied; User B tries to access the production bucket: permission granted.

Please refer to the AWS docs for a complete list of attributes and actions to fully customize your policy.

Android NoteApp with Dagger and Retrofit

Emanuele Papa — Wed, 12 Oct 2016 00:00:00 GMT

Today I show a simple Android project I wrote which shows the use of Dagger, Retrofit and some other stuff.

The full source code of the project is available for you here

The project’s main purposes are the following:

Show Dagger2 dependency injection; Show MVP architecture (made through Dagger2) Show the repository pattern used to cache server data Show the creation and use of a CustomView

Furthermore, I have used ButterKnife to remove the boilerplate code needed to bind classes/views, and GreenDao to automatically create the SQLite repository/model classes.

This project is based on the Google Android Architecture samples which are available here

ApplicationContextException using SpringBoot with Gradle and IntelliJ IDEA

Emanuele Papa — Sat, 16 Apr 2016 00:00:00 GMT

In my spare time I decided to have a better look to SpringBoot and in doing so I decided to leave back Maven and Eclipse and to move to Gradle and IntelliJ, which I already use to develop Android applications.

During the first phase of my development I encountered a strange issue: it seems that IntelliJ IDEA will add wrong dependencies to your SpringBoot project which will cause it to crash at runtime.

This was the exception thrown and the full stack trace:

org.springframework.context.ApplicationContextException: Unable to start embedded container; nested exception is org.springframework.context.ApplicationContextException: Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean.
    at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.onRefresh(EmbeddedWebApplicationContext.java:133) ~[spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:532) ~[spring-context-4.2.5.RELEASE.jar:4.2.5.RELEASE]
    at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh(EmbeddedWebApplicationContext.java:118) ~[spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:766) [spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.SpringApplication.createAndRefreshContext(SpringApplication.java:361) [spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:307) [spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1191) [spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.SpringApplication.run(SpringApplication.java:1180) [spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at com.sampleapp.SampleAppApplication.main(SampleAppApplication.java:16) [main/:na]
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_72]
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_72]
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_72]
    at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_72]
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144) [idea_rt.jar:na]
Caused by: org.springframework.context.ApplicationContextException: Unable to start EmbeddedWebApplicationContext due to missing EmbeddedServletContainerFactory bean.
    at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.getEmbeddedServletContainerFactory(EmbeddedWebApplicationContext.java:185) ~[spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.createEmbeddedServletContainer(EmbeddedWebApplicationContext.java:158) ~[spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.onRefresh(EmbeddedWebApplicationContext.java:130) ~[spring-boot-1.3.3.RELEASE.jar:1.3.3.RELEASE]
    ... 13 common frames omitted

This stacktrace is related to SpringBoot v1.3.3 but I experienced the same issue even with SpringBoot v1.4.0.

In the end I found that IntelliJ was putting this line in the build.gradle file:

providedRuntime('org.springframework.boot:spring-boot-starter-tomcat')

After removing that line, the project ran without issues.

So if you are experiencing an ApplicationContextException and you couldn’t find its cause, try to have a look at your build.gradle file.

Windows 10 Wake On Lan

Emanuele Papa — Sat, 26 Mar 2016 00:00:00 GMT

I was using the Wake On Lan feature of my motherboard brilliantly, but after having updated my system from Windows 7 to Windows 10 it stopped working and I had to figure out why.

Here below are the steps you need to check if you want to enable the Wake On Lan on your computer.

Enable Wake On LAN in your motherboard settings

First, you need to enter your BIOS/UEFI and check for Wake On Lan setting. It should be very simple, you should just find an option: the only thing you have to do is set it to Enabled.

Done!

Enable Wake On LAN in Windows 10 network device settings

Search for Device Manager from the Start Menu/toolbar and open it. Look for Network Adapters, if you open it you will find the list of all the network adapters you have installed in your computer (ethernet, wifi, virtual ones, etc..)

Find the one you use to connect to your LAN, and right click on it, then choose Properties.

The following depends on your hardware/driver version: the point as always here is to find the Wake On Lan setting. You could find it under the Advanced or Power Management tabs. Also here you need to enable the Wake On Lan property, if any, and some other properties like Wake on Magic Packet.

Done!

Disable Windows 10 fast startup

This step is only necessary if after have done the two previous ones the Wake On Lan isn’t yet working. Disabling this option could slightly increase your system startup but it was the only way to let my Wake On Lan work. By the way, I didn’t notice any difference between before and after startup times.

Search for Device Manager from the Start Menu/toolbar and open it. Now click on Choose what the power buttons do from the left menu. Disable Turn on fast startup.

Done!

If everything is setup correctly you should be able to turn on your computer from all the other computer and devices (smartphones, tablets, etc) which are connected to your LAN. There are a lot of softwares for whatever Operating System you need to perform this operation. You can also install Team Viewer on the computer you want to wake and at least on one other computer in the LAN to use this one to turn on the target machine from the Team Viewer web interface very easily with just a click!

Any suggestions/questions, feel free to write a comment below!

Install Oracle Java JDK on Linux

Emanuele Papa — Sat, 13 Feb 2016 00:00:00 GMT

In this post we will find out how to install the official Oracle Java JDK on Linux.

First, you need to download the correct package for your operating system. Go here and download the Linux .tar.gz file for x86 or x64 platform.

At the time of writing this article, the current available version is Java SE Development Kit 8u74.

Now, copy the file you just downloaded to the folder /usr/local/java by doing

sudo cp -r FILE_NAME /usr/local/java/

Now unpack the archive using this command

sudo tar xvzf FILE_NAME

Wait for the extraction to be completed, then remove the .tar.gz archive.

Now, to let the JDK folder be system-wide available, we need to add it to the PATH. To do this, let’s run this command

sudo gedit /etc/profile

and at the end of the file past these lines

JAVA_HOME=/usr/local/java/DIR_NAME
PATH=$PATH:$JAVA_HOME/bin
export JAVA_HOME
export PATH

where DIR_NAME is the name of the directory which was created when you extracted the .tar.gz archive.

Now let’s reload our changes by running

source /etc/profile

and it’s done!

If everything went out correctly you should be able to run

java -version

and see your current installed Java version!

Happy development!

Custom Fragment Backstack in Android

Emanuele Papa — Sun, 31 Jan 2016 00:00:00 GMT

Dealing with Fragments is always a pain: after some time I found a way to deal with them in a less painful way, creating a custom Fragment Backstack.

Put this code in your main Activity:

public class MainActivity extends AppCompatActivity {
  private Stack < Fragment > fragmentStack;
  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    fragmentStack = new Stack < > ();
  }
  @Override public void onBackPressed() {
    fragmentStack.pop();
    if (fragmentStack.size() == 0) {
      super.onBackPressed();
    } else {
      showFragment(fragmentStack.lastElement(), false);
    }
  }
  public void showFragment(Fragment fragment, boolean addToStack) {
    if (addToStack) {
      fragmentStack.push(fragment);
    }
    getFragmentManager().beginTransaction().replace(R.id.container_fragment, fragment).commit();
  }
}

We have a fragmentStack field which is a Stack of Fragment: we use this to save the Fragments we show in our app and we initialize it in the onCreate() method of the main Activity.

In the onBackPressed() method we remove the current Fragment from the Stack and then if there is another one, we show it, otherwise we close the app because there is nothing more to be shown.

The method showFragment() is the one we use to show a Fragment on the screen; we invoke it every time we need to change the visible Fragment. If we want to save the current transaction being able to come back to the current Fragment we pass true as addToStack value, otherwise we pass false.

Have a look at the full source code on my GitHub here.

Auto hide keyboard using Android EditText

Emanuele Papa — Mon, 14 Dec 2015 00:00:00 GMT

Do you want to automatically hide your keyboard whenever you touch outside it? Please continue reading and you will find out how to do it!

First, we will create our AutoHideKeyboardEditText class like the following:

public class AutoHideKeyboardEditText extends EditText {
  public AutoHideKeyboardEditText(Context context) {
    super(context);
    init();
  }
  public AutoHideKeyboardEditText(Context context, AttributeSet attrs) {
    super(context, attrs);
    init();
  }
  public AutoHideKeyboardEditText(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    init();
  }
  private void init() {
    setOnFocusChangeListener(new OnFocusChangeListener() {
      @Override public void onFocusChange(View v, boolean hasFocus) {
        if (!hasFocus) {
          hideKeyboard(v);
        }
      }
    });
  }
  private void hideKeyboard(View view) {
    InputMethodManager inputMethodManager = (InputMethodManager) view.getContext().getSystemService(Activity.INPUT_METHOD_SERVICE);
    inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
  }
}

Whatever Constructor is used, we set an onFocusChangeListener to hide the keyboard using the proper method if we touch outside the EditText area (if the focus is not anymore on it).

Afterwards, create a layout similar to this

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android" 
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:clickable="true"
    android:focusableInTouchMode="true"
    android:orientation="vertical"/>

being sure, whatever layout you want to use, to add clickable and focusableInTouchMode attributes with true value.

Now just add our AutoHideKeyboardTextView inside that layout. You can simply add it using XML like the following

<com.w3ma.androidshowcase.autohidekeyboard.AutoHideKeyboardEditText 
    android:layout_width="match_parent"
    android:layout_height="wrap_content"/>

You are done! Whenever you touch outside the EditText the keyboard will be automatically dismissed!

Please note: you should add the clickable and focusableInTouchMode attributes to the outermost view but if it is a ScrollView this might not work. For such case, those attributes could be added to the view directly under the ScrollView.

Full source code on my GitHub repository here.

Source: https://stackoverflow.com/questions/4165414/how-to-hide-soft-keyboard-on-android-after-clicking-outside-edittext/19828165#19828165

I don’t know why this wasn’t voted as the best answer because it is indeed.

Android Studio gitignore to avoid useless files

Emanuele Papa — Fri, 20 Nov 2015 00:00:00 GMT

Create a perfect Android Studio .gitignore file is sometimes tedious, so I have gathered some information on the Internet, mainly on StackOverflow, I made some experiments with my sample project over and over and finally I obtained a perfect Android Studio .gitignore file.

Usually, I create my project inside a parent folder which I initialize as my Git repository.

So, for example, this is a sample structure (folders are bolded):

AndroidShowcaseRepository

.git
AndroidShowCase
- .gradle
- .idea
- app
- build
- gradle
- .gitignore
- AndroidShowcase.iml
- build.gradle
- gradlew
- gradlew.bat
- local.properties
- settings.gradle
.gitignore
LICENSE
README.md

I use the following as content for the .gitignore file in the AndroidShowcaseRepository folder

# Built application files 
*.apk
*.ap_

# Files for the Dalvik VM
*.dex

# Java class files
*.class

# Generated files 
bin/
gen/

# Gradle files
.gradle/
build/
/*/build/

# Local configuration file (sdk path, etc)
local.properties

# Proguard folder generated by Eclipse
proguard/

# Log Files
*.log

and the following as content for the .gitignore file in the AndroidShowcase folder

.gradle
/local.properties
.DS_Store
/build
/captures
.idea
gradlew
gradlew.bat
gradle

Using these two .gitignore files (and the default ones created by Android Studio inside the app folder and into other folders you could have) you will likely save only the necessary source code to your repository and not files which could be generated by Android Studio itself.

Check w3ma showcase repository for the complete source code and for more explanation!

Making TextView with clickable link in Android

Emanuele Papa — Thu, 19 Nov 2015 00:00:00 GMT

I will explain how to create a TextView with inside a clickable link in Android.

Do you want to open a static link without doing other operations? So just follow the first part of this tutorial! Otherwise, if you want to have more control on the link customization and operations after the user taps on it, follow the second part of the tutorial.

Static clickable link inside strings.xml resource

Let’s create an example TextView in your layout like this one:

<TextView 
    android:id="@+id/messageWithLinkTextView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_centerInParent="true"
    android:gravity="center"
    android:text="@string/messageWithLink" />

Create this string in strings.xml:

<string name="messageWithLink">This is a message with a link inside!\n<a href="https://www.google.com/">Tap here to open it!</a></string>

Write this code in your activity/fragment:

@Bind(R.id.messageWithLinkTextView) 
TextView messageWithLinkTextView; 

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState); 
    ButterKnife.bind(this, view); 
    messageWithLinkTextView.setMovementMethod(LinkMovementMethod.getInstance());
}

Please note: I’m using ButterKnife library to bind fields and views (I suggest you to have a look at this fantastic library!)

You are done! You should get a TextView like the one in the following screenshot and when you tap on the hyperlink the browser should open! Cool!

TextView with link

P.S. unfortunately I didn’t find a way of achieving this only using XML properties. If anyone knows how to do it, please let me know in the comments!

Custom clickable link and custom actions

Create another TextView in your layout:

<TextView
   android:id="@+id/messageWithSpannableLinkTextView"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_centerInParent="true"
   android:gravity="center"
   tools:text="@string/messageWithSpannableLink" />

Create another string resource in strings.xml:

<string name="messageWithSpannableLink">This is a message with a spannable link inside!\nTap here to open it!</string>

Please note: this time there is no tag inside the string!

Now write this code in your activity/fragment:

@Bind(R.id.messageWithSpannableLinkTextView)
TextView messageWithSpannableLinkTextView;

@Override
public void onViewCreated(View view, Bundle savedInstanceState) { 
    super.onViewCreated(view, savedInstanceState);
    ButterKnife.bind(this, view);
    SpannableString spannableString = new SpannableString(getString(R.string.messageWithSpannableLink));
    ClickableSpan clickableSpan = new ClickableSpan() { 
        @Override 
        public void onClick(View textView) { 
            startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://www.google.com"))); 
        } 
    }; 
    spannableString.setSpan(clickableSpan, spannableString.length() - 20, spannableString.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
    messageWithSpannableLinkTextView.setText(spannableString, TextView.BufferType.SPANNABLE);
    messageWithSpannableLinkTextView.setMovementMethod(LinkMovementMethod.getInstance());
}

You are done! You should get a TextView like the one in the following screenshot and when you tap on the hyperlink the ClickableSpan->onClick() method should be called, so you can do your operations and let the browser open the link! Cool!

TextView with spannable link inside

Check out the complete source code on my GitHub here!

W3MA GitHub Repository Showcase

Emanuele Papa — Wed, 18 Nov 2015 00:00:00 GMT

Hi guys, this post is just to show you a link to the w3ma github repository showcase I will use to share the Android code I will post in the future in the blog.

It is the best way to always show a fully compiling code to everyone who wants to have a look at it.

Just click here to see it!

I hope you will enjoy my code.

Assign static device name using udev rules

Emanuele Papa — Sat, 24 Oct 2015 00:00:00 GMT

How can you assign static device name using udev rules to a USB device? Why do you need it?

Imagine you made a script which refers to a particular device you could plugin trough USB port: sometimes this device could be mounted as /dev/sdb1, sometimes as /dev/sdc1, and so on. You may need a static reference to it because you didn’t know which name it will use.

Another scenario could be a startup mount of a drive as discussed in How to mount ntfs partition at startup

To achieve this, let first discover some attributes of our device using the command

sudo lsusb

We will receive an output like this:

emanuele@ubuntu:~$ lsusb
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 008 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 007 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 006 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 004: ID 1058:107c Western Digital Technologies, Inc.

Have a look at the Western Digital Technologies row, this is the device we are looking for: 1058 is the Vendor ID and 107c is the Product ID! We will use these information to uniquely identify our device.

Now, let’s create a new udev rule typing

sudo nano /etc/udev/rules.d/99-my_rules.rules

and writing the following into the file

ACTION=="add", ATTRS{idVendor}=="1058", ATTRS{idProduct}=="107c", SYMLINK+="my_wd_usb_hd"

where the ATTRS numbers are the ones we discovered before, while my_wd_usb_hd is the name we choose for our device.

Now let’s reboot our pc! Everytime it reboots this rule will be applied and we will always find our device under /dev/my_wd_usb_hd

Mount NTFS partition at startup

Emanuele Papa — Thu, 22 Oct 2015 00:00:00 GMT

In this post we will learn how to mount NTFS partition at startup in a very simple way.

You can use the following command to retrieve a list of your partitions and their UUID.

ls -l /dev/disk/by-uuid

Pick the one you want to automatically mount and open the file /etc/fstab by using

sudo nano /etc/fstab

Add a new row like:

UUID=XXXXXXXXXXX /hd_mount_point ntfs-3g defaults 0 0

where XXXXXXXXXXX is your partition UUID and /hd_mount_point is a folder on your disk you will use to access that partition.

Simply reboot and you are done!

Force Ubuntu boot after power failure

Emanuele Papa — Sat, 10 Oct 2015 00:00:00 GMT

Hello,

in this blog post I will show a little trick to avoid your Ubuntu installation got stuck on GRUB boot menu waiting for you to choose an option after a power failure.

To force Ubuntu boot you can edit your /etc/default/grub with your favourite text editor, e.g. running this command from your terminal:

nano /etc/default/grub

and then add this line in the file:

GRUB_RECORDFAIL_TIMEOUT=0

Afterwards, remember to run:

sudo update-grub

Next time your pc will have a power failure it will reboot without getting stuck on GRUB!

Emanuele Papa RSS Feed

Test GitHub Actions workflows on a branch before merging

📝 Prerequisites

🛠️ Step-by-step: Testing a GitHub Actions workflow on a branch

1. Create a skeleton workflow triggered by push

2. Let GitHub register the workflow

3. Replace push with workflow_dispatch

4. Trigger the workflow using GitHub CLI

5. Continue developing and testing

✅ Conclusion

How to change Proxmox IP address when moving to a different network

📝 Prerequisites

🛠️ Step-by-Step: Changing Proxmox IP address

1. Access the server via console

2. Update the Network Configuration File

3. Update /etc/hosts

4. Check DNS Settings

5. Restart Networking

6. Verify the new configuration

✅ Conclusion

Block ads using DNS over TLS with AdGuard Home, Let's Encrypt, and Cloudflare for Android Devices

Prerequisites

Step 1: Create DNS Records in Cloudflare

Create an A Record:

Create a CNAME Record:

Step 2: Configure Cloudflare Integration in Home Assistant

Create API Tokens in Cloudflare:

Install and configure the Cloudflare Integration:

Step 3: Obtain and Configure Let’s Encrypt Certificates

Install the Let’s Encrypt Add-on in Home Assistant:

Configure the Let’s Encrypt Add-on:

Set Up Automatic Certificate Renewal:

Step 4: Configure AdGuard Home for DNS over TLS

Step 5: Configure Android Devices for DNS over TLS

Conclusion

Synchronize AdGuard Home instances with Docker and Proxmox

What is AdGuard Home Sync

Installation steps

AdGuard Home sync configuration

How to get username/password of HomeAssistant AdGuard Home

Understanding the Docker Run Command

Maintenance

Self-Hosting changedetection.io with Docker and Proxmox

What’s changedetection.io

Installation steps

Self-Hosting Stirling-PDF with Docker and Proxmox

What’s Stirling-PDF

Installation steps

Understanding the Docker Run Command

Security

OCR

Maintenance

Kotlin Multiplatform and Swift - Overcoming Interoperability Challenges for Multiplatform Development

Using a Swift library with Dependency Injection and Koin

Shared code

Create a wrapper

Android setup

iOS setup

Start Koin!

Instances injected by Koin

Considerations

Easily retrieve SHA fingerprints with Gradle signingReport task for Android development

Boost your Internet speed setting up a 2.5Gbps Ethernet connection with iliad FTTH and a Macbook Pro M1

Kotlin Essentials - My experience reviewing the latest Marcin Moskala book

Speaking about KMM at Commit University in November 2022

Solve ADB stuck on waiting for debugger

Speaking about KMM at droidcon Italy 2022

Meet me at droidcon Italy 2022

Android image and video picker using ActivityResultContracts in Jetpack Compose

Flutter code generation with Paddinger at droidcon London 2021

Meet me at droidcon London 2021

New website! emanuelepapa.dev and w3ma.com merge

Flutter Padding widgets generator with Paddinger

What is Paddinger

How to use Paddinger in your project

Clear all Android SharedPreferences

How to debug an Annotation Processor in Android Studio

Additional info

Add UEFI support to your AMD HD7970 to use Secure Boot

Sleep automation with Mi Band and Home Assistant

1. Create a skeleton workflow triggered by `push`

3. Replace `push` with `workflow_dispatch`

3. Update `/etc/hosts`