# gotify/android: Android notifications for a Gotify server

> Gotify Android is a Java app for receiving, viewing, and deleting messages from gotify/server. It is a focused companion client whose notification delivery can be affected by Android battery controls.

**gotify/android** — An app for creating push notifications for new messages posted to gotify/server.

- Repository: https://github.com/gotify/android
- Stars: 1,520 · Forks: 222
- Language: Java
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/gotify-android

## gotify/android's place in a Gotify setup

Gotify Android solves a narrow problem: turning messages received by a Gotify server into Android push notifications while also letting the device user view and delete those messages. Its intended user is someone who already runs or has access to gotify/server. It is not presented as a general Android push client for arbitrary services, and the README does not describe an independent messaging account, inbox provider, or separate delivery service.

That boundary matters. The app is a Java client for a particular server implementation. Its documented features are showing notifications for new messages, viewing messages, and deleting messages. It also maintains a foreground notification representing connection status, which gives Android users a visible indication that the client is active. The repository topics include Android, F-Droid, Google Play, push notifications, and Gotify, matching the focused integration described in the README.

The evaluation should therefore focus less on Android notification customization than on whether the server and phone can keep the client connected. Android may terminate long-running apps to conserve power, and the README explicitly warns that an app killed this way will not deliver notifications. Host configuration and device power settings are part of the application's practical reliability model.

## How the Gotify message connection works

The documented message flow starts at gotify/server. When the server receives a new message, Gotify Android connects to that server and displays a push notification. The user can then view and delete messages through the app. The README does not specify the server URL format, authentication procedure, message payload, or internal transport implementation, so those details cannot be confirmed.

The repository layout provides a limited architectural clue. The top level contains an `app/` directory, a `client/` directory, Gradle build files, and an `app.gif` demonstration asset. The build instructions identify Java 17 and the Gradle wrapper as the construction path. A separate `client/` directory and the `openApiGenerate` task indicate that client-facing API code has a generation step, although the README does not describe the generated classes or the full synchronization workflow.

Notification behavior follows the priority configured by the server. Gotify priority 0 has no visible notification. Priorities 1 through 3 produce an icon in the notification bar. Priorities 4 through 7 add sound, while priorities 8 through 10 also enable vibration. This mapping gives the server control over attention level, but it does not establish that every priority will look identical across devices. The README separately documents that Android 8 and later can minimize or reconfigure Gotify's foreground notification, so device-level settings can affect what users see.

## Installing Gotify Android and completing the first setup

Users can install Gotify Android by downloading the APK, obtaining the app through F-Droid, or installing it from Google Play. The repository does not provide an end-user installation command, so there is no documented APK filename or release path to copy into a tutorial.

After installation, the first operational check is battery optimization. The README says Android can kill long-running apps while conserving battery, and Gotify will then stop receiving notifications. On devices that expose the relevant setting, open Android Settings, search for "Battery Optimization," locate Gotify, and disable battery optimization for it. For manufacturer-specific behavior, the README also points users to `https://dontkillmyapp.com`.

The project supports a separate source-build route. Maintainers and contributors can build the APK with Java 17 and the included Gradle wrapper. From the repository root, the documented command is:

```bash
$ ./gradlew build
```

This invokes the project's Gradle build rather than requiring a separately installed build command. Its output consists of Android build artifacts, although the README does not identify their exact filenames.

Client updates also have a documented generation task:

```bash
$ ./gradlew openApiGenerate
```

The README says to commit the resulting changes. This task belongs to repository development rather than routine phone installation, and no trigger beyond updating the client is documented.

## Foreground notification controls on Android 8 and later

Gotify uses an Android foreground notification to show connection status. On Android 8 or later, users can minimize that notification to reduce its intrusiveness. The documented path is to open Settings, select Apps, choose Gotify, open Notifications, select `Gotify foreground notification`, and then enable "Minimize" or choose another "Behavior" or "Importance" option. Gotify must be restarted afterward.

This control concerns the connection-status notification rather than individual message alerts. Message notifications are governed by Gotify priority. The foreground notification represents the state of the client connection. Treating both as the same mechanism would make troubleshooting harder: a user may see no ordinary message alert because its priority is low while the client remains visible through its foreground notification.

The README does not document notification grouping, custom sounds, delivery retries, notification channel creation, or Android-version-specific behavior for ordinary message alerts. It also does not state that minimizing the foreground notification disables the connection or changes server priorities. Based on the documented procedure, restarting Gotify is the point at which the changed foreground-notification behavior is expected to take effect.

## Gotify priority levels and missing alerts

