Note: This site is currently "Under construction". I'm migrating to a new version of my site building software. Lots of things are in a state of disrepair as a result (for example, footnote links aren't working). It's all part of the process of building in public. Most things should still be readable though.

Considering Avatar Images For Syncing App Metadata

What if we use our profile images to store metadata for open-source apps?

Starting Out

I'm

With that goal in mind, I've been thinking about how to sync the app across devices. A standard route is to set up a database with a user account for each person that holds the sync data.

That's a lot of work. None of which I'm interested in. So, I've been thinking about alternatives. Specifically, alternatives that don't involve me administering a database or passwords.

My mind went to profile images.

QR Codes And Steganography

Nothing in the Spotify API is set up to store external metadata directly. But, you can upload avatar images and data can be stored in those images.

QR codes are a real world use of storing data in images. Humans can't read them. The software in our phones can. Using Spotify (or other services') avatars would work in a similar way. Encode data into an image and make that image the user's profile pic. Apps pull the image and/or updated it whenever they need to read or update their data. QR codes would be relatively straight-forward to implement. Of course, that would mean you don't get a friendly profile image.

Enter steganography: "the practice of representing information within another message or physical object, in such a manner that the presence of the information is not evident to human inspection"

Basically, an app can encode metadata and hide it inside your actual profile pic. It gets what it needs and folks still see your avatar.

RSS Reader Sync

Syncing data for my app isn't critical. Frankly, it may make little difference. RSS readers, on the other hand, could see a huge benefit.

One of the killer features of paid RSS feed readers is the ability to sync across devices. Finding a way to enable that sync in a free, open-source manner would be awesome. And, with all the various services we use that include profile images, it's very doable.

Notes

  • I'm talking about user profile images here, but it's really the playlist cover photos that you can access with the Spotify API. That's a footnote detail because all the really matters is if you can send and receive images. Even better, you can have 10,000 playlist with up to 256KB of jpg data each

  • I doubt this is a new thought, but it's new to me so I wrote it up. Finding prior art would be no surprise. If you've got posts where folks have already put more thought into this than I have, please send them my way

  • Mastodon is another likely place to use avatar images for data storage

  • Of course, you could also just create a mastodon account and store data directly in posts. Making sure the server admin is cool with that first, of course

  • I wouldn't be surprised if Mastodon instances designed specifically for metadata storage don't pop up (assuming they don't exist already)

  • The thing I like about the API approach is that if the app is using the service itself (e.g. Spotify) you don't have to log in anywhere else to use the profile images

  • Thinking one step further, there should probably be some standardization on the way metadata is stored so multiple apps could use the same source for a profile image. I thinking a JSON object where there's an "apps" key under which each app would have its own key. Something like:

    `{ "apps": { "tuneify": { "foo": "bar" } } }``

    Each app would be solely responsible for anything under its key and would also be responsible for not touching anything else. (Other than a possible `metadata`` key that would be a sibling of `apps`` to be defined at a later date)

  • Compression may present problems. If services add any to an image it can break the ability to translate the data. In practice, this can be dealt with by reducing the amount of data that's stored. Or, worse case, going all the way back to something like a QR Code

  • I expect there are or will be some policies made against this approach. But, with all the services out there (and things like mastodon), it feels like that shouldn't be an issue

  • I've also thought about using playlists themselves as a metadata storage mechanism, but that's for another post

References