bailu.ch

An activity tracker is software or hardware that records movement data for activities such as hiking, running, or cycling. A GPS-based tracker app does this by logging your position over time and saving the result as a track file. AAT Another Activity Tracker is a concrete example: an open-source Android app that records activities, stores tracks in standard GPX format, and doubles as a map viewer with offline map support. This explanation covers what these apps do, how the recording and storage work, and what to check before choosing one.

What an activity tracker actually does

The core job is simple: capture where you went and when, then keep that record in a usable form. For a GPS tracker app, that means:

• Sampling your position at intervals while you move.
• Turning those points into a continuous track (a route line).
• Saving the track so you can review, share, or reuse it later.

Some trackers add sensors (heart rate, steps, cadence), but GPS route recording is the baseline function. AAT focuses on that baseline plus map viewing, rather than on fitness metrics.

How GPS tracking and GPX storage work

A GPS receiver in your phone reports latitude, longitude, and usually altitude. The app records these as a sequence of points with timestamps.

The key design choice is the file format. AAT stores tracks in standard GPX format. GPX (GPS Exchange Format) is a widely supported, text-based format for routes, tracks, and waypoints. Practically, this matters because:

• A GPX file can be opened by many other mapping and fitness tools, not just the app that created it.
• You are not locked into one vendor's ecosystem to read your own data.
• Tracks can be edited or planned and then loaded back in.

AAT also includes a simple GPX editor for quick route planning, so you can sketch a route rather than only record one.

Common features in a GPS tracker app

Using AAT's feature set as the reference, a GPS activity tracker typically offers:

The offline map capability is the feature most likely to decide whether an app suits you. If you hike or ride outside network coverage, offline maps and offline POIs are the difference between a usable and an unusable tool.

General tracker vs. a dedicated open-source GPS app

These are not the same category:

• General activity trackers often bundle step counting, sleep, heart rate, and social features, and may push data to a vendor account.
• A dedicated GPS tracker app like AAT concentrates on recording tracks, viewing maps, and keeping data in an open format. AAT is open-source and licensed under GPL, which means the source is available to inspect, modify, and redistribute under that license.

If your priority is fitness metrics and a polished consumer dashboard, a general tracker fits better. If your priority is owning your route data in GPX and working with offline maps, a dedicated open-source tracker fits better.

Practical considerations before you install one

• Map coverage and offline use. Confirm the app supports offline maps for the regions you actually travel in.
• GPX compatibility. Check that tracks export as GPX so you can move them between tools.
• Altitude accuracy. GPS altitude is often less reliable than horizontal position; features like GPS-independent altitude and hill shading help compensate.
• Distribution and trust. AAT is available as source on GitHub and as a binary on F-Droid. F-Droid is an app repository that distributes free and open-source Android software, which is a relevant signal if you prefer not to use closed app stores.
• Platform. AAT runs on Android, so it is not an option on other mobile platforms.

Where to get it

AAT Another Activity Tracker is distributed two ways: source code from GitHub, and a binary build from F-Droid. If you want to verify or modify the app, use the source; if you just want to install it on an Android device, the F-Droid binary is the straightforward path.

An open-source data management system (DMS) is software whose source code is publicly available and that provides the core functions of publishing, sharing, and using data. CKAN is a leading example: it is an open-source DMS built to power data hubs and data portals, and it is used by hundreds of portals worldwide. It fits best when you need a catalog-style portal to publish datasets for others to find and reuse — typically government open data or enterprise internal data assets — rather than a general-purpose database or analytics platform.

What "open-source DMS" actually means

A DMS in this sense is not just storage. It is the layer that organizes data into a catalog, describes it with metadata, and gives people a way to discover and access it. The open-source part matters because it changes how you can adopt and extend the system.

Core capabilities of a DMS like CKAN, per the project's own description:

• Publish — make datasets available through a portal
• Share — expose data to external or internal audiences
• Use — let people find, understand, and reuse what is published

CKAN is written in Python and its repository shows roughly 5.1k stars and 2.1k forks, which indicates an active developer community around the codebase.

How CKAN fits as an open-source DMS

CKAN positions itself as "the world's leading open source data management system" and describes its purpose directly: it powers data hubs and data portals and makes it easy to publish, share, and use data. Two things follow from that framing:

