Skip to content


Repository files navigation

Internal App Store

Manage your own internal Android App Store.
Web appAndroid app
🤖 Android CI

App Store

Table of contents


A public version of the web app is hosted on
The latest Android apk can also be downloaded here.


  • Public or private access to the store

    • User roles (anonymous or verified users)
    • Account restrictions (only admins have write access)

    📷 Screenshots
    Web Android
  • Manage multiple applications

    • Notifications for new applications
    • Description with html support
    • Shortcuts for frequent actions

    📷 Screenshots
    Web Android
  • Manage multiple versions

    • Notifications for new versions
    • Upload apks or external links
    • Changelog with html support
    • Apk files are cached

    📷 Screenshots
    Web Android




  • Replace applicationId with your own unique id in app/build.gradle
  • Create a Firebase project
  • Select Add Firebase to your Android app and fill in the form
  • Download the config file google-services.json and move it to your Android app module root directory
  • In the Firebase Authentication page, enable sign-in methods, then create your first admin user
  • In the Firebase project settings, select ADD APP and Add Firebase to your web app
  • When using Firebase Hosting and the CLI, Web SDK auto-configuration is enabled by default
  • Verify the configuration of each module
    • Android: Store.kt

    • Web: index.js

    • Firebase Database: use your own domain

      Database schema
      │   └──{$uid}
      │   ├──applications
      │   │   └──{$application_id}
      │   │       ├──name
      │   │       ├──packageName
      │   │       ├──description
      │   │       ├──image
      │   │       ├──link_{#}
      │   │       │   ├──name
      │   │       │   └──uri
      │   │       └──silent
      │   └──versions
      │       └──{$application_id}
      │           └──{$version_id}
      │               ├──name
      │               ├──description
      │               ├──timestamp
      │               ├──apkRef
      │               ├──apkGeneration
      │               ├──apkUrl
      │               ├──silent
      │               ├──downloads
      │               └──installs
          │   └──{$application_id}
          │       └──{$version_id}
          │           └──{$uid}
    • Firebase Storage: use your own domain

      Storage schema


  • Initialize Firebase module
    # Move to Firebase root directory
    cd firebase
    # Initialize Firebase (login popup)
    firebase login
    # Set the default Firebase project
    firebase use --add
  • Add your first admin user (uid found in Firebase Authentication page)
    • Firebase Database, add admin uid
      firebase database:update /admins --data '{"<admin-uid>" : "<admin-email>"}'
      # On Windows, create a JSON file instead (unsupported JSON input)
      firebase database:update /admins update.json
    • Firebase Storage, add admin uid


  • Test web app on your machine http://localhost:5000
    firebase serve
  • Deploy all Firebase modules (database, storage, hosting, functions)
    firebase deploy
  • Sync, build and install Android module from Android Studio


A lot of settings can be tweaked in both web and Android apps

  • Store icons and titles
  • Firebase auth providers
  • Maximum apk size
  • Admin write access
  • Store visibility (private or public)


  • Firebase Database (Link 1, Link 2)
    // Backup
    firebase database:get / --pretty > database.json
    // Restore
    firebase database:set / database.json
  • Firebase Storage (Link)
    // Backup
    gsutil -m cp -R gs://<bucket_name> .
    // Restore
    gsutil -m cp -R . gs://<bucket_name>


Copyright 2018 Simon Marquis

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
See the License for the specific language governing permissions and
limitations under the License.