Gotify's message priorities determine which visual and audible elements appear. Priority 0 produces no notification, even though the message can still be managed in the app. Priorities 1 through 3 show an icon in the notification bar, priorities 4 through 7 add sound, and priorities 8 through 10 add vibration.

This is a deliberate operational setting, not a guarantee that every message triggers an alert. A user who expects all messages to appear prominently would need priorities that enable the corresponding notification behavior. The README presents the priority table but does not explain where the server setting is entered or how a particular message publisher selects it, so the exact server configuration procedure remains undocumented here.

Missing alerts can also result from Android process termination. The README directly links that case to battery optimization and says Gotify will not receive notifications after being killed. The priority table therefore addresses server-controlled alert presentation, while battery settings address whether the client remains active enough to receive the notification in the first place. Both need consideration when diagnosing a missing message.

## Battery management limits background notification delivery

The clearest failure mode is direct: Android kills Gotify while optimizing battery use, and the app then does not receive notifications. The README does not offer a technical workaround for preserving the connection in the background. Instead, it instructs users to disable battery optimization for Gotify and points to `https://dontkillmyapp.com` for phone-manufacturer instructions.

Battery settings therefore belong in the first deployment rather than in optional refinement. A Gotify installation can appear correctly configured while still missing alerts because the operating system has terminated the client. This is particularly relevant when a manufacturer applies additional background-app restrictions, since the README explicitly acknowledges that the required settings vary by phone manufacturer.

Gotify Android is also the wrong tool for users who want Android notifications without operating gotify/server. Its documented purpose is tied to messages posted to that server. The README does not describe support for other notification backends, arbitrary webhooks, or unrelated messaging services. Likewise, priority 0 intentionally produces no visible notification. These are configuration boundaries, but they can make the client unsuitable for someone expecting every incoming message to create a prominent alert.

## Release policy, licensing, and maintenance work

The project uses SemVer, and the README directs users to repository tags for available versions. The recorded releases are `v2.10.1` dated 2026-07-06, `v2.10.0` dated 2026-04-26, and `v2.9.0` dated 2025-09-29. The last push was on 2026-07-06, and the repository is not archived. The README does not describe a long-term support policy, Android compatibility matrix, migration policy, or automatic client upgrade mechanism.

For contributors, the API-generation task can add maintenance work when the client definition changes. The documented sequence is to run `./gradlew openApiGenerate` and commit the changes. The README does not say how developers determine that regeneration is required, so that part of the workflow is not defined.

The client is licensed under the MIT License, with details in the repository's `LICENSE` file. That license governs the client's source distribution and modification terms. The MIT identifier does not settle Android store conditions, privacy obligations, notification permissions, or the separate terms of gotify/server. The repository also contains `PRIVACY.md`, but the README does not summarize its contents.

Compared with building a custom Android notification receiver, this client provides an existing Gotify interface, message viewing and deletion, a documented priority mapping, and distribution through F-Droid and Google Play. A custom application would need to implement its own server connection, foreground-service handling, notification behavior, interface, and update process. Gotify Android reduces that work only for users who accept its documented scope and the need to review Android battery settings.

## Conclusion

Gotify Android suits people who already operate gotify/server and want its new messages on an Android device. It is unsuitable as a standalone messaging client or as a notification system expected to survive aggressive battery restrictions without configuration. Verify the server connection, notification visibility, battery-optimization setting, and foreground-notification behavior before relying on it for important messages.

## FAQ

### How do I install Gotify Android?

The README lists three installation routes: download the APK, install the app from F-Droid, or install it from Google Play. It does not provide an end-user installation command.

### Why am I not receiving Gotify notifications on Android?

The README says Android can kill Gotify while applying battery optimization, after which the app will not receive notifications. It instructs users to disable battery optimization for Gotify.

### How does Gotify Android control notification sound and vibration?

Gotify priority 0 produces no notification, priorities 1 through 3 show an icon, priorities 4 through 7 add sound, and priorities 8 through 10 add vibration. These ranges come from the README's message-priority table.

### How do I build Gotify Android from source?

The README specifies Java 17 and documents `./gradlew build` from the repository root. Client updates use `./gradlew openApiGenerate`, after which the documentation says to commit the changes.

## Sources

- [gotify/android on GitHub](https://github.com/gotify/android)
- [Issues](https://github.com/gotify/android/issues)
- [License: MIT](https://github.com/gotify/android/blob/master/LICENSE)
- [README](https://github.com/gotify/android/blob/master/README.md)
- [Releases](https://github.com/gotify/android/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gotify-android