Rework the music picker system to be a reactive, viewmodel-based system
instead of a janky UI system.
This should make it much easier to maintain and extend in the future.
Try to move multi-artist playback/navigation into a single function.
This function is really bad and is tacked onto the most convienent
location without much thought. I really wish to move this into the
ViewModel flow eventually, but I have no idea how to architecture
that. Oh well.
Add semi-complete support for multiple artists.
This changeset completely reworks the music linker to add the following
new behaviors:
1. Artists are now derived from both artist and album artist tags,
with them being linked to songs and albums respectively
2. Albums and songs can now have multiple artists that can be distinct
from eachother
3. Previous Genre picking infrastructure has been removed and replaced
with artist picking infrastructure. "Play from genre" has been retired
entirely.
This is a clean break to the previous artist model and may not work
with all libraries. Steps to migrate the music library will be added
to the changelog.
Resolves#195.
Combine validation into a new finalization routine that now
individually validates and in the future may finalize certain
fields that require linking to be properly created.
Keep changes when unshuffling and reshuffling the queue.
This quirk was a hold-over from the old queue system, and now it's
removed.
Note that sorting is still based on parent, and so sort orders might
remain somewhat wonky. I only see myself really tackling that come
gapless playback, as I have to remove that last vestige to get that
system working.
Add a dialog for picking a genre from several choices.
This basically completes multi-genre support in Auxio, save more
internal reworks.
Note that it is extremely likely that the "Play from genre" setting
will be removed soon. This feature has made me realize that such does
not many any real sense, as genres are more semantically similar to
playlists than artists or albums. This implementation only exists to
make multi-artist support an easy plug-and-play operation.
Resolves#201
Make UID structure dependent on the music mode.
This involves replacing the "tag" value with more structured fields and
appending the int code of the music mode to the UUID rather than making
it part of the UID's "tag". UIDs aren't quite a UUID, so this is
allowed.
Merge DisplayMode and PlaybackMode into a new class called MusicMode.
Both of these datatypes represented similar things, and thus it's much
easier to make them the same datatype. Moreover, it makes the
forthcoming addition of the music selector much easier if the same
datatype was tied to the representation of music.
This commit also moves around things around the project to be slightly
more coherent.
Use CollationKey when sorting music instead of String isntances.
This makes sorting aware of accented characters while still preserving
speed. I would ideally want to extend this to the search view too, but
there is no contains command in CollationKey, so I must continue with
the normalization method there.
Phase out the dumb hack TaskGuard class in favor of yield.
For some reason, I was under the impression that yield was horribly
slow. It's not, I was just using it wrong. So now TaskGuard is no
longer needed.
Completely rework the ID system to pave the way to MusicBrainz ID
support and greatly increase ID integrity in general.
This changeset removes the old ID field, an emulation of a polynomial
hash that was used in all items, and replaces it with a new type called
UID that is specific to Music. Other types just use plain equals now,
and most instances of "id" to check for equality in the app have either
been inlined into an equals override or removed outright.
The new UID format is as follows:
datatype/format:uuid
Datatype is a tag that is just the lowercase tag name. For example,
"song". Format is the program that created the UID. auxio will be an
md5 hash, and musicbrainz will the a musicbrainz ID extracted from a
file. UUID is the uuid itself.
This is much more reliable and extendable than the old ID format. This
will also be the last time I break compat with old ID formats. From now
on, a legacy UID field will not be included to enable backwards compat,
when the time comes for a breaking change.
Make adapter instances handle span sizes.
This supercedes the hackier solution where the fragments would have to
reference adapter data in order to determine span size. Not anymore.
Make the playing indicator animate when playback is ongoing.
Previously state issues stopped me from doing this, but apparently this
time I miraculously got it working. Yay.
Resolves#218.
Update transitions in the home fragment to X-axis.
I noticed a visual issue in the detail transition in the existing
version stemming from how the main fragment's drawing is clipped by
the bottom sheet, resulting in a less-than-ideal Z-axis transition.
While I wanted to fix this by attempting to switch to inset based
bottom sheet management, I still need to wait for more changes in
order to successfully pull that off, and hence I'll be reverting it
soon.
Moving these transitions to X-axis prevents this visual issue while
still being roughly semantically similar.
Use MaterialFadeThrough in the search transition and a Z-axis
transition in the detail views.
This is more semantically correct than the previous transitions.
Remove useless id fields from Headers, replacing them with vlaues
related to their string resource.
String resources and disc numbers are more or less garunteed to be
unique in Auxio's context.
Rework the queue internally to decouple the queue from playback and
better respond to reshuffling.
This is being implemented under the assumption that I will be
implementing the sliding queue eventually.
Make the search algorithm take in account the raw sort name and file
name when searching.
This allows the user to search for a particular song without typing in
a unicode/non-ideal title, instead typing in a latinized sort name or
suitable file name.
This does make Auxio's search a bit more fuzzy, but it still gets the
job done.
Resolves#184.
Related to #172.
Rework Sort again into a new class that leverages a better Mode design
and static comparator instances.
This somewhat improves efficiency, but is also far easier to work with
and has far less footguns with adding new sorts.
Add new shortcut utilities for collecting StateFlows in a safe manner.
The priamry addition here is collectImmediately. collectImmediately
just calls block with the existing value initially, which helps remove
a good amount of bugs regarding state initialization. Sure, it is a bit
inefficient given that it will also initialize on startup, but this is
okay.
The other utilities are the same, but simply remove the launch
boilerplate.
Add a new "Detail playback mode" option that allows one to configure
what selecting a song will do in an album/artist/genre.
This is mostly a clone of the prior setting, just in a new context.
Resolves#164.
Add a utility to easily work with lifecycle-dependent fragment objects.
This reduces the code duplication required to maintain objects that
would leak after the destruction of a fragment. We normally would not
do this as a delegate, as that usually entails some lifecycle wizardry
that can easily break and crash the app in esoteric situations.
However, this this just extends the normal lifecycle without watching
any state, it seems to be pretty safe to use.
Revamp the shared object SettingsManager into a standalone utility
called Settings.
This makes many things easier in Auxio. It completely unifies the key
format that we use (Android Strings instead of Java consts), eliminates
the pretty dumb initialization method that we use, and eliminates the
dubiousness of holding a Context-related utility in a global field.
The only cost was having to migrate even more ViewModels to Android
ViewModels. Whatever.
Introduce MenuFragment in order to replace ActionMenu.
ActionMenu was a terrible class filled with hacks. Introduce a new
fragment called MenuFragment that enables the same features, plus:
1. Requiring consumers the specify the menu, which prevents issues
from one-size-fits-all menus (unless absolutely necessary)
2. Fixing an issue where multiple menus appear at once
Make some ViewModel instances AndroidViewModels in order to make some
code less insane.
I don't like doing this, as I want to keep ViewModel instances clean of
android things, but this just makes a lot of functionality easier to
implement.
Make the home toolbar collapse on scroll.
I was planning to implement this back in 2.0.0, but visual bugs stopped
me. Now, knowing how much space the the Toolbar + Tab combination takes
up on smaller devices, I think it would be better to have this in
general.
Rework loading management into a new object, Indexer, which should act
as the base for all future loading changes.
Indexer tries to solve a two issues with music loading:
1. The issue of what occurs when tasks must be restarted or cancelled,
which is common with music loading.
2. Trying to find a good strategy to mediate between service and
ViewModel components in a sensible manner.
Indexer also rolls in a lot of the universal music loading code
alongside this, as much of MusicStore's loading state went unused
by app components and only raised technical challenges when reworking
it.
Add an indicator to gague the current music loading progress.
This is actually a lot harder to implement than it might seem, not only
due to UI state issues, but also due to the fact that MusicStore needs
to keep it's state sane across a myriad of possible events that could
occur while loading music. This system seems like a good stopgap until
a full service-backed implementation can be created.
Apply the notifyItemChanged fix everywhere by making it an explicit
part of the RecyclerView framework.
This way, implementing future selection and rewrite behavior will be
much easier, as the payload argument is available in every adapter
implementation.
Switch from LiveData to StateFlow.
While LiveData is a pretty good data storage/observer mechanism, it has
a few flaws:
- Values are always nullable in LiveData, even if you make them
non-null.
- LiveData can only be mutated on Dispatchers.Main, which frustrates
possible additions like a more fine-grained music status system.
- LiveData's perks are exclusive to ViewModels, which made coupling
with shared objects somewhat cumbersome.
StateFlow solves all of these by being a native coroutine solution with
proper android bindings. Use it instead.
Add sorting modes for duration and song count.
This was requested previously in the now-closed UI/UX changes
megathread, however I have only gotten to it now.
Do some miscellanious formatting reworks.
1. Remove all instances of m in favor of _. _ is only used when names
collide or if something should be internal.
2. Make fragments apply their own click listeners.
3. Remove instances of inc/dec and replace them with the more
straightfoward + 1 or - 1.
Rework the asynchronous aspects of MusicStore to rely on a more
conventional callback system.
In preparation for automatic rescanning, it would be more elegant
for music consumers to use a callback, so that updates can be
registered easier than if a co-routine continued to be used.
Convert MusicStore to this new model and rework the accesses of
MusicStore in-app to line up with this new system.
