Erics Blog

Enable the Android screen reader Talkback from the Linux command line

2022-04-30T20:52:05Z

You can enable Androids screen reader from the Linux command line with the following command:

adb shell settings put secure enabled_accessibility_services com.google.android.marvin.talkback/com.google.android.marvin.talkback.TalkBackService

Unfortunately you had to enable USB Debugging on your Android device before. Furthermore you must install the Android Debug Bridge on your PC. Otherwise the command above will not work.

Shell script for ADF scanner Fujitsu SP-1120

2021-07-03T21:10:31Z

Recently I bought a Fujitsu SP-1120 to replace my rather slow and old flatbed scanner. The Fujitsu is an an automatic document feeder (ADF) with duplex support. It’s faster, scans front and back pages in one go and produces a much better image quality for ocr.

This article describes the installation under Debian Linux and provides a simple scan-to-pdf shell script.

Install the scanner

First download the Linux driver package - at least it works under Ubuntu and Debian.

Then install:

# dpkg -i pfusp-ubuntu18.04_2.1.1_amd64.deb

And create the udev rule 99-fujitsu-sp-1120.rules under /etc/udev/rules.d with the following content:

# Fujitsu ScanSnap SP-1120
ATTRS{idVendor}=="04c5", ATTRS{idProduct}=="1473", MODE="0664", GROUP="scanner", ENV{libsane_matched}="yes"

Adapt the product id, if you bought a SP-1125 or SP-1130. Afterwards reload the udev rules:

# udevadm control --reload
# udevadm trigger

Lastly install the sane package (Scanner Access Now Easy) and turn on the scanner and check, if the scanner was installed correctly:

# apt install sane
# scanadf --list-devices

Expected output:

device `pfusp:SP1120:001:093' is a FUJITSU SP1120 scanner

Scan script

Download the shell script below, make it executable and adjust some defaults to your liking. For example you may change the pdf viewer variable. I use another shell script for that, which you can finde here.

To start scanning, put some document into your scanner and type:

adf

Use the -p parameter, to preview the ocr result of the first page and -h for help.

Download: adf

#!/bin/bash

# Script to control an ADF scanner
# - start scanning and create a single pdf file
# - with empty page and orientation detection
# - tested with Fujitsu SP-1120
#
# ... excessively borrowed from https://github.com/rocketraman/sane-scan-pdf
#
# Version: 0.1
# Date:    2021-06-16
# License: GNU General Public License
# Author:  Eric Scheibler
# E-Mail:  email [at] eric-scheibler [dot] de
# URL:     http://eric-scheibler.de/en/blog/2015/04/script-to-extract-text-from-images-and-scanned-pdf-files/
#
# Install:
#   sudo apt install imagemagick poppler-utils sane tesseract-ocr tesseract-ocr-deu tesseract-ocr-eng unpaper

OUTPUT="scan.pdf"
TEXT_EDITOR="/usr/bin/vim"
PDF_VIEWER="$HOME/bin/ocr"
HELP=0
VERBOSE=0

# scanner params
DEVICE=pfusp
RESOLUTION=400
MODE=Lineart

# ocr params
OCR_LANGUAGE=deu
OCR_PREVIEW_FIRST_PAGE=0
OVERWRITE_OUTPUT_FILE=0


#####

TMP_DIR=$(mktemp -d -p "" scan.XXXXXXXXXX)
cleanup() {
    rm -rf "$TMP_DIR"
}
trap cleanup EXIT

function yes_or_no {
    while true; do
        read -p "$* [y/n]: " yn
        case $yn in
            [Yy]*) return 0  ;;
            [Nn]*) echo "Aborted" ; return  1 ;;
        esac
    done
}


# Parse command-line options
while [[ $# > 0 ]]; do
    case "$1" in
    -h|--help) HELP=1 ;;
    -v|--verbose) VERBOSE=1 ;;
    -o|--output) shift; OUTPUT="$1" ;;
    -x|--device) shift; DEVICE=$1;;
    -m|--mode) shift; MODE=$1 ;;
    -r|--resolution) shift; RESOLUTION=$1 ;;
    -l|--language) shift; OCR_LANGUAGE=$1 ;;
    -p|--preview-first-page) OCR_PREVIEW_FIRST_PAGE=1 ;;
    -w|--overwrite-output-file) OVERWRITE_OUTPUT_FILE=1 ;;
    esac
    shift     # next option
done

if [[ $HELP == 1 ]]; then
    echo "$(basename $0) [OPTIONS]... [OUTPUT]"
    echo ""
    echo "OPTIONS"
    echo " -x, --device"
    echo "    Override scanner device name, defaulting to \"pfusp\""
    echo " -m, --mode"
    echo "     Mode e.g. Lineart (default), Halftone, Gray, Color, etc."
    echo " -r, --resolution"
    echo "     Resolution e.g 300 (default)"
    echo " -l, --language <lang>"
    echo "     which language to use for OCR"
    echo " -p, --preview-first-page"
    echo "     OCR first page and preview in $TEXT_EDITOR"
    echo ""
    echo "OUTPUT"
    echo " -o, --output <outputfile>"
    echo "     Output to named file default=scan.pdf"
    echo " -w, --overwrite-output-file"
    echo "     Overwrite the output pdf file, if it already exists"
    echo " -v, --verbose"
    exit 0
fi

if [[ $VERBOSE == 0 ]]; then
    quiet_paran="--quiet"
    suppress_error_messages="2> /dev/null"
fi

if [[ "$OUTPUT" == "" ]]; then
    echo >&2 "Output file must be specified. Aborting."
    exit 1
fi

if [[ -f "$OUTPUT" ]]; then
    if [[ $OVERWRITE_OUTPUT_FILE == 0 ]]; then
        echo >&2 "Output file $OUTPUT already exists. Aborting."
        exit 1
    else
        rm "$OUTPUT"
    fi
fi


echo >&2 "Scanning..."
scanadf --device-name "$DEVICE" --source Adf-duplex --resolution $RESOLUTION --mode $MODE -o $TMP_DIR/scan-%04d
if [[ $? != 0 ]]; then
    exit 1
fi
echo ""


shopt -s extglob nullglob
image_files=($TMP_DIR/scan-[0-9]*)
num_scans=${#image_files[@]}
if [[ $num_scans > 0 ]]; then

    if [[ $OCR_PREVIEW_FIRST_PAGE == 1 ]]; then
        echo "Creating preview..."
        preview_image_file="${image_files[0]}"
        preview_text_file="$TMP_DIR/preview_first_page.txt"
        # ocr
        eval tesseract $preview_image_file ${preview_text_file%.*} -l $OCR_LANGUAGE --psm 12 $suppress_error_messages
        # show
        $TEXT_EDITOR $preview_text_file
        if ! yes_or_no "Proceed?"; then
            exit 0
        fi
        # remove preview text file
        rm $preview_text_file
        echo ""
    fi

    echo "Processing $num_scans pages"
    for image_file in ${image_files[@]}; do
        echo "Process $(basename $image_file)"

        # unpaper
        eval unpaper $quiet_paran --overwrite --dpi $RESOLUTION $image_file $image_file $suppress_error_messages

        # convert to tiff
        convert -density ${RESOLUTION}x${RESOLUTION} -units PixelsPerInch $image_file ${image_file}.tiff
        rm $image_file

        # orientation detection
        orientation_result=$(eval tesseract ${image_file}.tiff - --psm 0 $suppress_error_messages) || orientation_result=
        if [[ $orientation_result == *"Rotate: 180"* ]]; then
            echo "Image orientation is upside down, rotate"
            convert -rotate 180 ${image_file}.tiff ${image_file}.tiff
        fi

        # empty page detection
        percentage_white=$(convert ${image_file}.tiff -fuzz 0% -negate -threshold 0 -negate -format "%[fx:100*mean]" info:) || percentage_white=0
        is_empty_page=$(echo "$percentage_white >= 99.8" | bc -l)
        if [[ $is_empty_page == 1 && $orientation_result == "" ]]; then
            echo "Empty page removed"

        else
            eval tesseract ${image_file}.tiff $image_file -l $OCR_LANGUAGE pdf $suppress_error_messages
            rm ${image_file}.tiff
        fi

        echo ""
    done

    # rename or unite created pdf(s)
    pdf_files=($TMP_DIR/scan-[0-9]*.pdf)
    num_pdf_files=${#pdf_files[@]}
    if [[ $num_pdf_files == 1 ]]; then
        echo "Renaming..."
        mv $TMP_DIR/scan-0*.pdf "$OUTPUT"
    elif [[ $num_pdf_files > 1 ]]; then
        echo "Concatenating pdfs..."
        pdfunite "${pdf_files[@]}" "$OUTPUT"
    fi
fi

if [[ -f "$OUTPUT" ]]; then
    echo "Done."
    if [[ $PDF_VIEWER != "" ]]; then
        if yes_or_no "Open ${OUTPUT}?"; then
            $PDF_VIEWER $OUTPUT
        fi
    fi
else
    echo "No scans found."
fi

Easy and accessible network request analysis

2021-06-12T12:56:47Z

I had to analyse some network requests while I was working on an Android app project. That turned out to be surprisingly easy, using mitmproxy. This article covers the proxy installation and usage by wget and within the source code of an Android app.

Basically it works like a mitm attack. You have to install a proxy server somewhere in your local network and route client requests through it. I’ve chosen mitmproxy, because it’s available for the Linux console, simple to use and its ui is fairly accessible to screen readers like brltty.

Install: sudo apt install mitmproxy

Run: mitmproxy --listen-host 192.168.100.100 --listen-port 22222 --save-stream-file +requests.log

Wget

Now try to send a http request through the proxy:

wget -e https_proxy=192.168.100.100:22222 http://example.org

It should appear in the main view of mitmproxy.

If you want to intercept encrypted requests as well, your client must trust the ssl certificate, which mitmproxy created during its first launch. You may find it under ~/.mitmproxy/mitmproxy-ca-cert.pem. Copy the file onto your client machine and send a second request:

wget -e https_proxy=192.168.100.100:22222 --ca-certificate /path/to/mitmproxy-ca-cert.pem https://example.org

If everything went well, you should see two lines in the mitmproxy main view. Use the arrow keys to select a request and press ENTER to show its details.

Unfortunately the view doesn’t use the hardware console cursor. Therefore screen readers can’t announce the selected list item properly. If you use brltty, you may disable the autom. cursor tracking (CAPSLOCK+ENTER) and follow the selected list item manually. It’s prefixed by “>>”.

The request details view consists of three tabs: request, response and details. Select them with left and right arrow keys or tab through). I was only interested in the request cookie headers, which I found directly in the request tab.

Android app development

First add the same mitmproxy certificate to your apps “res” folder:

mkdir /path/to/android_project/app/src/main/res/raw/
cp ~/.mitmproxy/mitmproxy-ca-cert.pem /path/to/android_project/app/src/main/res/raw/mitm_proxy.pem

Then include the following code into your app to:

set the proxy
use the SSL certificate from above for the request

import org.example.project.BuildConfig;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.security.KeyStore;
import java.security.cert.CertificateFactory;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;

URL url = new URL("https://example.org");
String proxyHost = "192.168.100.100";
int proxyPort = 22222;

HttpsURLConnection connection = null;
if (BuildConfig.DEBUG) {

    Proxy proxy = new Proxy(
            Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
    connection = (HttpsURLConnection) url.openConnection(proxy);

    try {
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        InputStream caInput;
        // Create a KeyStore containing our trusted CAs
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null);
        // load mitm_proxy certificate
        caInput = ApplicationInstance.getContext().getResources().openRawResource(R.raw.mitm_proxy);
        try {
            keyStore.setCertificateEntry("ca1", cf.generateCertificate(caInput));
        } finally {
            caInput.close();
        }
        // Create a TrustManager that trusts the CAs in our KeyStore
        String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
        tmf.init(keyStore);
        // Create an SSLContext that uses our TrustManager
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), null);
        connection.setSSLSocketFactory(sslContext.getSocketFactory());
    } catch (Exception e) {
        System.out.println(
                String.format("Cert exception: %1$s", e.getMessage()));
    }

} else {
    connection = (HttpsURLConnection) url.openConnection();
}

Of course it’s also possible to reroute every request from the Android device through your proxy. Then you have to add the certificate to your cert-store (Android settings -> security) and set a system-wide proxy. Unfortunately not every application respects this - for example browsers may define their own proxy settings.

Therefore if you want to debug your own app, go for the direct integration - much easier to implement.

MPD - Announce current song

2018-12-29T02:14:13Z

My server runs an MPD instance for music playback. The following script for Mac announces the currently playing song after every song change. It uses Mac OS build in TTS and tries to guess the song title language.

Download: mpd_speak_current_song.py

#!/Users/eric/.virtualenvs/speak_current_song/bin/python
# -*- coding: utf-8 -*-

# mpd: speak currently playing song after it has changed
#
# This script uses the mpd client mpc to watch for song changes on the running mpd server and speaks them aloud
# Song title language detection with https://github.com/Mimino666/langdetect
# It's written for Mac OS but could be easily adapted to Linux as well (change tts_command variable)
#
# author: Eric Scheibler <email@eric-scheibler.de>
# Date: 2019-03-29
# Version: 0.2
#
# Installation requirements:
#   brew install mpc
#   pip install langdetect
#
# Usage: Must run in background for example within a screen session
#   ./mpd_speak_current_song

# configuration
#
# adapt the following params to your needs
# leave them blank if not required
#
# mpd host and port
mpd_host = "192.168.2.11"
mpd_port = "6600"
# audio output device
# Mac: get all devices with: say -a '?'
audio_output_device = ""
# voice table
# Mac: get all installed voices with: say -v '?'
voices = {
        "de" : {"name":"Yannick", "rate":280},
        "en" : {"name":"Samantha", "rate":200},
        "fr" : {"name":"Thomas", "rate":200},
        # default: different German voice
        "default" : {"name":"Anna", "rate":240}
        }


import subprocess, sys, threading
from langdetect import detect, DetectorFactory
from langdetect.lang_detect_exception import LangDetectException


# construct commands
#
# control mpd with: mpc ...
mpc_command = ["mpc", "--quiet"]
if mpd_host:
    mpc_command += ["--host", mpd_host]
if mpd_port:
    mpc_command += ["--port", mpd_port]
# speak with: say ...
tts_command = ["say"]
if audio_output_device:
    tts_command += ["-a", audio_output_device]


class SpeakCurrentSong(threading.Thread):

    def __init__(self, song, voice):
        threading.Thread.__init__(self)
        self.song = song
        self.voice = voice
        # class variables
        self.process = None
        self.finished = False
        self.killed = False

    def run(self):
        # pause playback
        if not self.killed:
            self.execute(mpc_command + ["pause"])
        # announce new song
        if not self.killed:
            self.execute(tts_command + ["-v", self.voice.get("name"), "-r", str(self.voice.get("rate")), self.song])
        # resume playback
        if not self.killed:
            self.execute(mpc_command + ["play"])
        self.finished = True

    def execute(self, command):
        self.process = subprocess.Popen(command)
        self.process.wait()

    def kill(self):
        self.process.kill()
        self.killed = True


def main():
    speakCurrentSongThread = None
    # force deterministic language detection results
    DetectorFactory.seed = 0
    while True:
        try:
            # wait for change of current song
            current_song = subprocess.check_output(mpc_command + ["current", "--wait"], encoding='UTF-8').strip()
        except subprocess.CalledProcessError as e:
            # could not get current song
            error_message = "Error: Could not get the current song"
            subprocess.Popen(tts_command + ["-v", "Alex", error_message])
            print('{}: {}'.format(error_message, e))
            sys.exit(1)
        else:
            # detect language and get tts voice
            voice = voices.get("default")
            try:
                language = detect(current_song)
            except LangDetectException as e:
                pass
            else:
                if language in voices.keys():
                    voice = voices.get(language)
            # start SpeakCurrentSong thread
            if speakCurrentSongThread:
                # kill old thread if necessary
                if not speakCurrentSongThread.finished:
                    speakCurrentSongThread.kill()
                speakCurrentSongThread.join()
            speakCurrentSongThread = SpeakCurrentSong(current_song, voice)
            speakCurrentSongThread.start()
            # log to stdout
            print('{}.{}: {}'.format(language, voice.get("name"), current_song))


if __name__ == "__main__":
    main()

ClipboardToSpeech - Android app speaks the clipboard content

2018-02-10T09:43:24Z

This Android application Monitors the clipboard and speaks newly added text immediately.

Additional features are:

Uses the default tts engine for speech output
Contains a clipboard history with the last entries
Autostarts at boot time
Creates a low-priority notification when the background service is running
Requires at least Android version 4.1 and is compatible to 8.0 and 8.1

Clone the git repository:

git clone https://github.com/scheibler/ClipboardToSpeech/

Then install the pre-compiled version with:

adb install app/src/main/misc/releases/ClipboardToSpeech_vx.x.x.apk

Or build manually:

./gradlew build

Game of thrones - Tactile maps for the blind and visually impaired

2017-08-13T11:01:16Z

I’m a great fan of the TV series Game of Thrones and the books it’s based on. In cooperation with Jens Bornschein from the TU Dresden I’ve created tactile maps of Westeros and Essos and made them available for download . Be aware, you need a braille printer or similar device to produce tactile maps.

Currently the 7th season of Game of Thrones is running and outright in the first episode we see a big and still incomplete map of Westeros. Its creation was ordered by no lesser than Cersei Lannister. I suspect her point in doing so is to be able to better explain the threats facing house Lannister from all sides.

As a blind fan my understanding of that worlds geography is limited to the information I could extract from the books descriptions. To obtain a better overview in regard to the locations of the great house’s homes, I took this as an opportunity to crate a tactile map for my own use. I asked Jens for help, because he was at the time part of project TANGRAM at TU Dresden, focused on interactively creating tactile maps and images for the blind.

We took the map template from gameofthrones.net and had a brief discussion on which objects to include. Then Jens drew the contours of the continents and placed the POI, while I reviewed the progress on a 2-dimensional braille display.

Together we created these two maps:

A landscape format world map containing Westeros and Essos. (unfortunately there was no space left to include Sothoryos)
A portrait format map of Westeros, including the most important POI.

The maps are available in SVG format, each containing a second page detailing the abbreviations used.

We offer two sets of maps:

If you have access to a ViewPlus braille printer please download got_maps_viewPlus-tiger.zip. It produces the best results and should be easy to use.

Alternatively you can try got_maps_print.zip. This package is mainly intended for swell paper printers. The results are a bit less accurate but it still may give you a principle understanding of the worlds geography.

Disable laptop screen on Linux

2016-07-03T20:29:42Z

This article describes how to disable the laptop screen on Lenovo Thinkpads. This saves a lot of power and enhances your privacy. Root privileges required. Tested with a Thinkpad T450 on Debian Stretch.

Save the following script under /usr/local/sbin/monitor:

#!/bin/bash
if [ -f /tmp/screen_stays_active ]; then
    echo 0 > /sys/class/backlight/intel_backlight/brightness
    rm /tmp/screen_stays_active
    echo "Disable screen"
else
    echo 850 > /sys/class/backlight/intel_backlight/brightness
    touch /tmp/screen_stays_active
    echo "Restore screen brightness"
fi

and make it executable:

chmod +x /usr/local/sbin/monitor

The laptop monitor enables itself in irregular intervals again. Therefore you may create three cronjobs for the root user which disable the screen every 20 seconds continuously. A script with an endless while-loop certainly would serve the same purpose.

# crontab -e

*  *   *   *   *   if [ ! -f /tmp/screen_stays_active ]; then echo 0 > /sys/class/backlight/intel_backlight/brightness; fi
*  *   *   *   *   sleep 20 && if [ ! -f /tmp/screen_stays_active ]; then echo 0 > /sys/class/backlight/intel_backlight/brightness; fi
*  *   *   *   *   sleep 40 && if [ ! -f /tmp/screen_stays_active ]; then echo 0 > /sys/class/backlight/intel_backlight/brightness; fi

Please note, that the screen is disabled directly after you’ve created the cronjobs above and it will stay disabled even after reboot.

You may toggle the brightness state with the command sudo monitor. If you don’t want to enter a password every time, you may define an exception in the sudoers file. To do so enter the visudo command as root and append the following line:

MY_USER_NAME ALL = NOPASSWD: /usr/local/sbin/monitor

By the way: If you often enable the keyboard backlight accidentally via fn+space and you want to disable that automatically too, add the following cronjob:

# crontab -e

*  *   *   *   *   echo 0 > /sys/class/leds/tpacpi::kbd_backlight/brightness

Find additional information at http://www.thinkwiki.org/wiki/ThinkLight

Android app Tactile Clock vibrates the current time

2016-05-06T21:45:20Z

This Android app vibrates the current time when the display is locked and you double-click the power button of your device.

The app is free software. You can find the links to the play store, a f-droid repository and the source code below.

The latest version was released on June 23rd, 2026.

How it works

Double-click the power button. This might take some practice to work reliably. Press slowly and deliberately. If you double-click too fast the system only recognizes a single click and turns the screen on instead.

The time vibration is structured as follows:

A short vibration stands for the digit 1 and a long one for the digit 5. The 2 is represented by two consecutive short vibrations, the 6 by a long and a short one and so on. The 0 constitutes an exception with two long vibrations.

Examples:

00:00 =  --   --
01:18 =  .    .  -...
02:51 =  ..    -  .
10:11 =  .  --    .  .
19:06 =  .  -....    -.

Explanation:

The time is processed digit by digit:

. = short vibration
- = long vibration

Leading zeros in the hour and minute fields are omitted.

Gaps:

To simplify the recognition of the vibration pattern, there exist three kind of gaps with different durations:

[]: A short gap between vibrations in the same digit
[ ]: A medium gap for the separation of two digits within the hour and minute field
[ ]: A long gap to split hours and minutes

Additional features

Keep informed about the current time. The app can vibrate the current time automatically every X minutes or every hour.
Play the Greenwich Time Signal at the start of each hour, similar to a radio station.
Trigger time vibration with Tasker (see below for details)
Decide what to do if you double-click when the display is on. You can choose between a warning vibration and having the time vibrated as well.
The app starts automatically after the system reboots.
It runs on all devices with Android 6 or newer.

Double-click conflict

TactileClock is triggered by clicking the power button twice in quick succession. This may conflict with the ‘built-in’ double-click action of your Android device. For example, a Google Pixel device will typically launch the camera when the power button is double-clicked; a Samsung device may take a screenshot when the power button is double-clicked.

If your device has a ‘built-in’ action when the power button is double-clicked, there are three options to get TactileClock working.

Option 1: Disable the ‘built-in’ double-click action of your device.

Google Pixel: (Settings > System > Gestures > Quickly open camera)
Samsung Galaxy: (Settings > Advanced Features > Side Button > Double Press)
Other devices may require different settings to disable the double-click action.

Once the ‘built-in’ double-click action has been disabled, double-clicking the power button will trigger the TactileClock action.

Option 2: Configure TactileClock to trigger after a long double-click.

This will allow the ‘built-in’ double-click action to co-exist with the TactileClock double-click action.

1. Open TactileClock
2. Swipe left to show the 'Shortcut' screen.
3. Modify the 'Click Interval:'.
     3a. Set 'From:' to be 500ms.
     3b. Set 'To:' to be 1500ms.

The From: and To: values specified above should work, but may need to be adjusted for optimal results on your device. Once configured, a fast double-click will trigger your devices ‘built-in’ action, while a slow double-click will trigger the TactileClock action.

Power button	Double-click action
(click)(click)	Trigger the ‘built-in’ action (e.g. open camera).
(click)(pause-for-one-second)(click)	Trigger the TactileClock action (i.e. vibrate the time).

Option 3: Use Tasker to trigger time vibration with custom events

Use Tasker to trigger time vibration from hardware buttons, device shake, NFC tags, or any other event your phone supports.

To set this up, create a new task in the Tasker-app, choose an event and then add TactileClock’s vibrate-time action from the “Plugin” category.

Download and source code:

Change log

Version 2.6.2 from June 23rd, 2026

Add support for Android 17
Rebuild .apk because reproducible build failed for version 2.6.1 on f-droid

Version 2.6.1 from June 21st, 2026

Add support for Android 17

Version 2.6.0 from January 18th, 2026

Add Tasker integration
Add Ukrainian translation

Version 2.5.1 from December 29th, 2025

Add stop-clock action to the service notification
Add audio ducking during Greenwich time signal playback
Update tutorial text

Version 2.5.0 from December 16th, 2025

Duration of short and long vibrations configurable in settings
Test of time vibration added to tutorial and settings
When the screen is turned off and on, either a warning vibration or the current time can be vibrated
Greenwich Time Signal plays at the top of every hour
Tutorial text revised
Spanish translation added
Leading zeros in hour and minute field omitted