1. It is portal-oriented. The unit of work is the dataset and its metadata, presented through a browsable catalog — not raw tables or dashboards.
2. It is a platform, not a single site. The same software is deployed across many separate portals, each with its own data and branding.

CKAN has also been added to the Digital Public Goods Registry, recognized as a data management system contributing to 9 of the 17 UN Sustainable Development Goals. That recognition is a signal of institutional trust, not a technical specification, so treat it as context rather than a feature.

Typical use cases

The project splits its audience into two broad groups, and the distinction is useful when deciding whether CKAN matches your situation.

Government open data portals

CKAN is used by national and regional government organizations across the European Union, the Americas, Asia, and Oceania to power official and community data portals. Named adopters include:

If your goal resembles these — a public catalog of many datasets from many sources — CKAN's design and its existing deployments are strong evidence of fit.

Enterprise internal data assets

CKAN has also been adopted by enterprise organizations in sectors such as resources, energy, pharmaceuticals, and finance to publish and manage internal data assets. Here the same catalog model is applied behind a firewall, for internal discovery rather than public release.

Open-source DMS vs. proprietary alternatives

The trade-off is not simply cost. It is about who controls the system and how much you can shape it.

• Control and extensibility — with open source you can inspect, modify, and self-host the software. With proprietary tools you generally accept the vendor's roadmap and hosting model.
• Cost structure — open-source licensing does not by itself mean zero cost; you still fund hosting, integration, and operations. The CKAN site does not publish pricing, so do not assume any deployment is free.
• Community vs. vendor support — CKAN offers both community support and commercial support, and its site provides a contact route ("Speak with us") plus named stewards who help organizations implement portals. Proprietary vendors typically bundle support into the license.
• Ecosystem evidence — a public showcase of government and enterprise portals lets you evaluate real deployments before committing.

Choose open source when you need control, self-hosting, or deep customization. Choose proprietary when you want a single accountable vendor and minimal operational burden, and are willing to accept less flexibility.

How to evaluate whether CKAN fits your project

Work through these before deciding:

1. Confirm the shape of your need. Are you publishing a catalog of datasets for others to discover? If yes, CKAN's model matches. If you mainly need analytics, streaming, or transactional storage, look elsewhere.
2. Check features against your requirements. Review the Features and Docs sections on ckan.org for the specific capabilities you need.
3. Look at comparable deployments. Browse the Showcase for portals similar in scale and sector to yours.
4. Decide on hosting and operations. Determine whether you will self-host or use commercial support, and budget for that.
5. Assess community activity. Check the GitHub repository and community channels for current activity, since an active project is easier to depend on.
6. Talk to the maintainers' stewards. The site's contact form is described as the best way to reach them if you want guidance on implementation.

Common sticking points

• Assuming "open-source" means "free to run." The software may be freely licensed, but hosting, integration, and support are real costs. The site does not state pricing, so verify directly.
• Treating CKAN as a database. It is a management and portal layer over data, not a replacement for your storage or processing systems.
• Skipping the fit check. The government and enterprise examples are useful precisely because they show the intended scale and use pattern — a single small internal dataset may not justify a full portal.

If your project is a data hub or portal where publishing, sharing, and discovery are the point, CKAN is a well-evidenced open-source option. If your needs center on analysis or transactions, it is the wrong tool, and the evaluation steps above will make that clear quickly.

The GPL (GNU General Public License) is a software license that grants anyone the freedom to run, study, modify, and redistribute the licensed program, provided that derivative works are released under the same license. For a user of AAT Another Activity Tracker, this means the app's source code is publicly available and can be inspected, changed, and shared. For a developer, it means any modified version you distribute must also carry the GPL. The license does not require you to publish your own private changes — only distributed versions trigger that obligation.

The Four Freedoms the GPL Guarantees

The GPL is built around four freedoms, defined by the Free Software Foundation:

1. Run the program for any purpose.
2. Study how it works and change it (access to source code is a precondition).
3. Redistribute copies to others.
4. Improve the program and release your improvements to the public.

AAT Another Activity Tracker fits this model directly. Its source is published on GitHub, and a binary build is distributed through F-Droid. That combination — public source plus a redistributable binary — is exactly what the GPL is designed to enable.

Copyleft: The Key Difference From Permissive Licenses

The GPL is a copyleft license. Permissive licenses such as MIT or Apache-2.0 let you take the code, modify it, and ship it under a different (even proprietary) license. The GPL does not.

