David Vedvick

Side Projects

project blue

An alternative, open source streaming music client for JRiver Media Center.

It's features include:

  • Reliable streaming from your home server running JRiver Media Center
  • Caching of audio files during playback
  • Synchronize audio from a JRMC server to device
  • Play local files when present and metadata match
  • Updates server with now playing information
  • Interfaces with Bluetooth remote control clients
  • Interfaces with apps that implement the Scrobble Droid interface (Simple Last.fm Scrobbler is my scrobbler of choice) for scrobbling to Last.fm or Libre.fm
  • Intuitive layout
  • Android Auto support (beta)

Download on the Google Play Store

Requires JRiver Media Center running on your home server


Codefolio is a basic portfolio object builder for your projects.


  • Follow simple conventions to produce a standard Portfolio object from a Markdown Readme.
  • Or bring your own conventions, and just use Codefolio to produce standard Portfolio objects.

For example, given this markdown in a README.md file:

# Hi I'm a level one heading


Here's the body!

When passed into Codefolio:

const codefolio = require('codefolio');

const portfolios = await codefolio.promisePortfolios(['README.md']);

Produces a Portfolio object like this:

  body: "# Hi I'm a level one heading\n\nHere's the body!",
  image: {
    url: "./img.png",
    alt: "img",
    title: "img"
  examples: []


npm install --save-dev codefolio

Handoff, an A+ like Promise Implementation for Java

Handoff is a simple, A+ like Promises implementation for Java. It allows easy control flow to be written for asynchronous processes in Java:

public Promise<PlaybackFile> promiseFirstFile() {
    return new Promise<>(messenger -> {
        final IPositionedFileQueueProvider queueProvider = positionedFileQueueProviders.get(nowPlaying.isRepeating);
        try {
            final PreparedPlayableFileQueue preparedPlaybackQueue = preparedPlaybackQueueResourceManagement.initializePreparedPlaybackQueue(queueProvider.provideQueue(playlist, playlistPosition));
            startPlayback(preparedPlaybackQueue, filePosition)
                .firstElement() // Easily move from one asynchronous library (RxJava) to Handoff
                    playbackFile -> messenger.sendResolution(playbackFile.asPositionedFile()), // Resolve
                    messenger::sendRejection); // Reject
        } catch (Exception e) {

And the promise can then be chained as expected. The method then is used to continue execution immediately using the promised result:

    .then(f -> { // Perform another action immediately with the result - this continues on the same thread the result was returned on
        // perform action
        return f; // return a new type if wanted, return null to represent Void

For instances where another promise is needed, the method eventually should be used, and excuse should be used for catching errors, which will fall through if not caught earlier in the method chain.

    .eventually(f -> { // Handoff the result to a method that is expected to produce a new promise
        return new Promise<>(m -> {

    .excuse(e -> { // Do something with an error, errors fall through from the top, like with try/catch
        return e;

Picture Categorizer

Picture Categorizer is public image gallery software. An instance of Picture Categorizer runs at Catpics!, devoted entirely to those animals we most love, cats! To best serve our cat overlords, Picture Categorizer has gone through several different iterations:

  1. Originally developed in Kotlin + Spring Boot as a fun software engineering project for my master's.
  2. Next, the server back-end was migrated to Ktor to improve resource usage as Spring Boot has pretty heavy resource requirements.
  3. Then the server back-end was migrated to ExpressJS/Typescript to further improve resource usage (this surprised me as well).
  4. Finally, to further reduce resource requirements and improve the portability of the application, the database was migrated to SQLite from MySQL.

Given all of these migrations, there may be some artifacts from previous iterations that don't quite make sense in its current form. If you see them, submit a PR to clean them up!


A simple library that helps with serializing Android SQLite queries to and from Java objects:

public Collection<Library> getLibraries(Context context) {
  try (RepositoryAccessHelper repositoryAccessHelper = new RepositoryAccessHelper(context)) {
      return repositoryAccessHelper
          .mapSql("SELECT * FROM library")

What problems does it solve?

The standard Android library has for ages had numerous ways to pull back data from its built-in SQLite database. However, none of these ways either a) are easy to use, or b) give developers the power they need to develop performant, flexible applications.

In the C# world, developers have long had the excellent Dapper library, which maps C# types nicely to and from C# objects without getting in the way of how you want to write your queries. QueryDroid started off with Dapper as an inspiration and made querying your data in the built-in SQLite library much more natural and cleaner!