Spin off the data instances into their own class called BackingData.
This is to isolate the sane adapters that rely on one type of diffing
from the insane adapters that use synchronous and asynchronous diffing
simultaniously. It also allows some of the more esoteric adapters to
implement their own backing data without much trouble or leaky
abstractions.
Completely rework the base adapter class to require less boilerplate
and properly handle cases such as diffing. The major adapters have
been migrated to this system, but the other adapters have not been
changed so far.
This is only part 1 of a multi-part rework, as this is an incredibly
complex system.
Remove databinding entirely.
Databinding was a terrible idea for Auxio. I rarely leveraged it, and
when I did, it produced messy code and bloated build times. Dumpster it
for just viewbinding, which is good. This reduces building times by
nearly 2/3, and generally makes the codebase more coherent and usable.
Move all fragment instances to the new ViewBindingFragment paradigm,
which should help immensely with reducing memory leaks from list
bindings and to really alleviate the overloaded onCreate functions.
Rework the playback views to follow the new idioms I want to use for
Auxio.
This change mostly consists of flattening away some of the custom
views, removing databinding, and using a general viewbinding
fragment that I hope to extend to the entire app.
Migrate to a centralized constant table for easier management.
Previously, Auxio would tie constants to the class itself, which
led to a largely disjointed system that relied on an internal table
so that it would stay sane. This commit moves all of those constants
to a single table for easier usage and management.
Completely refactor the Sort class to be more efficient and
straightforward.
The original Sort class had *major* shortcomings, it was slow,
poorly organized, and relied on abusing compareBy to implement
special things like article sort. This rework eliminates all of
that in favor of a new system relying on custom comparators and
chaining to achieve something much faster and maintainable.
Make resolvedName the standard name to use across all music items.
Previously, the way Auxio differentiated between names in UIs was to
use name for normal items and resolvedName for parents. This was odd
and disjointed, as it muddled the meanings of the two fields and lead
to a lot of bugs. Fix this by making resolvedName *the* standard name
to use across all music items, even in ones that don't have to resolve
their name.
Switch to the spotless linter with ktfmt used as a backend instead of
ktlint.
This switch was done for two reasons:
1. ktfmt is more thorough than ktlint
2. License headers can be added more effectively with spotless than
the default Android Studio behavior.
Dump all of the changes now so I don't have to deal with it over a long
period of time. I don't care.
Turn the headset focus setting into the headset autoplay setting.
The way auxio handles headsets is...odd. Sometimes the MediaSession
handles it and Auxio could not care less, and sometimes Auxio actually
needs to handle it. As a result, the idea of being able to disable
headset focus is more or less moot because it will only apply to some
devices and not others.
On the other end, the way Auxio automatically begins playback once a
headset is plugged in is also quite weird. It only works on wired
headsets, and when it does, it overrides all other apps that might
also be playing audio. It's not to say that it's a bad feature, but
it's also one that I don't want to make the defualt. Auxio should
still play along within the confines of Android's expectations, after
all.
Replacing the existing "Headset focus" setting with a new "Headset
autoplay" setting solves both of these issues, as it prevents a
mis-guided disabling of the setting that doesn't actually disable
the feature and it relegates the quirky autoplay behavior to an
setting not enabled by default.
Add even more checks and guards to the music loading process to ensure
proper metadata loading.
Auxio has always had issues handling track numbers and years, mostly
with ensuring their validity. This change resolves them by more or less
surrounding them with gobs of null-checks and fallible parsing
routines, which should help avoid frustrating bugs and crashes with
metadata in the future.
Resolves#88.
Resolves#84.
Revert the removal of the song/artist values from list items for now.
The current plan of removing extraneous values from songs and albums
only works if I add multi-select and a dedicated menu button, but that
is still in the air, and in general I want feedback before I go ahead.
Aside from reverting the previous changes, this actually standardizes
all item descriptions under a single bullet point formatting system,
instead of the mix of commas and bullet points that existed beforehand.
Remove all usages of memberBinding from the app.
For some reason, certain devices running Android 10 and lower will
have a lifecycle race condition whenever the theme is mis-matched.
This ends up resulting in an invalid state whenever memberBinder was
used. Since we can't replace memberBinder with a better solution,
just dumpster the whole thing. This platform is so god damn broken,
jesus christ.
Resolves#80.
Rework logging to be clearer and more standardized.
Rework all usages of lossing to follow a single unified style,
introducing a new "warn" option alongside this.
Fix an issue where headset focus would restart playback unexpectedly.
At some point during the broadcast refactor, I accidentally switched
the values of CONNECTED and DISCONNECTED when handling
AudioManager.ACTION_HEADSET_PLUG. This resulted in playback starting
for no reason in some situations.
Improve the way track numbers are handled in the album detail view.
Previously, Auxio would show track numbers by simplying stringifying
the integer and then showing it in a TextView. This was problematic for
two reasons:
- Numerics from other languages like Arabic would not be respected
- Invalid track numbers [e.g 0] would be shown regardless of the
situation.
This commit fixes that by placing all track numbers through a format
string first, and showing a generic song icon instead of a number
whenever the track number is 0.
Completely rework the Context extensions for resources.
Previously, Auxio has used a strange hodge-podge of context extensions
and verbose code to get resources. Fix this by unifying most of the
resource accesses under a single, unified set of extensions. The only
ones excluded for now is the getString call, as that is used in far too
many places to effectively replace.
Modify the music loader to use the normal artist name when using song
titles while still retaining album artist functionality.
Oftentimes music files will be tagged as to use the artist tag to
specify performers, collaborators, and others, and then use the album
artist tag to group them up into a single artist. Previously, Auxio
would only use the album artist tag, which flattened the collaborator
information out for consistency. Resolve this by implementing a sort
of "resolved artist name" for songs that is used in the UI and nowhere
else. This seems to work well, but at the same time further ruins the
API surface for handling music objects. An acceptable price to pay
for a better UX.
Actually migrate to API 32 [Android 12L], co-inciding with the upgrade
of my studio install and the android gradle plugin. Alongside this, add
a bunch of fixes for lints that the new studio picked up.
Dumpster Inter in favor of Roboto. This is mostly for three reasons:
1. Reduces the insane typography setup that Auxio uses
2. Reduces total app size since .ttf files are pretty large and the
dynamic fonts feature was proprietary.
3. Creates a more cohesive look and feel given that nearly every
android app also uses Roboto.
Switch auxio to a single-queue system. "Play next" adds songs to the top
of the queue, similar to before, and then "Add to queue" adds songs to
the bottom of the queue. This enables many more enhancements to be made
to the playback experience, at the cost of a feature I preferred.
Resolves#44.
Refactor sorting again to support free-floating ascending/descending
values on every single sort mode. This enables greater freedom in how
users can sort their music and allows me to finally get rid of the
old legacy sematic sorting modes that chose their ascending/decending
order depending on how they wanted it.
Update the image behavior for the following:
1. Use ic_album as the default image for songs and albums this just
looks beter in general.
2. Use a special default drawable for the widget so that it doesn't
look as strange.
3. Generally update the loading process throughout the app
Show the name of the currently shown detail item when scrolling. This
is just UI candy that I've always wanted to add but couldn't due to
CollapsingToolbarLayout being a mess. This addition circumvents that
by simply doing some reflection magic and hooking the alpha of the
toolbar title to the current scroll state, solving the issue.
Improve playback persistence in the following ways:
1. Shift the boundary of PlaybackStateManager and PlaybackStateDatabase
so that the reading and searching phases both occur at the same time,
which is more efficient.
2. Improve music hashing so that conflicts are minimized [this also
helps the future playlists addition]
3. Generally improve code style
Refactor the way music models are constructed to achieve the following:
- Add a unified interface for resolving display names of artists
- Disambiguate the role of Header in the music objects
- Eliminate the need to load strings in with a context when creating
Header instances
Make MusicLoader instantiation fully asynchronous. This implementation
changes a lot about Auxio. For one, the loading screen is now gone.
However, many parts of the app now run under the fact that MusicStore
might not be available. However, I don't think there will be too much bugs
from it. Some more changes will be made to improve this implementation.
Add edge-to-edge on the Home, Detail, and Search fragments. This
solution is not ideal at all, relying on viewModel state to make
sure that the padding is only applied when the playback bar is not
present. However, it works. I'll likely replace it with a better
layout once I can figure out how similar layouts like Material
Files' PersistentBarLyout work.
Completely refactor the detail module. This is for a few reasons:
- Prevent data regeneration every time a fragment re-creates.
- Make DetailModel follow the customs of other ViewModels.
- Simplify layouts into a single detail item to reduce code
complexity.
Currently sorting doesn't work, but that is still being worked out
as the legacy SortMode continues to be phased out of Auxio.
Fix an issue where in certain cases a playing item would not be
highlighted if it was being re-played. This was solved my simply
adding a check for if the new item was equal and ignoring it if
it is.