So if someone forks AAT, adds a feature, and distributes the result, they must make that modified source available under the GPL. They cannot turn it into a closed-source paid app.

How This Plays Out for an Android App on GitHub and F-Droid

For AAT specifically, the practical consequences are:

• You can install it freely. F-Droid hosts the binary; GitHub hosts the source. No license fee is implied by the GPL itself.
• You can build it yourself. Because the source is on GitHub, you can compile your own APK from the same code.
• You can fork and modify it. Want to change the cockpit view or the GPX editor? The GPL permits it.
• If you distribute your fork, you must share the source. Publishing a modified APK to a store or sharing it with others triggers the copyleft requirement.
• F-Droid's model aligns with the GPL. F-Droid builds from source and distributes binaries, which is consistent with the license's redistribution terms.

Common Misconceptions

• "The GPL forces me to publish my changes." Only if you distribute the modified software. Private modifications for personal use carry no publication obligation.
• "GPL software can't be sold." It can. The GPL permits selling copies; what it prevents is distributing modified versions without source.
• "GPL and open source are the same thing." The GPL is one open-source license among many. Open source is the broader category; copyleft is the specific mechanism the GPL uses.
• "Using a GPL app makes my own project GPL." Merely using AAT does not affect your other software. The copyleft obligation attaches to derivative works of the licensed code, not to unrelated programs.

What to Check Before Reusing GPL Code

If you plan to build on AAT or any GPL project:

1. Confirm the exact version (GPLv2 vs. GPLv3) — the terms differ, especially around patents and anti-tivoization.
2. Check whether the project is "GPLv2 only" or "GPLv2 or later."
3. Verify that all dependencies are license-compatible.
4. Decide upfront whether you intend to distribute; that determines your obligations.

For an end user, the takeaway is simpler: the GPL is what makes AAT's source inspectable and its builds reproducible, and it keeps any public fork open to the same scrutiny.

Mapsforge is an open-source map-rendering library for Android that draws vector maps from OpenStreetMap data stored on the device, so an app can display maps without a network connection. It is the component behind the offline map view in apps such as AAT Another Activity Tracker, which lists "Global coverage of offline as well as tile based maps" among its features. If you are building or choosing an Android app that must show maps in areas with no signal, Mapsforge is the relevant mechanism to understand.

What Mapsforge actually does

Mapsforge takes two inputs:

• A map file — a pre-processed, compact file containing vector geometry (roads, buildings, land use, labels) derived from OpenStreetMap data.
• A render theme — an XML file that defines what gets drawn at each zoom level and with which colors and line widths.

It then renders the visible area on screen as vectors, not as pre-made images. Because the geometry is stored as coordinates and shapes, the app can redraw at any zoom level and rotate or scale the view without the map turning blurry.

Vector offline maps vs. tile-based maps

AAT's feature list mentions both "offline as well as tile based maps," which reflects two different approaches:

Neither is universally better. Tile-based maps are simpler to serve and cache; vector maps give more flexibility and usually better storage efficiency for large offline regions.

How the data gets onto the device

Mapsforge does not download map data itself. The workflow is:

1. Generate the map file on a desktop machine from OpenStreetMap extracts, using the Mapsforge tooling, for the region you need.
2. Transfer the file to the device (or let the app download a prepared file, if it supports that).
3. Load it in the app, which reads the file and renders the visible area using the selected theme.

The practical consequence: offline coverage is limited to the regions you generated or downloaded. "Global coverage" in AAT's description means the app can work with maps worldwide, not that every map is preinstalled.

Features this architecture enables

Because the map is vector data rendered on the fly, the app can support:

• Zoom across a wide range without losing detail.
• Hill shading — terrain relief drawn from elevation data, which AAT lists alongside "GPS independent altitude information."
• POI overlays — points of interest stored offline and drawn on top of the map, matching AAT's "Offline POI support."
• Track display — a recorded GPX track drawn over the map, which is the core of an activity tracker.

Why GPS tracking apps choose it

An activity tracker records position continuously, often in places with poor or no connectivity — trails, rural roads, foreign countries without a data plan. A vector renderer that reads from local storage keeps the map usable in exactly those conditions, and it does so without a per-request network cost. That combination — offline operation, adjustable styling, and reasonable file sizes — is why Mapsforge appears in open-source Android tracking apps like AAT.

What to check before relying on it

• Map file availability: confirm a prepared file exists for your region, or that you can generate one.
• Storage: offline regions take up space; larger areas mean larger files.
• Theme quality: rendering depends on the theme, so the same data can look very different between apps.
• Update cadence: offline files are snapshots; roads change, and you need to refresh the file to see new data.

If your goal is simply to record and view tracks offline, an app that already bundles Mapsforge support — AAT is distributed as source on GitHub and as a binary on F-Droid — saves you from assembling the rendering stack yourself.

Android is a mobile operating system, developed by Google, that runs on phones, tablets, and other devices — and it is one of the two primary target platforms for any mobile app, alongside iOS. If you are deciding how to build an app, Android matters because it determines your development language, your toolchain, and how you ship to users. You can build for Android natively (typically with Kotlin) or through a cross-platform framework like Flutter, which produces a single codebase for both Android and iOS. The right choice depends on your performance needs, budget, timeline, and how much platform-specific functionality you require.

Android's role in the mobile landscape

Android is an operating system, not a programming language or a framework. That distinction matters because people often conflate the platform with the tools used to build for it.

• The platform: Android is the OS layer that manages hardware, permissions, app lifecycle, and the user interface on a device.
• The apps: Applications are separate software packages installed onto that OS.
• The languages: Android apps are commonly written in Kotlin (Google's preferred language) or Java, though other languages and frameworks can target the platform.

Because Android and iOS together cover essentially the entire smartphone market, most businesses treat them as the two default platforms to support. The question is rarely whether to be on Android, but how to build for it.

How Android apps get built: native vs. cross-platform

There are two broad routes, and they trade off differently.

Native Android development

Native means writing code specifically for the platform — for Android, that is typically Kotlin (with Java still in use on older codebases). Locomotive Mobile describes its native offering as "Native solutions for iOS (Swift) and Android (Kotlin) with maximum performance," listing maximum performance and advanced features as the benefits.

Choose native when you need:

• The highest possible performance and the tightest hardware integration
• Platform-specific features and APIs that cross-platform frameworks may not fully expose
• Long-term maintenance by teams specialized in one platform

The cost is that you maintain separate codebases for Android and iOS, which generally means more development effort and a longer path to launching on both.

Cross-platform development with Flutter

Flutter lets you build one codebase that runs on both Android and iOS. Locomotive Mobile positions it as "Cross-platform apps with native performance and a single codebase," with the stated advantages of optimized performance, simplified maintenance, and reduced time to market.

Choose cross-platform when you need:

• To reach both Android and iOS users without duplicating effort
• Faster time to market and lower maintenance overhead
• A consistent experience across platforms

The trade-off is that you may hit limits when you need deep, platform-specific behavior, and performance — while strong — is not always identical to fully native code.

How Android differs from iOS in practice

If you are planning a project, these are the practical differences that affect your decisions:

• Language and toolchain: Android development centers on Kotlin (or Java); iOS centers on Swift. Locomotive Mobile frames its native work as "Swift for iOS" and "Kotlin for Android."
• Development effort: Building natively for both platforms means two separate efforts. A cross-platform approach like Flutter collapses that into one.
• Release process: Each platform has its own store and review process, so shipping to both means managing two distribution channels.

The takeaway: Android and iOS are distinct targets with distinct native languages, which is exactly why cross-platform frameworks exist — to avoid maintaining two separate codebases when you don't need to.

How to decide for your project

Work through these questions:

1. Do you need both Android and iOS? If yes, cross-platform (Flutter) usually reduces time and cost. If you only need one platform, native may be simpler.
2. Do you need maximum performance or deep platform-specific features? If yes, lean native. If your app is standard — content, community, forms, commerce — cross-platform is typically sufficient.
3. What is your timeline and budget? A single codebase generally means less work and faster launch, which matters if you are validating an idea.
4. What is your long-term maintenance capacity? Two native codebases require more ongoing effort than one shared codebase.

A reasonable default for many teams building a new app for both platforms is to start with Flutter and move to native only where a specific requirement demands it. For apps where performance or platform integration is the core value, native Android (Kotlin) is the stronger foundation.

If you are unsure, a technical consulting step — analyzing requirements, architecture, and performance needs — is the standard way to settle the native-versus-cross-platform question before committing to a build.