Merge pull request #97 from meowarex/dev

RL Pebble <3

.github/workflows/release.yml

@@ -6,6 +6,8 @@ on:
       - main
     paths-ignore:
       - "**/*.md"
+  # Lets a release be re-run by hand from the Actions tab if a push event is ever missed.
+  workflow_dispatch:
 
 jobs:
   Version:
@@ -16,8 +18,22 @@ jobs:
       - uses: actions/checkout@v4
       - id: set
         run: |
+          # .version now holds the full semver (e.g. 1.0.0) and is bumped per release.
+          # It used to be a "0.3" prefix with github.run_number appended as the patch,
+          # which cannot express an exact 1.0.0. versionCode still tracks run_number,
+          # so it stays monotonic regardless of what versionName says.
           BASE=$(cat .version | tr -d '[:space:]')
-          echo "version=$BASE.${{ github.run_number }}" >> $GITHUB_OUTPUT
+          echo "version=$BASE" >> $GITHUB_OUTPUT
+
+          # Releasing onto an existing tag silently overwrites that release's assets, so a
+          # forgotten .version bump replaces history instead of publishing. Fail loudly instead.
+          # ls-remote, not rev-parse: actions/checkout does not fetch tags by default,
+          # so a local lookup would always miss and the guard would never fire.
+          if git ls-remote --exit-code --tags origin "refs/tags/v$BASE" >/dev/null 2>&1; then
+            echo "::error::Tag v$BASE already exists - bump .version before releasing." \
+              "Re-running this workflow as-is would overwrite the v$BASE release assets."
+            exit 1
+          fi
 
   Build:
     needs: Version

.gitignore

@@ -27,3 +27,6 @@ Reference/
 !tidal-apk/*.apk
 !tidal-apk/*.apkm
 tidal-apk/*/
+
+# Kawarp-AGSL library (CLONE HERE! the build tooling in tools/kawarp-build expects it)
+tools/kawarp-agsl

.version

@@ -1 +1 @@
-0.3
+1.1.8

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Manager/app/build.gradle.kts

@@ -31,8 +31,8 @@ android {
     defaultConfig {
         minSdk = 24
         targetSdk = 36
-        versionCode = 10_05_02
-        versionName = "1.5.2"
+        versionCode = 68
+        versionName = "1.1.8"
 
         vectorDrawables {
             useSupportLibrary = true
@@ -190,6 +190,7 @@ dependencies {
     implementation(libs.bundles.ktor)
     implementation(libs.bundles.shizuku)
     implementation(libs.bundles.voyager)
+    implementation(libs.pebblekit2.client)
 
     implementation(libs.compose.ui.tooling.preview)
     debugImplementation(libs.compose.ui.tooling)

Manager/app/src/main/AndroidManifest.xml

@@ -43,6 +43,22 @@
         android:name=".installers.pm.PMIntentReceiver"
         android:exported="false" />
 
+    <!-- Pebble relay, bound by patched TIDAL -->
+    <service
+        android:name=".pebble.PebbleRelayService"
+        android:exported="true"
+        tools:ignore="ExportedService" />
+
+    <!-- Pebble watch messages -->
+    <service
+        android:name=".pebble.PebbleWatchListenerService"
+        android:exported="true"
+        tools:ignore="ExportedService">
+      <intent-filter>
+        <action android:name="io.rebble.pebblekit2.RECEIVE_DATA_FROM_WATCH" />
+      </intent-filter>
+    </service>
+
     <provider
         android:name="androidx.core.content.FileProvider"
         android:authorities="${applicationId}.provider"

Manager/app/src/main/assets/patches-manifest.json

@@ -14,17 +14,16 @@
         "DebugMenuUnlock"
       ],
       "disables": [
-        "LyricsDisableCover",
-        "LyricsReplaceLyricsButton",
-        "LyricsReplaceShareButton",
         "LyricsRlApi",
-        "LyricsKeepControlsVisible",
         "PlayerBackdrop",
         "QualityBadgeColors",
         "PlayerMovePlayingFrom",
         "PlayerOneHanded",
         "LyricsProgressPill",
-        "MiniPlayerRedesign"
+        "LyricsDisableCover",
+        "LyricsReplaceLyricsButton",
+        "LyricsReplaceShareButton",
+        "LyricsKeepControlsVisible"
       ]
     },
     {
@@ -119,36 +118,29 @@
       "order": 30,
       "fileNames": [],
       "title": "Player Backdrop",
-      "description": "Lets you fully adjust how the player backdrop blur looks and behaves",
+      "description": "Swap the player backdrop for the Kawarp shader, or fine-tune TIDAL's own blurred cover",
       "default": true,
-      "defaultVariantIndex": 2,
+      "defaultVariantIndex": 1,
       "variants": [
         {
-          "title": "Static",
-          "fileNames": [
-            "player-backdrop-static.patch"
-          ],
-          "extensionFiles": [
-            "radiant/BackdropFx.smali"
-          ]
-        },
-        {
-          "title": "Animated",
-          "fileNames": [
-            "player-backdrop-animated.patch"
-          ],
-          "extensionFiles": [
-            "radiant/BackdropFx.smali"
-          ]
-        },
-        {
-          "title": "Playback",
+          "title": "Tidal",
           "fileNames": [
             "player-backdrop-playback.patch"
           ],
           "extensionFiles": [
             "radiant/BackdropFx.smali"
           ]
+        },
+        {
+          "title": "Radiant",
+          "fileNames": [
+            "player-backdrop-kawarp.patch"
+          ],
+          "extensionFiles": [
+            "radiant/Kawarp.smali",
+            "dev/kawarp/KawarpEngine.smali"
+          ],
+          "minSdk": 33
         }
       ],
       "advancedOptions": [
@@ -166,7 +158,8 @@
           "encode": {
             "kind": "int",
             "scale": 1.0
-          }
+          },
+          "requiresVariant": 0
         },
         {
           "type": "slider",
@@ -182,7 +175,8 @@
           "encode": {
             "kind": "floatBits",
             "scale": 0.02
-          }
+          },
+          "requiresVariant": 0
         },
         {
           "type": "slider",
@@ -198,7 +192,8 @@
           "encode": {
             "kind": "floatBits",
             "scale": 0.02
-          }
+          },
+          "requiresVariant": 0
         },
         {
           "type": "slider",
@@ -214,7 +209,170 @@
           "encode": {
             "kind": "floatBits",
             "scale": 0.02
-          }
+          },
+          "requiresVariant": 0
+        },
+        {
+          "type": "toggle",
+          "key": "kawarp_reactive",
+          "title": "Playback Reactive",
+          "description": "Cover shader reacts to playback state by freezing/resuming",
+          "default": true,
+          "token": "RL_KW_REACTIVE",
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_blur",
+          "title": "Blur Passes",
+          "description": "Kawase blur passes, higher is softer but costs more GPU",
+          "default": 6,
+          "min": 1,
+          "max": 40,
+          "steps": 38,
+          "displayAsPercent": false,
+          "token": "RL_KW_BLUR",
+          "encode": {
+            "kind": "int",
+            "scale": 1.0
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_warp",
+          "title": "Warp Intensity",
+          "description": "Strength of the fluidity effect",
+          "default": 100,
+          "min": 0,
+          "max": 100,
+          "steps": 19,
+          "displayAsPercent": true,
+          "token": "RL_KW_WARP",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_speed",
+          "title": "Animation Speed",
+          "description": "How fast the backdrop flows",
+          "default": 175,
+          "min": 0,
+          "max": 500,
+          "steps": 19,
+          "displayAsPercent": true,
+          "token": "RL_KW_SPEED",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_scale",
+          "title": "Backdrop Scale",
+          "description": "Zoom level of the effect",
+          "default": 100,
+          "min": 10,
+          "max": 400,
+          "steps": 12,
+          "displayAsPercent": true,
+          "token": "RL_KW_SCALE",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_contrast",
+          "title": "Contrast",
+          "description": "Contrast of the backdrop",
+          "default": 100,
+          "min": 0,
+          "max": 300,
+          "steps": 11,
+          "displayAsPercent": true,
+          "token": "RL_KW_CONTRAST",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_saturation",
+          "title": "Saturation",
+          "description": "Colour intensity of the backdrop",
+          "default": 100,
+          "min": 0,
+          "max": 400,
+          "steps": 15,
+          "displayAsPercent": true,
+          "token": "RL_KW_SAT",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_brightness",
+          "title": "Brightness",
+          "description": "The value of Brightness applied to the backdrop",
+          "default": 100,
+          "min": 0,
+          "max": 200,
+          "steps": 19,
+          "displayAsPercent": true,
+          "token": "RL_KW_BRIGHT",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_darken",
+          "title": "Auto Darken Bright Covers",
+          "description": "Prevents bright covers from making text unreadable",
+          "default": 80,
+          "min": 0,
+          "max": 100,
+          "steps": 19,
+          "displayAsPercent": true,
+          "token": "RL_KW_DARKEN",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.01
+          },
+          "requiresVariant": 1
+        },
+        {
+          "type": "slider",
+          "key": "kawarp_dither",
+          "title": "Dithering",
+          "description": "Breaks up color banding in smooth gradients",
+          "default": 15,
+          "min": 0,
+          "max": 100,
+          "steps": 19,
+          "displayAsPercent": false,
+          "token": "RL_KW_DITHER",
+          "encode": {
+            "kind": "floatBits",
+            "scale": 0.001
+          },
+          "requiresVariant": 1
         },
         {
           "type": "toggle",
@@ -264,6 +422,142 @@
       "description": "Mirrors the bottom player buttons left-to-right for easier one-handed reach.",
       "default": false
     },
+    {
+      "id": "SwipeToQueue",
+      "order": 39,
+      "fileNames": [
+        "swipe-to-queue.patch",
+        "swipe-to-queue-compose.patch"
+      ],
+      "extensionFiles": [
+        "radiant/gestures/queue/SwipeToQueue.smali",
+        "radiant/gestures/queue/QueueSwipeRemove.smali",
+        "radiant/gestures/queue/QueueRequest.smali",
+        "radiant/gestures/queue/QueueRowResolver.smali",
+        "radiant/gestures/queue/QueueExecutor.smali",
+        "radiant/gestures/queue/FavoriteTracksResolver.smali",
+        "radiant/gestures/queue/DynamicTrackResolver.smali",
+        "radiant/gestures/queue/MyAlbumsResolver.smali",
+        "radiant/gestures/queue/MyPlaylistsResolver.smali",
+        "radiant/gestures/queue/MyMixesAndRadioResolver.smali",
+        "radiant/gestures/queue/SearchAlbumsResolver.smali",
+        "radiant/gestures/queue/SearchPlaylistsResolver.smali",
+        "radiant/gestures/queue/PlaylistItemsResolver.smali",
+        "radiant/gestures/queue/UnifiedSearchResolver.smali",
+        "radiant/gestures/queue/ComposeSwipeAction.smali",
+        "radiant/gestures/queue/ComposeSwipeState.smali",
+        "radiant/gestures/queue/ComposeSwipeState$Gesture.smali",
+        "radiant/gestures/queue/ComposeSwipeState$Draw.smali",
+        "radiant/gestures/queue/ComposeSwipeState$ResetAnimator.smali",
+        "radiant/gestures/queue/ComposeTapGuard.smali",
+        "radiant/gestures/queue/AlbumItemQueueAction.smali",
+        "radiant/gestures/queue/DynamicTrackQueueEvent.smali",
+        "radiant/gestures/queue/DynamicTrackQueueAction.smali",
+        "radiant/gestures/queue/DynamicTrackQueue.smali",
+        "radiant/gestures/queue/ViewAllTrackQueueAction.smali",
+        "radiant/gestures/queue/ViewAllTrackQueue.smali",
+        "radiant/gestures/queue/ComposeSearchQueueEvent.smali",
+        "radiant/gestures/queue/ComposeSearchQueueAction.smali",
+        "radiant/gestures/queue/ComposeSearchQueue.smali",
+        "radiant/gestures/queue/FeedResolver.smali",
+        "radiant/gestures/queue/ArtistTrackCreditsQueueEvent.smali",
+        "radiant/gestures/queue/ArtistTrackCreditsQueueAction.smali",
+        "radiant/gestures/queue/ArtistTrackCreditsQueue.smali",
+        "radiant/gestures/queue/DynamicMediaQueueEvent.smali",
+        "radiant/gestures/queue/CompactGridMediaQueueAction.smali",
+        "radiant/gestures/queue/VerticalMediaQueueAction.smali",
+        "radiant/gestures/queue/PublicPlaylistQueueAction.smali",
+        "radiant/gestures/queue/DynamicMediaQueue.smali",
+        "radiant/gestures/queue/SuggestionsResolver.smali"
+      ],
+      "title": "Swipe to Queue",
+      "description": "Swipe on tracks/albums/playlists to add them to the play queue (and more actions)",
+      "default": false,
+      "advancedOptions": [
+        {
+          "type": "choice",
+          "key": "left_action",
+          "title": "Left Swipe Action",
+          "entries": [
+            "Disabled",
+            "Play next",
+            "Add to queue",
+            "Add to playlist"
+          ],
+          "values": [
+            "0x0",
+            "0x1",
+            "0x2",
+            "0x3"
+          ],
+          "defaultIndex": 2,
+          "inline": true,
+          "distinctFrom": "right_action",
+          "token": "RL_SWIPE_TO_QUEUE_LEFT_ACTION"
+        },
+        {
+          "type": "choice",
+          "key": "right_action",
+          "title": "Right Swipe Action",
+          "entries": [
+            "Disabled",
+            "Play next",
+            "Add to queue",
+            "Add to playlist"
+          ],
+          "values": [
+            "0x0",
+            "0x1",
+            "0x2",
+            "0x3"
+          ],
+          "defaultIndex": 0,
+          "inline": true,
+          "distinctFrom": "left_action",
+          "token": "RL_SWIPE_TO_QUEUE_RIGHT_ACTION"
+        },
+        {
+          "type": "choice",
+          "key": "remove_direction",
+          "title": "Remove Track from Queue",
+          "entries": [
+            "Left swipe",
+            "Right swipe",
+            "Both directions"
+          ],
+          "values": [
+            "0x4",
+            "0x8",
+            "0xc"
+          ],
+          "defaultIndex": 0,
+          "forceDropdown": true,
+          "inline": true,
+          "token": "RL_SWIPE_TO_QUEUE_REMOVE_DIRECTION"
+        },
+        {
+          "type": "color",
+          "key": "background_color",
+          "title": "Add to Queue Color",
+          "default": -14408663,
+          "token": "RL_SWIPE_TO_QUEUE_ADD_COLOR"
+        },
+        {
+          "type": "color",
+          "key": "play_next_color",
+          "title": "Play Next Color",
+          "default": -14408663,
+          "token": "RL_SWIPE_TO_QUEUE_PLAY_NEXT_COLOR"
+        },
+        {
+          "type": "color",
+          "key": "add_to_playlist_color",
+          "title": "Add to Playlist Color",
+          "default": -14408663,
+          "token": "RL_SWIPE_TO_QUEUE_ADD_TO_PLAYLIST_COLOR"
+        }
+      ]
+    },
     {
       "id": "LyricsProgressPill",
       "order": 40,
@@ -384,14 +678,14 @@
             "lyrics-gesture-scroll-guard.patch"
           ],
           "extensionFiles": [
-            "radiant/gestures/MiniPlayerGestures.smali",
-            "radiant/gestures/MiniPlayerGestures$Gesture.smali",
-            "radiant/gestures/MiniPlayerGestures$FeedbackLayer.smali",
-            "radiant/gestures/MiniPlayerGestures$FeedbackResetAnimator.smali",
-            "radiant/gestures/MiniPlayerGestures$RootGesture.smali",
-            "radiant/gestures/MiniPlayerGestures$ApplyPending.smali",
-            "radiant/gestures/LyricsDrag.smali",
-            "radiant/gestures/LyricsDrag$Guard.smali"
+            "radiant/gestures/miniplayer/MiniPlayerGestures.smali",
+            "radiant/gestures/miniplayer/MiniPlayerGestures$Gesture.smali",
+            "radiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer.smali",
+            "radiant/gestures/miniplayer/MiniPlayerGestures$FeedbackResetAnimator.smali",
+            "radiant/gestures/miniplayer/MiniPlayerGestures$RootGesture.smali",
+            "radiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending.smali",
+            "radiant/gestures/lyrics/LyricsDrag.smali",
+            "radiant/gestures/lyrics/LyricsDrag$Guard.smali"
           ]
         },
         {
@@ -421,11 +715,11 @@
             "mini-player-left-right-gesture.patch"
           ],
           "extensionFiles": [
-            "radiant/gestures/MiniPlayerTrackGestures.smali",
-            "radiant/gestures/MiniPlayerTrackGestures$Gesture.smali",
-            "radiant/gestures/MiniPlayerTrackGestures$OffsetLayer.smali",
-            "radiant/gestures/MiniPlayerTrackGestures$ResetAnimator.smali",
-            "radiant/gestures/MiniPlayerTrackGestures$TextDraw.smali",
+            "radiant/gestures/miniplayer/MiniPlayerTrackGestures.smali",
+            "radiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture.smali",
+            "radiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer.smali",
+            "radiant/gestures/miniplayer/MiniPlayerTrackGestures$ResetAnimator.smali",
+            "radiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw.smali",
             "com/tidal/android/feature/appscaffold/ui/r$c.smali"
           ]
         }
@@ -486,6 +780,30 @@
         }
       ]
     },
+    {
+      "id": "PebbleIntegration",
+      "order": 91,
+      "category": "integration",
+      "fileNames": [
+        "integration-pebble-playback.patch",
+        "integration-pebble-lyrics.patch"
+      ],
+      "extensionFiles": [
+        "radiant/PebbleBridge.smali",
+        "radiant/PebbleBridge$1.smali",
+        "radiant/PebbleBridge$2.smali"
+      ],
+      "title": "Pebble Watch",
+      "description": "Shows synced lyrics on your Pebble Time 2 when listening, Everything is configured and managed in the Pebble App",
+      "default": false,
+      "requires": [
+        "LyricsRlApi"
+      ],
+      "companionApp": {
+        "storeId": "02b779dcf9084fecb0375df1",
+        "storeSource": "https://appstore-api.repebble.com/api"
+      }
+    },
     {
       "id": "DebugMenuUnlock",
       "order": 100,

Manager/app/src/main/kotlin/com/meowarex/rlmobile/network/services/RLMobileGithubService.kt

@@ -39,10 +39,14 @@ class RadiantLyricsGithubService(
     /**
      * Fetches manager self-update releases.
      */
-    suspend fun getManagerReleases(): ApiResponse<List<GithubRelease>> =
+    suspend fun getManagerReleases(force: Boolean = false): ApiResponse<List<GithubRelease>> =
         http.request {
             url("https://api.github.com/repos/${BuildConfig.PATCHES_REPO_OWNER}/${BuildConfig.PATCHES_REPO_NAME}/releases")
-            header(HttpHeaders.CacheControl, "public, max-age=60, s-maxage=60")
+            if (force) {
+                header(HttpHeaders.CacheControl, "no-cache")
+            } else {
+                header(HttpHeaders.CacheControl, "public, max-age=60, s-maxage=60")
+            }
         }
 
     /**
@@ -66,10 +70,18 @@ class RadiantLyricsGithubService(
     /**
      * Fetches a page of commits (paginated). Used by the Home screen's commit list.
      */
-    suspend fun getCommits(page: Int, perPage: Int = 30): ApiResponse<List<com.meowarex.rlmobile.network.models.GithubCommit>> =
+    suspend fun getCommits(
+        page: Int,
+        perPage: Int = 30,
+        force: Boolean = false,
+    ): ApiResponse<List<com.meowarex.rlmobile.network.models.GithubCommit>> =
         http.request {
             url("https://api.github.com/repos/${BuildConfig.PATCHES_REPO_OWNER}/${BuildConfig.PATCHES_REPO_NAME}/commits?per_page=$perPage&page=${page + 1}")
-            header(HttpHeaders.CacheControl, "public, max-age=120, s-maxage=120")
+            if (force) {
+                header(HttpHeaders.CacheControl, "no-cache")
+            } else {
+                header(HttpHeaders.CacheControl, "public, max-age=120, s-maxage=120")
+            }
         }
 
     companion object {

Manager/app/src/main/kotlin/com/meowarex/rlmobile/network/utils/CommitsPagingSource.kt

@@ -7,6 +7,8 @@ import com.meowarex.rlmobile.network.services.RadiantLyricsGithubService
 
 class CommitsPagingSource(
     private val github: RadiantLyricsGithubService,
+    /** Bypasses the http response cache */
+    private val force: Boolean = false,
 ) : PagingSource<Int, GithubCommit>() {
     private val seenShas = mutableSetOf<String>()
     private val seenTitles = mutableSetOf<String>()
@@ -19,7 +21,8 @@ class CommitsPagingSource(
 
     override suspend fun load(params: LoadParams<Int>): LoadResult<Int, GithubCommit> {
         val page = params.key ?: 0
-        return when (val r = github.getCommits(page)) {
+        // Only the first page skips the cache
+        return when (val r = github.getCommits(page, force = force && page == 0)) {
             is ApiResponse.Success -> LoadResult.Page(
                 data = r.data.filter { commit ->
                     val title = commit.commit.message.lineSequence().first().trim()

Manager/app/src/main/kotlin/com/meowarex/rlmobile/patcher/steps/patch/PatchManifestStep.kt

@@ -29,6 +29,9 @@ class PatchManifestStep(private val options: PatchOptions) : Step() {
         val wazeDefault = container.getStep<SmaliPatchStep>().specs
             .firstOrNull { it.id == "WazeIntegration" }?.defaultEnabled ?: false
         val enableWazeIntegration = options.patchStates["WazeIntegration"] ?: wazeDefault
+        val pebbleDefault = container.getStep<SmaliPatchStep>().specs
+            .firstOrNull { it.id == "PebbleIntegration" }?.defaultEnabled ?: false
+        val enablePebbleIntegration = options.patchStates["PebbleIntegration"] ?: pebbleDefault
 
         val patchedManifest = ManifestPatcher.patchManifest(
             manifestBytes = manifest,
@@ -36,6 +39,7 @@ class PatchManifestStep(private val options: PatchOptions) : Step() {
             appName = options.appName,
             debuggable = options.debuggable,
             enableWazeIntegration = enableWazeIntegration,
+            enablePebbleIntegration = enablePebbleIntegration,
         )
 
         container.log("Repacking apk with patched manifest")

Manager/app/src/main/kotlin/com/meowarex/rlmobile/patcher/util/ManifestPatcher.kt

@@ -21,6 +21,8 @@ object ManifestPatcher {
     private const val WAZE_PACKAGE = "com.waze"
     private const val WAZE_INIT_RECEIVER = "radiant.WazeInitReceiver"
     private const val WAZE_ACTION_INIT = "com.waze.sdk.audio.ACTION_INIT"
+    // Pebble bridge binds to the Manager
+    private const val MANAGER_PACKAGE = "com.meowarex.rlmobile"
 
     fun patchManifest(
         manifestBytes: ByteArray,
@@ -28,6 +30,7 @@ object ManifestPatcher {
         appName: String,
         debuggable: Boolean,
         enableWazeIntegration: Boolean,
+        enablePebbleIntegration: Boolean,
     ): ByteArray {
         // Extract original package name to rewrite every reference to it
         // (permissions, provider authorities) to the new packageName.
@@ -90,11 +93,12 @@ object ManifestPatcher {
                         return when (name) {
                             "queries" -> object : NodeVisitor(nv) {
                                 private var hasWazePackage = false
+                                private var hasManagerPackage = false
 
                                 override fun child(ns: String?, name: String): NodeVisitor {
                                     val visitor = super.child(ns, name)
 
-                                    return if (enableWazeIntegration && name == "package") {
+                                    return if ((enableWazeIntegration || enablePebbleIntegration) && name == "package") {
                                         object : NodeVisitor(visitor) {
                                             override fun attr(
                                                 ns: String?,
@@ -106,6 +110,9 @@ object ManifestPatcher {
                                                 if (name == "name" && value == WAZE_PACKAGE) {
                                                     hasWazePackage = true
                                                 }
+                                                if (name == "name" && value == MANAGER_PACKAGE) {
+                                                    hasManagerPackage = true
+                                                }
                                                 super.attr(ns, name, resourceId, type, value)
                                             }
                                         }
@@ -127,6 +134,18 @@ object ManifestPatcher {
                                             end()
                                         }
                                     }
+                                    if (enablePebbleIntegration && !hasManagerPackage) {
+                                        super.child(null, "package").apply {
+                                            attr(
+                                                ANDROID_NAMESPACE,
+                                                "name",
+                                                android.R.attr.name,
+                                                TYPE_STRING,
+                                                MANAGER_PACKAGE,
+                                            )
+                                            end()
+                                        }
+                                    }
                                     super.end()
                                 }
                             }

Manager/app/src/main/kotlin/com/meowarex/rlmobile/pebble/PebbleRelayService.kt

@@ -0,0 +1,483 @@
+package com.meowarex.rlmobile.pebble
+
+import android.app.Service
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.media.MediaMetadata
+import android.media.session.MediaController
+import android.media.session.MediaSession
+import android.media.session.PlaybackState
+import android.os.Build
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.os.Message
+import android.os.Messenger
+import android.os.SystemClock
+import android.util.Log
+import androidx.core.os.BundleCompat
+import com.meowarex.rlmobile.BuildConfig
+import io.rebble.pebblekit2.client.DefaultPebbleSender
+import io.rebble.pebblekit2.common.model.PebbleDictionary
+import io.rebble.pebblekit2.common.model.TransmissionResult
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.util.zip.CRC32
+import kotlin.math.abs
+
+// Relays patched TIDAL playback and lyrics to the watch
+class PebbleRelayService : Service() {
+    private val main = Handler(Looper.getMainLooper())
+    private val messenger = Messenger(Handler(Looper.getMainLooper()) { handleBridgeMessage(it); true })
+    private val scope = MainScope()
+    private val senderLazy = lazy { DefaultPebbleSender(this) }
+    private val sender by senderLazy
+
+    // Reported by the watchapp
+    private val prefs by lazy { getSharedPreferences("pebble_relay", MODE_PRIVATE) }
+    private var autoOpen: Boolean
+        get() = prefs.getBoolean(PREF_AUTO_OPEN, true)
+        set(value) = prefs.edit().putBoolean(PREF_AUTO_OPEN, value).apply()
+    private var tidalPackage: String? = null
+    private var controller: MediaController? = null
+
+    // Track
+    private var mediaId: String? = null
+    private var trackId = 0L
+    private var title = ""
+    private var artist = ""
+    private var durationMs = 0L
+    private var status = WatchProtocol.STATUS_IDLE
+    private var lines: List<WatchProtocol.Line> = emptyList()
+    private var openedFor: Long = -1
+
+    // May arrive before the metadata
+    private var lyrics: LyricsPayload? = null
+
+    // Playback
+    private var playing = false
+    private var sample: PositionSample? = null
+
+    // Watch
+    private var watchReady = true
+    private var watchConfirmed = false
+    private var inboxSize = 1024
+    private val queue = ArrayDeque<Outgoing>()
+    private var inFlight: Outgoing? = null
+
+    // Last clock sent to the watch
+    private var sentPosition = -1L
+    private var sentTime = 0L
+    private var sentPlaying = false
+
+    private class PositionSample(val mediaId: String?, val position: Long, val time: Long, val playing: Boolean)
+    private class LyricsPayload(val key: String, val title: String?, val body: String?, val failed: Boolean)
+
+    private class Outgoing(val kind: Int, val trackId: Long, val build: () -> PebbleDictionary) {
+        var attempts = 0
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        current = this
+        if (PebbleWatchListenerService.watchappOpen) {
+            watchConfirmed = true
+            watchReady = true
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder = messenger.binder
+
+    override fun onUnbind(intent: Intent?): Boolean {
+        // TIDAL stopped
+        releaseController()
+        resetTrack()
+        if (autoOpen) {
+            closeWatchApp()
+        } else {
+            enqueue(Outgoing(WatchProtocol.CMD_STATUS, ANY_TRACK) { WatchProtocol.status(0, WatchProtocol.STATUS_IDLE) })
+        }
+        return false
+    }
+
+    override fun onDestroy() {
+        if (current === this) current = null
+        releaseController()
+        main.removeCallbacksAndMessages(null)
+        scope.cancel()
+        if (senderLazy.isInitialized()) sender.close()
+        super.onDestroy()
+    }
+
+    private fun handleBridgeMessage(msg: Message) {
+        val data = msg.data ?: return
+        data.classLoader = MediaSession.Token::class.java.classLoader
+        if (msg.what != MSG_SESSION && controller == null) return
+
+        when (msg.what) {
+            MSG_SESSION -> {
+                val pkg = data.getString("package") ?: return
+                if (!isTrustedTidal(pkg, msg)) {
+                    Log.w(BuildConfig.TAG, "Pebble relay: rejected session from $pkg")
+                    return
+                }
+                val token = BundleCompat.getParcelable(data, "token", MediaSession.Token::class.java) ?: return
+                attach(pkg, token)
+            }
+
+            MSG_POSITION -> {
+                val next = PositionSample(
+                    mediaId = data.getString("mediaId"),
+                    position = data.getLong("position"),
+                    time = data.getLong("elapsedRealtime"),
+                    playing = data.getBoolean("playing"),
+                )
+                if (next.mediaId != null && next.mediaId != mediaId) return
+                sample = next
+                playing = next.playing
+                syncWatchClock()
+            }
+
+            MSG_LYRICS -> {
+                val key = data.getString("key") ?: return
+                lyrics = LyricsPayload(key, data.getString("title"), data.getString("body"), data.getBoolean("failed"))
+                applyLyrics()
+            }
+        }
+    }
+
+    // Patched TIDAL only
+    private fun isTrustedTidal(pkg: String, msg: Message): Boolean = try {
+        val info = packageManager.getApplicationInfo(pkg, PackageManager.GET_META_DATA)
+        val patched = info.metaData?.containsKey("isRadiantLyrics") == true
+        val uidOk = Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || msg.sendingUid == -1 || msg.sendingUid == info.uid
+        patched && uidOk
+    } catch (_: PackageManager.NameNotFoundException) {
+        false
+    }
+
+    private fun attach(pkg: String, token: MediaSession.Token) {
+        if (controller?.sessionToken == token && pkg == tidalPackage) return
+        releaseController()
+        tidalPackage = pkg
+        controller = MediaController(this, token).also {
+            it.registerCallback(controllerCallback, main)
+            onMetadata(it.metadata)
+            onPlaybackState(it.playbackState)
+        }
+    }
+
+    private fun releaseController() {
+        controller?.unregisterCallback(controllerCallback)
+        controller = null
+    }
+
+    private val controllerCallback = object : MediaController.Callback() {
+        override fun onMetadataChanged(metadata: MediaMetadata?) = onMetadata(metadata)
+        override fun onPlaybackStateChanged(state: PlaybackState?) = onPlaybackState(state)
+        override fun onSessionDestroyed() {
+            releaseController()
+        }
+    }
+
+    private fun resetTrack() {
+        main.removeCallbacks(lyricsTimeout)
+        mediaId = null
+        trackId = 0
+        title = ""
+        artist = ""
+        durationMs = 0
+        lines = emptyList()
+        status = WatchProtocol.STATUS_IDLE
+        playing = false
+        sample = null
+        sentPosition = -1
+    }
+
+    private fun onMetadata(metadata: MediaMetadata?) {
+        metadata ?: return
+        val newTitle = metadata.getString(MediaMetadata.METADATA_KEY_TITLE).orEmpty()
+        val newArtist = metadata.getString(MediaMetadata.METADATA_KEY_ARTIST)
+            ?: metadata.getString(MediaMetadata.METADATA_KEY_ALBUM_ARTIST).orEmpty()
+        val newDuration = metadata.getLong(MediaMetadata.METADATA_KEY_DURATION)
+        val id = metadata.getString(MediaMetadata.METADATA_KEY_MEDIA_ID) ?: "$newTitle\u0000$newArtist"
+        if (newTitle.isBlank()) return
+
+        if (id == mediaId) {
+            if (newDuration > 0 && newDuration != durationMs) {
+                durationMs = newDuration
+                sendTrack()
+            }
+            return
+        }
+
+        mediaId = id
+        trackId = CRC32().run { update(id.toByteArray()); value }.takeIf { it != 0L } ?: 1L
+        title = newTitle
+        artist = newArtist
+        durationMs = newDuration
+        lines = emptyList()
+        status = WatchProtocol.STATUS_LOADING
+        sample = null
+        sentPosition = -1
+        watchReady = true
+        queue.removeAll { it.trackId != ANY_TRACK }
+
+        sendTrack()
+        sendState()
+        if (!applyLyrics()) {
+            main.removeCallbacks(lyricsTimeout)
+            main.postDelayed(lyricsTimeout, LYRICS_TIMEOUT_MS)
+        }
+    }
+
+    // Apply lyrics if they match the track
+    private fun applyLyrics(): Boolean {
+        val payload = lyrics ?: return false
+        if (trackId == 0L) return false
+        val matches = payload.key == mediaId || (payload.title != null && payload.title.equals(title, ignoreCase = true))
+        if (!matches) return false
+
+        main.removeCallbacks(lyricsTimeout)
+        lines = payload.body?.let {
+            runCatching { WatchProtocol.shape(it) }
+                .onFailure { e -> Log.w(BuildConfig.TAG, "Pebble lyrics parse failed", e) }
+                .getOrNull()
+        }.orEmpty()
+        status = when {
+            payload.failed -> WatchProtocol.STATUS_ERROR
+            lines.isEmpty() -> WatchProtocol.STATUS_NO_LYRICS
+            else -> WatchProtocol.STATUS_READY
+        }
+        sendTrack()
+        sendLines()
+        sendState()
+        updateWatchApp()
+        return true
+    }
+
+    // Open with timed lyrics, close without
+    private fun updateWatchApp() {
+        if (!autoOpen || trackId == 0L) return
+        when (status) {
+            WatchProtocol.STATUS_READY -> if (openedFor != trackId) {
+                // Once per track so manual closes stick
+                openedFor = trackId
+                if (!watchConfirmed) scope.launch { sender.startAppOnTheWatch(WatchProtocol.APP_UUID) }
+            }
+
+            WatchProtocol.STATUS_NO_LYRICS, WatchProtocol.STATUS_ERROR -> closeWatchApp()
+        }
+    }
+
+    private fun closeWatchApp() {
+        if (!watchConfirmed) return
+        scope.launch { sender.stopAppOnTheWatch(WatchProtocol.APP_UUID) }
+        watchConfirmed = false
+        watchReady = false
+        queue.clear()
+    }
+
+    private val lyricsTimeout = Runnable {
+        if (status == WatchProtocol.STATUS_LOADING && trackId != 0L) {
+            // Lyrics worker never reported
+            status = WatchProtocol.STATUS_ERROR
+            sendTrack()
+            updateWatchApp()
+        }
+    }
+
+    private fun onPlaybackState(state: PlaybackState?) {
+        state ?: return
+        val nowPlaying = state.state == PlaybackState.STATE_PLAYING
+        if (nowPlaying == playing) return
+        playing = nowPlaying
+        syncWatchClock()
+    }
+
+    // Latest position and phone time, not extrapolated
+    private fun reference(): Pair<Long, Long> {
+        val now = SystemClock.elapsedRealtime()
+        val s = sample
+        if (s != null && (s.mediaId == null || s.mediaId == mediaId) && (!playing || now - s.time < SAMPLE_STALE_MS)) {
+            return s.position to s.time
+        }
+        // Casting has no player readings
+        val state = controller?.playbackState ?: return 0L to now
+        return state.position.coerceAtLeast(0) to (state.lastPositionUpdateTime.takeIf { it > 0 } ?: now)
+    }
+
+    // Resend state only on drift
+    private fun syncWatchClock() {
+        if (trackId == 0L) return
+        val (position, time) = reference()
+        val believed = if (sentPlaying) sentPosition + (time - sentTime) else sentPosition
+        if (sentPosition < 0 || sentPlaying != playing || abs(believed - position) > DRIFT_TOLERANCE_MS) {
+            sendState()
+        }
+    }
+
+    private fun sendTrack() {
+        if (trackId == 0L) return
+        val id = trackId
+        queue.removeAll { it.kind == WatchProtocol.CMD_TRACK }
+        enqueue(Outgoing(WatchProtocol.CMD_TRACK, id) {
+            WatchProtocol.track(
+                trackId = id,
+                title = title,
+                artist = artist,
+                durationMs = durationMs,
+                status = status,
+                lineCount = lines.size,
+            )
+        })
+    }
+
+    private fun sendLines() {
+        if (lines.isEmpty()) return
+        val id = trackId
+        queue.removeAll { it.kind == WatchProtocol.CMD_LINES }
+        val budget = (inboxSize - 64).coerceIn(256, 2000)
+        for ((first, blob) in WatchProtocol.chunks(lines, budget)) {
+            enqueue(Outgoing(WatchProtocol.CMD_LINES, id) { WatchProtocol.lines(id, first, blob) })
+        }
+    }
+
+    private fun sendState() {
+        if (trackId == 0L) return
+        queue.removeAll { it.kind == WatchProtocol.CMD_STATE }
+        val id = trackId
+        // Built at send time for freshness
+        enqueue(Outgoing(WatchProtocol.CMD_STATE, id) {
+            val (position, time) = reference()
+            sentPosition = position
+            sentTime = time
+            sentPlaying = playing
+            WatchProtocol.state(id, playing, position, time)
+        })
+    }
+
+    private fun enqueue(item: Outgoing, first: Boolean = false) {
+        if (first) queue.addFirst(item) else queue.addLast(item)
+        pump()
+    }
+
+    private fun pump() {
+        if (inFlight != null) return
+        if (!watchReady) {
+            queue.clear()
+            return
+        }
+        // Drop stale tracks
+        while (queue.firstOrNull()?.let { it.trackId != ANY_TRACK && it.trackId != trackId } == true) {
+            queue.removeFirst()
+        }
+        val item = queue.removeFirstOrNull() ?: return
+        inFlight = item
+        item.attempts++
+        scope.launch {
+            val results = runCatching { sender.sendDataToPebble(WatchProtocol.APP_UUID, item.build()) }
+                .onFailure { Log.w(BuildConfig.TAG, "Pebble send failed", it) }
+                .getOrNull()
+            onSent(item, results?.values.orEmpty())
+        }
+    }
+
+    private fun onSent(item: Outgoing, results: Collection<TransmissionResult>) {
+        inFlight = null
+        when {
+            results.any { it == TransmissionResult.Success } -> {
+                watchConfirmed = true
+                pump()
+            }
+
+            results.any { it == TransmissionResult.FailedWatchNacked || it == TransmissionResult.FailedTimeout } -> {
+                if (item.attempts < 3) {
+                    queue.addFirst(item)
+                } else if (item.kind == WatchProtocol.CMD_STATE) {
+                    sentPosition = -1
+                }
+                main.postDelayed({ pump() }, 150)
+            }
+
+            else -> {
+                // Watchapp not open, wait for it
+                if (item.kind == WatchProtocol.CMD_STATE) sentPosition = -1
+                watchReady = false
+                watchConfirmed = false
+                queue.clear()
+            }
+        }
+    }
+
+    fun onWatchappOpened() {
+        watchConfirmed = true
+        watchReady = true
+    }
+
+    fun onWatchappClosed() {
+        watchConfirmed = false
+        watchReady = false
+        queue.clear()
+    }
+
+    fun onWatchMessage(values: Map<Int, Long>, receivedAt: Long) {
+        watchConfirmed = true
+        watchReady = true
+        when (values[WatchProtocol.KEY_CMD]?.toInt()) {
+            WatchProtocol.CMD_SYNC_REQ -> {
+                val watchTime = values[WatchProtocol.KEY_WATCH_TIME] ?: return
+                // Front of queue, stamped at send
+                enqueue(Outgoing(WatchProtocol.CMD_SYNC, ANY_TRACK) {
+                    WatchProtocol.sync(watchTime, receivedAt, SystemClock.elapsedRealtime())
+                }, first = true)
+            }
+
+            WatchProtocol.CMD_SETTINGS -> {
+                values[WatchProtocol.KEY_SET_AUTO_OPEN]?.let { autoOpen = it != 0L }
+            }
+
+            WatchProtocol.CMD_HELLO -> {
+                values[WatchProtocol.KEY_SET_AUTO_OPEN]?.let { autoOpen = it != 0L }
+                values[WatchProtocol.KEY_INBOX_SIZE]?.let { inboxSize = it.toInt().coerceIn(256, 8192) }
+                queue.removeAll { it.kind != WatchProtocol.CMD_SYNC }
+                sentPosition = -1
+                if (trackId != 0L) {
+                    sendTrack()
+                    sendLines()
+                    sendState()
+                } else {
+                    enqueue(Outgoing(WatchProtocol.CMD_STATUS, ANY_TRACK) {
+                        WatchProtocol.status(0, WatchProtocol.STATUS_IDLE)
+                    })
+                }
+            }
+
+            WatchProtocol.CMD_PLAY_PAUSE -> controller?.transportControls?.let {
+                if (playing) it.pause() else it.play()
+            }
+
+            WatchProtocol.CMD_NEXT -> controller?.transportControls?.skipToNext()
+            WatchProtocol.CMD_PREV -> controller?.transportControls?.skipToPrevious()
+        }
+    }
+
+    companion object {
+        // Keep in sync with radiant.PebbleBridge
+        const val MSG_SESSION = 1
+        const val MSG_POSITION = 2
+        const val MSG_LYRICS = 3
+
+        // Used by PebbleWatchListenerService
+        @Volatile
+        var current: PebbleRelayService? = null
+            private set
+
+        private const val ANY_TRACK = -1L
+        private const val PREF_AUTO_OPEN = "auto_open"
+        private const val DRIFT_TOLERANCE_MS = 10L
+        private const val SAMPLE_STALE_MS = 8_000L
+        private const val LYRICS_TIMEOUT_MS = 90_000L
+    }
+}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/pebble/PebbleWatchListenerService.kt

@@ -0,0 +1,40 @@
+package com.meowarex.rlmobile.pebble
+
+import android.os.SystemClock
+import io.rebble.pebblekit2.client.BasePebbleListenerService
+import io.rebble.pebblekit2.common.model.PebbleDictionary
+import io.rebble.pebblekit2.common.model.ReceiveResult
+import io.rebble.pebblekit2.common.model.WatchIdentifier
+import java.util.UUID
+
+// Forwards watch events to the relay
+class PebbleWatchListenerService : BasePebbleListenerService() {
+    override suspend fun onMessageReceived(
+        watchappUUID: UUID,
+        data: PebbleDictionary,
+        watch: WatchIdentifier,
+    ): ReceiveResult {
+        val receivedAt = SystemClock.elapsedRealtime()
+        if (watchappUUID != WatchProtocol.APP_UUID) return ReceiveResult.Nack
+        PebbleRelayService.current?.onWatchMessage(WatchProtocol.ints(data), receivedAt)
+        return ReceiveResult.Ack
+    }
+
+    override fun onAppOpened(watchappUUID: UUID, watch: WatchIdentifier) {
+        if (watchappUUID != WatchProtocol.APP_UUID) return
+        watchappOpen = true
+        PebbleRelayService.current?.onWatchappOpened()
+    }
+
+    override fun onAppClosed(watchappUUID: UUID, watch: WatchIdentifier) {
+        if (watchappUUID != WatchProtocol.APP_UUID) return
+        watchappOpen = false
+        PebbleRelayService.current?.onWatchappClosed()
+    }
+
+    companion object {
+        @Volatile
+        var watchappOpen = false
+            private set
+    }
+}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/pebble/PebbleWatchapp.kt

@@ -0,0 +1,61 @@
+package com.meowarex.rlmobile.pebble
+
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import com.meowarex.rlmobile.R
+import com.meowarex.rlmobile.ui.screens.patchopts.CompanionAppSpec
+import com.meowarex.rlmobile.util.showToast
+import io.rebble.pebblekit2.client.DefaultPebbleSender
+import io.rebble.pebblekit2.common.model.TimelineResult
+
+// Watchapp install state and store links
+object PebbleWatchapp {
+    private const val PROBE_PIN_ID = "rl-install-probe"
+    private const val STORE_WEB = "https://apps.repebble.com/"
+    private const val APPS_TAB = "pebble://navbar/index"
+
+    enum class InstallState { Installed, NotInstalled, Unknown }
+
+    // Deleting a missing pin reveals install state
+    suspend fun installState(context: Context): InstallState = runCatching {
+        DefaultPebbleSender(context.applicationContext).use { sender ->
+            when (sender.deleteTimelinePin(WatchProtocol.APP_UUID, PROBE_PIN_ID)) {
+                TimelineResult.FailedUnknownPin, TimelineResult.Success -> InstallState.Installed
+                TimelineResult.FailedNoPermissions -> InstallState.NotInstalled
+                else -> InstallState.Unknown
+            }
+        }
+    }.getOrDefault(InstallState.Unknown)
+
+    fun canInstall(app: CompanionAppSpec): Boolean = !app.storeId.isNullOrBlank()
+
+    fun install(context: Context, app: CompanionAppSpec) = openStorePage(context, app)
+
+    // Apps tab, My Apps holds the settings
+    fun openSettings(context: Context) {
+        if (!start(context, Intent(Intent.ACTION_VIEW, Uri.parse(APPS_TAB)))) {
+            context.showToast(R.string.pebble_app_missing)
+        }
+    }
+
+    // Pebble app store page, else the web listing
+    private fun openStorePage(context: Context, app: CompanionAppSpec) {
+        val storeId = app.storeId?.takeIf { it.isNotBlank() } ?: return
+        val deepLink = Uri.Builder().scheme("pebble").authority("appstore").appendPath(storeId)
+            .apply { app.storeSource?.let { appendQueryParameter("source", it) } }
+            .build()
+        if (start(context, Intent(Intent.ACTION_VIEW, deepLink))) return
+        if (!start(context, Intent(Intent.ACTION_VIEW, Uri.parse(STORE_WEB + storeId)))) {
+            context.showToast(R.string.pebble_app_missing)
+        }
+    }
+
+    private fun start(context: Context, intent: Intent): Boolean = try {
+        context.startActivity(intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
+        true
+    } catch (_: ActivityNotFoundException) {
+        false
+    }
+}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/pebble/WatchProtocol.kt

@@ -0,0 +1,265 @@
+package com.meowarex.rlmobile.pebble
+
+import io.rebble.pebblekit2.common.model.PebbleDictionary
+import io.rebble.pebblekit2.common.model.PebbleDictionaryItem
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.ByteArrayOutputStream
+import java.util.UUID
+import kotlin.math.roundToLong
+
+// Mirrors rl-pebble main.c and emu_driver.py
+object WatchProtocol {
+    val APP_UUID: UUID = UUID.fromString("79d7fe6a-b970-483a-b096-16da10af0433")
+
+    // package.json messageKeys order
+    const val KEY_CMD = 10000
+    const val KEY_TRACK_ID = 10001
+    const val KEY_TITLE = 10002
+    const val KEY_ARTIST = 10003
+    const val KEY_DURATION = 10004
+    const val KEY_STATUS = 10005
+    const val KEY_LINE_COUNT = 10006
+    const val KEY_CHUNK_INDEX = 10007
+    const val KEY_CHUNK = 10008
+    const val KEY_PLAYING = 10009
+    const val KEY_POSITION = 10010
+    const val KEY_INBOX_SIZE = 10011
+    const val KEY_PHONE_TIME = 10012
+    const val KEY_WATCH_TIME = 10013
+    const val KEY_PHONE_TIME_2 = 10014
+    const val KEY_SET_AUTO_OPEN = 10021
+
+    const val CMD_TRACK = 1
+    const val CMD_LINES = 2
+    const val CMD_STATE = 3
+    const val CMD_STATUS = 4
+    const val CMD_SYNC = 5
+    const val CMD_HELLO = 20
+    const val CMD_PLAY_PAUSE = 21
+    const val CMD_NEXT = 22
+    const val CMD_PREV = 23
+    const val CMD_SYNC_REQ = 24
+    const val CMD_SETTINGS = 25
+
+    const val STATUS_IDLE = 0
+    const val STATUS_LOADING = 1
+    const val STATUS_READY = 2
+    const val STATUS_NO_LYRICS = 3
+    const val STATUS_ERROR = 4
+
+    private const val SEG_BG = 1 shl 0
+    private const val SEG_SPACE = 1 shl 1
+    private const val LINE_RIGHT = 1 shl 0
+
+    private val WHITESPACE = Regex("\\s+")
+    private const val HOLD_FOREVER = Int.MAX_VALUE.toLong()
+    private const val LINE_ONLY_MS = 800L
+    private const val MAX_SEGMENTS = 120
+
+    class Segment(val time: Long, val duration: Long, val flags: Int, val text: String)
+
+    // end is when the line stops being lit
+    class Line(val start: Long, val end: Long, val segments: List<Segment>, val right: Boolean)
+
+    // Syllable level lines, lit until the next lead line.
+    fun shape(body: String): List<Line> {
+        val root = JSONObject(body)
+        val data = root.optJSONArray("data") ?: return emptyList()
+        val sides = singerSides(root, data)
+
+        class Raw(val start: Long, val end: Long, val allBackground: Boolean, val segments: List<Segment>, val right: Boolean)
+
+        val raws = ArrayList<Raw>(data.length())
+        for (i in 0 until data.length()) {
+            val item = data.optJSONObject(i) ?: continue
+            val syllabus = item.optJSONArray("syllabus")?.takeIf { it.length() > 0 }
+
+            val segments = ArrayList<Segment>()
+            val start: Long
+            val end: Long
+            var allBackground = false
+            if (syllabus != null) {
+                val first = syllabus.optJSONObject(0)
+                val last = syllabus.optJSONObject(syllabus.length() - 1)
+                start = first?.optLong("time") ?: 0
+                end = (last?.optLong("time") ?: 0) + (last?.optLong("duration") ?: 0)
+                allBackground = (0 until syllabus.length()).all {
+                    syllabus.optJSONObject(it)?.optBoolean("isBackground") == true
+                }
+                for (j in 0 until syllabus.length()) {
+                    val syllable = syllabus.optJSONObject(j) ?: continue
+                    val raw = text(syllable)
+                    val trimmed = raw.trim()
+                    if (trimmed.isEmpty()) continue
+                    var flags = if (syllable.optBoolean("isBackground")) SEG_BG else 0
+                    if (raw != raw.trimEnd()) flags = flags or SEG_SPACE
+                    segments += Segment(syllable.optLong("time"), syllable.optLong("duration"), flags, trimmed)
+                }
+            } else {
+                // Line timed only, one segment per word
+                start = (item.optDouble("startTime", 0.0) * 1000).roundToLong()
+                end = start + LINE_ONLY_MS
+                val words = text(item).split(WHITESPACE).filter { it.isNotEmpty() }
+                words.forEachIndexed { index, word ->
+                    segments += Segment(start, 0, if (index < words.lastIndex) SEG_SPACE else 0, word)
+                }
+            }
+            if (segments.isEmpty()) continue
+            raws += Raw(start, end, allBackground, segments.take(MAX_SEGMENTS), sides?.get(i) == 1)
+        }
+
+        return raws.mapIndexed { index, raw ->
+            val nextLead = (index + 1 until raws.size).firstOrNull { !raws[it].allBackground }?.let { raws[it].start }
+            Line(raw.start, (nextLead ?: HOLD_FOREVER).coerceAtLeast(raw.end), raw.segments, raw.right)
+        }
+    }
+
+    // RL Mobile duet sides, null for one side.
+    private fun singerSides(root: JSONObject, data: JSONArray): IntArray? {
+        val agents = root.optJSONObject("metadata")?.optJSONObject("agents")
+        fun singerOf(i: Int) = data.optJSONObject(i)?.optJSONObject("element")?.optString("singer")?.takeIf { it.isNotEmpty() }
+        fun typeOf(singer: String): String = agents?.optJSONObject(singer)?.optString("type", "person")
+            ?: when (singer) {
+                "v1000" -> "group"
+                "v2000" -> "other"
+                else -> "person"
+            }
+
+        // Groups left, second person right
+        val sideOf = HashMap<String, Int>()
+        var persons = 0
+        for (i in 0 until data.length()) {
+            val singer = singerOf(i) ?: continue
+            if (singer in sideOf) continue
+            sideOf[singer] = if (typeOf(singer) != "person") 0 else if (++persons == 2) 1 else 0
+        }
+
+        val sides = IntArray(data.length()) { i -> singerOf(i)?.let { sideOf[it] ?: 0 } ?: -1 }
+        val sided = sides.count { it >= 0 }
+        val right = sides.count { it == 1 }
+        // Nearly all right, swap
+        if (sided > 0 && right * 100 / sided >= 85) {
+            for (i in sides.indices) if (sides[i] >= 0) sides[i] = 1 - sides[i]
+        }
+        return if (sides.any { it == 0 } && sides.any { it == 1 }) sides else null
+    }
+
+    private fun text(obj: JSONObject): String =
+        obj.optString("romanized").takeIf { it.isNotBlank() } ?: obj.optString("text")
+
+    private fun encodeLine(line: Line): ByteArray {
+        val out = ByteArrayOutputStream()
+        out.u32(line.start)
+        out.u32(line.end)
+        out.write(line.segments.size)
+        out.write(if (line.right) LINE_RIGHT else 0)
+        for (segment in line.segments) {
+            val text = utf8Truncate(segment.text, 255)
+            out.u16((segment.time - line.start).coerceIn(0, 65535))
+            out.u16(segment.duration.coerceIn(0, 65535))
+            out.write(segment.flags)
+            out.write(text.size)
+            out.write(text)
+        }
+        return out.toByteArray()
+    }
+
+    // Whole lines per chunk, keyed by first index.
+    fun chunks(lines: List<Line>, budget: Int): List<Pair<Int, ByteArray>> {
+        val result = ArrayList<Pair<Int, ByteArray>>()
+        val buf = ByteArrayOutputStream()
+        var first = 0
+        lines.forEachIndexed { index, line ->
+            val encoded = encodeLine(line)
+            if (buf.size() > 0 && buf.size() + encoded.size > budget) {
+                result += first to buf.toByteArray()
+                buf.reset()
+                first = index
+            }
+            buf.write(encoded)
+        }
+        if (buf.size() > 0) result += first to buf.toByteArray()
+        return result
+    }
+
+    fun track(trackId: Long, title: String, artist: String, durationMs: Long, status: Int, lineCount: Int): PebbleDictionary =
+        mapOf(
+            key(KEY_CMD) to PebbleDictionaryItem.UInt8(CMD_TRACK),
+            key(KEY_TRACK_ID) to PebbleDictionaryItem.UInt32(trackId),
+            key(KEY_TITLE) to PebbleDictionaryItem.Text(String(utf8Truncate(title, 60))),
+            key(KEY_ARTIST) to PebbleDictionaryItem.Text(String(utf8Truncate(artist, 60))),
+            key(KEY_DURATION) to PebbleDictionaryItem.UInt32(durationMs.coerceIn(0, 0xFFFFFFFFL)),
+            key(KEY_STATUS) to PebbleDictionaryItem.UInt8(status),
+            key(KEY_LINE_COUNT) to PebbleDictionaryItem.UInt16(lineCount),
+        )
+
+    fun lines(trackId: Long, firstIndex: Int, blob: ByteArray): PebbleDictionary = mapOf(
+        key(KEY_CMD) to PebbleDictionaryItem.UInt8(CMD_LINES),
+        key(KEY_TRACK_ID) to PebbleDictionaryItem.UInt32(trackId),
+        key(KEY_CHUNK_INDEX) to PebbleDictionaryItem.UInt16(firstIndex),
+        key(KEY_CHUNK) to PebbleDictionaryItem.Bytes(blob),
+    )
+
+    // Position at a phone elapsedRealtime.
+    fun state(trackId: Long, playing: Boolean, positionMs: Long, phoneTimeMs: Long): PebbleDictionary = mapOf(
+        key(KEY_CMD) to PebbleDictionaryItem.UInt8(CMD_STATE),
+        key(KEY_TRACK_ID) to PebbleDictionaryItem.UInt32(trackId),
+        key(KEY_PLAYING) to PebbleDictionaryItem.UInt8(if (playing) 1 else 0),
+        key(KEY_POSITION) to PebbleDictionaryItem.Int32(positionMs.coerceIn(0, Int.MAX_VALUE.toLong()).toInt()),
+        key(KEY_PHONE_TIME) to PebbleDictionaryItem.UInt32(phoneTimeMs and 0xFFFFFFFFL),
+    )
+
+    fun sync(watchTime: Long, receivedAt: Long, sentAt: Long): PebbleDictionary = mapOf(
+        key(KEY_CMD) to PebbleDictionaryItem.UInt8(CMD_SYNC),
+        key(KEY_WATCH_TIME) to PebbleDictionaryItem.UInt32(watchTime and 0xFFFFFFFFL),
+        key(KEY_PHONE_TIME) to PebbleDictionaryItem.UInt32(receivedAt and 0xFFFFFFFFL),
+        key(KEY_PHONE_TIME_2) to PebbleDictionaryItem.UInt32(sentAt and 0xFFFFFFFFL),
+    )
+
+    fun status(trackId: Long, status: Int): PebbleDictionary = mapOf(
+        key(KEY_CMD) to PebbleDictionaryItem.UInt8(CMD_STATUS),
+        key(KEY_TRACK_ID) to PebbleDictionaryItem.UInt32(trackId),
+        key(KEY_STATUS) to PebbleDictionaryItem.UInt8(status),
+    )
+
+    // Integer tuples from the watch.
+    fun ints(data: PebbleDictionary): Map<Int, Long> = buildMap {
+        for ((k, item) in data) {
+            val value = when (item) {
+                is PebbleDictionaryItem.UInt32 -> item.value.toLong()
+                is PebbleDictionaryItem.Int32 -> item.value.toLong()
+                is PebbleDictionaryItem.UInt16 -> item.value.toLong()
+                is PebbleDictionaryItem.Int16 -> item.value.toLong()
+                is PebbleDictionaryItem.UInt8 -> item.value.toLong()
+                is PebbleDictionaryItem.Int8 -> item.value.toLong()
+                else -> continue
+            }
+            put(k.toInt(), value)
+        }
+    }
+
+    private fun key(key: Int) = key.toUInt()
+
+    private fun utf8Truncate(text: String, limit: Int): ByteArray {
+        val raw = text.toByteArray(Charsets.UTF_8)
+        if (raw.size <= limit) return raw
+        var end = limit
+        // Don't split a code point
+        while (end > 0 && (raw[end].toInt() and 0xC0) == 0x80) end--
+        return raw.copyOf(end)
+    }
+
+    private fun ByteArrayOutputStream.u16(value: Long) {
+        write((value and 0xFF).toInt())
+        write(((value shr 8) and 0xFF).toInt())
+    }
+
+    private fun ByteArrayOutputStream.u32(value: Long) {
+        val v = value.coerceIn(0, 0xFFFFFFFFL)
+        write((v and 0xFF).toInt())
+        write(((v shr 8) and 0xFF).toInt())
+        write(((v shr 16) and 0xFF).toInt())
+        write(((v shr 24) and 0xFF).toInt())
+    }
+}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/components/radiant/RadiantInputs.kt

@@ -3,26 +3,49 @@ package com.meowarex.rlmobile.ui.components.radiant
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.animateDpAsState
 import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.MutableTransitionState
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.rememberTransition
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.interaction.collectIsFocusedAsState
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.role
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.input.VisualTransformation
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.DpOffset
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Popup
+import androidx.compose.ui.window.PopupProperties
+import com.meowarex.rlmobile.R
 import com.meowarex.rlmobile.ui.theme.*
 
 /**
@@ -114,7 +137,152 @@ fun RadiantTextField(
 }
 
 /**
- * Slider with a gradient and glow.
+ * Dropdown
+ */
+@Composable
+fun RadiantDropdown(
+    options: List<String>,
+    selectedIndex: Int,
+    onSelect: (Int) -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    disabledIndices: Set<Int> = emptySet(),
+) {
+    var expanded by rememberSaveable { mutableStateOf(false) }
+    val visibilityState = remember { MutableTransitionState(false) }
+    visibilityState.targetState = expanded
+    val transition = rememberTransition(visibilityState, label = "Dropdown")
+    val progress by transition.animateFloat(
+        transitionSpec = { tween(durationMillis = 160, easing = FastOutSlowInEasing) },
+        label = "DropdownProgress",
+    ) {
+        if (it) 1f else 0f
+    }
+    val scheme = MaterialTheme.colorScheme
+    val selectedLabel = options.getOrNull(selectedIndex).orEmpty()
+    val shape = if (radiantStyle.native) MaterialTheme.shapes.extraSmall else RoundedCornerShape(16.dp)
+    var anchorWidthPx by remember { mutableIntStateOf(0) }
+    val anchorWidth = with(LocalDensity.current) { anchorWidthPx.toDp() }
+    val positionProvider = MenuDefaults.rememberDropdownMenuPopupPositionProvider(
+        dropdownMenuAnchorPosition = MenuAnchorPosition.Below,
+        offset = DpOffset(0.dp, 6.dp),
+    )
+    Box(modifier = modifier.fillMaxWidth()) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
+            modifier = Modifier
+                .fillMaxWidth()
+                .onSizeChanged { anchorWidthPx = it.width }
+                .background(scheme.surfaceContainerLowest.copy(alpha = 0.8f), shape)
+                .then(
+                    if (radiantStyle.native) Modifier.border(1.dp, scheme.outline, shape)
+                    else Modifier.border(
+                        RadiantDesign.Hairline,
+                        hairlineBrush(scheme.onSurface, RadiantDesign.BORDER_ALPHA * 1.5f),
+                        shape,
+                    )
+                )
+                .clip(shape)
+                .clickable(enabled = enabled, role = Role.Button) { expanded = !expanded }
+                .alpha(if (enabled) 1f else 0.45f)
+                .heightIn(min = 52.dp)
+                .padding(horizontal = 16.dp, vertical = 10.dp),
+        ) {
+            Text(
+                text = selectedLabel,
+                style = MaterialTheme.typography.bodyLarge,
+                color = scheme.onSurface,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                modifier = Modifier.weight(1f),
+            )
+            Icon(
+                painter = painterResource(R.drawable.ic_arrow_down_small),
+                contentDescription = null,
+                modifier = Modifier.rotate(180f * progress),
+            )
+        }
+
+        if (
+            anchorWidthPx > 0 &&
+            (visibilityState.currentState || visibilityState.targetState || transition.isRunning)
+        ) {
+            Popup(
+                popupPositionProvider = positionProvider,
+                onDismissRequest = { expanded = false },
+                properties = PopupProperties(focusable = true),
+            ) {
+                Surface(
+                    modifier = Modifier
+                        .width(anchorWidth)
+                        .graphicsLayer {
+                            alpha = progress
+                            scaleX = 0.92f + 0.08f * progress
+                            scaleY = 0.92f + 0.08f * progress
+                            transformOrigin = positionProvider.transformOrigin
+                        },
+                    shape = shape,
+                    color = scheme.surfaceContainer,
+                    tonalElevation = 0.dp,
+                    shadowElevation = 8.dp,
+                    border = BorderStroke(
+                        RadiantDesign.Hairline,
+                        scheme.onSurface.copy(alpha = RadiantDesign.BORDER_ALPHA * 2f),
+                    ),
+                ) {
+                    Column(
+                        modifier = Modifier
+                            .heightIn(max = 320.dp)
+                            .verticalScroll(rememberScrollState())
+                            .padding(vertical = 6.dp),
+                    ) {
+                        options.forEachIndexed { index, option ->
+                            val selected = index == selectedIndex
+                            val itemEnabled = enabled && index !in disabledIndices
+                            DropdownMenuItem(
+                                text = {
+                                    Text(
+                                        text = option,
+                                        style = MaterialTheme.typography.bodyLarge,
+                                        maxLines = 1,
+                                        overflow = TextOverflow.Ellipsis,
+                                    )
+                                },
+                                trailingIcon = {
+                                    RadiantRadio(
+                                        selected = selected,
+                                        onClick = null,
+                                        enabled = itemEnabled,
+                                    )
+                                },
+                                enabled = itemEnabled,
+                                onClick = {
+                                    onSelect(index)
+                                    expanded = false
+                                },
+                                modifier = Modifier
+                                    .padding(horizontal = 6.dp, vertical = 2.dp)
+                                    .clip(RoundedCornerShape(12.dp))
+                                    .semantics {
+                                        this.selected = selected
+                                        role = Role.RadioButton
+                                    }
+                                    .then(
+                                        if (selected) Modifier.background(scheme.primary.copy(alpha = 0.1f))
+                                        else Modifier
+                                    ),
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Slider. (i prefer the old on tbh so i reverted it back <3)
  */
 @Composable
 fun RadiantSlider(
@@ -124,12 +292,10 @@ fun RadiantSlider(
     valueRange: ClosedFloatingPointRange<Float> = 0f..1f,
     steps: Int = 0,
     enabled: Boolean = true,
+    showStopIndicator: Boolean = true,
     onValueChangeFinished: (() -> Unit)? = null,
 ) {
-    val scheme = MaterialTheme.colorScheme
-    val interaction = remember(::MutableInteractionSource)
-
-    if (radiantStyle.native) {
+    if (showStopIndicator) {
         Slider(
             value = value,
             onValueChange = onValueChange,
@@ -139,51 +305,18 @@ fun RadiantSlider(
             enabled = enabled,
             modifier = modifier,
         )
-        return
+    } else {
+        Slider(
+            value = value,
+            onValueChange = onValueChange,
+            onValueChangeFinished = onValueChangeFinished,
+            valueRange = valueRange,
+            steps = steps,
+            enabled = enabled,
+            modifier = modifier,
+            track = { SliderDefaults.Track(sliderState = it, drawStopIndicator = null) },
+        )
     }
-
-    Slider(
-        value = value,
-        onValueChange = onValueChange,
-        onValueChangeFinished = onValueChangeFinished,
-        valueRange = valueRange,
-        steps = steps,
-        enabled = enabled,
-        interactionSource = interaction,
-        modifier = modifier,
-        track = { state ->
-            val fraction = if (valueRange.endInclusive > valueRange.start) {
-                ((state.value - valueRange.start) / (valueRange.endInclusive - valueRange.start))
-                    .coerceIn(0f, 1f)
-            } else 0f
-
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(6.dp)
-                    .clip(CircleShape)
-                    .background(scheme.surfaceContainerHighest),
-            ) {
-                Box(
-                    modifier = Modifier
-                        .fillMaxWidth(fraction)
-                        .fillMaxHeight()
-                        .clip(CircleShape)
-                        .background(accentBrush),
-                )
-            }
-        },
-        thumb = {
-            Box(
-                modifier = Modifier
-                    .glow(scheme.primary, 10.dp, CircleShape, alpha = 0.6f)
-                    .size(20.dp)
-                    .clip(CircleShape)
-                    .background(scheme.onPrimary, CircleShape)
-                    .border(3.dp, scheme.primary, CircleShape),
-            )
-        },
-    )
 }
 
 /**
@@ -196,6 +329,7 @@ fun RadiantSegmented(
     onSelect: (Int) -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    disabledIndices: Set<Int> = emptySet(),
 ) {
     if (radiantStyle.native) {
         SingleChoiceSegmentedButtonRow(modifier = modifier.fillMaxWidth()) {
@@ -203,7 +337,7 @@ fun RadiantSegmented(
                 SegmentedButton(
                     selected = index == selectedIndex,
                     onClick = { onSelect(index) },
-                    enabled = enabled,
+                    enabled = enabled && index !in disabledIndices,
                     shape = SegmentedButtonDefaults.itemShape(index = index, count = options.size),
                     icon = {},
                     label = { Text(text = label, maxLines = 1) },
@@ -231,6 +365,7 @@ fun RadiantSegmented(
     ) {
         options.forEachIndexed { index, label ->
             val selected = index == selectedIndex
+            val segmentEnabled = enabled && index !in disabledIndices
             val pillShape = RoundedCornerShape(13.dp)
             val alpha by animateFloatAsState(
                 targetValue = if (selected) 1f else 0f,
@@ -253,7 +388,7 @@ fun RadiantSegmented(
                         } else Modifier
                     )
                     .clickable(
-                        enabled = enabled,
+                        enabled = segmentEnabled,
                         role = Role.RadioButton,
                         onClick = { onSelect(index) },
                     ),
@@ -261,7 +396,11 @@ fun RadiantSegmented(
                 Text(
                     text = label,
                     style = MaterialTheme.typography.labelLarge,
-                    color = if (selected) scheme.onPrimary else scheme.onSurfaceVariant,
+                    color = when {
+                        selected -> scheme.onPrimary
+                        segmentEnabled -> scheme.onSurfaceVariant
+                        else -> scheme.onSurface.copy(alpha = 0.38f)
+                    },
                     maxLines = 1,
                 )
             }
@@ -270,37 +409,3 @@ fun RadiantSegmented(
 }
 
 /** something.. */
-@Composable
-fun RadiantLabeledSlider(
-    label: String,
-    value: Float,
-    onValueChange: (Float) -> Unit,
-    modifier: Modifier = Modifier,
-    valueRange: ClosedFloatingPointRange<Float> = 0f..1f,
-    steps: Int = 0,
-    trailingText: String? = null,
-) {
-    Column(modifier = modifier.fillMaxWidth()) {
-        Row(verticalAlignment = Alignment.CenterVertically) {
-            Text(
-                text = label,
-                style = MaterialTheme.typography.labelLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                modifier = Modifier.weight(1f),
-            )
-            if (trailingText != null) {
-                Text(
-                    text = trailingText,
-                    style = MaterialTheme.typography.labelLarge,
-                    color = MaterialTheme.colorScheme.primary,
-                )
-            }
-        }
-        RadiantSlider(
-            value = value,
-            onValueChange = onValueChange,
-            valueRange = valueRange,
-            steps = steps,
-        )
-    }
-}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/legacy/screens/home/HomeScreen.kt

@@ -15,6 +15,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.painter.BitmapPainter
 import androidx.activity.ComponentActivity
 import androidx.compose.ui.platform.LocalContext
@@ -57,6 +58,8 @@ class HomeScreen : Screen, Parcelable {
         val activity = LocalContext.current as ComponentActivity
         val updater = koinViewModel<UpdaterViewModel>(viewModelStoreOwner = activity)
         val managerUpdateAvailable = updater.targetVersion != null
+        val refreshing = model.refreshing
+        val refreshAngle = rememberRefreshAngle()
 
         LifecycleResumeEffect(Unit) {
             model.refresh(delay = true)
@@ -68,10 +71,19 @@ class HomeScreen : Screen, Parcelable {
                 TopAppBar(
                     title = { Text(stringResource(R.string.navigation_home)) },
                     actions = {
-                        IconButton(onClick = { model.refresh() }) {
+                        IconButton(
+                            onClick = {
+                                model.refresh(force = true)
+                                updater.checkForUpdates(force = true)
+                            },
+                            enabled = !refreshing,
+                        ) {
                             Icon(
                                 painterResource(R.drawable.ic_refresh),
                                 contentDescription = stringResource(R.string.navigation_refresh),
+                                modifier = Modifier.graphicsLayer {
+                                    rotationZ = if (refreshing) refreshAngle() else 0f
+                                },
                             )
                         }
                         if (managerUpdateAvailable) {

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/legacy/screens/patchopts/components/PatchAdvancedOptionsSheet.kt

@@ -33,10 +33,13 @@ import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import com.meowarex.rlmobile.R
+import com.meowarex.rlmobile.ui.components.radiant.RadiantDropdown
 import com.meowarex.rlmobile.ui.legacy.components.ResetToDefaultButton
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionLock
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionSpec
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptionState
+import com.meowarex.rlmobile.ui.screens.patchopts.hiddenForVariant
+import com.meowarex.rlmobile.ui.screens.patchopts.isInline
 import com.meowarex.rlmobile.ui.screens.patchopts.optionLock
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchSpec
 import kotlinx.coroutines.launch
@@ -102,13 +105,15 @@ fun PatchAdvancedOptionsSheet(
 
             val parentKeys = patch.advancedOptions
                 .filterIsInstance<OptionSpec.Toggle>()
-                .filter { !it.inline }
+                .filter { !it.isInline }
                 .map { it.key }
                 .toSet()
             val sheetOptions = patch.advancedOptions.filter { option ->
                 when {
-                    option is OptionSpec.Toggle && option.inline -> false
+                    option.isInline -> false
                     option is OptionSpec.Toggle && option.requiresOption in parentKeys -> false
+                    // Options belonging to another variant are hidden, not greyed out.
+                    option.hiddenForVariant(selectedVariant) -> false
                     else -> true
                 }
             }
@@ -118,7 +123,7 @@ fun PatchAdvancedOptionsSheet(
                     is OptionSpec.Toggle -> {
                         val toggleOn = state.toggle(patch, option)
                         val gatedChoices = patch.advancedOptions.filterIsInstance<OptionSpec.Choice>()
-                            .filter { it.requiresOption == option.key }
+                            .filter { it.requiresOption == option.key && !it.isInline }
                         val gatedToggles = patch.advancedOptions.filterIsInstance<OptionSpec.Toggle>()
                             .filter { it.requiresOption == option.key && !it.inline }
                         val hasSubOptions = gatedChoices.isNotEmpty() || gatedToggles.isNotEmpty()
@@ -161,8 +166,14 @@ fun PatchAdvancedOptionsSheet(
                                             key(choice.key) {
                                                 ChoiceOptionRow(
                                                     title = choice.title,
+                                                    description = choice.description,
                                                     entries = choice.entries,
                                                     selectedIndex = state.choice(patch, choice),
+                                                    forceDropdown = choice.forceDropdown,
+                                                    disabledIndices = patch.conflictingChoices(choice)
+                                                        .map { state.choice(patch, it) }
+                                                        .filter { it != 0 }
+                                                        .toSet(),
                                                     onSelect = { state.setChoice(patch, choice, it) },
                                                 )
                                             }
@@ -200,8 +211,14 @@ fun PatchAdvancedOptionsSheet(
                         if (option.requiresOption == null) {
                             ChoiceOptionRow(
                                 title = option.title,
+                                description = option.description,
                                 entries = option.entries,
                                 selectedIndex = state.choice(patch, option),
+                                forceDropdown = option.forceDropdown,
+                                disabledIndices = patch.conflictingChoices(option)
+                                    .map { state.choice(patch, it) }
+                                    .filter { it != 0 }
+                                    .toSet(),
                                 onSelect = { state.setChoice(patch, option, it) },
                             )
                         }
@@ -209,6 +226,7 @@ fun PatchAdvancedOptionsSheet(
                     is OptionSpec.Color -> ColorOptionRow(
                         title = option.title,
                         color = state.color(patch, option),
+                        defaultColor = option.default,
                         onColorChange = { state.setColor(patch, option, it) },
                     )
                 }
@@ -373,57 +391,41 @@ private fun snapToNearestStep(
 }
 
 @Composable
-private fun ChoiceOptionRow(
+internal fun ChoiceOptionRow(
     entries: List<String>,
     selectedIndex: Int,
     onSelect: (Int) -> Unit,
     title: String = "",
+    description: String = "",
+    forceDropdown: Boolean = false,
+    disabledIndices: Set<Int> = emptySet(),
     modifier: Modifier = Modifier,
 ) {
     Column(
         modifier = modifier.fillMaxWidth(),
         verticalArrangement = Arrangement.spacedBy(6.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
+        horizontalAlignment = Alignment.Start,
     ) {
         if (title.isNotEmpty()) {
             Text(
                 text = title,
-                style = MaterialTheme.typography.labelMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
+                style = MaterialTheme.typography.titleSmall,
             )
         }
-        if (entries.size > 3) {
-            var expanded by rememberSaveable { mutableStateOf(false) }
-            val selectedLabel = entries.getOrNull(selectedIndex).orEmpty()
-
-            Box(modifier = Modifier.fillMaxWidth()) {
-                OutlinedButton(
-                    onClick = { expanded = true },
-                    modifier = Modifier.fillMaxWidth(),
-                ) {
-                    Text(
-                        text = selectedLabel,
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis,
-                    )
-                }
-                DropdownMenu(
-                    expanded = expanded,
-                    onDismissRequest = { expanded = false },
-                    modifier = Modifier.fillMaxWidth(),
-                ) {
-                    entries.forEachIndexed { index, entry ->
-                        DropdownMenuItem(
-                            text = { Text(entry) },
-                            onClick = {
-                                onSelect(index)
-                                expanded = false
-                            },
-                        )
-                    }
-                }
-            }
+        if (description.isNotEmpty()) {
+            Text(
+                text = description,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        if (forceDropdown || entries.size > 3) {
+            RadiantDropdown(
+                options = entries,
+                selectedIndex = selectedIndex,
+                onSelect = onSelect,
+                disabledIndices = disabledIndices,
+            )
             return@Column
         }
         SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
@@ -431,6 +433,7 @@ private fun ChoiceOptionRow(
                 SegmentedButton(
                     selected = index == selectedIndex,
                     onClick = { onSelect(index) },
+                    enabled = index !in disabledIndices,
                     shape = SegmentedButtonDefaults.itemShape(index = index, count = entries.size),
                     icon = {},
                     label = {
@@ -452,17 +455,34 @@ private fun ChoiceOptionRow(
 private fun ColorOptionRow(
     title: String,
     color: Int,
+    defaultColor: Int,
     onColorChange: (Int) -> Unit,
 ) {
     var showPicker by rememberSaveable { mutableStateOf(false) }
     val selectedColor = color.withOpaqueAlpha()
-    val materialYouColor = MaterialTheme.colorScheme.primary.toArgb().withOpaqueAlpha()
-    val presets = listOf(
-        stringResource(R.string.patch_waze_color_waze_default),
-        stringResource(R.string.patch_waze_color_tidal_cyan),
-        stringResource(R.string.patch_waze_color_material_you),
-    )
-    val presetColors = listOf(WAZE_DEFAULT, TIDAL_CYAN, materialYouColor)
+    val isNeutralPalette = defaultColor.withOpaqueAlpha() == NEUTRAL
+    val presets = if (isNeutralPalette) {
+        listOf(
+            stringResource(R.string.patch_color_neutral),
+            stringResource(R.string.patch_color_green),
+            stringResource(R.string.patch_color_cyan),
+        )
+    } else {
+        listOf(
+            stringResource(R.string.patch_waze_color_waze_default),
+            stringResource(R.string.patch_waze_color_tidal_cyan),
+            stringResource(R.string.patch_waze_color_material_you),
+        )
+    }
+    val presetColors = if (isNeutralPalette) {
+        listOf(NEUTRAL, GREEN, CYAN)
+    } else {
+        listOf(
+            defaultColor.withOpaqueAlpha(),
+            TIDAL_CYAN,
+            MaterialTheme.colorScheme.primary.toArgb().withOpaqueAlpha(),
+        )
+    }
     val selectedPreset = presetColors.indexOf(selectedColor)
 
     Column(
@@ -490,6 +510,12 @@ private fun ColorOptionRow(
                 style = MaterialTheme.typography.labelLarge,
                 color = MaterialTheme.colorScheme.primary,
             )
+            Icon(
+                painter = painterResource(R.drawable.ic_edit),
+                contentDescription = stringResource(R.string.patch_color_edit),
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(18.dp),
+            )
         }
         SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
             presets.forEachIndexed { index, label ->
@@ -625,7 +651,9 @@ private fun formatSliderValue(option: OptionSpec.Slider, value: Float): String {
 }
 
 private const val OPAQUE_ALPHA = -0x1000000
-private const val WAZE_DEFAULT = -16747037 // #ff0075e3
+private const val NEUTRAL = -14408663 // #ff242429
+private const val GREEN = -14749031 // #ff1ef299
+private const val CYAN = -14748953 // #ff1ef2e7
 private const val TIDAL_CYAN = -14549268 // #ff21feec
 
 private fun Int.withOpaqueAlpha(): Int = (this and 0x00FFFFFF) or OPAQUE_ALPHA

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/legacy/screens/patchopts/components/PatchSelectionAccordion.kt

@@ -22,13 +22,18 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.fromHtml
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
 import com.meowarex.rlmobile.R
+import com.meowarex.rlmobile.pebble.PebbleWatchapp
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionSpec
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchLock
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptionState
@@ -36,6 +41,8 @@ import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptions
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchSpec
 import com.meowarex.rlmobile.ui.screens.patchopts.effectiveVariants
 import com.meowarex.rlmobile.ui.screens.patchopts.resolveVariantIndex
+import com.meowarex.rlmobile.ui.screens.patchopts.conflictingChoices
+import com.meowarex.rlmobile.ui.screens.patchopts.isInline
 
 private data class LockInfo(val patch: PatchSpec, val lock: PatchLock)
 
@@ -131,11 +138,11 @@ fun PatchSelectionAccordion(
                     val checked = isEnabled(patch)
                     val lock = lockState(patch)
 
-                    val inlineToggles = patch.advancedOptions
-                        .filterIsInstance<OptionSpec.Toggle>()
-                        .filter { it.inline }
-                    val hasSheetOptions = patch.advancedOptions.any { it !is OptionSpec.Toggle || !it.inline }
-                    val hasSettings = patch.variants.isNotEmpty() || inlineToggles.isNotEmpty() || hasSheetOptions
+                    val inlineOptions = patch.advancedOptions.filter { it.isInline }
+                    val hasSheetOptions = patch.advancedOptions.any { !it.isInline }
+                    val companionApp = patch.companionApp
+                    val hasSettings = patch.variants.isNotEmpty() || inlineOptions.isNotEmpty() || hasSheetOptions ||
+                        companionApp != null
 
                     // When a patch is enabled and has settings show a carded view of the settings
                     val carded = checked && hasSettings
@@ -191,16 +198,41 @@ fun PatchSelectionAccordion(
                                         )
                                     }
 
-                                    for (option in inlineToggles) key(option.key) {
-                                        val show = option.requiresVariant == null ||
-                                            option.requiresVariant == resolvedVariant
-                                        if (show) {
-                                            InlineToggleRow(
-                                                title = option.title,
-                                                description = option.description,
-                                                checked = optionState.toggle(patch, option),
-                                                onCheckedChange = { optionState.setToggle(patch, option, it) },
-                                            )
+                                    for (option in inlineOptions) key(option.key) {
+                                        when (option) {
+                                            is OptionSpec.Toggle -> {
+                                                val show = option.requiresVariant == null ||
+                                                    option.requiresVariant == resolvedVariant
+                                                if (show) {
+                                                    InlineToggleRow(
+                                                        title = option.title,
+                                                        description = option.description,
+                                                        checked = optionState.toggle(patch, option),
+                                                        onCheckedChange = { optionState.setToggle(patch, option, it) },
+                                                    )
+                                                }
+                                            }
+                                            is OptionSpec.Choice -> {
+                                                val requiredToggle = option.requiresOption?.let { key ->
+                                                    patch.advancedOptions.filterIsInstance<OptionSpec.Toggle>()
+                                                        .firstOrNull { it.key == key }
+                                                }
+                                                if (requiredToggle == null || optionState.toggle(patch, requiredToggle)) {
+                                                    ChoiceOptionRow(
+                                                        title = option.title,
+                                                        description = option.description,
+                                                        entries = option.entries,
+                                                        selectedIndex = optionState.choice(patch, option),
+                                                        forceDropdown = option.forceDropdown,
+                                                        disabledIndices = patch.conflictingChoices(option)
+                                                            .map { optionState.choice(patch, it) }
+                                                            .filter { it != 0 }
+                                                            .toSet(),
+                                                        onSelect = { optionState.setChoice(patch, option, it) },
+                                                    )
+                                                }
+                                            }
+                                            else -> Unit
                                         }
                                     }
 
@@ -215,6 +247,56 @@ fun PatchSelectionAccordion(
                                             )
                                         }
                                     }
+
+                                    if (companionApp != null) {
+                                        val context = LocalContext.current
+                                        val lifecycleOwner = LocalLifecycleOwner.current
+                                        var installState by remember { mutableStateOf(PebbleWatchapp.InstallState.Unknown) }
+                                        // Recheck on resume
+                                        LaunchedEffect(lifecycleOwner) {
+                                            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                                                installState = PebbleWatchapp.installState(context)
+                                            }
+                                        }
+                                        val installed = installState == PebbleWatchapp.InstallState.Installed
+                                        Row(
+                                            horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally),
+                                            modifier = Modifier.fillMaxWidth(),
+                                        ) {
+                                            FilledTonalButton(
+                                                onClick = { PebbleWatchapp.install(context, companionApp) },
+                                                enabled = !installed && PebbleWatchapp.canInstall(companionApp),
+                                                modifier = Modifier.weight(1f),
+                                            ) {
+                                                Icon(
+                                                    painter = painterResource(if (installed) R.drawable.ic_check_circle else R.drawable.ic_download),
+                                                    contentDescription = null,
+                                                    modifier = Modifier.size(18.dp),
+                                                )
+                                                Spacer(Modifier.width(8.dp))
+                                                Text(
+                                                    if (installed) {
+                                                        stringResource(R.string.patchopts_companion_installed)
+                                                    } else {
+                                                        companionApp.installTitle.ifBlank { stringResource(R.string.patchopts_companion_install) }
+                                                    }
+                                                )
+                                            }
+                                            FilledTonalButton(
+                                                onClick = { PebbleWatchapp.openSettings(context) },
+                                                enabled = installed,
+                                                modifier = Modifier.weight(1f),
+                                            ) {
+                                                Icon(
+                                                    painter = painterResource(R.drawable.ic_tune),
+                                                    contentDescription = null,
+                                                    modifier = Modifier.size(18.dp),
+                                                )
+                                                Spacer(Modifier.width(8.dp))
+                                                Text(companionApp.customizeTitle.ifBlank { stringResource(R.string.patchopts_companion_customize) })
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/home/HomeModel.kt

@@ -34,6 +34,9 @@ import com.meowarex.rlmobile.ui.util.TidalVersion
 import com.meowarex.rlmobile.ui.widgets.managerupdate.VersionDelta
 import com.meowarex.rlmobile.util.*
 import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.serialization.json.Json
@@ -53,9 +56,22 @@ class HomeModel(
     var managerUpdateDeltas by mutableStateOf<List<VersionDelta>?>(null)
         private set
 
-    val commits = Pager(PagingConfig(pageSize = 30)) {
-        CommitsPagingSource(github)
-    }.flow.cachedIn(screenModelScope)
+    /** Whether a user-initiated refresh is currently in flight */
+    var refreshing by mutableStateOf(false)
+        private set
+
+    // Bumped by every forced refresh, which restarts the pager with a fresh (cache-skipping) source.
+    // Without this the commit list would stay pinned to whatever it loaded on process start.
+    private val commitsGeneration = MutableStateFlow(0)
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    val commits = commitsGeneration
+        .flatMapLatest { generation ->
+            Pager(PagingConfig(pageSize = 30)) {
+                CommitsPagingSource(github, force = generation > 0)
+            }.flow
+        }
+        .cachedIn(screenModelScope)
 
     private val refreshingLock = Mutex()
     private var remoteDataJson: RLBuildInfo? = null
@@ -164,7 +180,10 @@ class HomeModel(
         )
     }
 
-    fun refresh(delay: Boolean = false) = screenModelScope.launchIO {
+    /**
+     * @param delay Waits a moment before starting
+     */
+    fun refresh(delay: Boolean = false, force: Boolean = false) = screenModelScope.launchIO {
         if (refreshingLock.isLocked) return@launchIO
         if (delay) {
             delay(250)
@@ -172,26 +191,32 @@ class HomeModel(
         }
 
         refreshingLock.withLock {
-            val pkg = fetchInstalled()
-            // Skip the remote fetch entirely when offline
-            val online = application.isOnline()
-            if (online) {
-                val remote = async(Dispatchers.IO) { if (remoteDataJson == null) fetchRemoteData() }
-                remote.await()
-            }
+            if (force) mainThread { refreshing = true }
+            try {
+                val pkg = fetchInstalled()
+                // Skip the remote fetch entirely when offline
+                val online = application.isOnline()
+                if (online && (force || remoteDataJson == null)) {
+                    fetchRemoteData(force)
+                }
+                // Offline the reload would only replace the visible list with a load error
+                if (force && online) commitsGeneration.update { it + 1 }
 
-            val install = pkg?.toInstallData()
-            val latest = remoteDataJson?.tidalVersionCode
-            val offlineRepatchReady = hasOfflineRepatchAssets()
+                val install = pkg?.toInstallData()
+                val latest = remoteDataJson?.tidalVersionCode
+                val offlineRepatchReady = hasOfflineRepatchAssets()
 
-            mainThread {
-                state = HomeState.Loaded(
-                    install = install,
-                    latestTidalVersionCode = latest,
-                    offline = !online,
-                    offlineRepatchReady = offlineRepatchReady,
-                )
-                maybeCheckManagerUpdate(pkg)
+                mainThread {
+                    state = HomeState.Loaded(
+                        install = install,
+                        latestTidalVersionCode = latest,
+                        offline = !online,
+                        offlineRepatchReady = offlineRepatchReady,
+                    )
+                    maybeCheckManagerUpdate(pkg)
+                }
+            } finally {
+                if (force) mainThread { refreshing = false }
             }
         }
     }
@@ -283,9 +308,9 @@ class HomeModel(
             paths.hasCachedSmaliPatches(info.data.patchesVersion)
     }
 
-    private suspend fun fetchRemoteData() {
+    private suspend fun fetchRemoteData(force: Boolean = false) {
         val release = try {
-            github.getLatestRelease().fold(
+            github.getLatestRelease(force).fold(
                 success = { it },
                 fail = { Log.w(BuildConfig.TAG, "Failed to fetch latest release", it); return },
             )
@@ -299,7 +324,7 @@ class HomeModel(
             ?.browserDownloadUrl
             ?: return
 
-        github.getBuildInfo(dataJsonUrl).fold(
+        github.getBuildInfo(dataJsonUrl, force).fold(
             success = { remoteDataJson = it },
             fail = { Log.w(BuildConfig.TAG, "Failed to fetch build info", it) },
         )

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/home/HomeScreen.kt

@@ -3,6 +3,11 @@ package com.meowarex.rlmobile.ui.screens.home
 import android.os.Parcelable
 import androidx.activity.ComponentActivity
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.basicMarquee
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -14,6 +19,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.graphics.painter.BitmapPainter
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalContext
@@ -70,6 +76,8 @@ class HomeScreen : Screen, Parcelable {
         val activity = LocalContext.current as ComponentActivity
         val updater = koinViewModel<UpdaterViewModel>(viewModelStoreOwner = activity)
         val managerUpdateAvailable = updater.targetVersion != null
+        val refreshing = model.refreshing
+        val refreshAngle = rememberRefreshAngle()
 
         LifecycleResumeEffect(Unit) {
             model.refresh(delay = true)
@@ -86,7 +94,14 @@ class HomeScreen : Screen, Parcelable {
                             icon = painterResource(R.drawable.ic_refresh),
                             contentDescription = stringResource(R.string.navigation_refresh),
                             subtle = true,
-                            onClick = { model.refresh() },
+                            enabled = !refreshing,
+                            onClick = {
+                                model.refresh(force = true)
+                                updater.checkForUpdates(force = true)
+                            },
+                            modifier = Modifier.graphicsLayer {
+                                rotationZ = if (refreshing) refreshAngle() else 0f
+                            },
                         )
                         if (managerUpdateAvailable) {
                             RadiantIconButton(
@@ -364,3 +379,18 @@ private fun HeroContainer(
         Column(modifier = Modifier.fillMaxWidth(), content = content)
     }
 }
+
+/**
+ * Refresh Spinner thing
+ */
+@Composable
+internal fun rememberRefreshAngle(): () -> Float {
+    val transition = rememberInfiniteTransition(label = "RefreshSpin")
+    val angle by transition.animateFloat(
+        initialValue = 0f,
+        targetValue = 360f,
+        animationSpec = infiniteRepeatable(tween(900, easing = LinearEasing)),
+        label = "RefreshSpinAngle",
+    )
+    return { angle }
+}

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/patchopts/PatchOptionsModel.kt

@@ -179,7 +179,12 @@ class PatchOptionsModel(
 
     fun setChoiceValue(spec: PatchSpec, option: OptionSpec.Choice, index: Int) {
         if (index !in option.entries.indices) return
-        optionInts = optionInts + (keyOf(spec, option) to index)
+        val selectedKey = keyOf(spec, option)
+        optionInts = normalizeChoiceSelections(
+            specs = listOf(spec),
+            values = optionInts + (selectedKey to index),
+            preferredKey = selectedKey,
+        )
     }
 
     fun colorValue(spec: PatchSpec, option: OptionSpec.Color): Int =
@@ -190,10 +195,9 @@ class PatchOptionsModel(
     }
 
     fun isAdvancedModified(spec: PatchSpec): Boolean = spec.advancedOptions.any { option ->
+        if (option.isInline) return@any false
         when (option) {
-            // inline toggles sit next to the variant picker, not in the sheet, so they
-            // must not light up the sheet's "modified" dot
-            is OptionSpec.Toggle -> !option.inline && toggleValue(spec, option) != option.default
+            is OptionSpec.Toggle -> toggleValue(spec, option) != option.default
             is OptionSpec.Slider -> sliderValue(spec, option) != option.default
             is OptionSpec.Choice -> choiceValue(spec, option) != option.defaultIndex
             is OptionSpec.Color -> colorValue(spec, option) != option.default
@@ -201,10 +205,22 @@ class PatchOptionsModel(
     }
 
     fun resetAdvanced(spec: PatchSpec) {
-        val prefix = "${spec.id}/"
-        optionBools = optionBools.filterKeys { !it.startsWith(prefix) }
-        optionFloats = optionFloats.filterKeys { !it.startsWith(prefix) }
-        optionInts = optionInts.filterKeys { !it.startsWith(prefix) }
+        val advancedOptions = spec.advancedOptions.filter { !it.isInline }
+        val boolKeys = advancedOptions.filterIsInstance<OptionSpec.Toggle>().map { keyOf(spec, it) }.toSet()
+        val floatKeys = advancedOptions.filterIsInstance<OptionSpec.Slider>().map { keyOf(spec, it) }.toSet()
+        val intKeys = advancedOptions.filter { it is OptionSpec.Choice || it is OptionSpec.Color }
+            .map { keyOf(spec, it) }
+            .toSet()
+        optionBools = optionBools.filterKeys { it !in boolKeys }
+        optionFloats = optionFloats.filterKeys { it !in floatKeys }
+        optionInts = normalizeChoiceSelections(
+            specs = listOf(spec),
+            values = optionInts.filterKeys { it !in intKeys },
+        )
+    }
+
+    private fun normalizeChoiceSelections(specs: List<PatchSpec>) {
+        optionInts = normalizeChoiceSelections(specs, optionInts)
     }
 
     val optionState: PatchOptionState = PatchOptionState(
@@ -222,7 +238,6 @@ class PatchOptionsModel(
 
     fun lockState(spec: PatchSpec): PatchLock {
         if (isBlockedByPackageName(spec)) return PatchLock.RequiresDefaultPackage
-        if (spec.variants.isNotEmpty()) return PatchLock.Free
 
         val byId = specs.associateBy { it.id }
         fun closure(seed: PatchSpec, step: (PatchSpec) -> List<PatchSpec>): Set<PatchSpec> =
@@ -238,7 +253,14 @@ class PatchOptionsModel(
             if (other.id == spec.id || !isPatchEnabled(other)) continue
 
             val requiresClosure = closure(other, requiresOf)
-            if (spec in requiresClosure - other) return PatchLock.LockedOn(other)
+            // A spec with variants is a multi-choice control, so there is no single state to
+            // force it *on* into - hence the exemption here. Forcing it *off* is unambiguous, so
+            // the disables check below still applies to it. Skipping both left LyricsRlApi and
+            // PlayerBackdrop tappable under Legacy UI even though setPatchEnabled had already
+            // switched them off, letting the user turn a patch back on that cannot work.
+            if (spec.variants.isEmpty() && spec in requiresClosure - other) {
+                return PatchLock.LockedOn(other)
+            }
 
             val disablesClosure = requiresClosure.flatMap { it.disables }
                 .mapNotNull(byId::get)
@@ -282,6 +304,7 @@ class PatchOptionsModel(
         val loaded = if (component == null) builtinSpecs else loadManifestSpecs(component) ?: builtinSpecs
         mainThread {
             specs = loaded
+            normalizeChoiceSelections(loaded)
             validatePatchSelection()
             specsLoading = false
         }
@@ -351,6 +374,7 @@ class PatchOptionsModel(
             ?: loadCachedReleaseManifestSpecs() ?: builtinSpecs
         mainThread {
             specs = loaded
+            normalizeChoiceSelections(loaded)
             validatePatchSelection()
             specsLoading = false
         }
@@ -415,6 +439,7 @@ class PatchOptionsModel(
     }
 
     init {
+        normalizeChoiceSelections(specs)
         validatePatchSelection()
         screenModelScope.launchBlock { fetchPkgNameState() }
         // Default source is the latest release's manifest; custom selections drive themselves.

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/patchopts/PatchSpec.kt

@@ -1,6 +1,7 @@
 package com.meowarex.rlmobile.ui.screens.patchopts
 
 import android.content.Context
+import android.os.Build
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.Stable
 import kotlinx.serialization.SerialName
@@ -33,6 +34,8 @@ data class PatchSpec(
     val advancedOptions: List<OptionSpec> = emptyList(),
     val category: String = CATEGORY_PATCH,
     val pathLocked: Boolean = false,
+    /** Watchapp shown under an integration. */
+    val companionApp: CompanionAppSpec? = null,
 ) {
     val isIntegration: Boolean get() = category == CATEGORY_INTEGRATION
 
@@ -42,6 +45,17 @@ data class PatchSpec(
     }
 }
 
+@Immutable
+@Serializable
+data class CompanionAppSpec(
+    val installTitle: String = "",
+    val customizeTitle: String = "",
+    /** Pebble appstore id. */
+    val storeId: String? = null,
+    /** Appstore feed url. */
+    val storeSource: String? = null,
+)
+
 @Immutable
 @Serializable
 data class VariantSpec(
@@ -49,7 +63,13 @@ data class VariantSpec(
     val fileNames: List<String> = emptyList(),
     val extensionFiles: List<String> = emptyList(),
     val enabled: Boolean = true,
-)
+    /**
+     * Hidden from the picker on devices below this API level (AGSL needs 33)
+     */
+    val minSdk: Int = 0,
+) {
+    val supportedHere: Boolean get() = Build.VERSION.SDK_INT >= minSdk
+}
 
 /** A single advanced option. Discriminated by `"type"` in JSON. */
 @Serializable
@@ -101,6 +121,8 @@ sealed interface OptionSpec {
         val token: String? = null,
         /** How the chosen value becomes the smali literal that replaces the token. */
         val encode: SmaliEncode? = null,
+        /** Hidden unless this variant index is the selected one. */
+        val requiresVariant: Int? = null,
     ) : OptionSpec {
         val valueRange: ClosedFloatingPointRange<Float> get() = min..max
     }
@@ -116,6 +138,10 @@ sealed interface OptionSpec {
         val defaultIndex: Int = 0,
         val values: List<String> = emptyList(),
         val requiresOption: String? = null,
+        val forceDropdown: Boolean = false,
+        /** Render inline in the patch card instead of inside the advanced sheet */
+        val inline: Boolean = false,
+        val distinctFrom: String? = null,
         val token: String? = null,
     ) : OptionSpec
 
@@ -132,6 +158,13 @@ sealed interface OptionSpec {
     ) : OptionSpec
 }
 
+val OptionSpec.isInline: Boolean
+    get() = when (this) {
+        is OptionSpec.Toggle -> inline
+        is OptionSpec.Choice -> inline
+        is OptionSpec.Slider, is OptionSpec.Color -> false
+    }
+
 @Serializable
 enum class EncodeKind {
     @SerialName("floatBits")
@@ -187,7 +220,9 @@ fun PatchSpec.effectiveVariants(isOptionOn: (OptionSpec.Toggle) -> Boolean): Lis
         }
     }
     return variants.mapIndexedNotNull { index, variant ->
-        if (index in hidden) null
+        // Everything downstream (variantIndex -> resolveVariantIndex) picks from this list, so
+        // dropping an unsupported variant here also keeps the patcher from ever applying it.
+        if (index in hidden || !variant.supportedHere) null
         else EffectiveVariant(index, relabel[index] ?: variant.title, variant.enabled)
     }
 }
@@ -206,6 +241,55 @@ fun PatchSpec.resolveVariantIndex(stored: Int, isOptionOn: (OptionSpec.Toggle) -
         ?: visible.first().originalIndex
 }
 
+/**
+ * The variant this option belongs to
+ */
+val OptionSpec.variantGate: Int?
+    get() = when (this) {
+        is OptionSpec.Toggle -> requiresVariant
+        is OptionSpec.Slider -> requiresVariant
+        is OptionSpec.Choice -> null
+        is OptionSpec.Color -> null
+    }
+
+fun OptionSpec.hiddenForVariant(selectedVariant: Int): Boolean =
+    variantGate.let { it != null && it != selectedVariant }
+
+fun PatchSpec.conflictingChoices(option: OptionSpec.Choice): List<OptionSpec.Choice> =
+    advancedOptions.filterIsInstance<OptionSpec.Choice>().filter { other ->
+        other.key != option.key &&
+                (option.distinctFrom == other.key || other.distinctFrom == option.key)
+    }
+
+internal fun normalizeChoiceSelections(
+    specs: List<PatchSpec>,
+    values: Map<String, Int>,
+    preferredKey: String? = null,
+): Map<String, Int> {
+    val normalized = values.toMutableMap()
+    for (spec in specs) {
+        val choices = spec.advancedOptions.filterIsInstance<OptionSpec.Choice>()
+        fun fullKey(option: OptionSpec.Choice) = "${spec.id}/${option.key}"
+        fun selected(option: OptionSpec.Choice): Int =
+            (normalized[fullKey(option)] ?: option.defaultIndex)
+                .coerceIn(0, option.entries.lastIndex.coerceAtLeast(0))
+
+        for (leftIndex in choices.indices) {
+            val left = choices[leftIndex]
+            for (rightIndex in leftIndex + 1 until choices.size) {
+                val right = choices[rightIndex]
+                if (left.distinctFrom != right.key && right.distinctFrom != left.key) continue
+                val selected = selected(left)
+                if (selected == 0 || selected != selected(right)) continue
+
+                val loser = if (preferredKey == fullKey(right)) left else right
+                normalized[fullKey(loser)] = 0
+            }
+        }
+    }
+    return if (normalized == values) values else normalized
+}
+
 sealed interface OptionLock {
     data object Free : OptionLock
     data class NeedsVariant(val title: String) : OptionLock

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/patchopts/components/PatchAdvancedOptionsSheet.kt

@@ -32,6 +32,7 @@ import androidx.compose.ui.unit.dp
 import com.meowarex.rlmobile.R
 import com.meowarex.rlmobile.ui.components.radiant.RadiantButton
 import com.meowarex.rlmobile.ui.components.radiant.RadiantDialog
+import com.meowarex.rlmobile.ui.components.radiant.RadiantDropdown
 import com.meowarex.rlmobile.ui.components.radiant.RadiantButtonSize
 import com.meowarex.rlmobile.ui.components.radiant.RadiantButtonStyle
 import com.meowarex.rlmobile.ui.components.radiant.RadiantIconButton
@@ -43,6 +44,9 @@ import com.meowarex.rlmobile.ui.components.ResetToDefaultButton
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionLock
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionSpec
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptionState
+import com.meowarex.rlmobile.ui.screens.patchopts.conflictingChoices
+import com.meowarex.rlmobile.ui.screens.patchopts.hiddenForVariant
+import com.meowarex.rlmobile.ui.screens.patchopts.isInline
 import com.meowarex.rlmobile.ui.screens.patchopts.optionLock
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchSpec
 import kotlinx.coroutines.launch
@@ -108,13 +112,15 @@ fun PatchAdvancedOptionsSheet(
 
             val parentKeys = patch.advancedOptions
                 .filterIsInstance<OptionSpec.Toggle>()
-                .filter { !it.inline }
+                .filter { !it.isInline }
                 .map { it.key }
                 .toSet()
             val sheetOptions = patch.advancedOptions.filter { option ->
                 when {
-                    option is OptionSpec.Toggle && option.inline -> false
+                    option.isInline -> false
                     option is OptionSpec.Toggle && option.requiresOption in parentKeys -> false
+                    // Options belonging to another variant are hidden, not greyed out.
+                    option.hiddenForVariant(selectedVariant) -> false
                     else -> true
                 }
             }
@@ -124,7 +130,7 @@ fun PatchAdvancedOptionsSheet(
                     is OptionSpec.Toggle -> {
                         val toggleOn = state.toggle(patch, option)
                         val gatedChoices = patch.advancedOptions.filterIsInstance<OptionSpec.Choice>()
-                            .filter { it.requiresOption == option.key }
+                            .filter { it.requiresOption == option.key && !it.isInline }
                         val gatedToggles = patch.advancedOptions.filterIsInstance<OptionSpec.Toggle>()
                             .filter { it.requiresOption == option.key && !it.inline }
                         val hasSubOptions = gatedChoices.isNotEmpty() || gatedToggles.isNotEmpty()
@@ -167,8 +173,14 @@ fun PatchAdvancedOptionsSheet(
                                             key(choice.key) {
                                                 ChoiceOptionRow(
                                                     title = choice.title,
+                                                    description = choice.description,
                                                     entries = choice.entries,
                                                     selectedIndex = state.choice(patch, choice),
+                                                    forceDropdown = choice.forceDropdown,
+                                                    disabledIndices = patch.conflictingChoices(choice)
+                                                        .map { state.choice(patch, it) }
+                                                        .filter { it != 0 }
+                                                        .toSet(),
                                                     onSelect = { state.setChoice(patch, choice, it) },
                                                 )
                                             }
@@ -206,8 +218,14 @@ fun PatchAdvancedOptionsSheet(
                         if (option.requiresOption == null) {
                             ChoiceOptionRow(
                                 title = option.title,
+                                description = option.description,
                                 entries = option.entries,
                                 selectedIndex = state.choice(patch, option),
+                                forceDropdown = option.forceDropdown,
+                                disabledIndices = patch.conflictingChoices(option)
+                                    .map { state.choice(patch, it) }
+                                    .filter { it != 0 }
+                                    .toSet(),
                                 onSelect = { state.setChoice(patch, option, it) },
                             )
                         }
@@ -215,6 +233,7 @@ fun PatchAdvancedOptionsSheet(
                     is OptionSpec.Color -> ColorOptionRow(
                         title = option.title,
                         color = state.color(patch, option),
+                        defaultColor = option.default,
                         onColorChange = { state.setColor(patch, option, it) },
                     )
                 }
@@ -354,6 +373,7 @@ private fun SliderOptionRow(
                 value = value,
                 onValueChange = onValueChange,
                 valueRange = valueRange,
+                showStopIndicator = false,
             )
         }
     }
@@ -372,59 +392,48 @@ private fun snapToNearestStep(
 }
 
 @Composable
-private fun ChoiceOptionRow(
+internal fun ChoiceOptionRow(
     entries: List<String>,
     selectedIndex: Int,
     onSelect: (Int) -> Unit,
     title: String = "",
+    description: String = "",
+    forceDropdown: Boolean = false,
+    disabledIndices: Set<Int> = emptySet(),
     modifier: Modifier = Modifier,
 ) {
     Column(
         modifier = modifier.fillMaxWidth(),
         verticalArrangement = Arrangement.spacedBy(6.dp),
-        horizontalAlignment = Alignment.CenterHorizontally,
+        horizontalAlignment = Alignment.Start,
     ) {
         if (title.isNotEmpty()) {
             Text(
                 text = title,
-                style = MaterialTheme.typography.labelMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
+                style = MaterialTheme.typography.titleSmall,
             )
         }
-        if (entries.size > 3) {
-            var expanded by rememberSaveable { mutableStateOf(false) }
-            val selectedLabel = entries.getOrNull(selectedIndex).orEmpty()
-
-            Box(modifier = Modifier.fillMaxWidth()) {
-                RadiantButton(
-                    text = selectedLabel,
-                    onClick = { expanded = true },
-                    style = RadiantButtonStyle.Ghost,
-                    fillWidth = true,
-                )
-                DropdownMenu(
-                    expanded = expanded,
-                    onDismissRequest = { expanded = false },
-                    modifier = Modifier.fillMaxWidth(),
-                ) {
-                    entries.forEachIndexed { index, entry ->
-                        DropdownMenuItem(
-                            text = { Text(entry) },
-                            onClick = {
-                                onSelect(index)
-                                expanded = false
-                            },
-                        )
-                    }
-                }
-            }
+        if (description.isNotEmpty()) {
+            Text(
+                text = description,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        if (forceDropdown || entries.size > 3) {
+            RadiantDropdown(
+                options = entries,
+                selectedIndex = selectedIndex,
+                onSelect = onSelect,
+                disabledIndices = disabledIndices,
+            )
             return@Column
         }
         RadiantSegmented(
             options = entries,
             selectedIndex = selectedIndex,
             onSelect = onSelect,
+            disabledIndices = disabledIndices,
         )
     }
 }
@@ -433,17 +442,34 @@ private fun ChoiceOptionRow(
 private fun ColorOptionRow(
     title: String,
     color: Int,
+    defaultColor: Int,
     onColorChange: (Int) -> Unit,
 ) {
     var showPicker by rememberSaveable { mutableStateOf(false) }
     val selectedColor = color.withOpaqueAlpha()
-    val materialYouColor = MaterialTheme.colorScheme.primary.toArgb().withOpaqueAlpha()
-    val presets = listOf(
-        stringResource(R.string.patch_waze_color_waze_default),
-        stringResource(R.string.patch_waze_color_tidal_cyan),
-        stringResource(R.string.patch_waze_color_material_you),
-    )
-    val presetColors = listOf(WAZE_DEFAULT, TIDAL_CYAN, materialYouColor)
+    val isNeutralPalette = defaultColor.withOpaqueAlpha() == NEUTRAL
+    val presets = if (isNeutralPalette) {
+        listOf(
+            stringResource(R.string.patch_color_neutral),
+            stringResource(R.string.patch_color_green),
+            stringResource(R.string.patch_color_cyan),
+        )
+    } else {
+        listOf(
+            stringResource(R.string.patch_waze_color_waze_default),
+            stringResource(R.string.patch_waze_color_tidal_cyan),
+            stringResource(R.string.patch_waze_color_material_you),
+        )
+    }
+    val presetColors = if (isNeutralPalette) {
+        listOf(NEUTRAL, GREEN, CYAN)
+    } else {
+        listOf(
+            defaultColor.withOpaqueAlpha(),
+            TIDAL_CYAN,
+            MaterialTheme.colorScheme.primary.toArgb().withOpaqueAlpha(),
+        )
+    }
     val selectedPreset = presetColors.indexOf(selectedColor)
 
     Column(
@@ -471,6 +497,12 @@ private fun ColorOptionRow(
                 style = MaterialTheme.typography.labelLarge,
                 color = MaterialTheme.colorScheme.primary,
             )
+            Icon(
+                painter = painterResource(R.drawable.ic_edit),
+                contentDescription = stringResource(R.string.patch_color_edit),
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(18.dp),
+            )
         }
         RadiantSegmented(
             options = presets,
@@ -584,7 +616,9 @@ private fun formatSliderValue(option: OptionSpec.Slider, value: Float): String {
 }
 
 private const val OPAQUE_ALPHA = -0x1000000
-private const val WAZE_DEFAULT = -16747037 // #ff0075e3
+private const val NEUTRAL = -14408663 // #ff242429
+private const val GREEN = -14749031 // #ff1ef299
+private const val CYAN = -14748953 // #ff1ef2e7
 private const val TIDAL_CYAN = -14549268 // #ff21feec
 
 private fun Int.withOpaqueAlpha(): Int = (this and 0x00FFFFFF) or OPAQUE_ALPHA

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/screens/patchopts/components/PatchSelectionAccordion.kt

@@ -19,13 +19,18 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.fromHtml
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
 import com.meowarex.rlmobile.R
+import com.meowarex.rlmobile.pebble.PebbleWatchapp
 import com.meowarex.rlmobile.ui.components.radiant.RadiantButton
 import com.meowarex.rlmobile.ui.components.radiant.RadiantButtonSize
 import com.meowarex.rlmobile.ui.components.radiant.RadiantSwitch
@@ -33,6 +38,8 @@ import com.meowarex.rlmobile.ui.components.radiant.RadiantDialog
 import com.meowarex.rlmobile.ui.theme.radiantSurface
 import com.meowarex.rlmobile.ui.theme.glassSurface
 import com.meowarex.rlmobile.ui.screens.patchopts.OptionSpec
+import com.meowarex.rlmobile.ui.screens.patchopts.conflictingChoices
+import com.meowarex.rlmobile.ui.screens.patchopts.isInline
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchLock
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptionState
 import com.meowarex.rlmobile.ui.screens.patchopts.PatchOptions
@@ -134,11 +141,11 @@ fun PatchSelectionAccordion(
                     val checked = isEnabled(patch)
                     val lock = lockState(patch)
 
-                    val inlineToggles = patch.advancedOptions
-                        .filterIsInstance<OptionSpec.Toggle>()
-                        .filter { it.inline }
-                    val hasSheetOptions = patch.advancedOptions.any { it !is OptionSpec.Toggle || !it.inline }
-                    val hasSettings = patch.variants.isNotEmpty() || inlineToggles.isNotEmpty() || hasSheetOptions
+                    val inlineOptions = patch.advancedOptions.filter { it.isInline }
+                    val hasSheetOptions = patch.advancedOptions.any { !it.isInline }
+                    val companionApp = patch.companionApp
+                    val hasSettings = patch.variants.isNotEmpty() || inlineOptions.isNotEmpty() || hasSheetOptions ||
+                        companionApp != null
 
                     // When a patch is enabled and has settings show a carded view of the settings
                     val carded = checked && hasSettings
@@ -189,16 +196,41 @@ fun PatchSelectionAccordion(
                                         )
                                     }
 
-                                    for (option in inlineToggles) key(option.key) {
-                                        val show = option.requiresVariant == null ||
-                                            option.requiresVariant == resolvedVariant
-                                        if (show) {
-                                            InlineToggleRow(
-                                                title = option.title,
-                                                description = option.description,
-                                                checked = optionState.toggle(patch, option),
-                                                onCheckedChange = { optionState.setToggle(patch, option, it) },
-                                            )
+                                    for (option in inlineOptions) key(option.key) {
+                                        when (option) {
+                                            is OptionSpec.Toggle -> {
+                                                val show = option.requiresVariant == null ||
+                                                    option.requiresVariant == resolvedVariant
+                                                if (show) {
+                                                    InlineToggleRow(
+                                                        title = option.title,
+                                                        description = option.description,
+                                                        checked = optionState.toggle(patch, option),
+                                                        onCheckedChange = { optionState.setToggle(patch, option, it) },
+                                                    )
+                                                }
+                                            }
+                                            is OptionSpec.Choice -> {
+                                                val requiredToggle = option.requiresOption?.let { key ->
+                                                    patch.advancedOptions.filterIsInstance<OptionSpec.Toggle>()
+                                                        .firstOrNull { it.key == key }
+                                                }
+                                                if (requiredToggle == null || optionState.toggle(patch, requiredToggle)) {
+                                                    ChoiceOptionRow(
+                                                        title = option.title,
+                                                        description = option.description,
+                                                        entries = option.entries,
+                                                        selectedIndex = optionState.choice(patch, option),
+                                                        forceDropdown = option.forceDropdown,
+                                                        disabledIndices = patch.conflictingChoices(option)
+                                                            .map { optionState.choice(patch, it) }
+                                                            .filter { it != 0 }
+                                                            .toSet(),
+                                                        onSelect = { optionState.setChoice(patch, option, it) },
+                                                    )
+                                                }
+                                            }
+                                            else -> Unit
                                         }
                                     }
 
@@ -213,6 +245,47 @@ fun PatchSelectionAccordion(
                                             )
                                         }
                                     }
+
+                                    if (companionApp != null) {
+                                        val context = LocalContext.current
+                                        val lifecycleOwner = LocalLifecycleOwner.current
+                                        var installState by remember { mutableStateOf(PebbleWatchapp.InstallState.Unknown) }
+                                        // Recheck on resume
+                                        LaunchedEffect(lifecycleOwner) {
+                                            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.RESUMED) {
+                                                installState = PebbleWatchapp.installState(context)
+                                            }
+                                        }
+                                        val installed = installState == PebbleWatchapp.InstallState.Installed
+                                        Row(
+                                            horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally),
+                                            modifier = Modifier.fillMaxWidth(),
+                                        ) {
+                                            RadiantButton(
+                                                text = if (installed) {
+                                                    stringResource(R.string.patchopts_companion_installed)
+                                                } else {
+                                                    companionApp.installTitle.ifBlank { stringResource(R.string.patchopts_companion_install) }
+                                                },
+                                                icon = painterResource(if (installed) R.drawable.ic_check_circle else R.drawable.ic_download),
+                                                onClick = { PebbleWatchapp.install(context, companionApp) },
+                                                enabled = !installed && PebbleWatchapp.canInstall(companionApp),
+                                                size = RadiantButtonSize.Small,
+                                                fillWidth = true,
+                                                modifier = Modifier.weight(1f),
+                                            )
+                                            RadiantButton(
+                                                text = companionApp.customizeTitle
+                                                    .ifBlank { stringResource(R.string.patchopts_companion_customize) },
+                                                icon = painterResource(R.drawable.ic_tune),
+                                                onClick = { PebbleWatchapp.openSettings(context) },
+                                                enabled = installed,
+                                                size = RadiantButtonSize.Small,
+                                                fillWidth = true,
+                                                modifier = Modifier.weight(1f),
+                                            )
+                                        }
+                                    }
                                 }
                             }
                         }

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/theme/ThemeColors.kt

@@ -33,13 +33,13 @@ private val Rose80 = Color(0xFFFFAFCC)
 private val Rose90 = Color(0xFFFFD9E4)
 private val Rose95 = Color(0xFFFFECF1)
 
-// ── Violet (secondary) ───────────────────────────────────────────────────────
-private val Violet10 = Color(0xFF25004E)
-private val Violet20 = Color(0xFF3D177A)
-private val Violet30 = Color(0xFF553194)
-private val Violet40 = Color(0xFF6E4BAF)
-private val Violet80 = Color(0xFFD6BBFF)
-private val Violet90 = Color(0xFFECDCFF)
+// ── Dusty rose (secondary) ───────────────────────────────────────────────────
+private val DustyRose10 = Color(0xFF2B0D18)
+private val DustyRose20 = Color(0xFF43202B)
+private val DustyRose30 = Color(0xFF5C3541)
+private val DustyRose40 = Color(0xFF774C58)
+private val DustyRose80 = Color(0xFFE4BCC8)
+private val DustyRose90 = Color(0xFFF5DCE4)
 
 // ── Aqua (tertiary) ──────────────────────────────────────────────────────────
 private val Aqua10 = Color(0xFF00201F)
@@ -89,10 +89,10 @@ val RadiantDarkColorScheme: ColorScheme = darkColorScheme(
     onPrimaryContainer = Rose90,
     inversePrimary = Rose40,
 
-    secondary = Violet80,
-    onSecondary = Violet20,
-    secondaryContainer = Violet30,
-    onSecondaryContainer = Violet90,
+    secondary = DustyRose80,
+    onSecondary = DustyRose20,
+    secondaryContainer = DustyRose30,
+    onSecondaryContainer = DustyRose90,
 
     tertiary = Aqua80,
     onTertiary = Aqua20,
@@ -134,10 +134,10 @@ val RadiantLightColorScheme: ColorScheme = lightColorScheme(
     onPrimaryContainer = Rose10,
     inversePrimary = Rose80,
 
-    secondary = Violet40,
+    secondary = DustyRose40,
     onSecondary = Neutral100,
-    secondaryContainer = Violet90,
-    onSecondaryContainer = Violet10,
+    secondaryContainer = DustyRose90,
+    onSecondaryContainer = DustyRose10,
 
     tertiary = Aqua40,
     onTertiary = Neutral100,

Manager/app/src/main/kotlin/com/meowarex/rlmobile/ui/widgets/updater/UpdaterViewModel.kt

@@ -37,17 +37,29 @@ class UpdaterViewModel(
         field = MutableStateFlow(null)
     val isWorking: StateFlow<Boolean>
         field = MutableStateFlow(false)
+    val isChecking: StateFlow<Boolean>
+        field = MutableStateFlow(false)
 
     private var targetApkUrl: String? = null
 
     init {
-        viewModelScope.launchIO {
-            try {
-                fetchInfo()
-            } catch (t: Throwable) {
-                Log.e(BuildConfig.TAG, "Failed to check for updates!", t)
-                mainThread { application.showToast(R.string.updater_check_fail) }
-            }
+        checkForUpdates()
+    }
+
+    /**
+     * Re-runs the update check
+     */
+    fun checkForUpdates(force: Boolean = false) = viewModelScope.launchIO {
+        if (!isChecking.compareAndSet(expect = false, update = true))
+            return@launchIO
+
+        try {
+            fetchInfo(force)
+        } catch (t: Throwable) {
+            Log.e(BuildConfig.TAG, "Failed to check for updates!", t)
+            mainThread { application.showToast(R.string.updater_check_fail) }
+        } finally {
+            isChecking.value = false
         }
     }
 
@@ -142,14 +154,14 @@ class UpdaterViewModel(
      * then finds the latest release based on the largest semantic version extracted from the tag name (`v1.0.0`),
      * and populates the state to show to the user.
      */
-    private suspend fun fetchInfo() {
+    private suspend fun fetchInfo(force: Boolean = false) {
         Log.d(BuildConfig.TAG, "Checking for updates...")
 
         val currentVersion = SemVer.parseOrNull(BuildConfig.VERSION_NAME)
             ?: throw Error("Failed to parse current app version")
 
         // Fetch releases from GitHub (60s local cache)
-        val releases = github.getManagerReleases().getOrThrow()
+        val releases = github.getManagerReleases(force).getOrThrow()
 
         // Find the latest release by parsed version
         val (version, release, apkUrl) = releases
@@ -171,12 +183,14 @@ class UpdaterViewModel(
             return
         }
 
-        Log.d(BuildConfig.TAG, "Found an update! $targetVersion $targetApkUrl")
+        Log.d(BuildConfig.TAG, "Found an update! $version $apkUrl")
+        val newVersion = version.toString()
         mainThread {
+            val alreadyKnown = targetVersion == newVersion
             targetReleaseUrl = release.htmlUrl
-            targetVersion = version.toString()
+            targetVersion = newVersion
             targetApkUrl = apkUrl
-            showDialog = true
+            if (!alreadyKnown) showDialog = true
         }
     }
 

Manager/app/src/main/res/drawable/ic_edit.xml

@@ -0,0 +1,9 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960">
+  <path
+      android:fillColor="#e8eaed"
+      android:pathData="M200,760h57l391,-391l-57,-57l-391,391v57zM160,840q-17,0 -28.5,-11.5T120,800v-97q0,-16 6,-30.5t17,-25.5l505,-504q12,-11 26.5,-17t30.5,-6q16,0 31,6t26,18l55,56q12,11 17.5,26t5.5,30q0,16 -5.5,30.5T817,313L313,817q-11,11 -25.5,17t-30.5,6h-97zM760,256l-56,-56l56,56zM619,341l-28,-29l57,57l-29,-28z" />
+</vector>

Manager/app/src/main/res/values/strings.xml

@@ -85,6 +85,10 @@
   <string name="settings_header_installation">Installation</string>
   <string name="settings_header_appearance">Appearance</string>
   <string name="settings_header_info">Info</string>
+  <string name="patchopts_companion_install">Install watchapp</string>
+  <string name="patchopts_companion_installed">Installed</string>
+  <string name="patchopts_companion_customize">Customize</string>
+  <string name="pebble_app_missing">Couldn\'t open the Pebble app. Is it installed?</string>
   <string name="setting_theme">Theme</string>
   <string name="setting_ui_style">UI style</string>
   <string name="setting_ui_style_desc">Want the old UI back?</string>
@@ -305,12 +309,16 @@
   <string name="patch_waze_browse_root_title">Media Menu</string>
   <string name="patch_waze_accent_color_title">Accent Color</string>
   <string name="patch_waze_color_waze_default">Waze Default</string>
+  <string name="patch_color_neutral">Neutral</string>
+  <string name="patch_color_green">Green</string>
+  <string name="patch_color_cyan">Cyan</string>
   <string name="patch_waze_color_tidal_cyan">TIDAL Cyan</string>
   <string name="patch_waze_color_material_you">Material You</string>
   <string name="patch_waze_root_auto">Auto Menu</string>
   <string name="patch_waze_root_home">Home</string>
   <string name="patch_waze_root_recents">Recents</string>
   <string name="patch_color_picker_title">Custom color</string>
+  <string name="patch_color_edit">Choose custom color</string>
   <string name="patch_color_picker_hex">Hex color</string>
   <string name="patch_color_picker_hex_error">Use #RRGGBB or #AARRGGBB.</string>
   <string name="patch_enable_legacy_ui_title">Enable Legacy UI</string>

Manager/gradle/libs.versions.toml

@@ -32,6 +32,7 @@ kotlinx-serialization = "1.10.0"
 ktor = "3.4.0"
 libsu = "6.0.0"
 microg = "0.3.6.244735"
+pebblekit2 = "1.3.1"
 shimmer = "1.3.3"
 shizuku = "13.1.5"
 smali = "3.0.9"
@@ -115,6 +116,7 @@ hiddenApi-stub = { module = "dev.rikka.hidden:stub", version.ref = "hiddenApi-st
 microg = { module = "org.microg.gms:play-services-safetynet", version.ref = "microg" }
 desugaring = { module = "com.android.tools:desugar_jdk_libs", version.ref = "desugaring" }
 libsu = { module = "com.aliucord.libsu:core", version.ref = "libsu" }
+pebblekit2-client = { module = "io.rebble.pebblekit2:client", version.ref = "pebblekit2" }
 
 [bundles]
 accompanist = [

README.md

@@ -21,6 +21,7 @@ Every Patch & Integration can be disabled/enabled & adjusted exactly how you wan
 ### Integrations
 
 - Waze | Control TIDAL playback from Waze
+- Pebble Watch | Synced lyrics (Line, Word or Syllable) & playback controls on your Pebble
 
 ### Disclaimer
 
@@ -94,10 +95,42 @@ Each patch file targets a specific class via its `--- a/` header — the filenam
 - Comment EACH patch line on the end with a simple 1-5 word description of what it does/or is for
 - Make sure the patch file name is descriptive of what it does
 
+### The Kawarp extension (generated smali)
+
+`patches/extension/radiant/Kawarp.smali` and `patches/extension/dev/kawarp/KawarpEngine.smali`
+are **generated — don't hand-edit them**. The engine comes from the
+[Kawarp-AGSL](https://github.com/meowarex/kawarp-agsl) library, which the build tooling expects
+cloned inside `tools/` (the clone is gitignored):
+
+```bash
+git clone https://github.com/meowarex/kawarp-agsl tools/kawarp-agsl
+```
+
+To change the TIDAL glue, edit `tools/kawarp-build/src/radiant/Kawarp.java`; to change the
+effect itself, PR the Kawarp-AGSL repo. Then regenerate and commit the refreshed smali:
+
+```bash
+./tools/kawarp-build/build.sh
+```
+
 ### Submitting
 Fork the repo, add your patch to `patches/`, and open a PR describing what it changes and why.
 - Patch PR should be prefixed with `[patch]` in the title
 
+## Licence
+
+**GPL-3.0** — see `LICENSE`.
+
+Plain English: use it, change it, share it, even sell it. But if you distribute it (or a fork),
+you must ship the source under the GPL too — **no closed-source forks**, and per GPL-3 §5(a) a
+modified version has to carry a prominent notice saying it was modified and when.
+
+"Radiant Lyrics" is the project's name — please pick your own for a fork, so users can tell
+them apart.
+
+Third-party components and their licences are listed in `THIRD-PARTY.md`. The TIDAL app itself
+is not covered by this licence and remains the property of its owners.
+
 ## Credits
 
 Inrixia — TidaLuna framework

THIRD-PARTY.md

@@ -0,0 +1,40 @@
+# Third-party notices
+
+Radiant Lyrics Mobile is licensed under the GPL-3.0 (see `LICENSE`). It includes work from the
+projects below, whose original licences and copyright notices are preserved as those licences
+require.
+
+---
+
+## Kawarp-AGSL
+
+`patches/extension/dev/kawarp/KawarpEngine.smali` is compiled from
+[Kawarp-AGSL](https://github.com/meowarex/kawarp-agsl), © 2026 meowarex, licensed **LGPL-3.0**.
+LGPL-3.0 code may be included in a GPL-3.0 work; the engine itself remains available under the
+LGPL from its own repository.
+
+## kawarp (@kawarp/core)
+
+Kawarp-AGSL is in turn a port of [kawarp](https://github.com/better-lyrics/kawarp),
+© better-lyrics (@boidushya), **MIT** licensed:
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+> and associated documentation files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all copies or
+> substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+> BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+> DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## TIDAL
+
+This project patches the TIDAL Android app, which is **not** covered by this licence. TIDAL and
+its APK remain the property of Aspiro AB / TIDAL. Nothing here grants any rights to their
+software; see the disclaimer in the README.

patches/R8-SYMBOLS.md

@@ -0,0 +1,985 @@
+# R8 Symbol Map - TIDAL 2.200.0-10004
+
+Maintained by hand. Snapshot of the tree as of TIDAL 2.200.0-10004 - counts and line
+numbers in section 4 drift as patches are edited, so treat them as a starting point
+rather than gospel, and re-check with `grep -rn 'MARKER: R8'`.
+
+Every identifier below is **renamed by R8 on each TIDAL build** and has to be re-derived
+when bumping the target APK. This file is the checklist for that sweep.
+
+In `extension/**/*.smali` and `tools/kawarp-build/**/*.java` each occurrence also carries
+an inline `MARKER: R8 <symbol>` comment, so `grep -rn 'MARKER: R8'` finds them in place.
+Smali comments are stripped by the assembler - verified by round-tripping the whole tree
+through `smali a` + `baksmali d`, which reproduced the unannotated bytecode exactly.
+
+**`.patch` files are deliberately NOT annotated inline.** A comment on a context or
+removed line changes the text `applyPatchFuzzy` matches against and makes the hunk
+unlocatable (`Fuzzy match failed: could not locate context for hunk near line N`).
+Comments on added `+` lines are unsafe too, because several patches stack on the same
+target class (8 hook `PlayerScreenKt.smali` alone), so one patch's output is another's
+context. Section 4 lists those occurrences by line number instead.
+
+## Re-deriving after a TIDAL bump
+
+1. baksmali the new APK.
+2. For **members** (section 2) the owner class name is usually stable - open the new owner
+   and match on the descriptor, which R8 does not change. That pins the new member name.
+3. For **classes** (section 1) match on shape: superclass, interfaces, method descriptors.
+4. Apply each rename everywhere, re-run the patch set, and check for failed hunks.
+5. Update the `TIDAL <version>` in the heading above once the sweep is done.
+
+## Gotcha: extension classes that are themselves patch targets
+
+`player-backdrop-kawarp.patch` has `--- a/radiant/HomeBackdrop.smali` - it patches one of our
+own extension classes, not a TIDAL class. For those files the extension smali IS the patch's
+match target, so a marker comment on a context or removed line breaks the hunk exactly like it
+would in a `.patch` file (`Fuzzy match failed: could not locate context for hunk near line N`).
+
+`extension/radiant/HomeBackdrop.smali` is therefore deliberately left unmarked. Before marking
+any extension file, check it is not a patch target:
+
+    grep -rn '^--- a/radiant/\|^--- a/dev/' --include=*.patch patches/
+
+## Gotcha: `tools/kawarp-build/build.sh` drops markers
+
+That script regenerates `extension/radiant/Kawarp.smali` and
+`extension/dev/kawarp/KawarpEngine.smali` from the Java sources on every run, so any
+`MARKER: R8` comments in those two files are lost. After running it, re-mark them
+(`Kawarp.smali` had 39 marked lines) or the Kawarp half of this map goes stale silently.
+The Java side under `tools/kawarp-build/{src,stubs}` is not regenerated and keeps its
+markers.
+
+## Gotcha: Pebble integration hooks
+
+`extension/radiant/PebbleBridge*.smali` is built by `tools/pebble-bridge-build/build.sh`.
+
+- `integration-pebble-playback.patch` hooks `bk0/e`, TIDAL's 200 ms position poller.
+  It holds `Lbk0/d;`, `ExoPlayer` and `Handler` and reposts with `0xc8`.
+- `integration-pebble-lyrics.patch` hooks our `RLAPILyricsWorker`, so no markers there.
+
+## 1. Rolled class references (270)
+
+| symbol | uses | referenced from |
+|---|---:|---|
+| `Lam0/l;` | 246 | `extension/radiant/Kawarp.smali`, `extension/radiant/MiniPlayerBackground.smali`, `extension/radiant/MiniSeekerFloating.smali` +31 more |
+| `Lh4/a;` | 152 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/FeedResolver.smali` +6 more |
+| `Lkotlin/u;` | 109 | `extension/radiant/Kawarp.smali`, `extension/radiant/MiniSeekerFloating.smali`, `extension/radiant/NoOp.smali` +22 more |
+| `Lam0/a;` | 74 | `extension/radiant/HomeBackdrop.smali`, `extension/radiant/Kawarp.smali`, `extension/radiant/NoOp.smali` +10 more |
+| `Lcf/b;` | 60 | `extension/radiant/gestures/queue/MyPlaylistsResolver.smali`, `extension/radiant/gestures/queue/SearchPlaylistsResolver.smali` |
+| `Lm40/e$e;` | 49 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueueAction.smali`, `extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali`, `extension/radiant/gestures/queue/DynamicTrackQueueAction.smali` +3 more |
+| `Lh40/p;` | 46 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` +2 more |
+| `Lo6/b;` | 46 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lzc/a;` | 44 | `extension/radiant/gestures/queue/MyAlbumsResolver.smali`, `extension/radiant/gestures/queue/SearchAlbumsResolver.smali` |
+| `La50/b;` | 42 | `extension/radiant/gestures/queue/FeedResolver.smali`, `extension/radiant/gestures/queue/PlaylistItemsResolver.smali`, `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/c;` | 42 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Lu5/b$a;` | 40 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali`, `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `La50/d;` | 38 | `extension/radiant/gestures/queue/MyAlbumsResolver.smali`, `extension/radiant/gestures/queue/MyMixesAndRadioResolver.smali`, `extension/radiant/gestures/queue/MyPlaylistsResolver.smali` +3 more |
+| `Le5/z$n2;` | 36 | `extension/radiant/MiniSeekerLine.smali`, `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lo6/b$a;` | 36 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lm40/e$d;` | 32 | `extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali`, `extension/radiant/gestures/queue/PublicPlaylistQueueAction.smali`, `extension/radiant/gestures/queue/VerticalMediaQueueAction.smali` +1 more |
+| `Lc60/r$b;` | 30 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Lu5/b$a$b;` | 30 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali`, `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lbm/k;` | 28 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcoil/request/b;` | 28 | `extension/radiant/Kawarp.smali` |
+| `Lbm/a;` | 26 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lm40/e$a;` | 26 | `extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali`, `extension/radiant/gestures/queue/VerticalMediaQueueAction.smali` |
+| `Lm40/e$c;` | 26 | `extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali`, `extension/radiant/gestures/queue/VerticalMediaQueueAction.smali` |
+| `Lve/a;` | 26 | `extension/radiant/gestures/queue/MyMixesAndRadioResolver.smali` |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | 25 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali`, `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/ComposeSearchQueue.smali` +8 more |
+| `Lbm/f;` | 24 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lbm/g;` | 24 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lh40/j;` | 24 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lb80/a;` | 22 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lb80/c;` | 20 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lo6/i;` | 20 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lf20/a;` | 19 | `extension/radiant/QualityBadge.smali`, `gestures/mini-player/mini-player-left-right-gesture.patch`, `gestures/mini-player/mini-player-up-gesture.patch` |
+| `Lb80/d;` | 18 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lc60/r;` | 18 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lh40/a;` | 18 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lh40/i;` | 18 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lm40/e;` | 18 | `extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali`, `extension/radiant/gestures/queue/VerticalMediaQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lx40/a;` | 17 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/FeedResolver.smali` +5 more |
+| `Lc60/b0;` | 16 | `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Lc60/d;` | 16 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali` |
+| `Lcom/tidal/android/core/adapterdelegate/c;` | 16 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/r$c;` | 16 | `extension/com/tidal/android/feature/appscaffold/ui/r$c.smali`, `extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture.smali`, `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `Le5/c;` | 16 | `extension/radiant/MiniSeekerLine.smali`, `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lgh/j;` | 16 | `extension/radiant/MiniSeekerLine.smali` |
+| `Lc60/c0;` | 14 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lc60/f;` | 14 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lcoil/f;` | 14 | `extension/radiant/Kawarp.smali` |
+| `Lh40/n;` | 14 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` +2 more |
+| `Lpb0/b;` | 14 | `extension/radiant/gestures/queue/ComposeSearchQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lu5/b$a$a;` | 14 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali`, `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/o0;` | 13 | `extension/radiant/gestures/queue/SuggestionsResolver.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lc60/v;` | 12 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/h;` | 12 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/search/v2/d;` | 12 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcom/tidal/android/navigation/a;` | 12 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` +2 more |
+| `Lh9/p1;` | 12 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lie0/i;` | 12 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` +2 more |
+| `Lo3/a$a;` | 12 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lo3/a;` | 12 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lu3/a$a;` | 12 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lu3/a;` | 12 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/l;` | 11 | `extension/radiant/gestures/queue/SuggestionsResolver.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lq20/c2;` | 11 | `extension/radiant/QualityBadge.smali`, `player-move-playing-from.patch`, `player-quality-badge-colors.patch` |
+| `Lql0/a;` | 11 | `extension/radiant/MiniSeekerLine.smali`, `extension/radiant/gestures/queue/QueueExecutor.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lc60/h;` | 10 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Lcoil/request/h$a;` | 10 | `extension/radiant/Kawarp.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/a1;` | 10 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/player/d;` | 10 | `extension/radiant/gestures/queue/QueueExecutor.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/playlist/ui/items/a;` | 10 | `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` |
+| `Lcom/aspiro/wamp/playqueue/g1;` | 10 | `extension/radiant/gestures/queue/QueueExecutor.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/tidal/android/dynamicpages/ui/b;` | 10 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Lcom/tidal/android/feature/playerscreen/ui/f;` | 10 | `extension/radiant/RLAPILyricsWorker.smali`, `lyrics-rl-api-syllable.patch`, `lyrics-rl-api-word.patch` |
+| `Li60/c;` | 10 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `extension/radiant/gestures/queue/DynamicTrackQueue.smali` |
+| `Ltl/h;` | 10 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcoil/request/h;` | 9 | `extension/radiant/Kawarp.smali` |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | 9 | `lyrics-disable-cover.patch`, `lyrics-replace-lyrics-button.patch`, `lyrics-replace-share-button.patch` +3 more |
+| `Lpb0/b$a;` | 9 | `extension/radiant/gestures/queue/ComposeSearchQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lpb0/b$e;` | 9 | `extension/radiant/gestures/queue/ComposeSearchQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lpb0/b$f;` | 9 | `extension/radiant/gestures/queue/ComposeSearchQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lpb0/b$i;` | 9 | `extension/radiant/gestures/queue/ComposeSearchQueueAction.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `La80/c;` | 8 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/b$b;` | 8 | `extension/radiant/gestures/miniplayer/MiniPlayerGestures$Gesture.smali`, `extension/radiant/gestures/miniplayer/MiniPlayerGestures.smali`, `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a;` | 8 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b;` | 8 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/i$a;` | 8 | `player-quality-badge-colors.patch` |
+| `Ldagger/internal/f;` | 8 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lfd/c;` | 8 | `extension/radiant/gestures/queue/MyAlbumsResolver.smali` |
+| `Li40/c$b;` | 8 | `extension/radiant/gestures/queue/ViewAllTrackQueueAction.smali` |
+| `Lie0/h;` | 8 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lld/c;` | 8 | `extension/radiant/gestures/queue/SearchAlbumsResolver.smali` |
+| `Lpe/f;` | 8 | `extension/radiant/gestures/queue/MyMixesAndRadioResolver.smali` |
+| `Ltl/q;` | 8 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lu5/g;` | 8 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali` |
+| `Lv9/e;` | 8 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Lbi/e;` | 7 | `extension/radiant/RLAPILyricsWorker.smali`, `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/p3;` | 7 | `extension/radiant/HomeBackdrop.smali`, `extension/radiant/Kawarp.smali`, `player-backdrop-kawarp.patch` +1 more |
+| `Lm3/f;` | 7 | `extension/radiant/gestures/queue/QueueExecutor.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lam0/p;` | 6 | `extension/radiant/SparkleButton.smali`, `extension/radiant/SparkleContent.smali`, `mini-player-black.patch` +1 more |
+| `Lc3/h;` | 6 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lc60/s;` | 6 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lce0/b$a;` | 6 | `extension/radiant/Kawarp.smali` |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/f;` | 6 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0;` | 6 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;` | 6 | `extension/radiant/gestures/queue/DynamicMediaQueue.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/feature/appscaffold/ui/b$a;` | 6 | `extension/radiant/gestures/miniplayer/MiniPlayerGestures.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/r;` | 6 | `extension/com/tidal/android/feature/appscaffold/ui/r$c.smali` |
+| `Lcom/tidal/android/feature/feed/ui/c;` | 6 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/f2;` | 6 | `lyrics-rl-api-syllable.patch`, `lyrics-rl-api-word.patch` |
+| `Lcom/tidal/android/feature/viewall/ui/e$c;` | 6 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali` |
+| `Lf20/d;` | 6 | `extension/radiant/QualityBadge.smali` |
+| `Lgh/b;` | 6 | `extension/radiant/SeekerConsumer.smali` |
+| `Lhf/c;` | 6 | `extension/radiant/gestures/queue/MyPlaylistsResolver.smali` |
+| `Lie0/a;` | 6 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lie0/g;` | 6 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lm3/d;` | 6 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lm3/f$a;` | 6 | `extension/radiant/gestures/queue/QueueExecutor.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lmb0/a;` | 6 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Ln8/d;` | 6 | `extension/radiant/gestures/queue/FavoriteTracksResolver.smali` |
+| `Lpd0/a;` | 6 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali` |
+| `Lq20/u1;` | 6 | `extension/radiant/SparkleButton.smali` |
+| `Lra/d;` | 6 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali` |
+| `Lxd0/g;` | 6 | `extension/radiant/Kawarp.smali` |
+| `Lcom/tidal/android/feature/playerscreen/ui/g$c;` | 5 | `extension/radiant/RLAPILyricsWorker.smali`, `lyrics-rl-api-observer.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/p;` | 5 | `lyrics-replace-lyrics-button.patch`, `lyrics-sparkle-conditional-visibility.patch`, `player-hide-playing-from.patch` +1 more |
+| `Lb0/c;` | 4 | `extension/radiant/Kawarp.smali` |
+| `Lbm/h;` | 4 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lc3/i$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lc3/i;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lc3/l$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lc3/l;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lce0/b;` | 4 | `extension/radiant/Kawarp.smali` |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/h$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/h;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/u$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/u;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/core/k;` | 4 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali`, `extension/radiant/gestures/queue/DynamicMediaQueue.smali` |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m;` | 4 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/i$a;` | 4 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/i$e;` | 4 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/playback/e0;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/playback/f;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/playback/k0;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lcom/aspiro/wamp/playqueue/d1;` | 4 | `extension/radiant/MiniSeekerLine.smali` |
+| `Lcom/aspiro/wamp/playqueue/u0;` | 4 | `extension/radiant/RLAPILyricsWorker.smali` |
+| `Lcom/aspiro/wamp/search/v2/a$g;` | 4 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcom/squareup/ui/market/core/theme/k$a;` | 4 | `extension/radiant/SparkleButton.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b$a;` | 4 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueueAction.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b$a;` | 4 | `extension/radiant/gestures/queue/DynamicTrackQueueAction.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/b$a;` | 4 | `extension/radiant/gestures/queue/VerticalMediaQueueAction.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/q;` | 4 | `cover-capture.patch`, `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `Lcom/tidal/android/feature/search/ui/f;` | 4 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Lcom/tidal/android/feature/viewall/ui/c;` | 4 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali` |
+| `Lcom/tidal/android/image/core/b$a;` | 4 | `extension/radiant/Kawarp.smali` |
+| `Ld0/c$a;` | 4 | `extension/radiant/Kawarp.smali` |
+| `Lj3/k$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lj3/k;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lj3/n$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lj3/n;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lj3/q$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lj3/q;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lm3/i$a;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lm3/i;` | 4 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lmb0/e;` | 4 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Lvn0/b;` | 4 | `extension/radiant/RLAPILyricsWorker.smali` |
+| `Lz70/a;` | 4 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lzf/c;` | 4 | `extension/radiant/gestures/queue/SearchPlaylistsResolver.smali` |
+| `Landroidx/navigation/f0;` | 3 | `gestures/mini-player/mini-player-left-right-gesture.patch`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Landroidx/window/embedding/a2;` | 3 | `lyrics-replace-lyrics-button.patch`, `lyrics-sparkle-conditional-visibility.patch` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c;` | 3 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/feature/appscaffold/ui/r$a;` | 3 | `extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/t;` | 3 | `gestures/mini-player/mini-player-left-right-gesture.patch`, `gestures/mini-player/mini-player-up-gesture.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/b;` | 3 | `lyrics-replace-share-button.patch` |
+| `Lcom/tidal/android/feature/viewall/ui/e;` | 3 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali`, `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/image/core/b$h$a;` | 3 | `extension/radiant/Kawarp.smali` |
+| `Ldagger/internal/j;` | 3 | `extension/radiant/MiniSeekerLine.smali`, `gestures/queue/swipe-to-queue.patch` |
+| `Lkotlin/jvm/internal/n;` | 3 | `integration-waze-playback.patch` |
+| `La30/a;` | 2 | `player-favorite-heart.patch` |
+| `Lad/f;` | 2 | `extension/radiant/gestures/queue/MyAlbumsResolver.smali` |
+| `Lam0/q;` | 2 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Landroidx/window/embedding/b2;` | 2 | `lyrics-replace-share-button.patch` |
+| `Lbd/d$a;` | 2 | `extension/radiant/gestures/queue/MyAlbumsResolver.smali` |
+| `Lbm/i;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcoil/request/d;` | 2 | `extension/radiant/Kawarp.smali` |
+| `Lcom/aspiro/wamp/contextmenu/menu/track/c;` | 2 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/contextmenu/menu/track/d;` | 2 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/h;` | 2 | `extension/radiant/gestures/queue/MyPlaylistsResolver.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/i;` | 2 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/j;` | 2 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/y$a;` | 2 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lcom/aspiro/wamp/search/v2/a;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lcom/aspiro/wamp/util/h0;` | 2 | `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` |
+| `Lcom/squareup/ui/market/components/n;` | 2 | `extension/radiant/SparkleButton.smali` |
+| `Lcom/squareup/ui/market/core/theme/k;` | 2 | `extension/radiant/SparkleButton.smali` |
+| `Lcom/squareup/ui/market/core/theme/z;` | 2 | `extension/radiant/SparkleButton.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/composables/compactgridcard/d;` | 2 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b;` | 2 | `extension/radiant/gestures/queue/ArtistTrackCreditsQueueEvent.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/b;` | 2 | `extension/radiant/gestures/queue/DynamicMediaQueueEvent.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b;` | 2 | `extension/radiant/gestures/queue/DynamicTrackQueueEvent.smali` |
+| `Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/b;` | 2 | `extension/radiant/gestures/queue/DynamicMediaQueueEvent.smali` |
+| `Lcom/tidal/android/feature/appscaffold/ui/composable/a;` | 2 | `mini-player-black.patch`, `mini-player-dynamic-bg.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/s3;` | 2 | `lyrics-replace-lyrics-button.patch`, `lyrics-sparkle-conditional-visibility.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/d;` | 2 | `lyrics-disable-cover.patch`, `player-move-playing-from.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/e0;` | 2 | `lyrics-replace-share-button.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/g;` | 2 | `lyrics-disable-cover.patch`, `lyrics-progress-pill.patch` |
+| `Lcom/tidal/android/feature/search/ui/b;` | 2 | `extension/radiant/gestures/queue/ComposeSearchQueueEvent.smali` |
+| `Lcom/tidal/android/feature/search/ui/e;` | 2 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Lcom/tidal/android/feature/viewall/ui/u;` | 2 | `extension/radiant/gestures/queue/ViewAllTrackQueue.smali` |
+| `Lcom/tidal/android/image/coil/c;` | 2 | `extension/radiant/Kawarp.smali` |
+| `Lcom/tidal/android/image/core/b;` | 2 | `extension/radiant/Kawarp.smali` |
+| `Ldf/d$a;` | 2 | `extension/radiant/gestures/queue/MyPlaylistsResolver.smali` |
+| `Lhu/akarnokd/rxjava/interop/f;` | 2 | `extension/radiant/gestures/queue/QueueExecutor.smali` |
+| `Lid/e;` | 2 | `extension/radiant/gestures/queue/SearchAlbumsResolver.smali` |
+| `Lij/a0$a;` | 2 | `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` |
+| `Lij/j0$a;` | 2 | `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` |
+| `Lij/q$a;` | 2 | `extension/radiant/gestures/queue/PlaylistItemsResolver.smali` |
+| `Ljd/d$a;` | 2 | `extension/radiant/gestures/queue/SearchAlbumsResolver.smali` |
+| `Lk5/f;` | 2 | `extension/radiant/gestures/queue/AlbumItemQueueAction.smali` |
+| `Lkotlin/collections/u;` | 2 | `extension/radiant/gestures/queue/SuggestionsResolver.smali` |
+| `Lkotlin/coroutines/e;` | 2 | `extension/radiant/gestures/lyrics/LyricsDrag$Guard.smali` |
+| `Lkotlin/coroutines/h;` | 2 | `extension/radiant/MiniPlayerBackground.smali` |
+| `Lkotlin/i;` | 2 | `mini-player-dynamic-bg.patch` |
+| `Lmb0/f;` | 2 | `extension/radiant/gestures/queue/ComposeSearchQueue.smali` |
+| `Lo4/g;` | 2 | `gestures/queue/swipe-to-queue.patch` |
+| `Lo50/a;` | 2 | `debug-menu-unlock.patch` |
+| `Lp7/a$a;` | 2 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lq20/r4;` | 2 | `extension/radiant/QualityBadge.smali` |
+| `Lq20/s4;` | 2 | `extension/radiant/QualityBadge.smali` |
+| `Lqe/c$a;` | 2 | `extension/radiant/gestures/queue/MyMixesAndRadioResolver.smali` |
+| `Ltl/f;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lul/a0$a;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lul/d$a;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lul/n0$a;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lul/w$a;` | 2 | `extension/radiant/gestures/queue/UnifiedSearchResolver.smali` |
+| `Lv6/e$a;` | 2 | `extension/radiant/gestures/queue/DynamicTrackResolver.smali` |
+| `Lv70/b;` | 2 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lvn0/a;` | 2 | `extension/radiant/RLAPILyricsWorker.smali` |
+| `Lw70/c$a;` | 2 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lw70/h$a;` | 2 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lw70/k$a;` | 2 | `extension/radiant/gestures/queue/FeedResolver.smali` |
+| `Lwf/d;` | 2 | `extension/radiant/gestures/queue/SearchPlaylistsResolver.smali` |
+| `Lxd0/e;` | 2 | `extension/radiant/Kawarp.smali` |
+| `Lxd0/f;` | 2 | `extension/radiant/Kawarp.smali` |
+| `Lxf/d$a;` | 2 | `extension/radiant/gestures/queue/SearchPlaylistsResolver.smali` |
+| `La30/b;` | 1 | `player-favorite-heart.patch` |
+| `Landroidx/compose/foundation/text/input/a;` | 1 | `player-backdrop-playback.patch` |
+| `Lbk0/d;` | 1 | `integration-pebble-playback.patch` |
+| `Lbk0/e;` | 1 | `integration-pebble-playback.patch` |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/n;` | 1 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/l;` | 1 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/a;` | 1 | `gestures/queue/swipe-to-queue.patch` |
+| `Lcom/squareup/ui/market/layout/e;` | 1 | `player-backdrop-playback.patch` |
+| `Lcom/squareup/ui/market/text/a;` | 1 | `player-move-playing-from.patch` |
+| `Lcom/tidal/android/dynamicpages/ui/composables/verticallistcard/m;` | 1 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/feature/appscaffold/ui/composable/g;` | 1 | `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/b0;` | 1 | `lyrics-disable-cover.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/e5;` | 1 | `lyrics-replace-share-button.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/k1;` | 1 | `lyrics-replace-lyrics-button.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/o1;` | 1 | `lyrics-fade-region.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/t4;` | 1 | `player-quality-badge-colors.patch` |
+| `Lcom/tidal/android/feature/playerscreen/ui/g$a;` | 1 | `lyrics-disable-cover.patch` |
+| `Lcom/tidal/android/feature/viewall/ui/e$a;` | 1 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/feature/viewall/ui/n;` | 1 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lcom/tidal/android/featureflags/n;` | 1 | `debug-menu-unlock.patch` |
+| `Lcom/tidal/android/tidalapi/domain/model/o;` | 1 | `lyrics-rl-api-isrc.patch` |
+| `Lde0/c;` | 1 | `player-backdrop-playback.patch` |
+| `Lmb/f;` | 1 | `integration-waze-playback.patch` |
+| `Ln8/b;` | 1 | `gestures/queue/swipe-to-queue.patch` |
+| `Lo4/g$e;` | 1 | `gestures/queue/swipe-to-queue.patch` |
+| `Lob0/q;` | 1 | `gestures/queue/swipe-to-queue-compose.patch` |
+| `Lob0/w;` | 1 | `gestures/queue/swipe-to-queue-compose.patch` |
+
+## 2. Rolled members on otherwise-stable classes (347)
+
+The owner name survives R8; only the member name rolls. Match on the descriptor.
+
+| owner | member | descriptor | uses |
+|---|---|---|---:|
+| `Lcom/aspiro/wamp/App$a;` | `a` | `()Lcom/aspiro/wamp/App;` | 8 |
+| `Lcom/aspiro/wamp/App;` | `e` | `()Le5/c;` | 8 |
+| `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b;` | `a` | `(Landroidx/lifecycle/LifecycleOwner;Landroidx/recyclerview/widget/RecyclerView;)Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a;` | 8 |
+| `Lm40/e$e;` | `a` | `:J` | 8 |
+| `La50/b;` | `b` | `:Ljava/util/ArrayList;` | 7 |
+| `Lcf/b;` | `a` | `:Lcom/aspiro/wamp/model/Playlist;` | 6 |
+| `Lcom/tidal/android/navigation/a;` | `b` | `(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/tidal/android/navigation/NavigationInfo$Node;` | 6 |
+| `Lie0/i;` | `a` | `(Lh40/p;)Lcom/aspiro/wamp/model/Track;` | 6 |
+| `Lo6/b;` | `c` | `:Lo6/b$a;` | 6 |
+| `Lzc/a;` | `b` | `:Lcom/aspiro/wamp/model/Album;` | 6 |
+| `Lc60/r$b;` | `a` | `:Lh40/n;` | 5 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `j` | `(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;` | 5 |
+| `Lcom/tidal/android/dynamicpages/ui/c;` | `b` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 5 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `P` | `:Lkotlinx/coroutines/flow/MutableStateFlow;` | 5 |
+| `Li60/c;` | `c` | `(Ljava/lang/String;)Lc60/h;` | 5 |
+| `Lm40/e$e;` | `j` | `:Z` | 5 |
+| `Lo6/b$a;` | `q` | `:Ljava/lang/String;` | 5 |
+| `Lo6/b;` | `a` | `:Lo6/i;` | 5 |
+| `Lbm/a;` | `a` | `:Lcom/aspiro/wamp/model/Album;` | 4 |
+| `Lbm/f;` | `a` | `:Lcom/aspiro/wamp/mix/model/Mix;` | 4 |
+| `Lbm/g;` | `a` | `:Lcom/aspiro/wamp/model/Playlist;` | 4 |
+| `Lbm/k;` | `a` | `:Lcom/aspiro/wamp/model/Track;` | 4 |
+| `Lcf/b;` | `h` | `:Z` | 4 |
+| `Lcf/b;` | `f` | `:Z` | 4 |
+| `Lcf/b;` | `g` | `:Ljava/lang/String;` | 4 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `o` | `(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;` | 4 |
+| `Lcom/aspiro/wamp/search/v2/UnifiedSearchView;` | `N` | `()Ltl/h;` | 4 |
+| `Lcom/tidal/android/feature/playerscreen/ui/f;` | `a` | `:Ljava/lang/String;` | 4 |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | `m` | `:Lcom/tidal/android/feature/playerscreen/ui/p;` | 4 |
+| `Lh40/p;` | `a` | `:J` | 4 |
+| `Lie0/h;` | `a` | `(Lh40/j;)Lcom/aspiro/wamp/model/Playlist;` | 4 |
+| `Lo6/b$a;` | `o` | `:I` | 4 |
+| `Lu5/b$a$b;` | `r` | `:I` | 4 |
+| `Lu5/b$a;` | `c` | `:Lu5/b$a$b;` | 4 |
+| `Lzc/a;` | `k` | `:Z` | 4 |
+| `Lb80/a;` | `a` | `:Lcom/aspiro/wamp/model/Album;` | 3 |
+| `Lb80/c;` | `a` | `:Lcom/aspiro/wamp/mix/model/Mix;` | 3 |
+| `Lb80/d;` | `a` | `:Lcom/aspiro/wamp/model/Playlist;` | 3 |
+| `Lc60/s;` | `a` | `(Lc60/r;)Ljava/lang/String;` | 3 |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;` | `i` | `:Z` | 3 |
+| `Lcom/aspiro/wamp/player/d;` | `b` | `()Lcom/aspiro/wamp/model/MediaItemParent;` | 3 |
+| `Lcom/aspiro/wamp/playqueue/g1;` | `a` | `()Lcom/aspiro/wamp/player/d;` | 3 |
+| `Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$a;` | `a` | `(Ljava/lang/String;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;` | 3 |
+| `Lcom/tidal/android/feature/appscaffold/ui/b$b;` | `a` | `:Lcom/tidal/android/feature/appscaffold/ui/b$b;` | 3 |
+| `Lcom/tidal/android/feature/appscaffold/ui/r$c;` | `a` | `:Lcom/tidal/android/feature/appscaffold/ui/r$c;` | 3 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/p3;` | `a` | `(ILjava/lang/String;ZZLam0/a;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V` | 3 |
+| `Lh4/a;` | `b` | `:Lo3/a$a;` | 3 |
+| `Lh4/a;` | `h` | `:Lu3/a$a;` | 3 |
+| `Lie0/a;` | `a` | `(Lh40/a;)Lcom/aspiro/wamp/model/Album;` | 3 |
+| `Lie0/g;` | `b` | `(Lh40/i;)Lcom/aspiro/wamp/mix/model/Mix;` | 3 |
+| `Lm40/e$d;` | `a` | `:Ljava/lang/String;` | 3 |
+| `Lm40/e$d;` | `g` | `:Z` | 3 |
+| `Lo3/a$a;` | `a` | `(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lo3/a;` | 3 |
+| `Lo6/b$a;` | `d` | `:I` | 3 |
+| `Lu3/a$a;` | `a` | `(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lu3/a;` | 3 |
+| `Lu5/b$a$b;` | `s` | `:Ljava/lang/String;` | 3 |
+| `Lu5/b$a;` | `a` | `:Lu5/b$a$a;` | 3 |
+| `Lve/a;` | `c` | `:Lcom/aspiro/wamp/mix/model/Mix;` | 3 |
+| `Lcoil/request/h$a;` | `b` | `:Lcoil/request/b;` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `Y` | `(ILcom/aspiro/wamp/model/FavoriteTrack;)Z` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `d` | `:Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0;` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `l` | `:Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m;` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0;` | `b` | `(I)Lcom/aspiro/wamp/model/FavoriteTrack;` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m;` | `f` | `:Landroidx/recyclerview/widget/RecyclerView;` | 2 |
+| `Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;` | `c` | `:Lpe/f;` | 2 |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;` | `h` | `:Landroid/graphics/drawable/Drawable;` | 2 |
+| `Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;` | `h` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 2 |
+| `Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;` | `c` | `:Lcom/aspiro/wamp/playlist/ui/items/a;` | 2 |
+| `Lcom/aspiro/wamp/search/v2/UnifiedSearchView;` | `g` | `:Lio/reactivex/disposables/CompositeDisposable;` | 2 |
+| `Lcom/aspiro/wamp/search/v2/d;` | `e` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 2 |
+| `Lcom/squareup/ui/market/core/theme/MarketStylesheet$c;` | `p0` | `()Lf20/a;` | 2 |
+| `Lcom/tidal/android/feature/appscaffold/ui/b$a;` | `a` | `:Lcom/tidal/android/feature/appscaffold/ui/b$a;` | 2 |
+| `Lcom/tidal/android/feature/appscaffold/ui/composable/a;` | `c` | `:Landroidx/compose/foundation/shape/RoundedCornerShape;` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/BroadcastButtonKt;` | `b` | `(Lcom/tidal/android/feature/playerscreen/ui/b;Lam0/a;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/f2;` | `b` | `:I` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/f2;` | `d` | `:J` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/f2;` | `e` | `:J` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/p3;` | `b` | `(Lcom/tidal/android/feature/playerscreen/ui/model/PlayerBackgroundStyle;JILjava/lang/String;ZZLam0/a;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/s3;` | `a` | `(ILam0/a;Landroidx/compose/runtime/Composer;Landroidx/compose/ui/Modifier;)V` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/i$a;` | `b` | `:I` | 2 |
+| `Lcom/tidal/android/feature/playerscreen/ui/i$a;` | `a` | `:Ljava/lang/String;` | 2 |
+| `Lcom/tidal/android/feature/search/ui/SearchQuery;` | `a` | `:Ljava/lang/String;` | 2 |
+| `Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;` | `m` | `:Lkotlinx/coroutines/flow/MutableStateFlow;` | 2 |
+| `Le5/z$n2;` | `r2` | `()Lcom/aspiro/wamp/playqueue/g1;` | 2 |
+| `Lh9/p1;` | `b` | `:Lx40/a;` | 2 |
+| `Lm3/f$a;` | `a` | `(Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Lm3/f;` | 2 |
+| `Lm3/f;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 2 |
+| `Lm40/e$a;` | `a` | `:J` | 2 |
+| `Lm40/e$a;` | `e` | `:Z` | 2 |
+| `Lm40/e$c;` | `a` | `:Ljava/lang/String;` | 2 |
+| `Lm40/e$c;` | `h` | `:Z` | 2 |
+| `Lo50/a;` | `a` | `:Ljava/lang/String;` | 2 |
+| `Lo6/b;` | `b` | `:J` | 2 |
+| `Lo6/i;` | `p` | `:Ljava/util/LinkedHashMap;` | 2 |
+| `Ltl/q;` | `a` | `:Lx40/a;` | 2 |
+| `Lu5/b$a$b;` | `g` | `:Lcom/aspiro/wamp/model/Availability;` | 2 |
+| `Lu5/b$a$b;` | `p` | `:Z` | 2 |
+| `Lu5/b$a;` | `b` | `:J` | 2 |
+| `Lve/a;` | `f` | `:Z` | 2 |
+| `Lve/a;` | `a` | `:Ljava/lang/String;` | 2 |
+| `La30/a;` | `a` | `:I` | 1 |
+| `La30/b;` | `O` | `:La30/a;` | 1 |
+| `La80/c;` | `a` | `:Ljava/lang/String;` | 1 |
+| `La80/c;` | `e` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `La80/c;` | `b` | `:Lx40/a;` | 1 |
+| `Lb80/a;` | `c` | `:Z` | 1 |
+| `Lb80/a;` | `g` | `:I` | 1 |
+| `Lb80/c;` | `c` | `:I` | 1 |
+| `Lb80/d;` | `c` | `:I` | 1 |
+| `Lbi/e;` | `i` | `()Z` | 1 |
+| `Lbi/e;` | `h` | `(Z)V` | 1 |
+| `Lbm/a;` | `c` | `:Lcom/aspiro/wamp/model/Availability$Album;` | 1 |
+| `Lbm/i;` | `a` | `(Lbm/h;)Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;` | 1 |
+| `Lbm/k;` | `e` | `:Lcom/aspiro/wamp/model/Availability$MediaItem;` | 1 |
+| `Lbm/k;` | `n` | `:Lcom/aspiro/wamp/search/SearchDataSource;` | 1 |
+| `Lc3/h;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lc3/i$a;` | `a` | `(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lc3/i;` | 1 |
+| `Lc3/i;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lc3/l$a;` | `a` | `(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lc3/l;` | 1 |
+| `Lc3/l;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lc60/b0;` | `b` | `:Ljava/lang/String;` | 1 |
+| `Lc60/b0;` | `f` | `:Ljava/util/ArrayList;` | 1 |
+| `Lc60/b0;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lc60/b0;` | `e` | `:I` | 1 |
+| `Lc60/b0;` | `c` | `:Ljava/lang/String;` | 1 |
+| `Lc60/b0;` | `g` | `:Ljava/lang/String;` | 1 |
+| `Lc60/c0;` | `b` | `:Ljava/lang/String;` | 1 |
+| `Lc60/c0;` | `g` | `:Ljava/util/ArrayList;` | 1 |
+| `Lc60/c0;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lc60/c0;` | `f` | `:I` | 1 |
+| `Lc60/c0;` | `c` | `:Ljava/lang/String;` | 1 |
+| `Lc60/d;` | `b` | `:Ljava/lang/String;` | 1 |
+| `Lc60/d;` | `f` | `:Ljava/util/ArrayList;` | 1 |
+| `Lc60/d;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lc60/d;` | `e` | `:I` | 1 |
+| `Lc60/d;` | `c` | `:Ljava/lang/String;` | 1 |
+| `Lc60/d;` | `g` | `:Ljava/lang/String;` | 1 |
+| `Lc60/f;` | `b` | `:Ljava/lang/String;` | 1 |
+| `Lc60/f;` | `g` | `:Ljava/util/ArrayList;` | 1 |
+| `Lc60/f;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lc60/f;` | `d` | `:I` | 1 |
+| `Lc60/f;` | `e` | `:Ljava/lang/String;` | 1 |
+| `Lc60/v;` | `b` | `:Ljava/lang/String;` | 1 |
+| `Lc60/v;` | `f` | `:Ljava/util/ArrayList;` | 1 |
+| `Lc60/v;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lc60/v;` | `e` | `:I` | 1 |
+| `Lce0/b$a;` | `a` | `()Lce0/b;` | 1 |
+| `Lce0/b;` | `a` | `()Lxd0/e;` | 1 |
+| `Lcoil/f;` | `b` | `(Lcoil/request/h;)Lcoil/request/d;` | 1 |
+| `Lcoil/request/b;` | `a` | `:Lkotlinx/coroutines/CoroutineDispatcher;` | 1 |
+| `Lcoil/request/b;` | `b` | `:Lkotlinx/coroutines/CoroutineDispatcher;` | 1 |
+| `Lcoil/request/b;` | `c` | `:Lkotlinx/coroutines/CoroutineDispatcher;` | 1 |
+| `Lcoil/request/b;` | `d` | `:Lkotlinx/coroutines/CoroutineDispatcher;` | 1 |
+| `Lcoil/request/b;` | `e` | `:Ld0/c$a;` | 1 |
+| `Lcoil/request/b;` | `f` | `:Lcoil/size/Precision;` | 1 |
+| `Lcoil/request/b;` | `g` | `:Landroid/graphics/Bitmap$Config;` | 1 |
+| `Lcoil/request/b;` | `h` | `:Z` | 1 |
+| `Lcoil/request/b;` | `i` | `:Lcoil/request/CachePolicy;` | 1 |
+| `Lcoil/request/b;` | `j` | `:Lcoil/request/CachePolicy;` | 1 |
+| `Lcoil/request/h$a;` | `d` | `:Lb0/c;` | 1 |
+| `Lcoil/request/h$a;` | `a` | `()Lcoil/request/h;` | 1 |
+| `Lcoil/request/h;` | `a` | `(Lcoil/request/h;)Lcoil/request/h$a;` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/f;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/h$a;` | `a` | `(Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/contextmenu/item/playlist/h;` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/h;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/u$a;` | `a` | `(Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/contextmenu/item/playlist/u;` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/item/playlist/u;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/menu/track/c;` | `b` | `:Ldagger/internal/j;` | 1 |
+| `Lcom/aspiro/wamp/contextmenu/menu/track/d;` | `a` | `:Lcom/aspiro/wamp/contextmenu/menu/track/c;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;` | `h` | `:Lad/f;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;` | `N` | `()La50/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;` | `c` | `:Lfd/c;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;` | `j` | `:Lio/reactivex/disposables/CompositeDisposable;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/search/SearchAlbumsView;` | `f` | `:Lid/e;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/search/SearchAlbumsView;` | `N` | `()La50/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/search/SearchAlbumsView;` | `c` | `:Lld/c;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/albums/search/SearchAlbumsView;` | `g` | `:Lio/reactivex/disposables/CompositeDisposable;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `Z` | `(ILcom/aspiro/wamp/model/FavoriteTrack;I)V` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `f` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `b` | `:Lx40/a;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `w` | `(Landroidx/recyclerview/widget/RecyclerView;ILandroid/view/View;)V` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;` | `N` | `()Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/n;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0;` | `m` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0;` | `k` | `:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;` | `N` | `()La50/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;` | `h` | `:Lio/reactivex/disposables/CompositeDisposable;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;` | `j` | `:Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/h;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;` | `N` | `()La50/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;` | `d` | `:Lhf/c;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/searchplaylists/SearchPlaylistsView;` | `g` | `:Lwf/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/searchplaylists/SearchPlaylistsView;` | `N` | `()La50/d;` | 1 |
+| `Lcom/aspiro/wamp/mycollection/subpages/playlists/searchplaylists/SearchPlaylistsView;` | `c` | `:Lzf/c;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;` | `c` | `:Landroid/graphics/drawable/ColorDrawable;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;` | `d` | `:Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl$ActionType;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/a1;` | `o` | `:Ljava/lang/Object;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/a1;` | `j` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/h;` | `d` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/h;` | `c` | `:Lcom/aspiro/wamp/nowplaying/view/suggestions/l;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/j;` | `a` | `(Lcom/aspiro/wamp/nowplaying/view/suggestions/i;)V` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/o0;` | `d` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/o0;` | `c` | `:Lcom/aspiro/wamp/nowplaying/view/suggestions/l;` | 1 |
+| `Lcom/aspiro/wamp/nowplaying/view/suggestions/o0;` | `M` | `()Lcom/aspiro/wamp/nowplaying/view/suggestions/l;` | 1 |
+| `Lcom/aspiro/wamp/playback/e0;` | `a` | `(Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;ZLjava/lang/String;)Lio/reactivex/disposables/Disposable;` | 1 |
+| `Lcom/aspiro/wamp/playback/f;` | `a` | `(ILcom/tidal/android/navigation/NavigationInfo;ZLjava/lang/String;)Lhu/akarnokd/rxjava/interop/f;` | 1 |
+| `Lcom/aspiro/wamp/playback/k0;` | `c` | `(Lcom/aspiro/wamp/model/Playlist;Lcom/tidal/android/navigation/NavigationInfo;)V` | 1 |
+| `Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;` | `d` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lcom/aspiro/wamp/playlist/ui/items/a;` | `k` | `()Lcom/aspiro/wamp/playlist/viewmodel/PlaylistCollectionViewModel;` | 1 |
+| `Lcom/aspiro/wamp/playlist/ui/items/a;` | `c` | `(Lcom/aspiro/wamp/model/Track;)V` | 1 |
+| `Lcom/aspiro/wamp/playlist/ui/items/a;` | `i` | `(I)V` | 1 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `c` | `(Lcom/aspiro/wamp/model/Album;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/AlbumSource;` | 1 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `f` | `(Lcom/aspiro/wamp/model/Playlist;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/PlaylistSource;` | 1 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `p` | `(Ljava/lang/String;Ljava/util/List;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;` | 1 |
+| `Lcom/aspiro/wamp/playqueue/source/model/b;` | `m` | `(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/MyItemsSource;` | 1 |
+| `Lcom/aspiro/wamp/search/v2/UnifiedSearchView;` | `c` | `:Ltl/q;` | 1 |
+| `Lcom/aspiro/wamp/search/v2/model/UnifiedSearchQuery;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lcom/aspiro/wamp/util/h0;` | `c` | `(I)Ljava/lang/String;` | 1 |
+| `Lcom/squareup/ui/market/components/MarketIconButtonKt;` | `P` | `(Lcom/squareup/ui/market/core/theme/MarketStylesheet;Lcom/squareup/ui/market/core/components/properties/IconButton$Size;Lcom/squareup/ui/market/core/components/properties/IconButton$Rank;Lcom/squareup/ui/market/core/components/properties/IconButton$Variant;ILjava/lang/Object;)Lq20/u1;` | 1 |
+| `Lcom/squareup/ui/market/components/MarketIconButtonKt;` | `b` | `(Lam0/a;Ljava/lang/String;Landroidx/compose/ui/Modifier;Landroidx/compose/foundation/interaction/MutableInteractionSource;ZLcom/squareup/ui/market/components/n;Lam0/a;Ljava/lang/String;Lq20/u1;Lam0/p;Landroidx/compose/runtime/Composer;II)V` | 1 |
+| `Lcom/squareup/ui/market/components/MarketLabelKt;` | `e` | `(Ljava/lang/String;Landroidx/compose/ui/Modifier;IILcom/squareup/ui/market/text/a;Landroidx/compose/foundation/interaction/MutableInteractionSource;Lam0/l;Lq20/c2;Landroidx/compose/runtime/Composer;II)V` | 1 |
+| `Lcom/squareup/ui/market/core/theme/k;` | `e` | `:Lcom/squareup/ui/market/core/theme/k$a;` | 1 |
+| `Lcom/squareup/ui/market/core/theme/z;` | `t` | `(Lcom/squareup/ui/market/core/theme/k$a;Landroidx/compose/runtime/Composer;I)Lcom/squareup/ui/market/core/theme/MarketStylesheet;` | 1 |
+| `Lcom/squareup/ui/market/layout/e;` | `c` | `(Landroid/graphics/Bitmap;I)Landroid/graphics/Bitmap;` | 1 |
+| `Lcom/tidal/android/core/debug/DebugFeatureInteractorDefault;` | `a` | `:Lcom/tidal/android/featureflags/n;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/c;` | `a` | `:Lcom/aspiro/wamp/core/k;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/composables/compactgridcard/d;` | `b` | `:Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/composables/compactgridcard/d;` | `c` | `:Ljava/lang/String;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/ArtistTrackCreditsModuleManager;` | `b` | `:Lcom/tidal/android/dynamicpages/ui/b;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;` | `b` | `:Lcom/tidal/android/dynamicpages/ui/b;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c;` | `f` | `:Lam0/q;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/PublicPlaylistListModuleManager;` | `f` | `:Lcom/tidal/android/dynamicpages/ui/b;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/tracklist/TrackListModuleManager;` | `b` | `:Lcom/tidal/android/dynamicpages/ui/b;` | 1 |
+| `Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/VerticalListCardModuleManager;` | `e` | `:Lcom/tidal/android/dynamicpages/ui/b;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/composable/g;` | `a` | `:Lam0/l;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/q;` | `d` | `:Ljava/lang/String;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/q;` | `e` | `:Z` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/r$a;` | `a` | `:Lcom/tidal/android/feature/appscaffold/ui/r$a;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/t;` | `b` | `:Lcom/tidal/android/feature/appscaffold/ui/q;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/t;` | `c` | `:Lcom/tidal/android/feature/appscaffold/ui/MiniPlayerContract$PlayState;` | 1 |
+| `Lcom/tidal/android/feature/appscaffold/ui/t;` | `a` | `:Lcom/tidal/android/feature/appscaffold/ui/MiniPlayerContract$ItemType;` | 1 |
+| `Lcom/tidal/android/feature/feed/ui/FeedView;` | `d` | `:Lv70/b;` | 1 |
+| `Lcom/tidal/android/feature/feed/ui/FeedView;` | `c` | `:La80/c;` | 1 |
+| `Lcom/tidal/android/feature/feed/ui/FeedView;` | `f` | `:Lio/reactivex/disposables/CompositeDisposable;` | 1 |
+| `Lcom/tidal/android/feature/feed/ui/c;` | `c` | `:Lz70/a;` | 1 |
+| `Lcom/tidal/android/feature/feed/ui/viewstates/UpdatedIntervals$a;` | `a` | `(I)Ljava/lang/String;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel$observeLyricsProgress$1$a;` | `a` | `:Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `W` | `:Lkotlinx/coroutines/flow/StateFlow;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `Q` | `:Lkotlin/i;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `a` | `:Lbi/e;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `O` | `:Lkotlinx/coroutines/flow/MutableStateFlow;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;` | `K` | `:Lkotlinx/coroutines/flow/MutableStateFlow;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/b0;` | `b` | `:Lcom/tidal/android/feature/playerscreen/ui/s$a;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/CoverPagerKt;` | `c` | `(Lcom/tidal/android/feature/playerscreen/ui/d;Lam0/l;FLandroidx/compose/ui/Modifier;ZLandroidx/compose/runtime/Composer;II)V` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/LyricsKt;` | `a` | `(Lcom/tidal/android/feature/playerscreen/ui/g;Lam0/l;Landroidx/compose/ui/Modifier;Landroidx/compose/foundation/layout/PaddingValues;Lam0/l;Landroidx/compose/runtime/Composer;II)V` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/anim/BouncePressKt;` | `a` | `(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/e5;` | `a` | `(ILam0/a;Landroidx/compose/runtime/Composer;Landroidx/compose/ui/Modifier;)V` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/k1;` | `a` | `(Landroidx/compose/ui/Modifier;Lam0/a;ZLandroidx/compose/runtime/Composer;I)V` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/o1;` | `a` | `:F` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/composables/t4;` | `g` | `:F` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/g$c;` | `c` | `:I` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/p;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | `j` | `:Lcom/tidal/android/feature/playerscreen/ui/g;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | `d` | `:Lcom/tidal/android/feature/playerscreen/ui/b;` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | `i` | `:Z` | 1 |
+| `Lcom/tidal/android/feature/playerscreen/ui/s$a;` | `c` | `:Lcom/tidal/android/feature/playerscreen/ui/d;` | 1 |
+| `Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;` | `n` | `:Ljava/util/List;` | 1 |
+| `Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;` | `d` | `:Lcom/tidal/android/feature/search/ui/e;` | 1 |
+| `Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;` | `f` | `:Lcom/tidal/android/feature/search/ui/f;` | 1 |
+| `Lcom/tidal/android/feature/search/ui/f;` | `a` | `(JLh40/p;Ljava/lang/String;)V` | 1 |
+| `Lcom/tidal/android/feature/viewall/ui/ViewAllScreenViewModel;` | `n` | `:Lcom/tidal/android/feature/viewall/ui/c;` | 1 |
+| `Lcom/tidal/android/feature/viewall/ui/ViewAllScreenViewModel;` | `f` | `:Lcom/tidal/android/feature/viewall/ui/u;` | 1 |
+| `Lcom/tidal/android/feature/viewall/ui/c;` | `f` | `:Ljava/util/ArrayList;` | 1 |
+| `Lcom/tidal/android/feature/viewall/ui/e$c;` | `a` | `:Ljava/lang/Object;` | 1 |
+| `Lcom/tidal/android/image/coil/base/CoilImageLoader;` | `a` | `:Lcoil/f;` | 1 |
+| `Lcom/tidal/android/image/coil/c;` | `a` | `(Lxd0/g;Landroidx/compose/ui/layout/ContentScale;)Lcoil/request/h;` | 1 |
+| `Lde0/c;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Le5/z$n2;` | `z0` | `:Ldagger/internal/j;` | 1 |
+| `Le5/z$n2;` | `u3` | `()Lcom/aspiro/wamp/playback/f;` | 1 |
+| `Le5/z$n2;` | `x3` | `()Lcom/aspiro/wamp/playback/e0;` | 1 |
+| `Le5/z$n2;` | `w8` | `:Ldagger/internal/f;` | 1 |
+| `Le5/z$n2;` | `y3` | `()Lcom/aspiro/wamp/playback/k0;` | 1 |
+| `Le5/z$n2;` | `v8` | `:Ldagger/internal/f;` | 1 |
+| `Le5/z$n2;` | `K9` | `:Ldagger/internal/f;` | 1 |
+| `Le5/z$n2;` | `k9` | `:Ldagger/internal/f;` | 1 |
+| `Lfd/c;` | `a` | `:Lx40/a;` | 1 |
+| `Lfd/c;` | `d` | `:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;` | 1 |
+| `Lfd/c;` | `c` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lgh/b;` | `b` | `:F` | 1 |
+| `Lgh/j;` | `a` | `()V` | 1 |
+| `Lgh/j;` | `d` | `:Lio/reactivex/subjects/BehaviorSubject;` | 1 |
+| `Lh4/a;` | `q` | `(Landroidx/fragment/app/FragmentActivity;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z` | 1 |
+| `Lh4/a;` | `n` | `:Lcom/aspiro/wamp/contextmenu/menu/track/TrackContextMenu$a;` | 1 |
+| `Lhf/c;` | `e` | `:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;` | 1 |
+| `Lhf/c;` | `d` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lj3/k$a;` | `a` | `(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/k;` | 1 |
+| `Lj3/k;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lj3/n$a;` | `a` | `(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/n;` | 1 |
+| `Lj3/n;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lj3/q$a;` | `a` | `(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/q;` | 1 |
+| `Lj3/q;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lk5/f;` | `l` | `(Ljava/lang/String;)Lcom/aspiro/wamp/dynamicpages/data/model/Module;` | 1 |
+| `Lld/c;` | `a` | `:Lx40/a;` | 1 |
+| `Lld/c;` | `d` | `:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;` | 1 |
+| `Lld/c;` | `c` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lm3/d;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lm3/f;` | `j` | `:Lcom/aspiro/wamp/playqueue/g1;` | 1 |
+| `Lm3/i$a;` | `a` | `(Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Lm3/i;` | 1 |
+| `Lm3/i;` | `b` | `(Landroidx/fragment/app/FragmentActivity;)V` | 1 |
+| `Lmb/f;` | `c` | `:Ljava/util/Map;` | 1 |
+| `Lmb0/a;` | `a` | `:Lh40/n;` | 1 |
+| `Lmb0/f;` | `a` | `(Lmb0/e;)Ljava/lang/String;` | 1 |
+| `Ln8/d;` | `f` | `:Lcom/aspiro/wamp/model/MediaItem;` | 1 |
+| `Lo3/a;` | `l` | `:Lcom/aspiro/wamp/module/album/AlbumProvider;` | 1 |
+| `Lo3/a;` | `e` | `:Lc3/i$a;` | 1 |
+| `Lo3/a;` | `d` | `:Lc3/l$a;` | 1 |
+| `Lo4/g;` | `e` | `:Lo4/g$e;` | 1 |
+| `Lo4/g;` | `b` | `:I` | 1 |
+| `Lo6/i;` | `g` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lo6/i;` | `e` | `(ILjava/lang/String;)V` | 1 |
+| `Lo6/i;` | `m` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lob0/q;` | `a` | `(Lpb0/b$e;Lam0/a;Landroidx/compose/ui/Modifier;Lam0/a;Landroidx/compose/runtime/Composer;I)V` | 1 |
+| `Lob0/w;` | `a` | `(Lpb0/b$f;Lam0/a;Landroidx/compose/ui/Modifier;Lam0/a;Landroidx/compose/runtime/Composer;I)V` | 1 |
+| `Lpb0/b$a;` | `a` | `:J` | 1 |
+| `Lpb0/b$a;` | `f` | `:Z` | 1 |
+| `Lpb0/b$e;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lpb0/b$f;` | `a` | `:Ljava/lang/String;` | 1 |
+| `Lpb0/b$i;` | `a` | `:J` | 1 |
+| `Lpb0/b$i;` | `i` | `:Z` | 1 |
+| `Lpd0/a;` | `a` | `:Lh40/n;` | 1 |
+| `Lpe/f;` | `a` | `:Lx40/a;` | 1 |
+| `Lpe/f;` | `b` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lq20/c2;` | `g` | `(Lq20/c2;Lq20/s4;Lf20/d;Lcom/squareup/ui/market/core/text/MarketTextAlignment;Lcom/squareup/ui/market/core/text/MarketTextTransform;Lq20/r4;ILjava/lang/Object;)Lq20/c2;` | 1 |
+| `Lra/d;` | `b` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Ltl/f;` | `e` | `(Lcom/aspiro/wamp/search/v2/a;)V` | 1 |
+| `Ltl/h;` | `c` | `()Lcom/aspiro/wamp/search/v2/model/UnifiedSearchQuery;` | 1 |
+| `Ltl/q;` | `c` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lu3/a;` | `j` | `:Lj3/k$a;` | 1 |
+| `Lu3/a;` | `e` | `:Lj3/n$a;` | 1 |
+| `Lu3/a;` | `d` | `:Lj3/q$a;` | 1 |
+| `Lu5/b$a$a;` | `g` | `(ILjava/lang/String;)V` | 1 |
+| `Lu5/g;` | `h` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lu5/g;` | `j` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lv9/e;` | `b` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+| `Lv9/e;` | `a` | `:Lcom/aspiro/wamp/core/k;` | 1 |
+| `Lvn0/a;` | `c` | `(Ljava/lang/Iterable;)Lvn0/b;` | 1 |
+| `Lz70/a;` | `c` | `:Lcom/aspiro/wamp/model/AvailabilityInteractor;` | 1 |
+| `Lzf/c;` | `c` | `:Lcom/tidal/android/navigation/NavigationInfo;` | 1 |
+
+## 3. Rolled patch target classes (65)
+
+`--- a/` headers naming an obfuscated class. If these move the hunk cannot even be located.
+
+| target | hooked by |
+|---|---|
+| `bk0/e.smali` | `integration-pebble-playback.patch` |
+| `cg0/h.smali` | `lyrics-rl-api-isrc.patch` |
+| `com/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/mycollection/subpages/albums/search/SearchAlbumsView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/mycollection/subpages/playlists/searchplaylists/SearchPlaylistsView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/nowplaying/view/playqueue/l.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/nowplaying/view/suggestions/h.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/nowplaying/view/suggestions/o0.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/playlist/ui/fragment/PlaylistFragment.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/aspiro/wamp/search/v2/UnifiedSearchView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/tidal/android/core/debug/DebugFeatureInteractorDefault.smali` | `debug-menu-unlock.patch` |
+| `com/tidal/android/core/ui/composable/c0.smali` | `player-backdrop-kawarp.patch`, `player-backdrop-playback.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/artisttrackcredits/h.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/compactgridcard/CompactGridCardModuleRowKt.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/compactgridcard/d.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/publicplaylistlist/i.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/verticallistcard/VerticalListCardKt.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/composables/verticaltracklist/j.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/modules/artisttrackcredits/ArtistTrackCreditsModuleManager$createModuleViewState$3.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/modules/compactgridcard/CompactGridCardModuleManager$createModuleViewState$2$2.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/modules/publicplaylistlist/PublicPlaylistListModuleManager$createModuleViewState$3.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/modules/tracklist/TrackListModuleManager$createModuleViewState$3.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/dynamicpages/ui/modules/verticallistcard/VerticalListCardModuleManager$createModuleViewState$3.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/feature/appscaffold/ui/MiniPlayerViewModel.smali` | `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `com/tidal/android/feature/appscaffold/ui/composable/MiniPlayerKt.smali` | `gestures/mini-player/mini-player-left-right-gesture.patch`, `gestures/mini-player/mini-player-up-gesture.patch` |
+| `com/tidal/android/feature/appscaffold/ui/composable/a.smali` | `mini-player-black.patch`, `mini-player-grey.patch` |
+| `com/tidal/android/feature/appscaffold/ui/composable/g.smali` | `gestures/mini-player/mini-player-left-right-gesture.patch` |
+| `com/tidal/android/feature/appscaffold/ui/composable/i.smali` | `gestures/mini-player/mini-player-up-gesture.patch`, `mini-player-black.patch`, `mini-player-dynamic-bg.patch`, `mini-player-floating-border.patch`, `mini-player-grey.patch` |
+| `com/tidal/android/feature/appscaffold/ui/q.smali` | `cover-capture.patch` |
+| `com/tidal/android/feature/appscaffold/ui/t.smali` | `cover-capture.patch` |
+| `com/tidal/android/feature/feed/ui/FeedView.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `com/tidal/android/feature/home/ui/composables/g.smali` | `home-backdrop.patch` |
+| `com/tidal/android/feature/home/ui/k.smali` | `home-backdrop.patch` |
+| `com/tidal/android/feature/home/ui/o.smali` | `home-backdrop.patch` |
+| `com/tidal/android/feature/playerscreen/ui/PlayerScreenKt$PlayerScreenPortrait$2$1.smali` | `lyrics-keep-controls-visible.patch` |
+| `com/tidal/android/feature/playerscreen/ui/PlayerScreenKt.smali` | `lyrics-replace-lyrics-button.patch`, `lyrics-replace-share-button.patch`, `lyrics-sparkle-conditional-visibility.patch`, `player-backdrop-kawarp.patch`, `player-backdrop-playback.patch`, `player-hide-playing-from.patch`, `player-move-playing-from.patch`, `player-one-handed.patch` |
+| `com/tidal/android/feature/playerscreen/ui/PlayerViewModel$observeLyricsProgress$1$a.smali` | `lyrics-rl-api-observer.patch` |
+| `com/tidal/android/feature/playerscreen/ui/PlayerViewModel$special$$inlined$mapNotNull$1$2.smali` | `lyrics-rl-api.patch`, `player-quality-badge-colors.patch` |
+| `com/tidal/android/feature/playerscreen/ui/PlayerViewModel.smali` | `lyrics-keep-controls-visible.patch`, `lyrics-rl-api.patch`, `mini-player-dynamic-bg.patch` |
+| `com/tidal/android/feature/playerscreen/ui/b0.smali` | `lyrics-disable-cover.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/LyricsKt.smali` | `gestures/lyrics/lyrics-gesture-scroll-guard.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/SeekbarAndTimeKt.smali` | `player-quality-badge-colors.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/c1.smali` | `player-favorite-heart.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/f2.smali` | `lyrics-rl-api-syllable.patch`, `lyrics-rl-api-word.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/n2.smali` | `player-move-playing-from.patch` |
+| `com/tidal/android/feature/playerscreen/ui/composables/o1.smali` | `lyrics-fade-region.patch` |
+| `com/tidal/android/feature/playerscreen/ui/i$a.smali` | `player-quality-badge-colors.patch` |
+| `com/tidal/android/feature/playerscreen/ui/m0.smali` | `lyrics-progress-pill.patch` |
+| `com/tidal/android/feature/search/ui/SearchScreenViewModel.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/feature/search/ui/composables/u0.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/feature/viewall/ui/ViewAllScreenViewModel.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/android/feature/viewall/ui/l.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `com/tidal/wave2/foundation/WaveScaffoldKt.smali` | `collection-backdrop.patch` |
+| `de0/c.smali` | `player-backdrop-playback.patch` |
+| `h4/a.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `hg/d.smali` | `enable-legacy-ui.patch` |
+| `j40/e4.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `j40/p2.smali` | `gestures/queue/swipe-to-queue-compose.patch` |
+| `mb/f.smali` | `integration-waze-playback.patch` |
+| `p7/a.smali` | `gestures/queue/swipe-to-queue.patch` |
+| `v6/e.smali` | `gestures/queue/swipe-to-queue.patch` |
+
+## 4. Occurrences inside .patch files - not marked inline (221)
+
+| file | line | kind | symbols |
+|---|---:|---|---|
+| `cover-capture.patch` | 5 | context | `Lcom/tidal/android/feature/appscaffold/ui/q; d` |
+| `cover-capture.patch` | 11 | context | `Lcom/tidal/android/feature/appscaffold/ui/q; e` |
+| `cover-capture.patch` | 15 | context | `Lcom/tidal/android/feature/appscaffold/ui/q;` |
+| `debug-menu-unlock.patch` | 11 | context | `Lcom/tidal/android/featureflags/n; a` |
+| `debug-menu-unlock.patch` | 26 | context | `Lo50/a; a` |
+| `debug-menu-unlock.patch` | 36 | context | `Lo50/a; a` |
+| `gestures/lyrics/lyrics-gesture-scroll-guard.patch` | 12 | context | `Lam0/l;` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 7 | added | `Lam0/l;` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 16 | context | `Lcom/tidal/android/feature/appscaffold/ui/t; Lcom/tidal/android/feature/appscaffold/ui/q; b` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 32 | context | `Lf20/a; p0` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 63 | context | `Lbi/e; i` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 73 | added | `Lcom/tidal/android/feature/appscaffold/ui/r$c; a` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 81 | added | `Lbi/e;` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 89 | added | `Lbi/e; h` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 95 | context | `Landroidx/navigation/f0;` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 116 | added | `Lkotlin/u;` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 122 | context | `Lcom/tidal/android/feature/appscaffold/ui/composable/g; Lam0/l; a` |
+| `gestures/mini-player/mini-player-left-right-gesture.patch` | 126 | context | `Lcom/tidal/android/feature/appscaffold/ui/b$b; a` |
+| `gestures/mini-player/mini-player-up-gesture.patch` | 14 | added | `Lam0/l;` |
+| `gestures/mini-player/mini-player-up-gesture.patch` | 23 | context | `Lcom/tidal/android/feature/appscaffold/ui/t; c` |
+| `gestures/mini-player/mini-player-up-gesture.patch` | 25 | added | `Lcom/tidal/android/feature/appscaffold/ui/t; a` |
+| `gestures/mini-player/mini-player-up-gesture.patch` | 64 | context | `Lf20/a; p0` |
+| `gestures/player/player-swipe-gesture.patch` | 35 | added | `Lam0/l;` |
+| `gestures/player/player-swipe-gesture.patch` | 37 | added | `Lam0/l;` |
+| `gestures/player/player-swipe-gesture.patch` | 41 | context | `Lam0/l;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 5 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 7 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 18 | added | `Lm40/e$e; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 26 | added | `Lam0/l; Lm40/e$e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 28 | added | `Lm40/e$e; j` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 54 | context | `Landroidx/navigation/f0;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 60 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 72 | added | `Lam0/l; Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 93 | added | `Lcom/tidal/android/dynamicpages/ui/composables/compactgridcard/d; Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c; b` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 95 | added | `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c; Lam0/q; f` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 97 | added | `Lcom/tidal/android/dynamicpages/ui/composables/compactgridcard/d; c` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 99 | added | `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/c; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 103 | added | `Lam0/q;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 105 | added | `Lkotlin/u;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 123 | added | `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 127 | added | `Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 129 | added | `Lkotlin/u;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 159 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 161 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 167 | added | `Lam0/l; Lpb0/b;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 173 | added | `Lpb0/b$a; f` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 187 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 193 | added | `Lam0/l; Lpb0/b;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 208 | context | `Lob0/w; Lpb0/b$f; Lam0/a; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 211 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 213 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 219 | added | `Lam0/l; Lpb0/b;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 225 | added | `Lpb0/b$i; i` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 239 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 245 | added | `Lam0/l; Lpb0/b;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 260 | context | `Lob0/q; Lpb0/b$e; Lam0/a; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 265 | context | `Lam0/l;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 267 | added | `Lm40/e$e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 273 | added | `Lm40/e$e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 275 | added | `Lm40/e$e; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 283 | added | `Lam0/l; Lm40/e$e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 285 | added | `Lm40/e$e; j` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 300 | added | `Lcom/tidal/android/feature/viewall/ui/n;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 304 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 318 | added | `Lcom/tidal/android/feature/viewall/ui/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 324 | added | `Lkotlin/u;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 330 | context | `Lcom/tidal/android/feature/viewall/ui/e$a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 334 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 335 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 341 | added | `Lm40/e$e; a` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 349 | added | `Lam0/l; Lm40/e$e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 351 | added | `Lm40/e$e; j` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 376 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 384 | added | `Lam0/l; Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 390 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 402 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 403 | added | `Lcom/tidal/android/dynamicpages/ui/composables/verticallistcard/m;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 407 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 413 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 415 | added | `Lm40/e;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 421 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 429 | context | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 430 | added | `Lam0/a;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 438 | added | `Lam0/l; Lm40/e$d;` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 444 | added | `Lm40/e$d; g` |
+| `gestures/queue/swipe-to-queue-compose.patch` | 480 | context | `Landroidx/navigation/f0;` |
+| `gestures/queue/swipe-to-queue.patch` | 13 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; d` |
+| `gestures/queue/swipe-to-queue.patch` | 17 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; b` |
+| `gestures/queue/swipe-to-queue.patch` | 33 | added | `f` |
+| `gestures/queue/swipe-to-queue.patch` | 62 | added | `Y` |
+| `gestures/queue/swipe-to-queue.patch` | 69 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; d` |
+| `gestures/queue/swipe-to-queue.patch` | 73 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; b` |
+| `gestures/queue/swipe-to-queue.patch` | 79 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; m` |
+| `gestures/queue/swipe-to-queue.patch` | 81 | added | `Lcom/aspiro/wamp/playqueue/source/model/b; m` |
+| `gestures/queue/swipe-to-queue.patch` | 87 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/g0; k` |
+| `gestures/queue/swipe-to-queue.patch` | 89 | added | `Lx40/a; b` |
+| `gestures/queue/swipe-to-queue.patch` | 91 | added | `Lh4/a;` |
+| `gestures/queue/swipe-to-queue.patch` | 95 | added | `Lh4/a;` |
+| `gestures/queue/swipe-to-queue.patch` | 126 | added | `Lh4/a; q` |
+| `gestures/queue/swipe-to-queue.patch` | 142 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m; l` |
+| `gestures/queue/swipe-to-queue.patch` | 146 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m; f` |
+| `gestures/queue/swipe-to-queue.patch` | 148 | added | `w` |
+| `gestures/queue/swipe-to-queue.patch` | 156 | context | `Ln8/b;` |
+| `gestures/queue/swipe-to-queue.patch` | 159 | context | `Lo4/g; Lo4/g$e; e` |
+| `gestures/queue/swipe-to-queue.patch` | 163 | context | `Lo4/g; b` |
+| `gestures/queue/swipe-to-queue.patch` | 164 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m; l` |
+| `gestures/queue/swipe-to-queue.patch` | 168 | added | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/m; f` |
+| `gestures/queue/swipe-to-queue.patch` | 174 | context | `Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/n; N` |
+| `gestures/queue/swipe-to-queue.patch` | 207 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 218 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 230 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 270 | added | `Lh4/a; n` |
+| `gestures/queue/swipe-to-queue.patch` | 272 | added | `Lcom/aspiro/wamp/contextmenu/menu/track/d;` |
+| `gestures/queue/swipe-to-queue.patch` | 274 | added | `Lcom/aspiro/wamp/contextmenu/menu/track/d; Lcom/aspiro/wamp/contextmenu/menu/track/c; a` |
+| `gestures/queue/swipe-to-queue.patch` | 276 | added | `Lcom/aspiro/wamp/contextmenu/menu/track/c; Ldagger/internal/j; b` |
+| `gestures/queue/swipe-to-queue.patch` | 278 | added | `Lql0/a;` |
+| `gestures/queue/swipe-to-queue.patch` | 282 | added | `Lm3/f$a;` |
+| `gestures/queue/swipe-to-queue.patch` | 284 | added | `Lm3/f$a; Lm3/f; a` |
+| `gestures/queue/swipe-to-queue.patch` | 288 | added | `Lm3/f; Lcom/aspiro/wamp/playqueue/g1; j` |
+| `gestures/queue/swipe-to-queue.patch` | 290 | added | `Lcom/aspiro/wamp/playqueue/g1; Lcom/aspiro/wamp/player/d; a` |
+| `gestures/queue/swipe-to-queue.patch` | 294 | added | `Lcom/aspiro/wamp/player/d; b` |
+| `gestures/queue/swipe-to-queue.patch` | 300 | added | `Lm3/f; b` |
+| `gestures/queue/swipe-to-queue.patch` | 323 | context | `Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/a; Lcom/aspiro/wamp/nowplaying/view/playqueue/l;` |
+| `gestures/queue/swipe-to-queue.patch` | 346 | added | `h` |
+| `gestures/queue/swipe-to-queue.patch` | 357 | added | `i` |
+| `gestures/queue/swipe-to-queue.patch` | 359 | context | `d` |
+| `gestures/queue/swipe-to-queue.patch` | 430 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 443 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 456 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 469 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 482 | context | `Lcom/tidal/android/feature/appscaffold/ui/recyclerview/b; Lcom/tidal/android/feature/appscaffold/ui/recyclerview/a; a` |
+| `gestures/queue/swipe-to-queue.patch` | 500 | context | `Lcom/aspiro/wamp/nowplaying/view/suggestions/o0; Lcom/aspiro/wamp/nowplaying/view/suggestions/l; M` |
+| `integration-pebble-playback.patch` | 30 | context | `Lbk0/d; Lbk0/e;` |
+| `integration-waze-playback.patch` | 9 | added | `Lkotlin/jvm/internal/n;` |
+| `integration-waze-playback.patch` | 17 | added | `Lkotlin/jvm/internal/n;` |
+| `integration-waze-playback.patch` | 35 | added | `Lkotlin/jvm/internal/n;` |
+| `integration-waze-playback.patch` | 55 | context | `Lmb/f; c` |
+| `lyrics-disable-cover.patch` | 11 | added | `Lcom/tidal/android/feature/playerscreen/ui/b0; Lcom/tidal/android/feature/playerscreen/ui/s$a; b` |
+| `lyrics-disable-cover.patch` | 13 | added | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/g; j` |
+| `lyrics-disable-cover.patch` | 15 | added | `Lcom/tidal/android/feature/playerscreen/ui/g$a;` |
+| `lyrics-disable-cover.patch` | 19 | context | `Lcom/tidal/android/feature/playerscreen/ui/d; Lam0/l; c` |
+| `lyrics-fade-region.patch` | 7 | removed | `Lcom/tidal/android/feature/playerscreen/ui/composables/o1; a` |
+| `lyrics-keep-controls-visible.patch` | 28 | added | `Lkotlin/u;` |
+| `lyrics-progress-pill.patch` | 14 | context | `Lcom/tidal/android/feature/playerscreen/ui/g; Lam0/l; a` |
+| `lyrics-progress-pill.patch` | 60 | added | `Lam0/a;` |
+| `lyrics-progress-pill.patch` | 72 | added | `Lam0/l;` |
+| `lyrics-replace-lyrics-button.patch` | 8 | removed | `Lcom/tidal/android/feature/playerscreen/ui/composables/k1; Lam0/a; a` |
+| `lyrics-replace-lyrics-button.patch` | 19 | context | `Lcom/tidal/android/feature/playerscreen/ui/composables/s3; Lam0/a; a` |
+| `lyrics-replace-lyrics-button.patch` | 21 | added | `Landroidx/window/embedding/a2;` |
+| `lyrics-replace-lyrics-button.patch` | 27 | added | `Landroidx/window/embedding/a2;` |
+| `lyrics-replace-lyrics-button.patch` | 35 | added | `Lam0/a;` |
+| `lyrics-replace-lyrics-button.patch` | 38 | context | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/p; m` |
+| `lyrics-replace-share-button.patch` | 7 | removed | `Lcom/tidal/android/feature/playerscreen/ui/b; Lam0/a; b` |
+| `lyrics-replace-share-button.patch` | 20 | removed | `Lcom/tidal/android/feature/playerscreen/ui/e0;` |
+| `lyrics-replace-share-button.patch` | 21 | added | `Landroidx/window/embedding/b2;` |
+| `lyrics-replace-share-button.patch` | 26 | removed | `Lcom/tidal/android/feature/playerscreen/ui/e0;` |
+| `lyrics-replace-share-button.patch` | 27 | added | `Landroidx/window/embedding/b2;` |
+| `lyrics-replace-share-button.patch` | 33 | context | `Lam0/a;` |
+| `lyrics-replace-share-button.patch` | 36 | added | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/b; d` |
+| `lyrics-replace-share-button.patch` | 42 | removed | `Lcom/tidal/android/feature/playerscreen/ui/composables/e5; Lam0/a; a` |
+| `lyrics-replace-share-button.patch` | 43 | added | `Lcom/tidal/android/feature/playerscreen/ui/b; Lam0/a; b` |
+| `lyrics-rl-api-isrc.patch` | 4 | context | `Lcom/tidal/android/tidalapi/domain/model/o;` |
+| `lyrics-rl-api-observer.patch` | 10 | context | `a` |
+| `lyrics-rl-api-observer.patch` | 34 | context | `Lcom/tidal/android/feature/playerscreen/ui/g$c; c` |
+| `lyrics-rl-api-syllable.patch` | 14 | context | `Lcom/tidal/android/feature/playerscreen/ui/f;` |
+| `lyrics-rl-api-syllable.patch` | 23 | context | `Lcom/tidal/android/feature/playerscreen/ui/f; a` |
+| `lyrics-rl-api-syllable.patch` | 25 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; b` |
+| `lyrics-rl-api-syllable.patch` | 29 | added | `Lcom/tidal/android/feature/playerscreen/ui/f; a` |
+| `lyrics-rl-api-syllable.patch` | 33 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; d` |
+| `lyrics-rl-api-syllable.patch` | 37 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; e` |
+| `lyrics-rl-api-syllable.patch` | 64 | added | `Lam0/l;` |
+| `lyrics-rl-api-syllable.patch` | 76 | removed | `Lam0/l;` |
+| `lyrics-rl-api-syllable.patch` | 77 | added | `Lam0/l;` |
+| `lyrics-rl-api-word.patch` | 14 | context | `Lcom/tidal/android/feature/playerscreen/ui/f;` |
+| `lyrics-rl-api-word.patch` | 23 | context | `Lcom/tidal/android/feature/playerscreen/ui/f; a` |
+| `lyrics-rl-api-word.patch` | 25 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; b` |
+| `lyrics-rl-api-word.patch` | 29 | added | `Lcom/tidal/android/feature/playerscreen/ui/f; a` |
+| `lyrics-rl-api-word.patch` | 33 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; d` |
+| `lyrics-rl-api-word.patch` | 37 | added | `Lcom/tidal/android/feature/playerscreen/ui/composables/f2; e` |
+| `lyrics-rl-api-word.patch` | 52 | removed | `Lam0/l;` |
+| `lyrics-rl-api-word.patch` | 53 | added | `Lam0/l;` |
+| `lyrics-rl-api.patch` | 77 | context | `P` |
+| `lyrics-sparkle-conditional-visibility.patch` | 5 | context | `Lcom/tidal/android/feature/playerscreen/ui/composables/s3; Lam0/a; a` |
+| `lyrics-sparkle-conditional-visibility.patch` | 7 | added | `Lcom/tidal/android/feature/playerscreen/ui/s$a; i` |
+| `lyrics-sparkle-conditional-visibility.patch` | 15 | context | `Landroidx/window/embedding/a2;` |
+| `lyrics-sparkle-conditional-visibility.patch` | 20 | context | `Lam0/a;` |
+| `lyrics-sparkle-conditional-visibility.patch` | 36 | context | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/p; m` |
+| `mini-player-black.patch` | 56 | context | `Lcom/tidal/android/feature/appscaffold/ui/composable/a; c` |
+| `mini-player-black.patch` | 71 | context | `Lam0/p;` |
+| `mini-player-dynamic-bg.patch` | 14 | context | `Lcom/tidal/android/feature/appscaffold/ui/composable/a; c` |
+| `mini-player-dynamic-bg.patch` | 20 | context | `W` |
+| `mini-player-dynamic-bg.patch` | 22 | added | `Lkotlin/i; Q` |
+| `mini-player-dynamic-bg.patch` | 24 | added | `Lkotlin/i;` |
+| `mini-player-floating-border.patch` | 9 | added | `Lam0/l;` |
+| `mini-player-floating-border.patch` | 14 | context | `Lkotlin/u;` |
+| `mini-player-grey.patch` | 58 | context | `Lam0/p;` |
+| `player-backdrop-kawarp.patch` | 8 | removed | `Lcom/tidal/android/feature/playerscreen/ui/composables/p3; Lam0/a; b` |
+| `player-backdrop-kawarp.patch` | 9 | added | `Lam0/a;` |
+| `player-backdrop-kawarp.patch` | 36 | removed | `Lcom/tidal/android/feature/playerscreen/ui/composables/p3; Lam0/a; a` |
+| `player-backdrop-playback.patch` | 10 | context | `Lcom/tidal/android/feature/playerscreen/ui/composables/p3; Lam0/a; b` |
+| `player-backdrop-playback.patch` | 46 | removed | `Landroidx/compose/foundation/text/input/a;` |
+| `player-backdrop-playback.patch` | 73 | context | `Lde0/c; a` |
+| `player-backdrop-playback.patch` | 95 | context | `Lcom/squareup/ui/market/layout/e; c` |
+| `player-favorite-heart.patch` | 16 | removed | `La30/b; La30/a; O` |
+| `player-favorite-heart.patch` | 20 | removed | `La30/a; a` |
+| `player-hide-playing-from.patch` | 5 | context | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/p; m` |
+| `player-move-playing-from.patch` | 8 | added | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/p; m` |
+| `player-move-playing-from.patch` | 12 | added | `Lcom/tidal/android/feature/playerscreen/ui/p; a` |
+| `player-move-playing-from.patch` | 22 | context | `Lcom/tidal/android/feature/playerscreen/ui/s$a; Lcom/tidal/android/feature/playerscreen/ui/d; c` |
+| `player-move-playing-from.patch` | 29 | context | `Lq20/c2;` |
+| `player-move-playing-from.patch` | 61 | added | `Lcom/squareup/ui/market/text/a; Lam0/l; Lq20/c2; e` |
+| `player-quality-badge-colors.patch` | 5 | context | `Lcom/tidal/android/feature/playerscreen/ui/composables/t4; g` |
+| `player-quality-badge-colors.patch` | 16 | context | `Lcom/tidal/android/feature/playerscreen/ui/i$a;` |
+| `player-quality-badge-colors.patch` | 18 | added | `Lcom/tidal/android/feature/playerscreen/ui/i$a; b` |
+| `player-quality-badge-colors.patch` | 22 | context | `Lcom/tidal/android/feature/playerscreen/ui/i$a; a` |
+| `player-quality-badge-colors.patch` | 33 | added | `Lq20/c2;` |
+| `player-quality-badge-colors.patch` | 55 | added | `Lcom/tidal/android/feature/playerscreen/ui/i$a;` |
+| `player-quality-badge-colors.patch` | 66 | context | `Lcom/tidal/android/feature/playerscreen/ui/i$a; a` |
+| `player-quality-badge-colors.patch` | 68 | added | `Lcom/tidal/android/feature/playerscreen/ui/i$a; b` |
+| `player-quality-badge-colors.patch` | 111 | removed | `Lcom/tidal/android/feature/playerscreen/ui/i$a;` |
+| `player-quality-badge-colors.patch` | 114 | added | `Lcom/tidal/android/feature/playerscreen/ui/i$a;` |

patches/data.json

@@ -1,5 +1,5 @@
 {
   "tidalVersionCode": 10004,
   "tidalApkUrl": "https://github.com/meowarex/rl-mobile/releases/download/latest/tidal-stock.apk",
-  "patchesVersion": "1.1.2"
+  "patchesVersion": "1.2.8"
 }

patches/extension/com/tidal/android/feature/appscaffold/ui/r$c.smali

@@ -1,12 +1,12 @@
-.class public final Lcom/tidal/android/feature/appscaffold/ui/r$c;
-.super Lcom/tidal/android/feature/appscaffold/ui/r;
+.class public final Lcom/tidal/android/feature/appscaffold/ui/r$c;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c;
+.super Lcom/tidal/android/feature/appscaffold/ui/r;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r;
 .source "SourceFile"
 
 # Synthetic mini-player event used by right swipe (previous/rewind).
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lcom/tidal/android/feature/appscaffold/ui/r;
+    value = Lcom/tidal/android/feature/appscaffold/ui/r;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -16,18 +16,18 @@
 
 
 # static fields
-.field public static final a:Lcom/tidal/android/feature/appscaffold/ui/r$c;
+.field public static final a:Lcom/tidal/android/feature/appscaffold/ui/r$c;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c;
 
 
 # direct methods
 .method static constructor <clinit>()V
     .locals 1
 
-    new-instance v0, Lcom/tidal/android/feature/appscaffold/ui/r$c;
+    new-instance v0, Lcom/tidal/android/feature/appscaffold/ui/r$c;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c;
 
-    invoke-direct {v0}, Lcom/tidal/android/feature/appscaffold/ui/r;-><init>()V
+    invoke-direct {v0}, Lcom/tidal/android/feature/appscaffold/ui/r;-><init>()V    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r;
 
-    sput-object v0, Lcom/tidal/android/feature/appscaffold/ui/r$c;->a:Lcom/tidal/android/feature/appscaffold/ui/r$c;
+    sput-object v0, Lcom/tidal/android/feature/appscaffold/ui/r$c;->a:Lcom/tidal/android/feature/appscaffold/ui/r$c;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c; a
 
     return-void
 .end method
@@ -44,7 +44,7 @@
     return v0
 
     :cond_0
-    instance-of p1, p1, Lcom/tidal/android/feature/appscaffold/ui/r$c;
+    instance-of p1, p1, Lcom/tidal/android/feature/appscaffold/ui/r$c;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c;
 
     if-nez p1, :cond_1
 

patches/extension/radiant/HomeBackdrop.smali

@@ -5,9 +5,6 @@
 # static fields
 .field public static volatile currentAlbumId:I
 
-# 0 = Static, 1 = Animated (always rotate), 2 = Playback (follow live play state)
-.field public static volatile mode:I
-
 # Live play state from the mini-player (t.c PlayState = Playing)
 .field public static isPlayingState:Landroidx/compose/runtime/MutableState;
     .annotation system Ldalvik/annotation/Signature;
@@ -38,10 +35,6 @@
 
     sput v0, Lradiant/HomeBackdrop;->currentAlbumId:I
 
-    const/4 v0, 0x2
-
-    sput v0, Lradiant/HomeBackdrop;->mode:I
-
     sget-object v0, Ljava/lang/Boolean;->FALSE:Ljava/lang/Boolean;
 
     const/4 v1, 0x0
@@ -73,36 +66,6 @@
     return-void
 .end method
 
-.method public static setModeStatic()V
-    .locals 1
-
-    const/4 v0, 0x0
-
-    sput v0, Lradiant/HomeBackdrop;->mode:I
-
-    return-void
-.end method
-
-.method public static setModeAnimated()V
-    .locals 1
-
-    const/4 v0, 0x1
-
-    sput v0, Lradiant/HomeBackdrop;->mode:I
-
-    return-void
-.end method
-
-.method public static setModePlayback()V
-    .locals 1
-
-    const/4 v0, 0x2
-
-    sput v0, Lradiant/HomeBackdrop;->mode:I
-
-    return-void
-.end method
-
 # from the mini-player state ctor (t.<init>) whenever play state changes.
 .method public static onPlayState(Lcom/tidal/android/feature/appscaffold/ui/MiniPlayerContract$PlayState;)V
     .locals 2
@@ -378,13 +341,7 @@
 
     move-object v9, v1    # v9 = cover uuid
 
-    # v10 = isPlaying, mirrored from the Player Backdrop variant
-    sget v10, Lradiant/HomeBackdrop;->mode:I
-
-    const/4 v11, 0x2
-
-    if-ne v10, v11, :rl_mode_done
-
+    # v10 = isPlaying, straight from the live mini-player state (both modes follow it)
     sget-object v10, Lradiant/HomeBackdrop;->isPlayingState:Landroidx/compose/runtime/MutableState;
 
     invoke-interface {v10}, Landroidx/compose/runtime/State;->getValue()Ljava/lang/Object;
@@ -397,7 +354,6 @@
 
     move-result v10
 
-    :rl_mode_done
     const/4 v11, 0x0    # v11 = isSeeking = false
 
     const/4 v12, 0x0    # v12 = progress callback = null (unused while not seeking)

patches/extension/radiant/Kawarp.smali

@@ -0,0 +1,828 @@
+.class public final Lradiant/Kawarp;
+.super Ljava/lang/Object;
+
+# interfaces
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+.implements Ljava/lang/Runnable;
+.implements Landroid/view/Choreographer$FrameCallback;
+.implements Lb0/c;    # MARKER: R8 Lb0/c;
+
+
+# static fields
+.field private static final DRAW:Lradiant/Kawarp;
+
+.field private static final IDLE_STOP_MS:J = 0x1f4L
+
+.field private static final LOADER:Ljava/util/concurrent/ExecutorService;
+
+.field private static volatile appContext:Landroid/content/Context;
+
+.field private static engine:Ldev/kawarp/KawarpEngine;
+
+.field private static final fallbackState:Landroidx/compose/runtime/MutableState;
+
+.field private static frameScheduled:Z
+
+.field private static final frameState:Landroidx/compose/runtime/MutableIntState;
+
+.field private static frameTick:I
+
+.field private static lastDrawUptime:J
+
+.field private static volatile loadToken:I
+
+.field private static volatile loader:Lcoil/f;    # MARKER: R8 Lcoil/f;
+
+.field private static volatile requestedUuid:Ljava/lang/String;
+
+
+# instance fields
+.field private final albumId:I
+
+.field private final token:I
+
+.field private final uuid:Ljava/lang/String;
+
+
+# direct methods
+.method static constructor <clinit>()V
+    .registers 4
+
+    invoke-static {}, Ljava/util/concurrent/Executors;->newSingleThreadExecutor()Ljava/util/concurrent/ExecutorService;
+
+    move-result-object v0
+
+    sput-object v0, Lradiant/Kawarp;->LOADER:Ljava/util/concurrent/ExecutorService;
+
+    const/4 v0, 0x0
+
+    invoke-static {v0}, Landroidx/compose/runtime/SnapshotIntStateKt;->mutableIntStateOf(I)Landroidx/compose/runtime/MutableIntState;
+
+    move-result-object v1
+
+    sput-object v1, Lradiant/Kawarp;->frameState:Landroidx/compose/runtime/MutableIntState;
+
+    sget-object v1, Ljava/lang/Boolean;->FALSE:Ljava/lang/Boolean;
+
+    const/4 v2, 0x2
+
+    const/4 v3, 0x0
+
+    invoke-static {v1, v3, v2, v3}, Landroidx/compose/runtime/SnapshotStateKt;->mutableStateOf$default(Ljava/lang/Object;Landroidx/compose/runtime/SnapshotMutationPolicy;ILjava/lang/Object;)Landroidx/compose/runtime/MutableState;
+
+    move-result-object v1
+
+    sput-object v1, Lradiant/Kawarp;->fallbackState:Landroidx/compose/runtime/MutableState;
+
+    new-instance v1, Lradiant/Kawarp;
+
+    invoke-direct {v1, v0, v3, v0}, Lradiant/Kawarp;-><init>(ILjava/lang/String;I)V
+
+    sput-object v1, Lradiant/Kawarp;->DRAW:Lradiant/Kawarp;
+
+    return-void
+.end method
+
+.method private constructor <init>(ILjava/lang/String;I)V
+    .registers 4
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput p1, p0, Lradiant/Kawarp;->albumId:I
+
+    iput-object p2, p0, Lradiant/Kawarp;->uuid:Ljava/lang/String;
+
+    iput p3, p0, Lradiant/Kawarp;->token:I
+
+    return-void
+.end method
+
+.method private static attach(Landroidx/compose/runtime/Composer;)V
+    .registers 3
+
+    sget-object v0, Lradiant/Kawarp;->loader:Lcoil/f;    # MARKER: R8 Lcoil/f;
+
+    if-eqz v0, :cond_5
+
+    return-void
+
+    :cond_5
+    :try_start_5
+    invoke-static {}, Landroidx/compose/ui/platform/AndroidCompositionLocals_androidKt;->getLocalContext()Landroidx/compose/runtime/ProvidableCompositionLocal;
+
+    move-result-object v0
+
+    invoke-interface {p0, v0}, Landroidx/compose/runtime/Composer;->consume(Landroidx/compose/runtime/CompositionLocal;)Ljava/lang/Object;
+
+    move-result-object p0
+
+    instance-of v0, p0, Landroid/content/Context;
+
+    if-nez v0, :cond_12
+
+    return-void
+
+    :cond_12
+    check-cast p0, Landroid/content/Context;
+
+    invoke-virtual {p0}, Landroid/content/Context;->getApplicationContext()Landroid/content/Context;
+
+    move-result-object p0
+
+    instance-of v0, p0, Lce0/b$a;    # MARKER: R8 Lce0/b$a;
+
+    if-nez v0, :cond_1d
+
+    return-void
+
+    :cond_1d
+    move-object v0, p0
+
+    check-cast v0, Lce0/b$a;    # MARKER: R8 Lce0/b$a;
+
+    invoke-interface {v0}, Lce0/b$a;->a()Lce0/b;    # MARKER: R8 Lce0/b$a; Lce0/b; a
+
+    move-result-object v0
+
+    invoke-interface {v0}, Lce0/b;->a()Lxd0/e;    # MARKER: R8 Lce0/b; Lxd0/e; a
+
+    move-result-object v0
+
+    instance-of v1, v0, Lcom/tidal/android/image/coil/base/CoilImageLoader;
+
+    if-nez v1, :cond_2d
+
+    return-void
+
+    :cond_2d
+    sput-object p0, Lradiant/Kawarp;->appContext:Landroid/content/Context;
+
+    check-cast v0, Lcom/tidal/android/image/coil/base/CoilImageLoader;
+
+    iget-object p0, v0, Lcom/tidal/android/image/coil/base/CoilImageLoader;->a:Lcoil/f;    # MARKER: R8 Lcoil/f; a
+
+    sput-object p0, Lradiant/Kawarp;->loader:Lcoil/f;    # MARKER: R8 Lcoil/f;
+    :try_end_35
+    .catchall {:try_start_5 .. :try_end_35} :catchall_36
+
+    goto :goto_37
+
+    :catchall_36
+    move-exception p0
+
+    :goto_37
+    return-void
+.end method
+
+.method public static b(Lcom/tidal/android/feature/playerscreen/ui/model/PlayerBackgroundStyle;JILjava/lang/String;ZZLam0/a;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V    # MARKER: R8 Lam0/a;
+    .registers 11
+
+    invoke-static {p3, p4, p5, p8, p9}, Lradiant/Kawarp;->render(ILjava/lang/String;ZLandroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;)V
+
+    return-void
+.end method
+
+.method private static draw(Landroidx/compose/ui/graphics/drawscope/DrawScope;)V
+    .registers 4
+
+    sget-object v0, Lradiant/Kawarp;->frameState:Landroidx/compose/runtime/MutableIntState;
+
+    invoke-interface {v0}, Landroidx/compose/runtime/MutableIntState;->getIntValue()I
+
+    invoke-static {}, Landroid/os/SystemClock;->uptimeMillis()J
+
+    move-result-wide v0
+
+    sput-wide v0, Lradiant/Kawarp;->lastDrawUptime:J
+
+    invoke-static {}, Lradiant/Kawarp;->schedule()V
+
+    invoke-interface {p0}, Landroidx/compose/ui/graphics/drawscope/DrawScope;->getSize-NH-jbRc()J
+
+    move-result-wide v0
+
+    invoke-static {v0, v1}, Landroidx/compose/ui/geometry/Size;->getWidth-impl(J)F
+
+    move-result v2
+
+    invoke-static {v0, v1}, Landroidx/compose/ui/geometry/Size;->getHeight-impl(J)F
+
+    move-result v0
+
+    :try_start_1a
+    sget-object v1, Lradiant/Kawarp;->engine:Ldev/kawarp/KawarpEngine;
+
+    invoke-interface {p0}, Landroidx/compose/ui/graphics/drawscope/DrawScope;->getDrawContext()Landroidx/compose/ui/graphics/drawscope/DrawContext;
+
+    move-result-object p0
+
+    invoke-interface {p0}, Landroidx/compose/ui/graphics/drawscope/DrawContext;->getCanvas()Landroidx/compose/ui/graphics/Canvas;
+
+    move-result-object p0
+
+    invoke-static {p0}, Landroidx/compose/ui/graphics/AndroidCanvas_androidKt;->getNativeCanvas(Landroidx/compose/ui/graphics/Canvas;)Landroid/graphics/Canvas;
+
+    move-result-object p0
+
+    invoke-virtual {v1, p0, v2, v0}, Ldev/kawarp/KawarpEngine;->draw(Landroid/graphics/Canvas;FF)Z
+    :try_end_2b
+    .catchall {:try_start_1a .. :try_end_2b} :catchall_2c
+
+    goto :goto_34
+
+    :catchall_2c
+    move-exception p0
+
+    sget-object p0, Lradiant/Kawarp;->fallbackState:Landroidx/compose/runtime/MutableState;
+
+    sget-object v0, Ljava/lang/Boolean;->TRUE:Ljava/lang/Boolean;
+
+    invoke-interface {p0, v0}, Landroidx/compose/runtime/MutableState;->setValue(Ljava/lang/Object;)V
+
+    :goto_34
+    return-void
+.end method
+
+.method private static ensureEngine()Z
+    .registers 4
+
+    sget-object v0, Lradiant/Kawarp;->engine:Ldev/kawarp/KawarpEngine;
+
+    const/4 v1, 0x1
+
+    if-eqz v0, :cond_6
+
+    return v1
+
+    :cond_6
+    invoke-static {}, Ldev/kawarp/KawarpEngine;->isSupported()Z
+
+    move-result v0
+
+    const/4 v2, 0x0
+
+    if-nez v0, :cond_e
+
+    return v2
+
+    :cond_e
+    :try_start_e
+    new-instance v0, Ldev/kawarp/KawarpEngine;
+
+    invoke-direct {v0}, Ldev/kawarp/KawarpEngine;-><init>()V
+
+    const v3, __RL_KW_WARP__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setWarpIntensity(F)V
+
+    const v3, __RL_KW_SPEED__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setAnimationSpeed(F)V
+
+    const v3, __RL_KW_SCALE__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setScale(F)V
+
+    const v3, __RL_KW_DITHER__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setDithering(F)V
+
+    const v3, __RL_KW_DARKEN__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setAutoDarken(F)V
+
+    const v3, __RL_KW_REACTIVE__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    if-eqz v3, :cond_64
+
+    move v3, v1
+
+    goto :goto_65
+
+    :cond_64
+    move v3, v2
+
+    :goto_65
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setPlaybackReactive(Z)V
+
+    const v3, __RL_KW_BLUR__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setBlurPasses(I)V
+
+    const v3, __RL_KW_CONTRAST__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setContrast(F)V
+
+    const v3, __RL_KW_SAT__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setSaturation(F)V
+
+    const v3, __RL_KW_BRIGHT__
+
+    invoke-static {v3}, Lradiant/Kawarp;->tk(I)I
+
+    move-result v3
+
+    invoke-static {v3}, Ljava/lang/Float;->intBitsToFloat(I)F
+
+    move-result v3
+
+    invoke-virtual {v0, v3}, Ldev/kawarp/KawarpEngine;->setBrightness(F)V
+
+    sput-object v0, Lradiant/Kawarp;->engine:Ldev/kawarp/KawarpEngine;
+    :try_end_9e
+    .catchall {:try_start_e .. :try_end_9e} :catchall_9f
+
+    return v1
+
+    :catchall_9f
+    move-exception v0
+
+    sget-object v0, Lradiant/Kawarp;->fallbackState:Landroidx/compose/runtime/MutableState;
+
+    sget-object v1, Ljava/lang/Boolean;->TRUE:Ljava/lang/Boolean;
+
+    invoke-interface {v0, v1}, Landroidx/compose/runtime/MutableState;->setValue(Ljava/lang/Object;)V
+
+    return v2
+.end method
+
+.method private fail()V
+    .registers 3
+
+    iget v0, p0, Lradiant/Kawarp;->token:I
+
+    sget v1, Lradiant/Kawarp;->loadToken:I
+
+    if-ne v0, v1, :cond_9
+
+    const/4 v0, 0x0
+
+    sput-object v0, Lradiant/Kawarp;->requestedUuid:Ljava/lang/String;
+
+    :cond_9
+    return-void
+.end method
+
+.method public static render(ILjava/lang/String;ZLandroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;)V
+    .registers 13
+
+    const v0, 0x52415750
+
+    invoke-interface {p4, v0}, Landroidx/compose/runtime/Composer;->startReplaceGroup(I)V
+
+    invoke-static {p4}, Lradiant/Kawarp;->attach(Landroidx/compose/runtime/Composer;)V
+
+    sget-object v0, Lradiant/Kawarp;->fallbackState:Landroidx/compose/runtime/MutableState;
+
+    invoke-interface {v0}, Landroidx/compose/runtime/MutableState;->getValue()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Ljava/lang/Boolean;
+
+    invoke-virtual {v0}, Ljava/lang/Boolean;->booleanValue()Z
+
+    move-result v0
+
+    if-nez v0, :cond_37
+
+    invoke-static {}, Lradiant/Kawarp;->ensureEngine()Z
+
+    move-result v0
+
+    if-eqz v0, :cond_37
+
+    sget-object v0, Lradiant/Kawarp;->engine:Ldev/kawarp/KawarpEngine;
+
+    invoke-virtual {v0, p2}, Ldev/kawarp/KawarpEngine;->setPlaying(Z)V
+
+    invoke-static {p0, p1}, Lradiant/Kawarp;->request(ILjava/lang/String;)V
+
+    const/high16 p0, 0x3f800000    # 1.0f
+
+    invoke-static {p3, p0}, Landroidx/compose/foundation/layout/SizeKt;->fillMaxSize(Landroidx/compose/ui/Modifier;F)Landroidx/compose/ui/Modifier;
+
+    move-result-object p0
+
+    sget-object p1, Lradiant/Kawarp;->DRAW:Lradiant/Kawarp;
+
+    invoke-static {p0, p1}, Landroidx/compose/ui/draw/DrawModifierKt;->drawBehind(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
+
+    move-result-object p0
+
+    const/4 p1, 0x0
+
+    invoke-static {p0, p4, p1}, Landroidx/compose/foundation/layout/SpacerKt;->Spacer(Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V
+
+    move-object v6, p4
+
+    goto :goto_42
+
+    :cond_37
+    const/4 v4, 0x0
+
+    const/4 v7, 0x0
+
+    const/4 v3, 0x0
+
+    move v0, p0
+
+    move-object v1, p1
+
+    move v2, p2
+
+    move-object v5, p3
+
+    move-object v6, p4
+
+    invoke-static/range {v0 .. v7}, Lcom/tidal/android/feature/playerscreen/ui/composables/p3;->a(ILjava/lang/String;ZZLam0/a;Landroidx/compose/ui/Modifier;Landroidx/compose/runtime/Composer;I)V    # MARKER: R8 Lcom/tidal/android/feature/playerscreen/ui/composables/p3; Lam0/a; a
+
+    :goto_42
+    invoke-interface {v6}, Landroidx/compose/runtime/Composer;->endReplaceGroup()V
+
+    return-void
+.end method
+
+.method private static request(ILjava/lang/String;)V
+    .registers 5
+
+    if-eqz p1, :cond_28
+
+    invoke-virtual {p1}, Ljava/lang/String;->length()I
+
+    move-result v0
+
+    if-eqz v0, :cond_28
+
+    sget-object v0, Lradiant/Kawarp;->requestedUuid:Ljava/lang/String;
+
+    invoke-virtual {p1, v0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v0
+
+    if-eqz v0, :cond_11
+
+    goto :goto_28
+
+    :cond_11
+    sget-object v0, Lradiant/Kawarp;->loader:Lcoil/f;    # MARKER: R8 Lcoil/f;
+
+    if-nez v0, :cond_16
+
+    return-void
+
+    :cond_16
+    sput-object p1, Lradiant/Kawarp;->requestedUuid:Ljava/lang/String;
+
+    sget-object v0, Lradiant/Kawarp;->LOADER:Ljava/util/concurrent/ExecutorService;
+
+    new-instance v1, Lradiant/Kawarp;
+
+    sget v2, Lradiant/Kawarp;->loadToken:I
+
+    add-int/lit8 v2, v2, 0x1
+
+    sput v2, Lradiant/Kawarp;->loadToken:I
+
+    invoke-direct {v1, p0, p1, v2}, Lradiant/Kawarp;-><init>(ILjava/lang/String;I)V
+
+    invoke-interface {v0, v1}, Ljava/util/concurrent/ExecutorService;->execute(Ljava/lang/Runnable;)V
+
+    :cond_28
+    :goto_28
+    return-void
+.end method
+
+.method private static schedule()V
+    .registers 2
+
+    sget-boolean v0, Lradiant/Kawarp;->frameScheduled:Z
+
+    if-eqz v0, :cond_5
+
+    return-void
+
+    :cond_5
+    const/4 v0, 0x1
+
+    sput-boolean v0, Lradiant/Kawarp;->frameScheduled:Z
+
+    invoke-static {}, Landroid/view/Choreographer;->getInstance()Landroid/view/Choreographer;
+
+    move-result-object v0
+
+    sget-object v1, Lradiant/Kawarp;->DRAW:Lradiant/Kawarp;
+
+    invoke-virtual {v0, v1}, Landroid/view/Choreographer;->postFrameCallback(Landroid/view/Choreographer$FrameCallback;)V
+
+    return-void
+.end method
+
+.method private static tk(I)I
+    .registers 1
+
+    return p0
+.end method
+
+.method private static toBitmap(Landroid/graphics/drawable/Drawable;)Landroid/graphics/Bitmap;
+    .registers 4
+
+    if-nez p0, :cond_4
+
+    const/4 p0, 0x0
+
+    return-object p0
+
+    :cond_4
+    instance-of v0, p0, Landroid/graphics/drawable/BitmapDrawable;
+
+    if-eqz v0, :cond_f
+
+    check-cast p0, Landroid/graphics/drawable/BitmapDrawable;
+
+    invoke-virtual {p0}, Landroid/graphics/drawable/BitmapDrawable;->getBitmap()Landroid/graphics/Bitmap;
+
+    move-result-object p0
+
+    return-object p0
+
+    :cond_f
+    sget-object v0, Landroid/graphics/Bitmap$Config;->ARGB_8888:Landroid/graphics/Bitmap$Config;
+
+    const/16 v1, 0x100
+
+    invoke-static {v1, v1, v0}, Landroid/graphics/Bitmap;->createBitmap(IILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;
+
+    move-result-object v0
+
+    const/4 v2, 0x0
+
+    invoke-virtual {p0, v2, v2, v1, v1}, Landroid/graphics/drawable/Drawable;->setBounds(IIII)V
+
+    new-instance v1, Landroid/graphics/Canvas;
+
+    invoke-direct {v1, v0}, Landroid/graphics/Canvas;-><init>(Landroid/graphics/Bitmap;)V
+
+    invoke-virtual {p0, v1}, Landroid/graphics/drawable/Drawable;->draw(Landroid/graphics/Canvas;)V
+
+    return-object v0
+.end method
+
+
+# virtual methods
+.method public a(Landroid/graphics/drawable/Drawable;)V
+    .registers 4
+
+    iget v0, p0, Lradiant/Kawarp;->token:I
+
+    sget v1, Lradiant/Kawarp;->loadToken:I
+
+    if-eq v0, v1, :cond_7
+
+    return-void
+
+    :cond_7
+    invoke-static {p1}, Lradiant/Kawarp;->toBitmap(Landroid/graphics/drawable/Drawable;)Landroid/graphics/Bitmap;
+
+    move-result-object p1
+
+    if-nez p1, :cond_11
+
+    invoke-direct {p0}, Lradiant/Kawarp;->fail()V
+
+    return-void
+
+    :cond_11
+    sget-object v0, Lradiant/Kawarp;->engine:Ldev/kawarp/KawarpEngine;
+
+    invoke-virtual {v0, p1}, Ldev/kawarp/KawarpEngine;->setCover(Landroid/graphics/Bitmap;)V
+
+    return-void
+.end method
+
+.method public b(Landroid/graphics/drawable/Drawable;)V
+    .registers 2
+
+    return-void
+.end method
+
+.method public d(Landroid/graphics/drawable/Drawable;)V
+    .registers 2
+
+    invoke-direct {p0}, Lradiant/Kawarp;->fail()V
+
+    return-void
+.end method
+
+.method public doFrame(J)V
+    .registers 5
+
+    const/4 p1, 0x0
+
+    sput-boolean p1, Lradiant/Kawarp;->frameScheduled:Z
+
+    invoke-static {}, Landroid/os/SystemClock;->uptimeMillis()J
+
+    move-result-wide p1
+
+    sget-wide v0, Lradiant/Kawarp;->lastDrawUptime:J
+
+    sub-long/2addr p1, v0
+
+    const-wide/16 v0, 0x1f4
+
+    cmp-long p1, p1, v0
+
+    if-lez p1, :cond_11
+
+    return-void
+
+    :cond_11
+    sget-object p1, Lradiant/Kawarp;->frameState:Landroidx/compose/runtime/MutableIntState;
+
+    sget p2, Lradiant/Kawarp;->frameTick:I
+
+    add-int/lit8 p2, p2, 0x1
+
+    sput p2, Lradiant/Kawarp;->frameTick:I
+
+    invoke-interface {p1, p2}, Landroidx/compose/runtime/MutableIntState;->setIntValue(I)V
+
+    invoke-static {}, Lradiant/Kawarp;->schedule()V
+
+    return-void
+.end method
+
+.method public invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .registers 2
+
+    check-cast p1, Landroidx/compose/ui/graphics/drawscope/DrawScope;
+
+    invoke-static {p1}, Lradiant/Kawarp;->draw(Landroidx/compose/ui/graphics/drawscope/DrawScope;)V
+
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object p1
+.end method
+
+.method public run()V
+    .registers 15
+
+    :try_start_0
+    new-instance v0, Lxd0/g;    # MARKER: R8 Lxd0/g;
+
+    sget-object v1, Lradiant/Kawarp;->appContext:Landroid/content/Context;
+
+    new-instance v2, Lcom/tidal/android/image/core/b$a;    # MARKER: R8 Lcom/tidal/android/image/core/b$a;
+
+    iget v3, p0, Lradiant/Kawarp;->albumId:I
+
+    invoke-static {v3}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v3
+
+    iget-object v4, p0, Lradiant/Kawarp;->uuid:Ljava/lang/String;
+
+    invoke-direct {v2, v3, v4}, Lcom/tidal/android/image/core/b$a;-><init>(Ljava/lang/String;Ljava/lang/String;)V    # MARKER: R8 Lcom/tidal/android/image/core/b$a;
+
+    const/4 v7, 0x0
+
+    const/4 v8, 0x0
+
+    const/4 v3, 0x0
+
+    const/4 v4, 0x0
+
+    const/4 v5, 0x0
+
+    const/4 v6, 0x0
+
+    invoke-direct/range {v0 .. v8}, Lxd0/g;-><init>(Landroid/content/Context;Lcom/tidal/android/image/core/b;Lcom/tidal/android/image/core/b$h$a;Lcom/tidal/android/image/core/b$h$a;ZLjava/util/List;Lxd0/f;Z)V    # MARKER: R8 Lxd0/g; Lcom/tidal/android/image/core/b; Lcom/tidal/android/image/core/b$h$a; Lxd0/f;
+
+    const/4 v1, 0x0
+
+    invoke-static {v0, v1}, Lcom/tidal/android/image/coil/c;->a(Lxd0/g;Landroidx/compose/ui/layout/ContentScale;)Lcoil/request/h;    # MARKER: R8 Lcom/tidal/android/image/coil/c; Lxd0/g; Lcoil/request/h; a
+
+    move-result-object v0
+
+    invoke-static {v0}, Lcoil/request/h;->a(Lcoil/request/h;)Lcoil/request/h$a;    # MARKER: R8 Lcoil/request/h; Lcoil/request/h$a; a
+
+    move-result-object v0
+
+    iget-object v1, v0, Lcoil/request/h$a;->b:Lcoil/request/b;    # MARKER: R8 Lcoil/request/h$a; Lcoil/request/b; b
+
+    new-instance v2, Lcoil/request/b;    # MARKER: R8 Lcoil/request/b;
+
+    iget-object v3, v1, Lcoil/request/b;->a:Lkotlinx/coroutines/CoroutineDispatcher;    # MARKER: R8 Lcoil/request/b; a
+
+    iget-object v4, v1, Lcoil/request/b;->b:Lkotlinx/coroutines/CoroutineDispatcher;    # MARKER: R8 Lcoil/request/b; b
+
+    iget-object v5, v1, Lcoil/request/b;->c:Lkotlinx/coroutines/CoroutineDispatcher;    # MARKER: R8 Lcoil/request/b; c
+
+    iget-object v6, v1, Lcoil/request/b;->d:Lkotlinx/coroutines/CoroutineDispatcher;    # MARKER: R8 Lcoil/request/b; d
+
+    iget-object v7, v1, Lcoil/request/b;->e:Ld0/c$a;    # MARKER: R8 Lcoil/request/b; Ld0/c$a; e
+
+    iget-object v8, v1, Lcoil/request/b;->f:Lcoil/size/Precision;    # MARKER: R8 Lcoil/request/b; f
+
+    iget-object v9, v1, Lcoil/request/b;->g:Landroid/graphics/Bitmap$Config;    # MARKER: R8 Lcoil/request/b; g
+
+    iget-boolean v10, v1, Lcoil/request/b;->h:Z    # MARKER: R8 Lcoil/request/b; h
+
+    iget-object v11, v1, Lcoil/request/b;->i:Lcoil/request/CachePolicy;    # MARKER: R8 Lcoil/request/b; i
+
+    iget-object v12, v1, Lcoil/request/b;->j:Lcoil/request/CachePolicy;    # MARKER: R8 Lcoil/request/b; j
+
+    sget-object v13, Lcoil/request/CachePolicy;->DISABLED:Lcoil/request/CachePolicy;
+
+    invoke-direct/range {v2 .. v13}, Lcoil/request/b;-><init>(Lkotlinx/coroutines/CoroutineDispatcher;Lkotlinx/coroutines/CoroutineDispatcher;Lkotlinx/coroutines/CoroutineDispatcher;Lkotlinx/coroutines/CoroutineDispatcher;Ld0/c$a;Lcoil/size/Precision;Landroid/graphics/Bitmap$Config;ZLcoil/request/CachePolicy;Lcoil/request/CachePolicy;Lcoil/request/CachePolicy;)V    # MARKER: R8 Lcoil/request/b; Ld0/c$a;
+
+    iput-object v2, v0, Lcoil/request/h$a;->b:Lcoil/request/b;    # MARKER: R8 Lcoil/request/h$a; Lcoil/request/b; b
+
+    iput-object p0, v0, Lcoil/request/h$a;->d:Lb0/c;    # MARKER: R8 Lcoil/request/h$a; Lb0/c; d
+
+    sget-object v1, Lradiant/Kawarp;->loader:Lcoil/f;    # MARKER: R8 Lcoil/f;
+
+    invoke-virtual {v0}, Lcoil/request/h$a;->a()Lcoil/request/h;    # MARKER: R8 Lcoil/request/h$a; Lcoil/request/h; a
+
+    move-result-object v0
+
+    invoke-interface {v1, v0}, Lcoil/f;->b(Lcoil/request/h;)Lcoil/request/d;    # MARKER: R8 Lcoil/f; Lcoil/request/h; Lcoil/request/d; b
+    :try_end_4d
+    .catchall {:try_start_0 .. :try_end_4d} :catchall_4e
+
+    goto :goto_52
+
+    :catchall_4e
+    move-exception v0
+
+    invoke-direct {p0}, Lradiant/Kawarp;->fail()V
+
+    :goto_52
+    return-void
+.end method

patches/extension/radiant/MiniPlayerBackground.smali

@@ -3,22 +3,20 @@
 
 
 # static fields
-.field public static final colorState:Landroidx/compose/runtime/MutableState; # player bg color
+.field public static final colorFlow:Lkotlinx/coroutines/flow/MutableStateFlow; # player bg color
 
 
 # direct methods
 .method static constructor <clinit>()V
-    .locals 2
+    .locals 1
 
     const/4 v0, 0x0
 
-    const/4 v1, 0x2
-
-    invoke-static {v0, v0, v1, v0}, Landroidx/compose/runtime/SnapshotStateKt;->mutableStateOf$default(Ljava/lang/Object;Landroidx/compose/runtime/SnapshotMutationPolicy;ILjava/lang/Object;)Landroidx/compose/runtime/MutableState;
+    invoke-static {v0}, Lkotlinx/coroutines/flow/StateFlowKt;->MutableStateFlow(Ljava/lang/Object;)Lkotlinx/coroutines/flow/MutableStateFlow;
 
     move-result-object v0
 
-    sput-object v0, Lradiant/MiniPlayerBackground;->colorState:Landroidx/compose/runtime/MutableState;
+    sput-object v0, Lradiant/MiniPlayerBackground;->colorFlow:Lkotlinx/coroutines/flow/MutableStateFlow;
 
     return-void
 .end method
@@ -42,9 +40,19 @@
 
     invoke-interface {p2, v0}, Landroidx/compose/runtime/Composer;->startReplaceGroup(I)V
 
-    sget-object v0, Lradiant/MiniPlayerBackground;->colorState:Landroidx/compose/runtime/MutableState;
+    sget-object v0, Lradiant/MiniPlayerBackground;->colorFlow:Lkotlinx/coroutines/flow/MutableStateFlow;
 
-    invoke-interface {v0}, Landroidx/compose/runtime/MutableState;->getValue()Ljava/lang/Object; # read player color
+    const/4 v1, 0x0
+
+    const/4 v3, 0x0
+
+    const/4 v4, 0x1
+
+    invoke-static {v0, v1, p2, v3, v4}, Landroidx/compose/runtime/SnapshotStateKt;->collectAsState(Lkotlinx/coroutines/flow/StateFlow;Lkotlin/coroutines/h;Landroidx/compose/runtime/Composer;II)Landroidx/compose/runtime/State;    # MARKER: R8 Lkotlin/coroutines/h;
+
+    move-result-object v0
+
+    invoke-interface {v0}, Landroidx/compose/runtime/State;->getValue()Ljava/lang/Object;
 
     move-result-object v0
 
@@ -83,7 +91,7 @@
 
     const/16 v7, 0x8
 
-    invoke-static/range {v0 .. v7}, Landroidx/compose/animation/SingleValueAnimationKt;->animateColorAsState-euL9pac(JLandroidx/compose/animation/core/AnimationSpec;Ljava/lang/String;Lam0/l;Landroidx/compose/runtime/Composer;II)Landroidx/compose/runtime/State;
+    invoke-static/range {v0 .. v7}, Landroidx/compose/animation/SingleValueAnimationKt;->animateColorAsState-euL9pac(JLandroidx/compose/animation/core/AnimationSpec;Ljava/lang/String;Lam0/l;Landroidx/compose/runtime/Composer;II)Landroidx/compose/runtime/State;    # MARKER: R8 Lam0/l;
 
     move-result-object v0
 
@@ -131,9 +139,9 @@
     move-exception p0
 
     :set_color
-    sget-object p0, Lradiant/MiniPlayerBackground;->colorState:Landroidx/compose/runtime/MutableState;
+    sget-object p0, Lradiant/MiniPlayerBackground;->colorFlow:Lkotlinx/coroutines/flow/MutableStateFlow;
 
-    invoke-interface {p0, v0}, Landroidx/compose/runtime/MutableState;->setValue(Ljava/lang/Object;)V
+    invoke-interface {p0, v0}, Lkotlinx/coroutines/flow/MutableStateFlow;->setValue(Ljava/lang/Object;)V
 
     return-void
 .end method

patches/extension/radiant/MiniSeekerFloating.smali

@@ -1,7 +1,7 @@
 .class public final Lradiant/MiniSeekerFloating;
 .super Ljava/lang/Object;
 
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # static fields
@@ -46,7 +46,7 @@
     .catch Ljava/lang/Throwable; {:try_start .. :try_end} :swallow
 
     :swallow
-    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # Unit
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # Unit  MARKER: R8 Lkotlin/u;
 
     return-object v0
 .end method

patches/extension/radiant/MiniSeekerLine.smali

@@ -5,7 +5,7 @@
 # static fields
 .field public static progressState:Landroidx/compose/runtime/MutableFloatState;
 
-.field public static volatile vm:Lgh/j;
+.field public static volatile vm:Lgh/j;    # MARKER: R8 Lgh/j;
 
 .field public static volatile sub:Lio/reactivex/disposables/Disposable;
 
@@ -57,40 +57,40 @@
 
     :start_block
     :try_start
-    sget-object v0, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # cached vm
+    sget-object v0, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # cached vm  MARKER: R8 Lgh/j;
 
     if-nez v0, :got_vm    # reuse if present
 
-    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # app singleton
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # app singleton  MARKER: R8 a
 
     move-result-object v0    # app
 
-    invoke-virtual {v0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # dagger component
+    invoke-virtual {v0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # dagger component  MARKER: R8 Le5/c; e
 
     move-result-object v0    # component
 
-    check-cast v0, Le5/z$n2;    # narrow type
+    check-cast v0, Le5/z$n2;    # narrow type  MARKER: R8 Le5/z$n2;
 
-    iget-object v0, v0, Le5/z$n2;->z0:Ldagger/internal/j;    # playqueue provider
+    iget-object v0, v0, Le5/z$n2;->z0:Ldagger/internal/j;    # playqueue provider  MARKER: R8 Le5/z$n2; Ldagger/internal/j; z0
 
-    invoke-interface {v0}, Lql0/a;->get()Ljava/lang/Object;    # resolve
+    invoke-interface {v0}, Lql0/a;->get()Ljava/lang/Object;    # resolve  MARKER: R8 Lql0/a;
 
     move-result-object v0    # playqueue
 
-    check-cast v0, Lcom/aspiro/wamp/playqueue/d1;    # narrow type
+    check-cast v0, Lcom/aspiro/wamp/playqueue/d1;    # narrow type  MARKER: R8 Lcom/aspiro/wamp/playqueue/d1;
 
-    new-instance v1, Lgh/j;    # build vm
+    new-instance v1, Lgh/j;    # build vm  MARKER: R8 Lgh/j;
 
-    invoke-direct {v1, v0}, Lgh/j;-><init>(Lcom/aspiro/wamp/playqueue/d1;)V    # ctor
+    invoke-direct {v1, v0}, Lgh/j;-><init>(Lcom/aspiro/wamp/playqueue/d1;)V    # ctor  MARKER: R8 Lgh/j; Lcom/aspiro/wamp/playqueue/d1;
 
-    sput-object v1, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # cache
+    sput-object v1, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # cache  MARKER: R8 Lgh/j;
 
     :got_vm
-    sget-object v0, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # vm ref
+    sget-object v0, Lradiant/MiniSeekerLine;->vm:Lgh/j;    # vm ref  MARKER: R8 Lgh/j;
 
-    invoke-virtual {v0}, Lgh/j;->a()V    # activate emission
+    invoke-virtual {v0}, Lgh/j;->a()V    # activate emission  MARKER: R8 Lgh/j; a
 
-    iget-object v0, v0, Lgh/j;->d:Lio/reactivex/subjects/BehaviorSubject;    # position subject
+    iget-object v0, v0, Lgh/j;->d:Lio/reactivex/subjects/BehaviorSubject;    # position subject  MARKER: R8 Lgh/j; d
 
     invoke-static {}, Lio/reactivex/android/schedulers/AndroidSchedulers;->mainThread()Lio/reactivex/Scheduler;    # main scheduler
 

patches/extension/radiant/NoOp.smali

@@ -1,6 +1,6 @@
 .class public final Lradiant/NoOp;
 .super Ljava/lang/Object;
-.implements Lam0/a;
+.implements Lam0/a;    # MARKER: R8 Lam0/a;
 
 
 # static fields
@@ -33,7 +33,7 @@
 .method public final invoke()Ljava/lang/Object;
     .locals 1
 
-    sget-object v0, Lkotlin/u;->a:Lkotlin/u;
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     return-object v0
 .end method

patches/extension/radiant/PebbleBridge$1.smali

@@ -0,0 +1,56 @@
+.class Lradiant/PebbleBridge$1;
+.super Ljava/lang/Object;
+
+# interfaces
+.implements Ljava/lang/Runnable;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingMethod;
+    value = Lradiant/PebbleBridge;->onPosition(J)V
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x0
+    name = null
+.end annotation
+
+
+# instance fields
+.field final synthetic val$at:J
+
+.field final synthetic val$position:J
+
+
+# direct methods
+.method constructor <init>(JJ)V
+    .registers 5
+    .annotation system Ldalvik/annotation/Signature;
+        value = {
+            "()V"
+        }
+    .end annotation
+
+    iput-wide p1, p0, Lradiant/PebbleBridge$1;->val$position:J
+
+    iput-wide p3, p0, Lradiant/PebbleBridge$1;->val$at:J
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public run()V
+    .registers 5
+
+    iget-wide v0, p0, Lradiant/PebbleBridge$1;->val$position:J
+
+    iget-wide v2, p0, Lradiant/PebbleBridge$1;->val$at:J
+
+    # invokes: Lradiant/PebbleBridge;->onSample(JJ)V
+    invoke-static {v0, v1, v2, v3}, Lradiant/PebbleBridge;->access$000(JJ)V
+
+    return-void
+.end method

patches/extension/radiant/PebbleBridge$2.smali

@@ -0,0 +1,50 @@
+.class Lradiant/PebbleBridge$2;
+.super Ljava/lang/Object;
+
+# interfaces
+.implements Ljava/lang/Runnable;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingMethod;
+    value = Lradiant/PebbleBridge;->onLyrics(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x0
+    name = null
+.end annotation
+
+
+# direct methods
+.method constructor <init>()V
+    .registers 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public run()V
+    .registers 2
+
+    # getter for: Lradiant/PebbleBridge;->instance:Lradiant/PebbleBridge;
+    invoke-static {}, Lradiant/PebbleBridge;->access$100()Lradiant/PebbleBridge;
+
+    move-result-object v0
+
+    if-eqz v0, :cond_d
+
+    # getter for: Lradiant/PebbleBridge;->instance:Lradiant/PebbleBridge;
+    invoke-static {}, Lradiant/PebbleBridge;->access$100()Lradiant/PebbleBridge;
+
+    move-result-object v0
+
+    # invokes: Lradiant/PebbleBridge;->sendLyrics()V
+    invoke-static {v0}, Lradiant/PebbleBridge;->access$200(Lradiant/PebbleBridge;)V
+
+    :cond_d
+    return-void
+.end method

patches/extension/radiant/QualityBadge.smali

@@ -85,15 +85,15 @@
     return-object p0
 .end method
 
-.method public static style(ILq20/c2;)Lq20/c2;
+.method public static style(ILq20/c2;)Lq20/c2;    # MARKER: R8 Lq20/c2;
     .registers 16
 
     invoke-static {p0}, Lradiant/QualityBadge;->textArgb(I)I
 
     move-result v0
-    new-instance v1, Lf20/a;
-    invoke-direct {v1, v0}, Lf20/a;-><init>(I)V
-    new-instance v0, Lf20/d;
+    new-instance v1, Lf20/a;    # MARKER: R8 Lf20/a;
+    invoke-direct {v1, v0}, Lf20/a;-><init>(I)V    # MARKER: R8 Lf20/a;
+    new-instance v0, Lf20/d;    # MARKER: R8 Lf20/d;
     const/4 v2, 0x0
     const/4 v3, 0x0
     const/4 v4, 0x0
@@ -107,7 +107,7 @@
     const/4 v12, 0x0
     const/16 v13, 0xffe
     const/4 v14, 0x0
-    invoke-direct/range {v0 .. v14}, Lf20/d;-><init>(Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+    invoke-direct/range {v0 .. v14}, Lf20/d;-><init>(Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;Lf20/a;ILkotlin/jvm/internal/DefaultConstructorMarker;)V    # MARKER: R8 Lf20/d; Lf20/a;
 
     move-object v9, v0
     move-object/from16 v0, p1
@@ -118,7 +118,7 @@
     const/4 v5, 0x0
     const/16 v6, 0x1d
     const/4 v7, 0x0
-    invoke-static/range {v0 .. v7}, Lq20/c2;->g(Lq20/c2;Lq20/s4;Lf20/d;Lcom/squareup/ui/market/core/text/MarketTextAlignment;Lcom/squareup/ui/market/core/text/MarketTextTransform;Lq20/r4;ILjava/lang/Object;)Lq20/c2;
+    invoke-static/range {v0 .. v7}, Lq20/c2;->g(Lq20/c2;Lq20/s4;Lf20/d;Lcom/squareup/ui/market/core/text/MarketTextAlignment;Lcom/squareup/ui/market/core/text/MarketTextTransform;Lq20/r4;ILjava/lang/Object;)Lq20/c2;    # MARKER: R8 Lq20/c2; Lq20/s4; Lf20/d; Lq20/r4; g
     move-result-object p0
     return-object p0
 .end method

patches/extension/radiant/RLAPILyricsHook.smali

@@ -223,7 +223,7 @@
     return-void
 
     :rl_new_track
-    iget-object v5, p0, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v5, p0, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 P
 
     invoke-interface {v5}, Lkotlinx/coroutines/flow/MutableStateFlow;->getValue()Ljava/lang/Object;
 
@@ -243,7 +243,7 @@
 
     if-eq p0, v6, :store_keep_open
 
-    iget-object v7, v6, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v7, v6, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 P
 
     invoke-interface {v7}, Lkotlinx/coroutines/flow/MutableStateFlow;->getValue()Ljava/lang/Object;
 

patches/extension/radiant/RLAPILyricsWorker.smali

@@ -63,7 +63,7 @@
 
     iget-object v1, p0, Lradiant/RLAPILyricsWorker;->vm:Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;
 
-    iget-object v2, v1, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v2, v1, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 P
 
     sget-object v3, Ljava/lang/Boolean;->FALSE:Ljava/lang/Boolean;
 
@@ -82,15 +82,15 @@
 
     if-ne v0, v1, :not_current
 
-    iget-object v1, v0, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->a:Lbi/e;
+    iget-object v1, v0, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->a:Lbi/e;    # MARKER: R8 Lbi/e; a
 
-    invoke-interface {v1}, Lbi/e;->getCurrentItem()Lcom/aspiro/wamp/playqueue/u0;
+    invoke-interface {v1}, Lbi/e;->getCurrentItem()Lcom/aspiro/wamp/playqueue/u0;    # MARKER: R8 Lbi/e; Lcom/aspiro/wamp/playqueue/u0;
 
     move-result-object v1
 
     if-eqz v1, :not_current
 
-    invoke-interface {v1}, Lcom/aspiro/wamp/playqueue/u0;->getMediaItem()Lcom/aspiro/wamp/model/MediaItem;
+    invoke-interface {v1}, Lcom/aspiro/wamp/playqueue/u0;->getMediaItem()Lcom/aspiro/wamp/model/MediaItem;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/u0;
 
     move-result-object v1
 
@@ -375,7 +375,7 @@
 .end method
 
 .method public static parseLines(Ljava/lang/String;)Ljava/util/ArrayList;
-    .locals 11
+    .locals 13
 
     :try_start
     new-instance v0, Lorg/json/JSONObject;
@@ -466,9 +466,49 @@
 
     double-to-long v7, v7
 
-    new-instance v4, Lcom/tidal/android/feature/playerscreen/ui/f;
+    # Prefer the first syllable time
+    const-string v6, "syllabus"
 
-    invoke-direct {v4, v5, v7, v8}, Lcom/tidal/android/feature/playerscreen/ui/f;-><init>(Ljava/lang/String;J)V
+    invoke-virtual {v4, v6}, Lorg/json/JSONObject;->optJSONArray(Ljava/lang/String;)Lorg/json/JSONArray;
+
+    move-result-object v6
+
+    if-eqz v6, :no_syl
+
+    invoke-virtual {v6}, Lorg/json/JSONArray;->length()I
+
+    move-result v9
+
+    if-eqz v9, :no_syl
+
+    const/4 v9, 0x0
+
+    invoke-virtual {v6, v9}, Lorg/json/JSONArray;->optJSONObject(I)Lorg/json/JSONObject;
+
+    move-result-object v6
+
+    if-eqz v6, :no_syl
+
+    const-string v9, "time"
+
+    const-wide/16 v11, -0x1
+
+    invoke-virtual {v6, v9, v11, v12}, Lorg/json/JSONObject;->optLong(Ljava/lang/String;J)J
+
+    move-result-wide v11
+
+    const-wide/16 v9, 0x0
+
+    cmp-long v6, v11, v9
+
+    if-ltz v6, :no_syl
+
+    move-wide v7, v11
+
+    :no_syl
+    new-instance v4, Lcom/tidal/android/feature/playerscreen/ui/f;    # MARKER: R8 Lcom/tidal/android/feature/playerscreen/ui/f;
+
+    invoke-direct {v4, v5, v7, v8}, Lcom/tidal/android/feature/playerscreen/ui/f;-><init>(Ljava/lang/String;J)V    # MARKER: R8 Lcom/tidal/android/feature/playerscreen/ui/f;
 
     invoke-virtual {v2, v4}, Ljava/util/ArrayList;->add(Ljava/lang/Object;)Z
 
@@ -815,9 +855,9 @@
 
     iget-object v4, p0, Lradiant/RLAPILyricsWorker;->vm:Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;
 
-    iget-object v5, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->O:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v5, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->O:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 O
 
-    invoke-static {v3}, Lvn0/a;->c(Ljava/lang/Iterable;)Lvn0/b;
+    invoke-static {v3}, Lvn0/a;->c(Ljava/lang/Iterable;)Lvn0/b;    # MARKER: R8 Lvn0/a; Lvn0/b; c
 
     move-result-object v6
 
@@ -828,13 +868,13 @@
     const-string v7, ""
 
     :have_id
-    new-instance v8, Lcom/tidal/android/feature/playerscreen/ui/g$c;
+    new-instance v8, Lcom/tidal/android/feature/playerscreen/ui/g$c;    # MARKER: R8 Lcom/tidal/android/feature/playerscreen/ui/g$c;
 
     const/4 v9, -0x1
 
     const/4 v10, 0x0
 
-    invoke-direct {v8, v7, v6, v9, v10}, Lcom/tidal/android/feature/playerscreen/ui/g$c;-><init>(Ljava/lang/String;Lvn0/b;IZ)V
+    invoke-direct {v8, v7, v6, v9, v10}, Lcom/tidal/android/feature/playerscreen/ui/g$c;-><init>(Ljava/lang/String;Lvn0/b;IZ)V    # MARKER: R8 Lcom/tidal/android/feature/playerscreen/ui/g$c; Lvn0/b;
 
     const-string v6, "publishing g$c -> K=true (O=true if sticky) N=g$c"
 
@@ -846,7 +886,7 @@
 
     sput-boolean v6, Lradiant/RLAPILyricsHook;->isRlState:Z
 
-    iget-object v6, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->K:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v6, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->K:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 K
 
     sget-object v7, Ljava/lang/Boolean;->TRUE:Ljava/lang/Boolean;
 
@@ -862,7 +902,7 @@
 
     :open_lyrics
 
-    iget-object v6, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;
+    iget-object v6, v4, Lcom/tidal/android/feature/playerscreen/ui/PlayerViewModel;->P:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 P
 
     invoke-interface {v6, v7}, Lkotlinx/coroutines/flow/MutableStateFlow;->setValue(Ljava/lang/Object;)V
 

patches/extension/radiant/SeekerConsumer.smali

@@ -20,13 +20,13 @@
 
     if-eqz p1, :ret    # null guard
 
-    instance-of v0, p1, Lgh/b;    # type guard
+    instance-of v0, p1, Lgh/b;    # type guard  MARKER: R8 Lgh/b;
 
     if-eqz v0, :ret    # skip if wrong type
 
-    check-cast p1, Lgh/b;    # narrow type
+    check-cast p1, Lgh/b;    # narrow type  MARKER: R8 Lgh/b;
 
-    iget v0, p1, Lgh/b;->b:F    # raw progress
+    iget v0, p1, Lgh/b;->b:F    # raw progress  MARKER: R8 Lgh/b; b
 
     invoke-static {v0}, Ljava/lang/Float;->isNaN(F)Z    # nan check
 

patches/extension/radiant/SparkleButton.smali

@@ -4,7 +4,7 @@
 
 
 # direct methods
-.method public static final a(ILandroidx/compose/runtime/Composer;Landroidx/compose/ui/Modifier;Lam0/a;)V
+.method public static final a(ILandroidx/compose/runtime/Composer;Landroidx/compose/ui/Modifier;Lam0/a;)V    # MARKER: R8 Lam0/a;
     .locals 21
     .annotation build Landroidx/compose/runtime/Composable;
     .end annotation
@@ -94,11 +94,11 @@
     invoke-static {v2, v3, v4, v5}, Landroidx/compose/runtime/ComposerKt;->traceEventStart(IIILjava/lang/String;)V
 
     :cond_3
-    sget-object v2, Lcom/squareup/ui/market/core/theme/k;->e:Lcom/squareup/ui/market/core/theme/k$a;
+    sget-object v2, Lcom/squareup/ui/market/core/theme/k;->e:Lcom/squareup/ui/market/core/theme/k$a;    # MARKER: R8 Lcom/squareup/ui/market/core/theme/k; Lcom/squareup/ui/market/core/theme/k$a; e
 
     const/4 v4, 0x6
 
-    invoke-static {v2, v11, v4}, Lcom/squareup/ui/market/core/theme/z;->t(Lcom/squareup/ui/market/core/theme/k$a;Landroidx/compose/runtime/Composer;I)Lcom/squareup/ui/market/core/theme/MarketStylesheet;
+    invoke-static {v2, v11, v4}, Lcom/squareup/ui/market/core/theme/z;->t(Lcom/squareup/ui/market/core/theme/k$a;Landroidx/compose/runtime/Composer;I)Lcom/squareup/ui/market/core/theme/MarketStylesheet;    # MARKER: R8 Lcom/squareup/ui/market/core/theme/z; Lcom/squareup/ui/market/core/theme/k$a; t
 
     move-result-object v15
 
@@ -131,7 +131,7 @@
 
     const/16 v18, 0x0
 
-    invoke-static/range {v15 .. v20}, Lcom/squareup/ui/market/components/MarketIconButtonKt;->P(Lcom/squareup/ui/market/core/theme/MarketStylesheet;Lcom/squareup/ui/market/core/components/properties/IconButton$Size;Lcom/squareup/ui/market/core/components/properties/IconButton$Rank;Lcom/squareup/ui/market/core/components/properties/IconButton$Variant;ILjava/lang/Object;)Lq20/u1;
+    invoke-static/range {v15 .. v20}, Lcom/squareup/ui/market/components/MarketIconButtonKt;->P(Lcom/squareup/ui/market/core/theme/MarketStylesheet;Lcom/squareup/ui/market/core/components/properties/IconButton$Size;Lcom/squareup/ui/market/core/components/properties/IconButton$Rank;Lcom/squareup/ui/market/core/components/properties/IconButton$Variant;ILjava/lang/Object;)Lq20/u1;    # MARKER: R8 Lq20/u1; P
 
     move-result-object v4
 
@@ -140,7 +140,7 @@
     :cond_5
     move-object v9, v4
 
-    check-cast v9, Lq20/u1;
+    check-cast v9, Lq20/u1;    # MARKER: R8 Lq20/u1;
 
     sget v2, Lcom/tidal/android/feature/playerscreen/ui/R$string;->lyrics:I
 
@@ -150,7 +150,7 @@
 
     move v4, v3
 
-    invoke-static {v14}, Lcom/tidal/android/feature/playerscreen/ui/composables/anim/BouncePressKt;->a(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;
+    invoke-static {v14}, Lcom/tidal/android/feature/playerscreen/ui/composables/anim/BouncePressKt;->a(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;    # MARKER: R8 a
 
     move-result-object v3
 
@@ -172,7 +172,7 @@
 
     const/4 v8, 0x0
 
-    invoke-static/range {v1 .. v13}, Lcom/squareup/ui/market/components/MarketIconButtonKt;->b(Lam0/a;Ljava/lang/String;Landroidx/compose/ui/Modifier;Landroidx/compose/foundation/interaction/MutableInteractionSource;ZLcom/squareup/ui/market/components/n;Lam0/a;Ljava/lang/String;Lq20/u1;Lam0/p;Landroidx/compose/runtime/Composer;II)V
+    invoke-static/range {v1 .. v13}, Lcom/squareup/ui/market/components/MarketIconButtonKt;->b(Lam0/a;Ljava/lang/String;Landroidx/compose/ui/Modifier;Landroidx/compose/foundation/interaction/MutableInteractionSource;ZLcom/squareup/ui/market/components/n;Lam0/a;Ljava/lang/String;Lq20/u1;Lam0/p;Landroidx/compose/runtime/Composer;II)V    # MARKER: R8 Lam0/a; Lcom/squareup/ui/market/components/n; Lq20/u1; Lam0/p; b
 
     invoke-static {}, Landroidx/compose/runtime/ComposerKt;->isTraceInProgress()Z
 

patches/extension/radiant/SparkleContent.smali

@@ -3,7 +3,7 @@
 .source "SourceFile"
 
 # interfaces
-.implements Lam0/p;
+.implements Lam0/p;    # MARKER: R8 Lam0/p;
 
 
 # virtual methods

patches/extension/radiant/SpvFactory.smali

@@ -1,6 +1,6 @@
 .class public final Lradiant/SpvFactory;
 .super Ljava/lang/Object;
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # static fields

patches/extension/radiant/SylLayout.smali

@@ -2,7 +2,7 @@
 .super Ljava/lang/Object;
 
 # interfaces
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 # Remembers where each line's glyphs landed
 
@@ -31,7 +31,7 @@
 
 
 # One reusable callback per line
-.method public static cb(I)Lam0/l;
+.method public static cb(I)Lam0/l;    # MARKER: R8 Lam0/l;
     .locals 5
 
     if-gez p0, :have_idx
@@ -258,7 +258,7 @@
     aput-object p1, v1, v0
 
     :ret
-    sget-object v0, Lkotlin/u;->a:Lkotlin/u;
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     return-object v0
 .end method

patches/extension/radiant/gestures/MiniPlayerGestures$Gesture.smali

@@ -1,521 +0,0 @@
-.class public final Lradiant/gestures/MiniPlayerGestures$Gesture;
-.super Ljava/lang/Object;
-.implements Lam0/l;
-
-# annotations
-.annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerGestures;
-.end annotation
-
-.annotation system Ldalvik/annotation/InnerClass;
-    accessFlags = 0x19
-    name = "Gesture"
-.end annotation
-
-
-# instance fields
-.field public final a:Lam0/l;
-
-# Y at ACTION_DOWN
-.field public b:F
-
-# Last Y seen (on this pointer stream)
-.field public c:F
-
-# True while this listener owns an active pointer stream
-.field public d:Z
-
-# True when sheet drag has started
-.field public e:Z
-
-.field public final f:Landroidx/compose/material3/SheetState;
-
-.field public g:F
-
-# X at ACTION_DOWN
-.field public i:F
-
-# True once horizontal movement wins (prevents later vertical start)
-.field public j:Z
-
-# Drag option enabled
-.field public final k:Z
-
-
-# direct methods
-.method public constructor <init>(Lam0/l;Landroidx/compose/material3/SheetState;Z)V
-    .locals 0
-
-    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
-
-    iput-object p1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->a:Lam0/l;
-
-    iput-object p2, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    iput-boolean p3, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->k:Z
-
-    return-void
-.end method
-
-.method private static dp(F)F
-    .locals 1
-
-    invoke-static {}, Landroid/content/res/Resources;->getSystem()Landroid/content/res/Resources;
-
-    move-result-object v0
-
-    invoke-virtual {v0}, Landroid/content/res/Resources;->getDisplayMetrics()Landroid/util/DisplayMetrics;
-
-    move-result-object v0
-
-    iget v0, v0, Landroid/util/DisplayMetrics;->density:F
-
-    mul-float/2addr p0, v0
-
-    return p0
-.end method
-
-.method private dragSheet(FJ)V
-    .locals 1
-
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    invoke-static {v0, p1, p2, p3}, Lradiant/gestures/MiniPlayerGestures;->updateDragTimed(Landroidx/compose/material3/SheetState;FJ)V
-
-    return-void
-.end method
-
-.method private finishSheet(F)V
-    .locals 2
-
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    iget-object v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->a:Lam0/l;
-
-    invoke-static {v0, v1, p1}, Lradiant/gestures/MiniPlayerGestures;->finishDrag(Landroidx/compose/material3/SheetState;Lam0/l;F)V
-
-    return-void
-.end method
-
-.method private openPlayer()V
-    .locals 2
-
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->a:Lam0/l;
-
-    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/b$b;->a:Lcom/tidal/android/feature/appscaffold/ui/b$b;
-
-    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;
-
-    return-void
-.end method
-
-.method private reset()V
-    .locals 1
-
-    const/4 v0, 0x0
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->d:Z
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->j:Z
-
-    const/4 v0, 0x0
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->i:F
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->g:F
-
-    return-void
-.end method
-
-.method private startSheet(FJ)V
-    .locals 2
-
-    # empty player guard
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->hasMiniPlayerMedia()Z
-
-    move-result v0
-
-    if-nez v0, :start_guard
-
-    return-void
-
-    :start_guard
-
-    # avoid starting twice
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    if-eqz v0, :start
-
-    return-void
-
-    :start
-    const/4 v0, 0x1
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->k:Z
-
-    if-eqz v0, :done
-
-    iget-object v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    iget v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->b:F
-
-    invoke-static {v1, p1, v0, p2, p3}, Lradiant/gestures/MiniPlayerGestures;->beginDrag(Landroidx/compose/material3/SheetState;FFJ)V
-
-    invoke-direct {p0}, Lradiant/gestures/MiniPlayerGestures$Gesture;->openPlayer()V
-
-    :done
-    return-void
-.end method
-
-
-# virtual methods
-# Listens for MotionEvents
-.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;
-    .locals 11
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
-
-    move-result v0
-
-    if-eqz v0, :down
-
-    const/4 v1, 0x1
-
-    if-eq v0, v1, :up
-
-    const/4 v1, 0x2
-
-    if-eq v0, v1, :move
-
-    const/4 v1, 0x3
-
-    if-eq v0, v1, :cancel
-
-    goto :done
-
-    # ACTION_DOWN
-    :down
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->resetGestureLock()V
-
-    invoke-static {p1}, Lradiant/gestures/MiniPlayerGestures;->beginMotion(Landroid/view/MotionEvent;)V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v0
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->b:F
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->c:F
-
-    const/4 v0, 0x1
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->d:Z
-
-    const/4 v0, 0x0
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    const/4 v0, 0x0
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->g:F
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
-
-    move-result v0
-
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->i:F
-
-    const/4 v0, 0x0
-
-    iput-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->j:Z
-
-    iget v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->b:F
-
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->beginSwipeGesture(F)V
-
-    :skip_feedback_down
-
-    goto :done
-
-    # ACTION_MOVE
-    :move
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->d:Z
-
-    if-eqz v0, :done
-
-    invoke-static {p1}, Lradiant/gestures/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v0
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
-
-    move-result-wide v5
-
-    iget v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->c:F
-
-    sub-float v1, v0, v1
-
-    iput v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->g:F
-
-    iget v2, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->b:F
-
-    sub-float v2, v0, v2
-
-    iget-boolean v3, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    if-eqz v3, :maybe_start
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->suppressHorizontalGestures()V
-
-    iget-boolean v3, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->k:Z
-
-    if-eqz v3, :feedback_active
-
-    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/MiniPlayerGestures$Gesture;->dragSheet(FJ)V
-
-    :feedback_active
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
-
-    goto :store_last
-
-    :maybe_start
-    iget-boolean v3, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->j:Z
-
-    if-eqz v3, :axis_check
-
-    goto :store_last
-
-    :axis_check
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
-
-    move-result v7
-
-    iget v8, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->i:F
-
-    sub-float/2addr v7, v8
-
-    invoke-static {v7}, Ljava/lang/Math;->abs(F)F
-
-    move-result v7
-
-    invoke-static {v2}, Ljava/lang/Math;->abs(F)F
-
-    move-result v8
-
-    const/high16 v9, 0x40c00000    # 6.0f axis deadzone
-
-    invoke-static {v9}, Lradiant/gestures/MiniPlayerGestures$Gesture;->dp(F)F
-
-    move-result v9
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->isHorizontalGestureLocked()Z
-
-    move-result v10
-
-    if-eqz v10, :horizontal_check
-
-    const/4 v10, 0x0
-
-    invoke-static {v10}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
-
-    goto :store_last
-
-    :horizontal_check
-
-    cmpg-float v10, v7, v9
-
-    if-gez v10, :horizontal_dominance
-
-    goto :vertical_check
-
-    :horizontal_dominance
-
-    const v10, 0x3f8ccccd    # 1.1f
-
-    mul-float/2addr v10, v8
-
-    cmpg-float v10, v7, v10
-
-    if-gez v10, :horizontal_wins
-
-    goto :vertical_check
-
-    :horizontal_wins
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->lockHorizontalGesture()Z
-
-    move-result v10
-
-    if-eqz v10, :store_last
-
-    const/4 v10, 0x1
-
-    iput-boolean v10, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->j:Z
-
-    const/4 v10, 0x0
-
-    invoke-static {v10}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
-
-    goto :store_last
-
-    # At least 16dp up to open the player
-    :vertical_check
-    neg-float v9, v9
-
-    cmpg-float v10, v2, v9
-
-    if-lez v10, :vertical_dominance
-
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
-
-    goto :store_last
-
-    :vertical_dominance
-    const v10, 0x3f8ccccd    # 1.1f -> early vertical axis lock
-
-    mul-float/2addr v7, v10
-
-    cmpl-float v10, v8, v7
-
-    if-gtz v10, :begin
-
-    goto :store_last
-
-    :begin
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->lockVerticalGesture()Z
-
-    move-result v10
-
-    if-eqz v10, :store_last
-
-    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/MiniPlayerGestures$Gesture;->startSheet(FJ)V
-
-    iget-boolean v10, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    if-eqz v10, :store_last
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->suppressHorizontalGestures()V
-
-    iget-boolean v10, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->k:Z
-
-    if-eqz v10, :feedback_begin
-
-    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/MiniPlayerGestures$Gesture;->dragSheet(FJ)V
-
-    :feedback_begin
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
-
-
-    :store_last
-    iput v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->c:F
-
-    goto :done
-
-    # ACTION_UP
-    :up
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->d:Z
-
-    if-eqz v0, :done
-
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    if-eqz v0, :up_no_drag
-
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->k:Z
-
-    if-eqz v0, :open_simple
-
-    invoke-static {p1}, Lradiant/gestures/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v0
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
-
-    move-result-wide v5
-
-    iget-object v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    invoke-static {v1, v0, v5, v6}, Lradiant/gestures/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
-
-    invoke-static {v1}, Lradiant/gestures/MiniPlayerGestures;->releaseVelocity(Landroidx/compose/material3/SheetState;)F
-
-    move-result v0
-
-    invoke-direct {p0, v0}, Lradiant/gestures/MiniPlayerGestures$Gesture;->finishSheet(F)V
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    goto :finish
-
-    :up_no_drag
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    goto :finish
-
-    :open_simple
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->suppressHorizontalGestures()V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v0
-
-    iget-object v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->a:Lam0/l;
-
-    invoke-static {v1, v0}, Lradiant/gestures/MiniPlayerGestures;->completeSimpleSwipe(Lam0/l;F)Z
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-
-    :finish
-    invoke-direct {p0}, Lradiant/gestures/MiniPlayerGestures$Gesture;->reset()V
-
-    goto :done
-
-    # ACTION_CANCEL
-    :cancel
-    iget-boolean v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->e:Z
-
-    if-eqz v0, :cancel_no_active
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
-
-    iget-object v1, p0, Lradiant/gestures/MiniPlayerGestures$Gesture;->a:Lam0/l;
-
-    invoke-static {v0, v1}, Lradiant/gestures/MiniPlayerGestures;->cancelDrag(Landroidx/compose/material3/SheetState;Lam0/l;)V
-
-    goto :cancel_reset
-
-    :cancel_no_active
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    :cancel_reset
-    invoke-direct {p0}, Lradiant/gestures/MiniPlayerGestures$Gesture;->reset()V
-
-
-    :done
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
-
-    return-object p1
-.end method
-
-.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
-    .locals 0
-
-    check-cast p1, Landroid/view/MotionEvent;
-
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerGestures$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;
-
-    move-result-object p1
-
-    return-object p1
-.end method

patches/extension/radiant/gestures/MiniPlayerGestures$RootGesture.smali

@@ -1,178 +0,0 @@
-.class public final Lradiant/gestures/MiniPlayerGestures$RootGesture;
-.super Ljava/lang/Object;
-.implements Lam0/l;
-
-
-# annotations
-.annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerGestures;
-.end annotation
-
-.annotation system Ldalvik/annotation/InnerClass;
-    accessFlags = 0x19
-    name = "RootGesture"
-.end annotation
-
-
-# instance fields
-.field public final a:Lam0/l;
-
-.field public final b:Landroidx/compose/material3/SheetState;
-
-
-# direct methods
-.method public constructor <init>(Lam0/l;Landroidx/compose/material3/SheetState;)V
-    .locals 0
-
-    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
-
-    iput-object p1, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->a:Lam0/l;
-
-    iput-object p2, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->b:Landroidx/compose/material3/SheetState;
-
-    return-void
-.end method
-
-
-# virtual methods
-.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;
-    .locals 6
-
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->b:Landroidx/compose/material3/SheetState;
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
-
-    move-result v1
-
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->isDragging(Landroidx/compose/material3/SheetState;)Z
-
-    move-result v2
-
-    if-eqz v2, :maybe_reset_only
-
-    const/4 v2, 0x1
-
-    if-eq v1, v2, :up
-
-    const/4 v2, 0x2
-
-    if-eq v1, v2, :move
-
-    const/4 v2, 0x3
-
-    if-eq v1, v2, :cancel
-
-    goto :done
-
-    :maybe_reset_only
-    const/4 v2, 0x1
-
-    if-eq v1, v2, :simple_up
-
-    const/4 v2, 0x3
-
-    if-eq v1, v2, :reset_only
-
-    const/4 v2, 0x2
-
-    if-eq v1, v2, :simple_move
-
-    goto :done
-
-    :reset_only
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->resetGestureLock()V
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    goto :done
-
-    :simple_move
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v1
-
-    invoke-static {v1}, Lradiant/gestures/MiniPlayerGestures;->updateSimpleSwipe(F)Z
-
-    goto :done
-
-    :simple_up
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v1
-
-    iget-object v2, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->a:Lam0/l;
-
-    invoke-static {v2, v1}, Lradiant/gestures/MiniPlayerGestures;->completeSimpleSwipe(Lam0/l;F)Z
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    goto :done
-
-
-    # ACTION_MOVE
-    :move
-    invoke-static {p1}, Lradiant/gestures/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v2
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
-
-    move-result-wide v4
-
-    invoke-static {v0, v2, v4, v5}, Lradiant/gestures/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
-
-    goto :done
-
-    # ACTION_UP
-    :up
-    invoke-static {p1}, Lradiant/gestures/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
-
-    move-result v1
-
-    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
-
-    move-result-wide v4
-
-    invoke-static {v0, v1, v4, v5}, Lradiant/gestures/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
-
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->releaseVelocity(Landroidx/compose/material3/SheetState;)F
-
-    move-result v1
-
-    iget-object v2, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->a:Lam0/l;
-
-    invoke-static {v0, v2, v1}, Lradiant/gestures/MiniPlayerGestures;->finishDrag(Landroidx/compose/material3/SheetState;Lam0/l;F)V
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    goto :done
-
-    # ACTION_CANCEL
-    :cancel
-    iget-object v2, p0, Lradiant/gestures/MiniPlayerGestures$RootGesture;->a:Lam0/l;
-
-    invoke-static {v0, v2}, Lradiant/gestures/MiniPlayerGestures;->cancelDrag(Landroidx/compose/material3/SheetState;Lam0/l;)V
-
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->animateSwipeFeedbackReset()V
-
-    :done
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
-
-    return-object p1
-.end method
-
-.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
-    .locals 0
-
-    check-cast p1, Landroid/view/MotionEvent;
-
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerGestures$RootGesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;
-
-    move-result-object p1
-
-    return-object p1
-.end method

patches/extension/radiant/gestures/MiniPlayerTrackGestures$OffsetLayer.smali

@@ -1,70 +0,0 @@
-.class public final Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;
-.super Ljava/lang/Object;
-.implements Lam0/l;
-
-
-# annotations
-.annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerTrackGestures;
-.end annotation
-
-.annotation system Ldalvik/annotation/InnerClass;
-    accessFlags = 0x19
-    name = "OffsetLayer"
-.end annotation
-
-
-# static fields
-.field public static final INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;
-
-
-# direct methods
-.method static constructor <clinit>()V
-    .locals 1
-
-    new-instance v0, Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;
-
-    invoke-direct {v0}, Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;-><init>()V
-
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;->INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;
-
-    return-void
-.end method
-
-.method private constructor <init>()V
-    .locals 0
-
-    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
-
-    return-void
-.end method
-
-
-# virtual methods
-.method public final invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;
-    .locals 1
-
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
-
-    invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
-
-    move-result v0
-
-    invoke-interface {p1, v0}, Landroidx/compose/ui/graphics/GraphicsLayerScope;->setTranslationX(F)V
-
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
-
-    return-object p1
-.end method
-
-.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
-    .locals 0
-
-    check-cast p1, Landroidx/compose/ui/graphics/GraphicsLayerScope;
-
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;->invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;
-
-    move-result-object p1
-
-    return-object p1
-.end method

patches/extension/radiant/gestures/lyrics/LyricsDrag$Guard.smali

@@ -1,4 +1,4 @@
-.class public final Lradiant/gestures/LyricsDrag$Guard;
+.class public final Lradiant/gestures/lyrics/LyricsDrag$Guard;
 .super Ljava/lang/Object;
 
 # interfaces
@@ -9,17 +9,17 @@
 
 # static state
 
-.field public static final INSTANCE:Lradiant/gestures/LyricsDrag$Guard;
+.field public static final INSTANCE:Lradiant/gestures/lyrics/LyricsDrag$Guard;
 
 
 .method static constructor <clinit>()V
     .locals 1
 
-    new-instance v0, Lradiant/gestures/LyricsDrag$Guard;
+    new-instance v0, Lradiant/gestures/lyrics/LyricsDrag$Guard;
 
-    invoke-direct {v0}, Lradiant/gestures/LyricsDrag$Guard;-><init>()V
+    invoke-direct {v0}, Lradiant/gestures/lyrics/LyricsDrag$Guard;-><init>()V
 
-    sput-object v0, Lradiant/gestures/LyricsDrag$Guard;->INSTANCE:Lradiant/gestures/LyricsDrag$Guard;
+    sput-object v0, Lradiant/gestures/lyrics/LyricsDrag$Guard;->INSTANCE:Lradiant/gestures/lyrics/LyricsDrag$Guard;
 
     return-void
 .end method
@@ -42,7 +42,7 @@
     return-wide p3
 .end method
 
-.method public onPostFling-RZ2iAVY(JJLkotlin/coroutines/e;)Ljava/lang/Object;
+.method public onPostFling-RZ2iAVY(JJLkotlin/coroutines/e;)Ljava/lang/Object;    # MARKER: R8 Lkotlin/coroutines/e;
     .locals 2
 
     invoke-static {p3, p4}, Landroidx/compose/ui/unit/Velocity;->box-impl(J)Landroidx/compose/ui/unit/Velocity;

patches/extension/radiant/gestures/lyrics/LyricsDrag.smali

@@ -1,4 +1,4 @@
-.class public final Lradiant/gestures/LyricsDrag;
+.class public final Lradiant/gestures/lyrics/LyricsDrag;
 .super Ljava/lang/Object;
 
 # Stops lyrics scroll dismissing the player
@@ -16,7 +16,7 @@
 .method public static wrap(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;
     .locals 2
 
-    sget-object v0, Lradiant/gestures/LyricsDrag$Guard;->INSTANCE:Lradiant/gestures/LyricsDrag$Guard;
+    sget-object v0, Lradiant/gestures/lyrics/LyricsDrag$Guard;->INSTANCE:Lradiant/gestures/lyrics/LyricsDrag$Guard;
 
     const/4 v1, 0x0
 

patches/extension/radiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending.smali

@@ -1,10 +1,10 @@
-.class public final Lradiant/gestures/MiniPlayerGestures$ApplyPending;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending;
 .super Ljava/lang/Object;
 .implements Ljava/lang/Runnable;
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -25,9 +25,9 @@
 
     invoke-direct {p0}, Ljava/lang/Object;-><init>()V
 
-    iput-object p1, p0, Lradiant/gestures/MiniPlayerGestures$ApplyPending;->a:Landroidx/compose/material3/SheetState;
+    iput-object p1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending;->a:Landroidx/compose/material3/SheetState;
 
-    iput p2, p0, Lradiant/gestures/MiniPlayerGestures$ApplyPending;->b:I
+    iput p2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending;->b:I
 
     return-void
 .end method
@@ -39,23 +39,23 @@
 .method public final run()V
     .locals 3
 
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerGestures$ApplyPending;->a:Landroidx/compose/material3/SheetState;
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending;->a:Landroidx/compose/material3/SheetState;
 
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->applyPendingDrag(Landroidx/compose/material3/SheetState;)V
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->applyPendingDrag(Landroidx/compose/material3/SheetState;)V
 
-    iget v1, p0, Lradiant/gestures/MiniPlayerGestures$ApplyPending;->b:I
+    iget v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$ApplyPending;->b:I
 
     add-int/lit8 v1, v1, -0x1
 
     if-lez v1, :done
 
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->needsApply(Landroidx/compose/material3/SheetState;)Z
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->needsApply(Landroidx/compose/material3/SheetState;)Z
 
     move-result v2
 
     if-eqz v2, :done
 
-    invoke-static {v0, v1}, Lradiant/gestures/MiniPlayerGestures;->scheduleApply(Landroidx/compose/material3/SheetState;I)V
+    invoke-static {v0, v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->scheduleApply(Landroidx/compose/material3/SheetState;I)V
 
     :done
     return-void

patches/extension/radiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer.smali

@@ -1,11 +1,11 @@
-.class public final Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;
 .super Ljava/lang/Object;
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -15,18 +15,18 @@
 
 
 # static fields
-.field public static final INSTANCE:Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;
+.field public static final INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;
 
 
 # direct methods
 .method static constructor <clinit>()V
     .locals 1
 
-    new-instance v0, Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;
+    new-instance v0, Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;
 
-    invoke-direct {v0}, Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;-><init>()V
+    invoke-direct {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;-><init>()V
 
-    sput-object v0, Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;->INSTANCE:Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;->INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;
 
     return-void
 .end method
@@ -41,10 +41,10 @@
 
 
 # virtual methods
-.method public final invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;
+.method public final invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
     .locals 1
 
-    sget-object v0, Lradiant/gestures/MiniPlayerGestures;->v:Landroidx/compose/runtime/MutableFloatState;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerGestures;->v:Landroidx/compose/runtime/MutableFloatState;
 
     invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
 
@@ -52,7 +52,7 @@
 
     invoke-interface {p1, v0}, Landroidx/compose/ui/graphics/GraphicsLayerScope;->setTranslationY(F)V
 
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     return-object p1
 .end method
@@ -62,7 +62,7 @@
 
     check-cast p1, Landroidx/compose/ui/graphics/GraphicsLayerScope;
 
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerGestures$FeedbackLayer;->invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackLayer;->invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     move-result-object p1
 

patches/extension/radiant/gestures/miniplayer/MiniPlayerGestures$FeedbackResetAnimator.smali

@@ -1,11 +1,11 @@
-.class public final Lradiant/gestures/MiniPlayerGestures$FeedbackResetAnimator;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerGestures$FeedbackResetAnimator;
 .super Ljava/lang/Object;
 .implements Landroid/animation/ValueAnimator$AnimatorUpdateListener;
 
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -41,7 +41,7 @@
 
     move-result v1
 
-    invoke-static {v1}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
+    invoke-static {v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
 
     invoke-virtual {v0}, Landroid/animation/ValueAnimator;->getAnimatedFraction()F
 
@@ -53,7 +53,7 @@
 
     if-gez v1, :done
 
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerGestures;->clearSwipeFeedbackAnimator(Landroid/animation/ValueAnimator;)V
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->clearSwipeFeedbackAnimator(Landroid/animation/ValueAnimator;)V
 
     :done
     return-void

patches/extension/radiant/gestures/miniplayer/MiniPlayerGestures$Gesture.smali

@@ -0,0 +1,521 @@
+.class public final Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;
+.super Ljava/lang/Object;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/miniplayer/MiniPlayerGestures;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "Gesture"
+.end annotation
+
+
+# instance fields
+.field public final a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+# Y at ACTION_DOWN
+.field public b:F
+
+# Last Y seen (on this pointer stream)
+.field public c:F
+
+# True while this listener owns an active pointer stream
+.field public d:Z
+
+# True when sheet drag has started
+.field public e:Z
+
+.field public final f:Landroidx/compose/material3/SheetState;
+
+.field public g:F
+
+# X at ACTION_DOWN
+.field public i:F
+
+# True once horizontal movement wins (prevents later vertical start)
+.field public j:Z
+
+# Drag option enabled
+.field public final k:Z
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Landroidx/compose/material3/SheetState;Z)V    # MARKER: R8 Lam0/l;
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    iput-boolean p3, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->k:Z
+
+    return-void
+.end method
+
+.method private static dp(F)F
+    .locals 1
+
+    invoke-static {}, Landroid/content/res/Resources;->getSystem()Landroid/content/res/Resources;
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Landroid/content/res/Resources;->getDisplayMetrics()Landroid/util/DisplayMetrics;
+
+    move-result-object v0
+
+    iget v0, v0, Landroid/util/DisplayMetrics;->density:F
+
+    mul-float/2addr p0, v0
+
+    return p0
+.end method
+
+.method private dragSheet(FJ)V
+    .locals 1
+
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    invoke-static {v0, p1, p2, p3}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->updateDragTimed(Landroidx/compose/material3/SheetState;FJ)V
+
+    return-void
+.end method
+
+.method private finishSheet(F)V
+    .locals 2
+
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    iget-object v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v0, v1, p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->finishDrag(Landroidx/compose/material3/SheetState;Lam0/l;F)V    # MARKER: R8 Lam0/l;
+
+    return-void
+.end method
+
+.method private openPlayer()V
+    .locals 2
+
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/b$b;->a:Lcom/tidal/android/feature/appscaffold/ui/b$b;    # MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/b$b; a
+
+    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    return-void
+.end method
+
+.method private reset()V
+    .locals 1
+
+    const/4 v0, 0x0
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->d:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->j:Z
+
+    const/4 v0, 0x0
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->i:F
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->g:F
+
+    return-void
+.end method
+
+.method private startSheet(FJ)V
+    .locals 2
+
+    # empty player guard
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->hasMiniPlayerMedia()Z
+
+    move-result v0
+
+    if-nez v0, :start_guard
+
+    return-void
+
+    :start_guard
+
+    # avoid starting twice
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    if-eqz v0, :start
+
+    return-void
+
+    :start
+    const/4 v0, 0x1
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->k:Z
+
+    if-eqz v0, :done
+
+    iget-object v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    iget v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->b:F
+
+    invoke-static {v1, p1, v0, p2, p3}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->beginDrag(Landroidx/compose/material3/SheetState;FFJ)V
+
+    invoke-direct {p0}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->openPlayer()V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+# Listens for MotionEvents
+.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+    .locals 11
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
+
+    move-result v0
+
+    if-eqz v0, :down
+
+    const/4 v1, 0x1
+
+    if-eq v0, v1, :up
+
+    const/4 v1, 0x2
+
+    if-eq v0, v1, :move
+
+    const/4 v1, 0x3
+
+    if-eq v0, v1, :cancel
+
+    goto :done
+
+    # ACTION_DOWN
+    :down
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->resetGestureLock()V
+
+    invoke-static {p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->beginMotion(Landroid/view/MotionEvent;)V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v0
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->b:F
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->c:F
+
+    const/4 v0, 0x1
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->d:Z
+
+    const/4 v0, 0x0
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    const/4 v0, 0x0
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->g:F
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
+
+    move-result v0
+
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->i:F
+
+    const/4 v0, 0x0
+
+    iput-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->j:Z
+
+    iget v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->b:F
+
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->beginSwipeGesture(F)V
+
+    :skip_feedback_down
+
+    goto :done
+
+    # ACTION_MOVE
+    :move
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->d:Z
+
+    if-eqz v0, :done
+
+    invoke-static {p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v0
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
+
+    move-result-wide v5
+
+    iget v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->c:F
+
+    sub-float v1, v0, v1
+
+    iput v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->g:F
+
+    iget v2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->b:F
+
+    sub-float v2, v0, v2
+
+    iget-boolean v3, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    if-eqz v3, :maybe_start
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->suppressHorizontalGestures()V
+
+    iget-boolean v3, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->k:Z
+
+    if-eqz v3, :feedback_active
+
+    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->dragSheet(FJ)V
+
+    :feedback_active
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
+
+    goto :store_last
+
+    :maybe_start
+    iget-boolean v3, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->j:Z
+
+    if-eqz v3, :axis_check
+
+    goto :store_last
+
+    :axis_check
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
+
+    move-result v7
+
+    iget v8, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->i:F
+
+    sub-float/2addr v7, v8
+
+    invoke-static {v7}, Ljava/lang/Math;->abs(F)F
+
+    move-result v7
+
+    invoke-static {v2}, Ljava/lang/Math;->abs(F)F
+
+    move-result v8
+
+    const/high16 v9, 0x40c00000    # 6.0f axis deadzone
+
+    invoke-static {v9}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->dp(F)F
+
+    move-result v9
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->isHorizontalGestureLocked()Z
+
+    move-result v10
+
+    if-eqz v10, :horizontal_check
+
+    const/4 v10, 0x0
+
+    invoke-static {v10}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
+
+    goto :store_last
+
+    :horizontal_check
+
+    cmpg-float v10, v7, v9
+
+    if-gez v10, :horizontal_dominance
+
+    goto :vertical_check
+
+    :horizontal_dominance
+
+    const v10, 0x3f8ccccd    # 1.1f
+
+    mul-float/2addr v10, v8
+
+    cmpg-float v10, v7, v10
+
+    if-gez v10, :horizontal_wins
+
+    goto :vertical_check
+
+    :horizontal_wins
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->lockHorizontalGesture()Z
+
+    move-result v10
+
+    if-eqz v10, :store_last
+
+    const/4 v10, 0x1
+
+    iput-boolean v10, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->j:Z
+
+    const/4 v10, 0x0
+
+    invoke-static {v10}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
+
+    goto :store_last
+
+    # At least 16dp up to open the player
+    :vertical_check
+    neg-float v9, v9
+
+    cmpg-float v10, v2, v9
+
+    if-lez v10, :vertical_dominance
+
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
+
+    goto :store_last
+
+    :vertical_dominance
+    const v10, 0x3f8ccccd    # 1.1f -> early vertical axis lock
+
+    mul-float/2addr v7, v10
+
+    cmpl-float v10, v8, v7
+
+    if-gtz v10, :begin
+
+    goto :store_last
+
+    :begin
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->lockVerticalGesture()Z
+
+    move-result v10
+
+    if-eqz v10, :store_last
+
+    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->startSheet(FJ)V
+
+    iget-boolean v10, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    if-eqz v10, :store_last
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->suppressHorizontalGestures()V
+
+    iget-boolean v10, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->k:Z
+
+    if-eqz v10, :feedback_begin
+
+    invoke-direct {p0, v2, v5, v6}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->dragSheet(FJ)V
+
+    :feedback_begin
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackFromDrag(F)V
+
+
+    :store_last
+    iput v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->c:F
+
+    goto :done
+
+    # ACTION_UP
+    :up
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->d:Z
+
+    if-eqz v0, :done
+
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    if-eqz v0, :up_no_drag
+
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->k:Z
+
+    if-eqz v0, :open_simple
+
+    invoke-static {p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v0
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
+
+    move-result-wide v5
+
+    iget-object v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    invoke-static {v1, v0, v5, v6}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
+
+    invoke-static {v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->releaseVelocity(Landroidx/compose/material3/SheetState;)F
+
+    move-result v0
+
+    invoke-direct {p0, v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->finishSheet(F)V
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    goto :finish
+
+    :up_no_drag
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    goto :finish
+
+    :open_simple
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->suppressHorizontalGestures()V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v0
+
+    iget-object v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v1, v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->completeSimpleSwipe(Lam0/l;F)Z    # MARKER: R8 Lam0/l;
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+
+    :finish
+    invoke-direct {p0}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->reset()V
+
+    goto :done
+
+    # ACTION_CANCEL
+    :cancel
+    iget-boolean v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->e:Z
+
+    if-eqz v0, :cancel_no_active
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->f:Landroidx/compose/material3/SheetState;
+
+    iget-object v1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v0, v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->cancelDrag(Landroidx/compose/material3/SheetState;Lam0/l;)V    # MARKER: R8 Lam0/l;
+
+    goto :cancel_reset
+
+    :cancel_no_active
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    :cancel_reset
+    invoke-direct {p0}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->reset()V
+
+
+    :done
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object p1
+.end method
+
+.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .locals 0
+
+    check-cast p1, Landroid/view/MotionEvent;
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    move-result-object p1
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/miniplayer/MiniPlayerGestures$RootGesture.smali

@@ -0,0 +1,178 @@
+.class public final Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;
+.super Ljava/lang/Object;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/miniplayer/MiniPlayerGestures;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "RootGesture"
+.end annotation
+
+
+# instance fields
+.field public final a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field public final b:Landroidx/compose/material3/SheetState;
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Landroidx/compose/material3/SheetState;)V    # MARKER: R8 Lam0/l;
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->b:Landroidx/compose/material3/SheetState;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+    .locals 6
+
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->b:Landroidx/compose/material3/SheetState;
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
+
+    move-result v1
+
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->isDragging(Landroidx/compose/material3/SheetState;)Z
+
+    move-result v2
+
+    if-eqz v2, :maybe_reset_only
+
+    const/4 v2, 0x1
+
+    if-eq v1, v2, :up
+
+    const/4 v2, 0x2
+
+    if-eq v1, v2, :move
+
+    const/4 v2, 0x3
+
+    if-eq v1, v2, :cancel
+
+    goto :done
+
+    :maybe_reset_only
+    const/4 v2, 0x1
+
+    if-eq v1, v2, :simple_up
+
+    const/4 v2, 0x3
+
+    if-eq v1, v2, :reset_only
+
+    const/4 v2, 0x2
+
+    if-eq v1, v2, :simple_move
+
+    goto :done
+
+    :reset_only
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->resetGestureLock()V
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    goto :done
+
+    :simple_move
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    invoke-static {v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->updateSimpleSwipe(F)Z
+
+    goto :done
+
+    :simple_up
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    iget-object v2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v2, v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->completeSimpleSwipe(Lam0/l;F)Z    # MARKER: R8 Lam0/l;
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    goto :done
+
+
+    # ACTION_MOVE
+    :move
+    invoke-static {p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v2
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
+
+    move-result-wide v4
+
+    invoke-static {v0, v2, v4, v5}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
+
+    goto :done
+
+    # ACTION_UP
+    :up
+    invoke-static {p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->trackMotion(Landroid/view/MotionEvent;)V
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getEventTime()J
+
+    move-result-wide v4
+
+    invoke-static {v0, v1, v4, v5}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->updateDragToYTimed(Landroidx/compose/material3/SheetState;FJ)V
+
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->releaseVelocity(Landroidx/compose/material3/SheetState;)F
+
+    move-result v1
+
+    iget-object v2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v0, v2, v1}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->finishDrag(Landroidx/compose/material3/SheetState;Lam0/l;F)V    # MARKER: R8 Lam0/l;
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    goto :done
+
+    # ACTION_CANCEL
+    :cancel
+    iget-object v2, p0, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {v0, v2}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->cancelDrag(Landroidx/compose/material3/SheetState;Lam0/l;)V    # MARKER: R8 Lam0/l;
+
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->animateSwipeFeedbackReset()V
+
+    :done
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object p1
+.end method
+
+.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .locals 0
+
+    check-cast p1, Landroid/view/MotionEvent;
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerGestures$RootGesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    move-result-object p1
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture.smali

@@ -1,11 +1,11 @@
-.class public final Lradiant/gestures/MiniPlayerTrackGestures$Gesture;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;
 .super Ljava/lang/Object;
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerTrackGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -15,16 +15,16 @@
 
 
 # instance fields
-.field public final a:Lam0/l;
+.field public final a:Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # direct methods
-.method public constructor <init>(Lam0/l;)V
+.method public constructor <init>(Lam0/l;)V    # MARKER: R8 Lam0/l;
     .locals 0
 
     invoke-direct {p0}, Ljava/lang/Object;-><init>()V
 
-    iput-object p1, p0, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;
+    iput-object p1, p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
 
     return-void
 .end method
@@ -32,11 +32,11 @@
 .method private nextTrack()V
     .locals 2
 
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
 
-    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/r$a;->a:Lcom/tidal/android/feature/appscaffold/ui/r$a; # Tidal's built-in next track mini-player event
+    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/r$a;->a:Lcom/tidal/android/feature/appscaffold/ui/r$a; # Tidal's built-in next track mini-player event  MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$a; a
 
-    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
 
     return-void
 .end method
@@ -44,18 +44,18 @@
 .method private previousTrack()V
     .locals 2
 
-    iget-object v0, p0, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;
+    iget-object v0, p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->a:Lam0/l;    # MARKER: R8 Lam0/l;
 
-    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/r$c;->a:Lcom/tidal/android/feature/appscaffold/ui/r$c; # Our synthetic previous track event
+    sget-object v1, Lcom/tidal/android/feature/appscaffold/ui/r$c;->a:Lcom/tidal/android/feature/appscaffold/ui/r$c; # Our synthetic previous track event  MARKER: R8 Lcom/tidal/android/feature/appscaffold/ui/r$c; a
 
-    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    invoke-interface {v0, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
 
     return-void
 .end method
 
 
 # virtual methods
-.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;
+.method public final invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
     .locals 3
 
     invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
@@ -86,7 +86,7 @@
     invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
 
     move-result v1
-    invoke-static {v0, v1}, Lradiant/gestures/MiniPlayerTrackGestures;->beginDrag(FF)V
+    invoke-static {v0, v1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->beginDrag(FF)V
     goto :done
 
     # ACTION_MOVE
@@ -97,7 +97,7 @@
     invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
 
     move-result v1
-    invoke-static {v0, v1}, Lradiant/gestures/MiniPlayerTrackGestures;->moveDrag(FF)V
+    invoke-static {v0, v1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->moveDrag(FF)V
     goto :done
 
     # ACTION_UP
@@ -108,7 +108,7 @@
     invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
 
     move-result v1
-    invoke-static {v0, v1}, Lradiant/gestures/MiniPlayerTrackGestures;->finishDrag(FF)I
+    invoke-static {v0, v1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->finishDrag(FF)I
 
     move-result v0
 
@@ -117,22 +117,22 @@
     # Negative result = swipe left -> next. Positive result = swipe right -> previous
     if-gez v0, :previous
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->suppressTapOpen()V
-    invoke-direct {p0}, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->nextTrack()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->suppressTapOpen()V
+    invoke-direct {p0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->nextTrack()V
     goto :done
 
     :previous
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->suppressTapOpen()V
-    invoke-direct {p0}, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->previousTrack()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->suppressTapOpen()V
+    invoke-direct {p0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->previousTrack()V
     goto :done
 
     # ACTION_CANCEL
     :cancel
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->cancelDrag()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->cancelDrag()V
 
     :done
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     return-object p1
 .end method
@@ -142,7 +142,7 @@
 
     check-cast p1, Landroid/view/MotionEvent;
 
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     move-result-object p1
 

patches/extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer.smali

@@ -0,0 +1,70 @@
+.class public final Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;
+.super Ljava/lang/Object;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "OffsetLayer"
+.end annotation
+
+
+# static fields
+.field public static final INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;
+
+
+# direct methods
+.method static constructor <clinit>()V
+    .locals 1
+
+    new-instance v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;
+
+    invoke-direct {v0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;-><init>()V
+
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;->INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;
+
+    return-void
+.end method
+
+.method private constructor <init>()V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public final invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+    .locals 1
+
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
+
+    invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
+
+    move-result v0
+
+    invoke-interface {p1, v0}, Landroidx/compose/ui/graphics/GraphicsLayerScope;->setTranslationX(F)V
+
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object p1
+.end method
+
+.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .locals 0
+
+    check-cast p1, Landroidx/compose/ui/graphics/GraphicsLayerScope;
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;->invoke(Landroidx/compose/ui/graphics/GraphicsLayerScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    move-result-object p1
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$ResetAnimator.smali

@@ -1,11 +1,11 @@
-.class public final Lradiant/gestures/MiniPlayerTrackGestures$ResetAnimator;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$ResetAnimator;
 .super Ljava/lang/Object;
 .implements Landroid/animation/ValueAnimator$AnimatorUpdateListener;
 
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerTrackGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -40,7 +40,7 @@
 
     move-result v1
 
-    invoke-static {v1}, Lradiant/gestures/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
+    invoke-static {v1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
 
     invoke-virtual {v0}, Landroid/animation/ValueAnimator;->getAnimatedFraction()F
 
@@ -52,7 +52,7 @@
 
     if-gez v1, :done
 
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerTrackGestures;->clearResetAnimator(Landroid/animation/ValueAnimator;)V
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->clearResetAnimator(Landroid/animation/ValueAnimator;)V
 
     :done
 

patches/extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw.smali

@@ -1,11 +1,11 @@
-.class public final Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;
 .super Ljava/lang/Object;
-.implements Lam0/l;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
 
 
 # annotations
 .annotation system Ldalvik/annotation/EnclosingClass;
-    value = Lradiant/gestures/MiniPlayerTrackGestures;
+    value = Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;
 .end annotation
 
 .annotation system Ldalvik/annotation/InnerClass;
@@ -15,18 +15,18 @@
 
 
 # static fields
-.field public static final INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;
+.field public static final INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;
 
 
 # direct methods
 .method static constructor <clinit>()V
     .locals 1
 
-    new-instance v0, Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;
+    new-instance v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;
 
-    invoke-direct {v0}, Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;-><init>()V
+    invoke-direct {v0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;-><init>()V
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;->INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;->INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;
 
     return-void
 .end method
@@ -41,10 +41,10 @@
 
 
 # virtual methods
-.method public final invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;
+.method public final invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
     .locals 12
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
 
     invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
 
@@ -109,7 +109,7 @@
 
     invoke-interface {v7, v8, v9}, Landroidx/compose/ui/graphics/drawscope/DrawContext;->setSize-uvyYCjk(J)V
 
-    sget-object p1, Lkotlin/u;->a:Lkotlin/u;
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     return-object p1
 
@@ -132,7 +132,7 @@
 
     check-cast p1, Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;
 
-    invoke-virtual {p0, p1}, Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;->invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;
+    invoke-virtual {p0, p1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;->invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
 
     move-result-object p1
 

patches/extension/radiant/gestures/miniplayer/MiniPlayerTrackGestures.smali

@@ -1,4 +1,4 @@
-.class public final Lradiant/gestures/MiniPlayerTrackGestures;
+.class public final Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;
 .super Ljava/lang/Object;
 
 
@@ -32,7 +32,7 @@
 
     move-result-object v0
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
 
     return-void
 .end method
@@ -48,7 +48,7 @@
 .method public static animateReset()V
     .locals 7
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     if-eqz v0, :read_offset
 
@@ -56,10 +56,10 @@
 
     const/4 v0, 0x0
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     :read_offset
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
 
     invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
 
@@ -105,20 +105,20 @@
 
     invoke-virtual {v1, v0}, Landroid/animation/ValueAnimator;->setInterpolator(Landroid/animation/TimeInterpolator;)V
 
-    new-instance v0, Lradiant/gestures/MiniPlayerTrackGestures$ResetAnimator;
+    new-instance v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$ResetAnimator;
 
-    invoke-direct {v0}, Lradiant/gestures/MiniPlayerTrackGestures$ResetAnimator;-><init>()V
+    invoke-direct {v0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$ResetAnimator;-><init>()V
 
     invoke-virtual {v1, v0}, Landroid/animation/ValueAnimator;->addUpdateListener(Landroid/animation/ValueAnimator$AnimatorUpdateListener;)V
 
-    sput-object v1, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sput-object v1, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     invoke-virtual {v1}, Landroid/animation/ValueAnimator;->start()V
 
     return-void
 
     :snap_zero
-    invoke-static {v3}, Lradiant/gestures/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
+    invoke-static {v3}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
 
     return-void
 .end method
@@ -126,21 +126,21 @@
 .method public static beginDrag(FF)V
     .locals 2
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->resetGestureLock()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->resetGestureLock()V
 
-    sput p0, Lradiant/gestures/MiniPlayerTrackGestures;->e:F
+    sput p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->e:F
 
-    sput p1, Lradiant/gestures/MiniPlayerTrackGestures;->f:F
+    sput p1, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->f:F
 
     const/4 v0, 0x1
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     if-eqz v0, :zero
 
@@ -148,12 +148,12 @@
 
     const/4 v0, 0x0
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     :zero
     const/4 v0, 0x0
 
-    invoke-static {v0}, Lradiant/gestures/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
+    invoke-static {v0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
 
     return-void
 .end method
@@ -163,11 +163,11 @@
 
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     return-void
 .end method
@@ -175,13 +175,13 @@
 .method public static clearResetAnimator(Landroid/animation/ValueAnimator;)V
     .locals 1
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     if-ne v0, p0, :done
 
     const/4 v0, 0x0
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     :done
     return-void
@@ -190,7 +190,7 @@
 .method public static finishDrag(FF)I
     .locals 5
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->isAnyDragging()Z
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->isAnyDragging()Z
 
     move-result v0
 
@@ -198,17 +198,17 @@
 
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     return v0
 
     :check_active
 
-    sget-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sget-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
     if-nez v0, :active
 
@@ -219,26 +219,26 @@
     :active
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
-    sget-boolean v1, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sget-boolean v1, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    sget v2, Lradiant/gestures/MiniPlayerTrackGestures;->e:F
+    sget v2, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->e:F
 
     sub-float/2addr p0, v2
 
-    sget v2, Lradiant/gestures/MiniPlayerTrackGestures;->f:F
+    sget v2, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->f:F
 
     sub-float/2addr p1, v2
 
     if-eqz v1, :reset
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->suppressTapOpen()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->suppressTapOpen()V
 
     :reset
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     invoke-static {p0}, Ljava/lang/Math;->abs(F)F
 
@@ -246,7 +246,7 @@
 
     const/high16 v2, 0x42400000    # 48.0f -> at least 48dp horizontal swipe
 
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerTrackGestures;->dp(F)F
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->dp(F)F
 
     move-result v2
 
@@ -291,11 +291,11 @@
 .method public static moveDrag(FF)V
     .locals 6
 
-    sget-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sget-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
     if-eqz v0, :done
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->isAnyDragging()Z
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->isAnyDragging()Z
 
     move-result v0
 
@@ -303,20 +303,20 @@
 
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     goto :done
 
     :move_continue
-    sget v0, Lradiant/gestures/MiniPlayerTrackGestures;->e:F
+    sget v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->e:F
 
     sub-float/2addr p0, v0
 
-    sget v0, Lradiant/gestures/MiniPlayerTrackGestures;->f:F
+    sget v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->f:F
 
     sub-float/2addr p1, v0
 
@@ -328,13 +328,13 @@
 
     move-result v1
 
-    sget-boolean v2, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sget-boolean v2, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
     if-nez v2, :publish
 
     const/high16 v2, 0x40c00000    # 6.0f dp dead zone
 
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerTrackGestures;->dp(F)F
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->dp(F)F
 
     move-result v2
 
@@ -356,7 +356,7 @@
     goto :done
 
     :accept
-    invoke-static {}, Lradiant/gestures/MiniPlayerGestures;->lockHorizontalGesture()Z
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->lockHorizontalGesture()Z
 
     move-result v2
 
@@ -364,16 +364,16 @@
 
     const/4 v2, 0x1
 
-    sput-boolean v2, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v2, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
     :publish
     const/4 v2, 0x0
 
-    invoke-static {v2}, Lradiant/gestures/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
+    invoke-static {v2}, Lradiant/gestures/miniplayer/MiniPlayerGestures;->setSwipeFeedbackDirect(F)V
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->suppressTapOpen()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->suppressTapOpen()V
 
-    invoke-static {p0}, Lradiant/gestures/MiniPlayerTrackGestures;->setDragOffset(F)V
+    invoke-static {p0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->setDragOffset(F)V
 
     :done
     return-void
@@ -381,11 +381,11 @@
     :cancel_locked
     const/4 v0, 0x0
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->g:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->g:Z
 
-    sput-boolean v0, Lradiant/gestures/MiniPlayerTrackGestures;->h:Z
+    sput-boolean v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->h:Z
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     goto :done
 .end method
@@ -417,9 +417,9 @@
 
     move-result-object p0
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;->INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$OffsetLayer;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;->INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$OffsetLayer;
 
-    invoke-static {p0, v0}, Landroidx/compose/ui/graphics/GraphicsLayerModifierKt;->graphicsLayer(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;
+    invoke-static {p0, v0}, Landroidx/compose/ui/graphics/GraphicsLayerModifierKt;->graphicsLayer(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
 
     move-result-object p0
 
@@ -429,9 +429,9 @@
 .method public static textFeedbackModifier(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;
     .locals 1
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures$TextDraw;->INSTANCE:Lradiant/gestures/MiniPlayerTrackGestures$TextDraw; # text clip on right only
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw;->INSTANCE:Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$TextDraw; # text clip on right only
 
-    invoke-static {p0, v0}, Landroidx/compose/ui/draw/DrawModifierKt;->drawWithContent(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;
+    invoke-static {p0, v0}, Landroidx/compose/ui/draw/DrawModifierKt;->drawWithContent(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
 
     move-result-object p0
 
@@ -441,7 +441,7 @@
 .method public static onRenderedItem(Ljava/lang/Object;)V
     .locals 2
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
 
     if-eqz v0, :store_initial
 
@@ -451,14 +451,14 @@
 
     if-nez v1, :done
 
-    sput-object p0, Lradiant/gestures/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
+    sput-object p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
 
-    invoke-static {}, Lradiant/gestures/MiniPlayerTrackGestures;->animateReset()V
+    invoke-static {}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->animateReset()V
 
     return-void
 
     :store_initial
-    sput-object p0, Lradiant/gestures/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
+    sput-object p0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->d:Ljava/lang/Object;
 
     :done
     return-void
@@ -467,7 +467,7 @@
 .method public static consumeTapOpenSuppression()Z
     .locals 5
 
-    sget-wide v0, Lradiant/gestures/MiniPlayerTrackGestures;->a:J
+    sget-wide v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->a:J
 
     const-wide/16 v2, 0x0
 
@@ -480,7 +480,7 @@
     return v0
 
     :check_time
-    sput-wide v2, Lradiant/gestures/MiniPlayerTrackGestures;->a:J
+    sput-wide v2, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->a:J
 
     invoke-static {}, Landroid/os/SystemClock;->uptimeMillis()J
 
@@ -511,7 +511,7 @@
 
     add-long/2addr v0, v2
 
-    sput-wide v0, Lradiant/gestures/MiniPlayerTrackGestures;->a:J
+    sput-wide v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->a:J
 
     return-void
 .end method
@@ -519,7 +519,7 @@
 .method public static setDragOffset(F)V
     .locals 5
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     if-eqz v0, :rubber_band
 
@@ -527,7 +527,7 @@
 
     const/4 v0, 0x0
 
-    sput-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
+    sput-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->c:Landroid/animation/ValueAnimator;
 
     :rubber_band
     invoke-static {p0}, Ljava/lang/Math;->abs(F)F
@@ -536,7 +536,7 @@
 
     const/high16 v1, 0x42800000    # 64.0f dp free travel
 
-    invoke-static {v1}, Lradiant/gestures/MiniPlayerTrackGestures;->dp(F)F
+    invoke-static {v1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->dp(F)F
 
     move-result v1
 
@@ -575,7 +575,7 @@
 
 
     :publish
-    invoke-static {p0}, Lradiant/gestures/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
+    invoke-static {p0}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->setDragOffsetDirect(F)V
 
     return-void
 .end method
@@ -583,21 +583,21 @@
 .method public static setDragOffsetDirect(F)V
     .locals 1
 
-    sget-object v0, Lradiant/gestures/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
+    sget-object v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures;->b:Landroidx/compose/runtime/MutableFloatState;
 
     invoke-interface {v0, p0}, Landroidx/compose/runtime/MutableFloatState;->setFloatValue(F)V
 
     return-void
 .end method
 
-.method public static trackModifier(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;
+.method public static trackModifier(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
     .locals 1
 
-    new-instance v0, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;
+    new-instance v0, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;
 
-    invoke-direct {v0, p1}, Lradiant/gestures/MiniPlayerTrackGestures$Gesture;-><init>(Lam0/l;)V
+    invoke-direct {v0, p1}, Lradiant/gestures/miniplayer/MiniPlayerTrackGestures$Gesture;-><init>(Lam0/l;)V    # MARKER: R8 Lam0/l;
 
-    invoke-static {p0, v0}, Landroidx/compose/ui/input/pointer/PointerInteropFilter_androidKt;->motionEventSpy(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;
+    invoke-static {p0, v0}, Landroidx/compose/ui/input/pointer/PointerInteropFilter_androidKt;->motionEventSpy(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
 
     move-result-object p0
 

patches/extension/radiant/gestures/queue/AlbumItemQueueAction.smali

@@ -0,0 +1,217 @@
+.class public final Lradiant/gestures/queue/AlbumItemQueueAction;
+.super Ljava/lang/Object;
+.source "AlbumItemQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a$a;
+
+.field private context:Landroid/content/Context;
+
+.field private final mediaItemId:I
+
+.field private final moduleId:Ljava/lang/String;
+
+
+# direct methods
+.method public constructor <init>(Lu5/b$a;)V    # MARKER: R8 Lu5/b$a;
+    .locals 2
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iget-object v0, p1, Lu5/b$a;->a:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a; Lu5/b$a$a; a
+
+    iput-object v0, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->callback:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a$a;
+
+    iget-object v0, p1, Lu5/b$a;->c:Lu5/b$a$b;    # MARKER: R8 Lu5/b$a; Lu5/b$a$b; c
+
+    iget v1, v0, Lu5/b$a$b;->r:I    # MARKER: R8 Lu5/b$a$b; r
+
+    iput v1, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->mediaItemId:I
+
+    iget-object v0, v0, Lu5/b$a$b;->s:Ljava/lang/String;    # MARKER: R8 Lu5/b$a$b; s
+
+    iput-object v0, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->moduleId:Ljava/lang/String;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 10
+
+    iget-object v0, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->callback:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a$a;
+
+    iget v1, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->mediaItemId:I
+
+    iget-object v2, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->moduleId:Ljava/lang/String;
+
+    const/4 v3, 0x3
+
+    if-eq p1, v3, :active_queue
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v3
+
+    if-nez v3, :active_queue
+
+    invoke-interface {v0, v1, v2}, Lu5/b$a$a;->g(ILjava/lang/String;)V    # MARKER: R8 Lu5/b$a$a; g
+
+    goto :done
+
+    :active_queue
+    iget-object v3, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v3, :done
+
+    instance-of v4, v0, Lu5/g;    # MARKER: R8 Lu5/g;
+
+    if-eqz v4, :done
+
+    check-cast v0, Lu5/g;    # MARKER: R8 Lu5/g;
+
+    invoke-virtual {v0, v2}, Lk5/f;->l(Ljava/lang/String;)Lcom/aspiro/wamp/dynamicpages/data/model/Module;    # MARKER: R8 Lk5/f; l
+
+    move-result-object v4
+
+    instance-of v5, v4, Lcom/aspiro/wamp/dynamicpages/data/model/collection/AlbumItemCollectionModule;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lcom/aspiro/wamp/dynamicpages/data/model/collection/AlbumItemCollectionModule;
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/dynamicpages/data/model/collection/AlbumItemCollectionModule;->getMediaItemParents()Ljava/util/List;
+
+    move-result-object v5
+
+    invoke-interface {v5}, Ljava/lang/Iterable;->iterator()Ljava/util/Iterator;
+
+    move-result-object v5
+
+    :find_item
+    invoke-interface {v5}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v6
+
+    if-eqz v6, :done
+
+    invoke-interface {v5}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v6
+
+    check-cast v6, Lcom/aspiro/wamp/model/MediaItemParent;
+
+    invoke-virtual {v6}, Lcom/aspiro/wamp/model/MediaItemParent;->getMediaItem()Lcom/aspiro/wamp/model/MediaItem;
+
+    move-result-object v7
+
+    if-eqz v7, :find_item
+
+    invoke-virtual {v7}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+
+    move-result v8
+
+    if-ne v8, v1, :find_item
+
+    instance-of v8, v7, Lcom/aspiro/wamp/model/Track;
+
+    if-eqz v8, :done
+
+    check-cast v7, Lcom/aspiro/wamp/model/Track;
+
+    iget-object v8, v0, Lu5/g;->h:Lcom/aspiro/wamp/model/AvailabilityInteractor;    # MARKER: R8 Lu5/g; h
+
+    invoke-interface {v8, v7}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getAvailability(Lcom/aspiro/wamp/model/MediaItem;)Lcom/aspiro/wamp/model/Availability$MediaItem;
+
+    move-result-object v8
+
+    invoke-virtual {v8}, Lcom/aspiro/wamp/model/Availability$MediaItem;->isAvailable()Z
+
+    move-result v8
+
+    if-eqz v8, :done
+
+    new-instance v5, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getPageId()Ljava/lang/String;
+
+    move-result-object v6
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getId()Ljava/lang/String;
+
+    move-result-object v8
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getPosition()I
+
+    move-result v9
+
+    invoke-static {v9}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v9
+
+    invoke-direct {v5, v6, v8, v9}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    invoke-virtual {v7}, Lcom/aspiro/wamp/model/MediaItem;->getAlbum()Lcom/aspiro/wamp/model/Album;
+
+    move-result-object v6
+
+    if-eqz v6, :done
+
+    iget-object v8, v0, Lu5/g;->j:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lu5/g; j
+
+    invoke-static {v6, v8}, Lcom/aspiro/wamp/playqueue/source/model/b;->c(Lcom/aspiro/wamp/model/Album;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/AlbumSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; c
+
+    move-result-object v6
+
+    invoke-virtual {v6, v7}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    const/4 v8, 0x1
+
+    if-ne p1, v8, :check_add_to_playlist
+
+    invoke-static {v3, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_to_playlist
+    const/4 v8, 0x3
+
+    if-ne p1, v8, :append_track
+
+    invoke-static {v3, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append_track
+    invoke-static {v3, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/AlbumItemQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/AlbumItemQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ArtistTrackCreditsQueue.smali

@@ -0,0 +1,181 @@
+.class public final Lradiant/gestures/queue/ArtistTrackCreditsQueue;
+.super Ljava/lang/Object;
+.source "ArtistTrackCreditsQueue.smali"
+
+
+# direct methods
+.method public static handle(Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/ArtistTrackCreditsModuleManager;Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;)V
+    .locals 11
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget-object v0, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->pageId:Ljava/lang/String;
+
+    if-eqz v0, :done
+
+    invoke-virtual {v0}, Ljava/lang/String;->length()I
+
+    move-result v1
+
+    if-lez v1, :done
+
+    iget-object v1, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    if-eqz v1, :done
+
+    invoke-virtual {v1}, Ljava/lang/String;->length()I
+
+    move-result v2
+
+    if-lez v2, :done
+
+    iget-wide v2, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->trackId:J
+
+    const-wide/16 v4, 0x0
+
+    cmp-long v4, v2, v4
+
+    if-lez v4, :done
+
+    invoke-virtual {p0, v1}, Li60/c;->c(Ljava/lang/String;)Lc60/h;    # MARKER: R8 Li60/c; Lc60/h; c
+
+    move-result-object v4
+
+    instance-of v5, v4, Lc60/d;    # MARKER: R8 Lc60/d;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lc60/d;    # MARKER: R8 Lc60/d;
+
+    iget-object v5, v4, Lc60/d;->b:Ljava/lang/String;    # MARKER: R8 Lc60/d; b
+
+    invoke-virtual {v1, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    iget-object v1, v4, Lc60/d;->f:Ljava/util/ArrayList;    # MARKER: R8 Lc60/d; f
+
+    if-eqz v1, :done
+
+    invoke-virtual {v1}, Ljava/util/ArrayList;->iterator()Ljava/util/Iterator;
+
+    move-result-object v1
+
+    :find_track
+    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v5
+
+    if-eqz v5, :done
+
+    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v5
+
+    instance-of v6, v5, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    if-eqz v6, :find_track
+
+    check-cast v5, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    iget-object v5, v5, Lc60/r$b;->a:Lh40/n;    # MARKER: R8 Lc60/r$b; Lh40/n; a
+
+    instance-of v6, v5, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    if-eqz v6, :find_track
+
+    check-cast v5, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    iget-wide v6, v5, Lh40/p;->a:J    # MARKER: R8 Lh40/p; a
+
+    cmp-long v6, v6, v2
+
+    if-nez v6, :find_track
+
+    iget-object v1, p0, Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/ArtistTrackCreditsModuleManager;->b:Lcom/tidal/android/dynamicpages/ui/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/b; b
+
+    instance-of v2, v1, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    if-eqz v2, :done
+
+    check-cast v1, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    iget-object v6, v1, Lcom/tidal/android/dynamicpages/ui/c;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; b
+
+    if-eqz v6, :done
+
+    iget-object v1, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    invoke-static {v5}, Lie0/i;->a(Lh40/p;)Lcom/aspiro/wamp/model/Track;    # MARKER: R8 Lie0/i; Lh40/p; a
+
+    move-result-object v7
+
+    if-eqz v7, :done
+
+    iget-object v2, v4, Lc60/d;->a:Ljava/lang/String;    # MARKER: R8 Lc60/d; a
+
+    if-eqz v2, :done
+
+    new-instance v8, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    iget v3, v4, Lc60/d;->e:I    # MARKER: R8 Lc60/d; e
+
+    invoke-static {v3}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v3
+
+    invoke-direct {v8, v0, v2, v3}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    iget-wide v2, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->trackId:J
+
+    invoke-static {v2, v3}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object v2
+
+    iget-object v3, v4, Lc60/d;->c:Ljava/lang/String;    # MARKER: R8 Lc60/d; c
+
+    iget-object v10, v4, Lc60/d;->g:Ljava/lang/String;    # MARKER: R8 Lc60/d; g
+
+    invoke-static {v10}, Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$a;->a(Ljava/lang/String;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;    # MARKER: R8 a
+
+    move-result-object v4
+
+    invoke-static {v2, v3, v6, v4}, Lcom/aspiro/wamp/playqueue/source/model/b;->j(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; j
+
+    move-result-object v9
+
+    if-eqz v9, :done
+
+    invoke-virtual {v9, v7}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget v0, p1, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->action:I
+
+    const/4 v2, 0x1
+
+    if-ne v0, v2, :check_add_to_playlist
+
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_to_playlist
+    const/4 v2, 0x3
+
+    if-ne v0, v2, :append
+
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ArtistTrackCreditsQueueAction.smali

@@ -0,0 +1,113 @@
+.class public final Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;
+.super Ljava/lang/Object;
+.source "ArtistTrackCreditsQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field private context:Landroid/content/Context;
+
+.field private final moduleUuid:Ljava/lang/String;
+
+.field private final pageId:Ljava/lang/String;
+
+.field private final trackId:J
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Ljava/lang/String;Ljava/lang/String;Lm40/e$e;)V    # MARKER: R8 Lam0/l; Lm40/e$e;
+    .locals 2
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->moduleUuid:Ljava/lang/String;
+
+    iget-wide v0, p4, Lm40/e$e;->a:J    # MARKER: R8 Lm40/e$e; a
+
+    iput-wide v0, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->trackId:J
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 8
+
+    iget-wide v1, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->trackId:J
+
+    const/4 v0, 0x3
+
+    if-eq p1, v0, :active_queue
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v0
+
+    if-nez v0, :active_queue
+
+    new-instance v0, Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b$a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b$a;
+
+    iget-object v3, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v4, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->moduleUuid:Ljava/lang/String;
+
+    invoke-direct {v0, v1, v2, v3, v4}, Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b$a;-><init>(JLjava/lang/String;Ljava/lang/String;)V    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b$a;
+
+    goto :emit
+
+    :active_queue
+    new-instance v0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;
+
+    iget-object v1, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    iget-object v2, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v3, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->moduleUuid:Ljava/lang/String;
+
+    iget-wide v4, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->trackId:J
+
+    move v6, p1
+
+    invoke-direct/range {v0 .. v6}, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;-><init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;JI)V
+
+    :emit
+    iget-object v7, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-interface {v7, v0}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ArtistTrackCreditsQueueEvent.smali

@@ -0,0 +1,38 @@
+.class public final Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;
+.super Ljava/lang/Object;
+.source "ArtistTrackCreditsQueueEvent.smali"
+
+# interfaces
+.implements Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/artisttrackcredits/b;
+
+
+# instance fields
+.field public final action:I
+
+.field public final context:Landroid/content/Context;
+
+.field public final moduleUuid:Ljava/lang/String;
+
+.field public final pageId:Ljava/lang/String;
+
+.field public final trackId:J
+
+
+# direct methods
+.method public constructor <init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;JI)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->context:Landroid/content/Context;
+
+    iput-object p2, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iput-wide p4, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->trackId:J
+
+    iput p6, p0, Lradiant/gestures/queue/ArtistTrackCreditsQueueEvent;->action:I
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/CompactGridMediaQueueAction.smali

@@ -0,0 +1,281 @@
+.class public final Lradiant/gestures/queue/CompactGridMediaQueueAction;
+.super Ljava/lang/Object;
+.source "CompactGridMediaQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field private context:Landroid/content/Context;
+
+.field private final itemId:Ljava/lang/String;
+
+.field private final mediaType:I
+
+.field private final moduleUuid:Ljava/lang/String;
+
+.field private final pageId:Ljava/lang/String;
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Ljava/lang/String;Ljava/lang/String;Lm40/e;)V    # MARKER: R8 Lam0/l; Lm40/e;
+    .locals 3
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->moduleUuid:Ljava/lang/String;
+
+    instance-of v0, p4, Lm40/e$a;    # MARKER: R8 Lm40/e$a;
+
+    if-eqz v0, :mix
+
+    check-cast p4, Lm40/e$a;    # MARKER: R8 Lm40/e$a;
+
+    iget-wide v0, p4, Lm40/e$a;->a:J    # MARKER: R8 Lm40/e$a; a
+
+    invoke-static {v0, v1}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object v0
+
+    const/4 v1, 0x1
+
+    goto :store
+
+    :mix
+    instance-of v0, p4, Lm40/e$c;    # MARKER: R8 Lm40/e$c;
+
+    if-eqz v0, :playlist
+
+    check-cast p4, Lm40/e$c;    # MARKER: R8 Lm40/e$c;
+
+    iget-object v0, p4, Lm40/e$c;->a:Ljava/lang/String;    # MARKER: R8 Lm40/e$c; a
+
+    const/4 v1, 0x2
+
+    goto :store
+
+    :playlist
+    instance-of v0, p4, Lm40/e$d;    # MARKER: R8 Lm40/e$d;
+
+    if-eqz v0, :track
+
+    check-cast p4, Lm40/e$d;    # MARKER: R8 Lm40/e$d;
+
+    iget-object v0, p4, Lm40/e$d;->a:Ljava/lang/String;    # MARKER: R8 Lm40/e$d; a
+
+    const/4 v1, 0x3
+
+    goto :store
+
+    :track
+    instance-of v0, p4, Lm40/e$e;    # MARKER: R8 Lm40/e$e;
+
+    if-eqz v0, :unsupported
+
+    check-cast p4, Lm40/e$e;    # MARKER: R8 Lm40/e$e;
+
+    iget-wide v0, p4, Lm40/e$e;->a:J    # MARKER: R8 Lm40/e$e; a
+
+    invoke-static {v0, v1}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object v0
+
+    const/4 v1, 0x4
+
+    goto :store
+
+    :unsupported
+    const/4 v0, 0x0
+
+    const/4 v1, 0x0
+
+    :store
+    iput-object v0, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->itemId:Ljava/lang/String;
+
+    iput v1, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->mediaType:I
+
+    return-void
+.end method
+
+.method public static isEligible(Lm40/e;)Z    # MARKER: R8 Lm40/e;
+    .locals 1
+
+    instance-of v0, p0, Lm40/e$a;    # MARKER: R8 Lm40/e$a;
+
+    if-eqz v0, :mix
+
+    check-cast p0, Lm40/e$a;    # MARKER: R8 Lm40/e$a;
+
+    iget-boolean p0, p0, Lm40/e$a;->e:Z    # MARKER: R8 Lm40/e$a; e
+
+    return p0
+
+    :mix
+    instance-of v0, p0, Lm40/e$c;    # MARKER: R8 Lm40/e$c;
+
+    if-eqz v0, :playlist
+
+    check-cast p0, Lm40/e$c;    # MARKER: R8 Lm40/e$c;
+
+    iget-boolean p0, p0, Lm40/e$c;->h:Z    # MARKER: R8 Lm40/e$c; h
+
+    return p0
+
+    :playlist
+    instance-of v0, p0, Lm40/e$d;    # MARKER: R8 Lm40/e$d;
+
+    if-eqz v0, :track
+
+    check-cast p0, Lm40/e$d;    # MARKER: R8 Lm40/e$d;
+
+    iget-boolean p0, p0, Lm40/e$d;->g:Z    # MARKER: R8 Lm40/e$d; g
+
+    return p0
+
+    :track
+    instance-of v0, p0, Lm40/e$e;    # MARKER: R8 Lm40/e$e;
+
+    if-eqz v0, :invalid
+
+    check-cast p0, Lm40/e$e;    # MARKER: R8 Lm40/e$e;
+
+    iget-boolean p0, p0, Lm40/e$e;->j:Z    # MARKER: R8 Lm40/e$e; j
+
+    return p0
+
+    :invalid
+    const/4 p0, 0x0
+
+    return p0
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 8
+
+    iget-object v7, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    if-eqz v7, :done
+
+    iget-object v4, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->itemId:Ljava/lang/String;
+
+    if-eqz v4, :done
+
+    iget v5, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->mediaType:I
+
+    if-eqz v5, :done
+
+    const/4 v1, 0x3
+
+    if-eq p1, v1, :queue_event
+
+    const/4 v1, 0x4
+
+    if-ne v5, v1, :queue_event
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-nez v1, :queue_event
+
+    move-object v1, v4
+
+    goto :emit
+
+    :queue_event
+    iget-object v1, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    new-instance v0, Lradiant/gestures/queue/DynamicMediaQueueEvent;
+
+    iget-object v2, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v3, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->moduleUuid:Ljava/lang/String;
+
+    move v6, p1
+
+    invoke-direct/range {v0 .. v6}, Lradiant/gestures/queue/DynamicMediaQueueEvent;-><init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;II)V
+
+    move-object v1, v0
+
+    :emit
+    invoke-interface {v7, v1}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/CompactGridMediaQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method
+
+.method public stableKey()Ljava/lang/String;
+    .locals 3
+
+    iget-object v0, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->itemId:Ljava/lang/String;
+
+    if-eqz v0, :invalid
+
+    new-instance v1, Ljava/lang/StringBuilder;
+
+    const-string v2, "cgc:"
+
+    invoke-direct {v1, v2}, Ljava/lang/StringBuilder;-><init>(Ljava/lang/String;)V
+
+    iget-object v2, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->moduleUuid:Ljava/lang/String;
+
+    invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+
+    const/16 v2, 0x3a
+
+    invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder;
+
+    iget v2, p0, Lradiant/gestures/queue/CompactGridMediaQueueAction;->mediaType:I
+
+    invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;
+
+    const/16 v2, 0x3a
+
+    invoke-virtual {v1, v2}, Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder;
+
+    invoke-virtual {v1, v0}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+
+    invoke-virtual {v1}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
+
+    move-result-object v0
+
+    return-object v0
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method

patches/extension/radiant/gestures/queue/ComposeSearchQueue.smali

@@ -0,0 +1,367 @@
+.class public final Lradiant/gestures/queue/ComposeSearchQueue;
+.super Ljava/lang/Object;
+.source "ComposeSearchQueue.smali"
+
+
+# direct methods
+.method public static handle(Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;Lradiant/gestures/queue/ComposeSearchQueueEvent;)V
+    .locals 10
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-lt v0, v1, :done
+
+    const/4 v1, 0x3
+
+    if-gt v0, v1, :done
+
+    iget-object v8, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v8, :done
+
+    iget-object v2, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->id:Ljava/lang/String;
+
+    if-eqz v2, :done
+
+    iget v4, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->type:I
+
+    const/4 v0, 0x1
+
+    if-lt v4, v0, :done
+
+    const/4 v0, 0x4
+
+    if-gt v4, v0, :done
+
+    iget-object v0, p0, Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;->n:Ljava/util/List;    # MARKER: R8 n
+
+    invoke-interface {v0}, Ljava/lang/Iterable;->iterator()Ljava/util/Iterator;
+
+    move-result-object v0
+
+    :find_row
+    invoke-interface {v0}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    invoke-interface {v0}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Lmb0/e;    # MARKER: R8 Lmb0/e;
+
+    invoke-static {v1}, Lmb0/f;->a(Lmb0/e;)Ljava/lang/String;    # MARKER: R8 Lmb0/f; Lmb0/e; a
+
+    move-result-object v9
+
+    invoke-virtual {v2, v9}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v9
+
+    if-eqz v9, :find_row
+
+    instance-of v9, v1, Lmb0/a;    # MARKER: R8 Lmb0/a;
+
+    if-eqz v9, :find_row
+
+    check-cast v1, Lmb0/a;    # MARKER: R8 Lmb0/a;
+
+    iget-object v3, v1, Lmb0/a;->a:Lh40/n;    # MARKER: R8 Lmb0/a; Lh40/n; a
+
+    const/4 v9, 0x1
+
+    if-ne v4, v9, :check_album
+
+    instance-of v9, v3, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    if-eqz v9, :find_row
+
+    goto :recover_dependencies
+
+    :check_album
+    const/4 v9, 0x2
+
+    if-ne v4, v9, :check_playlist
+
+    instance-of v9, v3, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    if-eqz v9, :find_row
+
+    goto :recover_dependencies
+
+    :check_playlist
+    const/4 v9, 0x3
+
+    if-ne v4, v9, :check_mix
+
+    instance-of v9, v3, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    if-eqz v9, :find_row
+
+    goto :recover_dependencies
+
+    :check_mix
+    instance-of v9, v3, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    if-eqz v9, :find_row
+
+    :recover_dependencies
+    iget-object v9, p0, Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;->d:Lcom/tidal/android/feature/search/ui/e;    # MARKER: R8 Lcom/tidal/android/feature/search/ui/e; d
+
+    instance-of v0, v9, Lv9/e;    # MARKER: R8 Lv9/e;
+
+    if-eqz v0, :done
+
+    check-cast v9, Lv9/e;    # MARKER: R8 Lv9/e;
+
+    iget-object v5, v9, Lv9/e;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lv9/e; b
+
+    iget-object v9, v9, Lv9/e;->a:Lcom/aspiro/wamp/core/k;    # MARKER: R8 Lv9/e; Lcom/aspiro/wamp/core/k; a
+
+    const/4 v6, 0x0
+
+    const/4 v0, 0x2
+
+    if-eq v4, v0, :recover_menu
+
+    const/4 v0, 0x4
+
+    if-ne v4, v0, :dependencies_ready
+
+    :recover_menu
+
+    instance-of v0, v9, Lh9/p1;    # MARKER: R8 Lh9/p1;
+
+    if-eqz v0, :done
+
+    check-cast v9, Lh9/p1;    # MARKER: R8 Lh9/p1;
+
+    iget-object v9, v9, Lh9/p1;->b:Lx40/a;    # MARKER: R8 Lh9/p1; Lx40/a; b
+
+    instance-of v0, v9, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    if-eqz v0, :done
+
+    move-object v6, v9
+
+    check-cast v6, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    :dependencies_ready
+
+    new-instance v7, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    const-string v0, "search"
+
+    invoke-direct {v7, v0, v2}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;)V
+
+    const/4 v0, 0x1
+
+    if-ne v4, v0, :album
+
+    check-cast v3, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x3
+
+    if-eq v0, v1, :queue_track
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v0
+
+    if-eqz v0, :play_track
+
+    :queue_track
+    invoke-static {v3}, Lie0/i;->a(Lh40/p;)Lcom/aspiro/wamp/model/Track;    # MARKER: R8 Lie0/i; Lh40/p; a
+
+    move-result-object v9
+
+    iget-object v4, p0, Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;->m:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 m
+
+    invoke-interface {v4}, Lkotlinx/coroutines/flow/MutableStateFlow;->getValue()Ljava/lang/Object;
+
+    move-result-object v4
+
+    check-cast v4, Lcom/tidal/android/feature/search/ui/SearchQuery;
+
+    iget-object v4, v4, Lcom/tidal/android/feature/search/ui/SearchQuery;->a:Ljava/lang/String;    # MARKER: R8 a
+
+    if-nez v4, :track_query_ready
+
+    const-string v4, ""
+
+    :track_query_ready
+    const/4 v1, 0x0
+
+    if-eqz v5, :track_navigation_ready
+
+    invoke-static {v5}, Lcom/tidal/android/navigation/a;->b(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/tidal/android/navigation/NavigationInfo$Node;    # MARKER: R8 Lcom/tidal/android/navigation/a; b
+
+    move-result-object v1
+
+    :track_navigation_ready
+    invoke-static {v2, v4, v1}, Lcom/aspiro/wamp/playqueue/source/model/b;->o(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; o
+
+    move-result-object v4
+
+    invoke-virtual {v4, v9}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_track_to_playlist
+
+    invoke-static {v8, v9, v7, v4}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_track_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_track
+
+    invoke-static {v8, v9, v7, v4}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append_track
+    invoke-static {v8, v9, v7, v4}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :play_track
+    iget-object v5, p0, Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;->m:Lkotlinx/coroutines/flow/MutableStateFlow;    # MARKER: R8 m
+
+    invoke-interface {v5}, Lkotlinx/coroutines/flow/MutableStateFlow;->getValue()Ljava/lang/Object;
+
+    move-result-object v5
+
+    check-cast v5, Lcom/tidal/android/feature/search/ui/SearchQuery;
+
+    iget-object v5, v5, Lcom/tidal/android/feature/search/ui/SearchQuery;->a:Ljava/lang/String;    # MARKER: R8 a
+
+    if-nez v5, :play_query_ready
+
+    const-string v5, ""
+
+    :play_query_ready
+    iget-object v9, p0, Lcom/tidal/android/feature/search/ui/SearchScreenViewModel;->f:Lcom/tidal/android/feature/search/ui/f;    # MARKER: R8 Lcom/tidal/android/feature/search/ui/f; f
+
+    iget-wide v0, v3, Lh40/p;->a:J    # MARKER: R8 Lh40/p; a
+
+    invoke-interface {v9, v0, v1, v3, v5}, Lcom/tidal/android/feature/search/ui/f;->a(JLh40/p;Ljava/lang/String;)V    # MARKER: R8 Lcom/tidal/android/feature/search/ui/f; Lh40/p; a
+
+    goto :done
+
+    :album
+    const/4 v0, 0x2
+
+    if-ne v4, v0, :playlist
+
+    check-cast v3, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    invoke-static {v3}, Lie0/a;->a(Lh40/a;)Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lie0/a; Lh40/a; a
+
+    move-result-object v9
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_album_to_playlist
+
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_album_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_album
+
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_album
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :playlist
+    const/4 v0, 0x3
+
+    if-ne v4, v0, :mix
+
+    check-cast v3, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    invoke-static {v3}, Lie0/h;->a(Lh40/j;)Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lie0/h; Lh40/j; a
+
+    move-result-object v9
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_playlist_to_playlist
+
+    invoke-static {v8, v9, v7, v5}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :check_add_playlist_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_playlist
+
+    invoke-static {v8, v9, v7, v5}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append_playlist
+    invoke-static {v8, v9, v7, v5}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :mix
+    check-cast v3, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    invoke-static {v3}, Lie0/g;->b(Lh40/i;)Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lie0/g; Lh40/i; b
+
+    move-result-object v9
+
+    iget v0, p1, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_mix_to_playlist
+
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_mix_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_mix
+
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_mix
+    invoke-static {v8, v9, v7, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    :done
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeSearchQueueAction.smali

@@ -0,0 +1,232 @@
+.class public final Lradiant/gestures/queue/ComposeSearchQueueAction;
+.super Ljava/lang/Object;
+.source "ComposeSearchQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field private context:Landroid/content/Context;
+
+.field private final id:Ljava/lang/String;
+
+.field private final type:I
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Lpb0/b;)V    # MARKER: R8 Lam0/l; Lpb0/b;
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-static {p2}, Lradiant/gestures/queue/ComposeSearchQueueAction;->key(Lpb0/b;)Ljava/lang/String;    # MARKER: R8 Lpb0/b;
+
+    move-result-object v0
+
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->id:Ljava/lang/String;
+
+    invoke-static {p2}, Lradiant/gestures/queue/ComposeSearchQueueAction;->type(Lpb0/b;)I    # MARKER: R8 Lpb0/b;
+
+    move-result p1
+
+    iput p1, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->type:I
+
+    return-void
+.end method
+
+.method public static key(Lpb0/b;)Ljava/lang/String;    # MARKER: R8 Lpb0/b;
+    .locals 2
+
+    instance-of v0, p0, Lpb0/b$i;    # MARKER: R8 Lpb0/b$i;
+
+    if-eqz v0, :album
+
+    check-cast p0, Lpb0/b$i;    # MARKER: R8 Lpb0/b$i;
+
+    iget-wide v0, p0, Lpb0/b$i;->a:J    # MARKER: R8 Lpb0/b$i; a
+
+    invoke-static {v0, v1}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object p0
+
+    return-object p0
+
+    :album
+    instance-of v0, p0, Lpb0/b$a;    # MARKER: R8 Lpb0/b$a;
+
+    if-eqz v0, :playlist
+
+    check-cast p0, Lpb0/b$a;    # MARKER: R8 Lpb0/b$a;
+
+    iget-wide v0, p0, Lpb0/b$a;->a:J    # MARKER: R8 Lpb0/b$a; a
+
+    invoke-static {v0, v1}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object p0
+
+    return-object p0
+
+    :playlist
+    instance-of v0, p0, Lpb0/b$f;    # MARKER: R8 Lpb0/b$f;
+
+    if-eqz v0, :mix
+
+    check-cast p0, Lpb0/b$f;    # MARKER: R8 Lpb0/b$f;
+
+    iget-object p0, p0, Lpb0/b$f;->a:Ljava/lang/String;    # MARKER: R8 Lpb0/b$f; a
+
+    return-object p0
+
+    :mix
+    instance-of v0, p0, Lpb0/b$e;    # MARKER: R8 Lpb0/b$e;
+
+    if-eqz v0, :invalid
+
+    check-cast p0, Lpb0/b$e;    # MARKER: R8 Lpb0/b$e;
+
+    iget-object p0, p0, Lpb0/b$e;->a:Ljava/lang/String;    # MARKER: R8 Lpb0/b$e; a
+
+    return-object p0
+
+    :invalid
+    const/4 p0, 0x0
+
+    return-object p0
+.end method
+
+.method public stableKey()Ljava/lang/String;
+    .locals 3
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->id:Ljava/lang/String;
+
+    if-eqz v0, :invalid
+
+    iget v1, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->type:I
+
+    if-eqz v1, :invalid
+
+    new-instance v2, Ljava/lang/StringBuilder;
+
+    invoke-direct {v2}, Ljava/lang/StringBuilder;-><init>()V
+
+    invoke-virtual {v2, v1}, Ljava/lang/StringBuilder;->append(I)Ljava/lang/StringBuilder;
+
+    const/16 v1, 0x3a
+
+    invoke-virtual {v2, v1}, Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder;
+
+    invoke-virtual {v2, v0}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+
+    invoke-virtual {v2}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
+
+    move-result-object v0
+
+    return-object v0
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method private static type(Lpb0/b;)I    # MARKER: R8 Lpb0/b;
+    .locals 1
+
+    instance-of v0, p0, Lpb0/b$i;    # MARKER: R8 Lpb0/b$i;
+
+    if-eqz v0, :album
+
+    const/4 p0, 0x1
+
+    return p0
+
+    :album
+    instance-of v0, p0, Lpb0/b$a;    # MARKER: R8 Lpb0/b$a;
+
+    if-eqz v0, :playlist
+
+    const/4 p0, 0x2
+
+    return p0
+
+    :playlist
+    instance-of v0, p0, Lpb0/b$f;    # MARKER: R8 Lpb0/b$f;
+
+    if-eqz v0, :mix
+
+    const/4 p0, 0x3
+
+    return p0
+
+    :mix
+    instance-of p0, p0, Lpb0/b$e;    # MARKER: R8 Lpb0/b$e;
+
+    if-eqz p0, :invalid
+
+    const/4 p0, 0x4
+
+    return p0
+
+    :invalid
+    const/4 p0, 0x0
+
+    return p0
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 4
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    if-eqz v0, :done
+
+    iget-object v1, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    iget-object v2, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->id:Ljava/lang/String;
+
+    if-eqz v2, :done
+
+    iget v3, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->type:I
+
+    if-eqz v3, :done
+
+    new-instance p0, Lradiant/gestures/queue/ComposeSearchQueueEvent;
+
+    invoke-direct {p0, v1, v2, v3, p1}, Lradiant/gestures/queue/ComposeSearchQueueEvent;-><init>(Landroid/content/Context;Ljava/lang/String;II)V
+
+    invoke-interface {v0, p0}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSearchQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSearchQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeSearchQueueEvent.smali

@@ -0,0 +1,44 @@
+.class public final Lradiant/gestures/queue/ComposeSearchQueueEvent;
+.super Ljava/lang/Object;
+.source "ComposeSearchQueueEvent.smali"
+
+# interfaces
+.implements Lcom/tidal/android/feature/search/ui/b;    # MARKER: R8 Lcom/tidal/android/feature/search/ui/b;
+
+
+# static fields
+.field public static final TYPE_ALBUM:I = 0x2
+
+.field public static final TYPE_MIX:I = 0x4
+
+.field public static final TYPE_PLAYLIST:I = 0x3
+
+.field public static final TYPE_TRACK:I = 0x1
+
+
+# instance fields
+.field public final action:I
+
+.field public final context:Landroid/content/Context;
+
+.field public final id:Ljava/lang/String;
+
+.field public final type:I
+
+
+# direct methods
+.method public constructor <init>(Landroid/content/Context;Ljava/lang/String;II)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSearchQueueEvent;->context:Landroid/content/Context;
+
+    iput-object p2, p0, Lradiant/gestures/queue/ComposeSearchQueueEvent;->id:Ljava/lang/String;
+
+    iput p3, p0, Lradiant/gestures/queue/ComposeSearchQueueEvent;->type:I
+
+    iput p4, p0, Lradiant/gestures/queue/ComposeSearchQueueEvent;->action:I
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeSwipeAction.smali

@@ -0,0 +1,17 @@
+.class public interface abstract Lradiant/gestures/queue/ComposeSwipeAction;
+.super Ljava/lang/Object;
+.source "ComposeSwipeAction.smali"
+
+# interfaces
+.implements Lam0/a;    # MARKER: R8 Lam0/a;
+
+
+# virtual methods
+.method public abstract invoke()Ljava/lang/Object;
+.end method
+
+.method public abstract invoke(I)Ljava/lang/Object;
+.end method
+
+.method public abstract setContext(Landroid/content/Context;)V
+.end method

patches/extension/radiant/gestures/queue/ComposeSwipeState$Draw.smali

@@ -0,0 +1,275 @@
+.class public final Lradiant/gestures/queue/ComposeSwipeState$Draw;
+.super Ljava/lang/Object;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/queue/ComposeSwipeState;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "Draw"
+.end annotation
+
+
+# instance fields
+.field private final state:Lradiant/gestures/queue/ComposeSwipeState;
+
+
+# direct methods
+.method public constructor <init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSwipeState$Draw;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+    .locals 16
+
+    move-object/from16 v0, p1
+
+    move-object/from16 v5, p0
+
+    invoke-interface {v0}, Landroidx/compose/ui/graphics/drawscope/DrawScope;->getSize-NH-jbRc()J
+
+    move-result-wide v1
+
+    invoke-static {v1, v2}, Landroidx/compose/ui/geometry/Size;->getWidth-impl(J)F
+
+    move-result v3
+
+    invoke-static {v1, v2}, Landroidx/compose/ui/geometry/Size;->getHeight-impl(J)F
+
+    move-result v4
+
+    iget-object v5, v5, Lradiant/gestures/queue/ComposeSwipeState$Draw;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    iput v3, v5, Lradiant/gestures/queue/ComposeSwipeState;->rowWidth:F
+
+    iget-object v1, v5, Lradiant/gestures/queue/ComposeSwipeState;->translation:Landroidx/compose/runtime/MutableFloatState;
+
+    invoke-interface {v1}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
+
+    move-result v6
+
+    const/4 v1, 0x0
+
+    cmpl-float v2, v6, v1
+
+    if-eqz v2, :draw_plain
+
+    invoke-interface {v0}, Landroidx/compose/ui/graphics/drawscope/DrawScope;->getDrawContext()Landroidx/compose/ui/graphics/drawscope/DrawContext;
+
+    move-result-object v2
+
+    invoke-interface {v2}, Landroidx/compose/ui/graphics/drawscope/DrawContext;->getCanvas()Landroidx/compose/ui/graphics/Canvas;
+
+    move-result-object v2
+
+    invoke-static {v2}, Landroidx/compose/ui/graphics/AndroidCanvas_androidKt;->getNativeCanvas(Landroidx/compose/ui/graphics/Canvas;)Landroid/graphics/Canvas;
+
+    move-result-object v7
+
+    invoke-virtual {v7}, Landroid/graphics/Canvas;->save()I
+
+    move-result v8
+
+    cmpg-float v9, v6, v1
+
+    if-gez v9, :right_exposure
+
+    add-float v9, v3, v6
+
+    invoke-static {v1, v9}, Ljava/lang/Math;->max(FF)F
+
+    move-result v9
+
+    move v10, v3
+
+    goto :exposure_ready
+
+    :right_exposure
+    move v9, v1
+
+    invoke-static {v3, v6}, Ljava/lang/Math;->min(FF)F
+
+    move-result v10
+
+    :exposure_ready
+    invoke-virtual {v7, v9, v1, v10, v4}, Landroid/graphics/Canvas;->clipRect(FFFF)Z
+
+    invoke-virtual {v5, v6}, Lradiant/gestures/queue/ComposeSwipeState;->actionForOffset(F)I
+
+    move-result v11
+
+    const/4 v12, 0x1
+
+    if-ne v11, v12, :add_color
+
+    const v11, __RL_SWIPE_TO_QUEUE_PLAY_NEXT_COLOR__
+
+    goto :color_ready
+
+    :add_color
+    const/4 v12, 0x3
+
+    if-ne v11, v12, :add_to_queue_color
+
+    const v11, __RL_SWIPE_TO_QUEUE_ADD_TO_PLAYLIST_COLOR__
+
+    goto :color_ready
+
+    :add_to_queue_color
+    const v11, __RL_SWIPE_TO_QUEUE_ADD_COLOR__
+
+    :color_ready
+
+    invoke-virtual {v7, v11}, Landroid/graphics/Canvas;->drawColor(I)V
+
+    invoke-virtual {v5, v6}, Lradiant/gestures/queue/ComposeSwipeState;->actionForOffset(F)I
+
+    move-result v11
+
+    const/4 v12, 0x1
+
+    if-ne v11, v12, :add_icon
+
+    iget-object v11, v5, Lradiant/gestures/queue/ComposeSwipeState;->playNextIcon:Landroid/graphics/drawable/Drawable;
+
+    goto :icon_ready
+
+    :add_icon
+    const/4 v12, 0x3
+
+    if-ne v11, v12, :add_to_queue_icon
+
+    iget-object v11, v5, Lradiant/gestures/queue/ComposeSwipeState;->addToPlaylistIcon:Landroid/graphics/drawable/Drawable;
+
+    goto :icon_ready
+
+    :add_to_queue_icon
+    iget-object v11, v5, Lradiant/gestures/queue/ComposeSwipeState;->addIcon:Landroid/graphics/drawable/Drawable;
+
+    :icon_ready
+
+    if-eqz v11, :background_done
+
+    invoke-virtual {v11}, Landroid/graphics/drawable/Drawable;->getIntrinsicWidth()I
+
+    move-result v12
+
+    invoke-virtual {v11}, Landroid/graphics/drawable/Drawable;->getIntrinsicHeight()I
+
+    move-result v13
+
+    if-lez v12, :background_done
+
+    if-lez v13, :background_done
+
+    const/high16 v14, 0x41800000 # 16.0f
+
+    invoke-virtual {v5, v14}, Lradiant/gestures/queue/ComposeSwipeState;->dp(F)F
+
+    move-result v14
+
+    const/4 v15, 0x0
+
+    int-to-float v15, v15
+
+    cmpg-float v15, v6, v15
+
+    if-gez v15, :right_icon
+
+    int-to-float v1, v12
+
+    sub-float v1, v3, v1
+
+    sub-float/2addr v1, v14
+
+    goto :icon_x_ready
+
+    :right_icon
+    move v1, v14
+
+    :icon_x_ready
+    int-to-float v14, v13
+
+    sub-float v14, v4, v14
+
+    const/high16 v15, 0x40000000 # 2.0f
+
+    div-float/2addr v14, v15
+
+    float-to-int v15, v1
+
+    float-to-int v14, v14
+
+    add-int v1, v15, v12
+
+    add-int v12, v14, v13
+
+    invoke-virtual {v11, v15, v14, v1, v12}, Landroid/graphics/drawable/Drawable;->setBounds(IIII)V
+
+    const/16 v1, 0xff
+
+    invoke-virtual {v11, v1}, Landroid/graphics/drawable/Drawable;->setAlpha(I)V
+
+    invoke-virtual {v11, v7}, Landroid/graphics/drawable/Drawable;->draw(Landroid/graphics/Canvas;)V
+
+    :background_done
+    invoke-virtual {v7, v8}, Landroid/graphics/Canvas;->restoreToCount(I)V
+
+    invoke-virtual {v7}, Landroid/graphics/Canvas;->save()I
+
+    move-result v8
+
+    const/4 v1, 0x0
+
+    invoke-virtual {v7, v1, v1, v3, v4}, Landroid/graphics/Canvas;->clipRect(FFFF)Z
+
+    invoke-virtual {v7, v6, v1}, Landroid/graphics/Canvas;->translate(FF)V
+
+    :try_start_0
+    invoke-interface {v0}, Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;->drawContent()V
+    :try_end_0
+    .catchall {:try_start_0 .. :try_end_0} :catchall_0
+
+    invoke-virtual {v7, v8}, Landroid/graphics/Canvas;->restoreToCount(I)V
+
+    goto :done
+
+    :catchall_0
+    move-exception v0
+
+    invoke-virtual {v7, v8}, Landroid/graphics/Canvas;->restoreToCount(I)V
+
+    throw v0
+
+    :draw_plain
+    invoke-interface {v0}, Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;->drawContent()V
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .locals 1
+
+    check-cast p1, Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/queue/ComposeSwipeState$Draw;->invoke(Landroidx/compose/ui/graphics/drawscope/ContentDrawScope;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    move-result-object v0
+
+    return-object v0
+.end method

patches/extension/radiant/gestures/queue/ComposeSwipeState$Gesture.smali

@@ -0,0 +1,231 @@
+.class public final Lradiant/gestures/queue/ComposeSwipeState$Gesture;
+.super Landroidx/compose/ui/input/pointer/PointerInputFilter;
+.implements Lam0/l;    # MARKER: R8 Lam0/l;
+.implements Landroidx/compose/ui/input/pointer/PointerInputModifier;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/queue/ComposeSwipeState;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "Gesture"
+.end annotation
+
+
+# instance fields
+.field private consumeAfterDispatch:Z
+
+.field private final state:Lradiant/gestures/queue/ComposeSwipeState;
+
+
+# direct methods
+.method public constructor <init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+    .locals 0
+
+    invoke-direct {p0}, Landroidx/compose/ui/input/pointer/PointerInputFilter;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public getInterceptOutOfBoundsChildEvents()Z
+    .locals 1
+
+    const/4 v0, 0x1
+
+    return v0
+.end method
+
+.method public getPointerInputFilter()Landroidx/compose/ui/input/pointer/PointerInputFilter;
+    .locals 0
+
+    return-object p0
+.end method
+
+.method public invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+    .locals 3
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getActionMasked()I
+
+    move-result v0
+
+    const/4 v1, 0x0
+
+    iput-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->consumeAfterDispatch:Z
+
+    if-eqz v0, :down
+
+    const/4 v1, 0x1
+
+    if-eq v0, v1, :up
+
+    const/4 v1, 0x2
+
+    if-eq v0, v1, :move
+
+    const/4 v1, 0x3
+
+    if-eq v0, v1, :cancel
+
+    const/4 v1, 0x5
+
+    if-eq v0, v1, :cancel
+
+    const/4 v1, 0x6
+
+    if-eq v0, v1, :cancel
+
+    goto :done
+
+    :down
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
+
+    move-result v0
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    iget-object v2, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v2, v0, v1}, Lradiant/gestures/queue/ComposeSwipeState;->begin(FF)V
+
+    goto :done
+
+    :move
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
+
+    move-result v0
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    iget-object v2, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v2, v0, v1}, Lradiant/gestures/queue/ComposeSwipeState;->move(FF)V
+
+    goto :done
+
+    :up
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawX()F
+
+    move-result v0
+
+    invoke-virtual {p1}, Landroid/view/MotionEvent;->getRawY()F
+
+    move-result v1
+
+    iget-object v2, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v2, v0, v1}, Lradiant/gestures/queue/ComposeSwipeState;->move(FF)V
+
+    iget-boolean v0, v2, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->consumeAfterDispatch:Z
+
+    invoke-virtual {v2}, Lradiant/gestures/queue/ComposeSwipeState;->finish()V
+
+    goto :done
+
+    :cancel
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v0}, Lradiant/gestures/queue/ComposeSwipeState;->cancelGesture()V
+
+    :done
+    sget-object p1, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object p1
+.end method
+
+.method public bridge synthetic invoke(Ljava/lang/Object;)Ljava/lang/Object;
+    .locals 1
+
+    check-cast p1, Landroid/view/MotionEvent;
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public onCancel()V
+    .locals 1
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v0}, Lradiant/gestures/queue/ComposeSwipeState;->cancelGesture()V
+
+    return-void
+.end method
+
+.method public onPointerEvent-H0pRuoY(Landroidx/compose/ui/input/pointer/PointerEvent;Landroidx/compose/ui/input/pointer/PointerEventPass;J)V
+    .locals 4
+
+    sget-object v0, Landroidx/compose/ui/input/pointer/PointerEventPass;->Initial:Landroidx/compose/ui/input/pointer/PointerEventPass;
+
+    if-ne p2, v0, :done
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    iget-boolean v1, v0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    const/4 v2, 0x0
+
+    iput-boolean v2, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->consumeAfterDispatch:Z
+
+    invoke-virtual {p1}, Landroidx/compose/ui/input/pointer/PointerEvent;->getMotionEvent()Landroid/view/MotionEvent;
+
+    move-result-object v2
+
+    if-eqz v2, :after_dispatch
+
+    invoke-virtual {p0, v2}, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->invoke(Landroid/view/MotionEvent;)Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    :after_dispatch
+    iget-boolean v2, p0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;->consumeAfterDispatch:Z
+
+    or-int/2addr v1, v2
+
+    iget-boolean v2, v0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    or-int/2addr v1, v2
+
+    if-eqz v1, :done
+
+    invoke-virtual {p1}, Landroidx/compose/ui/input/pointer/PointerEvent;->getChanges()Ljava/util/List;
+
+    move-result-object v0
+
+    invoke-interface {v0}, Ljava/util/List;->size()I
+
+    move-result v1
+
+    const/4 v2, 0x0
+
+    :consume_loop
+    if-ge v2, v1, :done
+
+    invoke-interface {v0, v2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v3
+
+    check-cast v3, Landroidx/compose/ui/input/pointer/PointerInputChange;
+
+    invoke-virtual {v3}, Landroidx/compose/ui/input/pointer/PointerInputChange;->consume()V
+
+    add-int/lit8 v2, v2, 0x1
+
+    goto :consume_loop
+
+    :done
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeSwipeState$ResetAnimator.smali

@@ -0,0 +1,67 @@
+.class public final Lradiant/gestures/queue/ComposeSwipeState$ResetAnimator;
+.super Ljava/lang/Object;
+.implements Landroid/animation/ValueAnimator$AnimatorUpdateListener;
+
+
+# annotations
+.annotation system Ldalvik/annotation/EnclosingClass;
+    value = Lradiant/gestures/queue/ComposeSwipeState;
+.end annotation
+
+.annotation system Ldalvik/annotation/InnerClass;
+    accessFlags = 0x19
+    name = "ResetAnimator"
+.end annotation
+
+
+# instance fields
+.field private final state:Lradiant/gestures/queue/ComposeSwipeState;
+
+
+# direct methods
+.method public constructor <init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSwipeState$ResetAnimator;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public onAnimationUpdate(Landroid/animation/ValueAnimator;)V
+    .locals 3
+
+    invoke-virtual {p1}, Landroid/animation/ValueAnimator;->getAnimatedValue()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Ljava/lang/Float;
+
+    invoke-virtual {v0}, Ljava/lang/Float;->floatValue()F
+
+    move-result v0
+
+    iget-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState$ResetAnimator;->state:Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v1, v0}, Lradiant/gestures/queue/ComposeSwipeState;->setOffset(F)V
+
+    invoke-virtual {p1}, Landroid/animation/ValueAnimator;->getAnimatedFraction()F
+
+    move-result v0
+
+    const/high16 v2, 0x3f800000 # 1.0f
+
+    cmpg-float v0, v0, v2
+
+    if-gez v0, :finished
+
+    return-void
+
+    :finished
+    invoke-virtual {v1, p1}, Lradiant/gestures/queue/ComposeSwipeState;->clearAnimator(Landroid/animation/ValueAnimator;)V
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeSwipeState.smali

@@ -0,0 +1,704 @@
+.class public final Lradiant/gestures/queue/ComposeSwipeState;
+.super Ljava/lang/Object;
+
+
+# instance fields
+.field translation:Landroidx/compose/runtime/MutableFloatState;
+
+.field action:Lradiant/gestures/queue/ComposeSwipeAction;
+
+.field context:Landroid/content/Context;
+
+.field view:Landroid/view/View;
+
+.field enabled:Z
+
+.field downX:F
+
+.field downY:F
+
+.field tracking:Z
+
+.field locked:Z
+
+.field armed:Z
+
+.field rowWidth:F
+
+.field animator:Landroid/animation/ValueAnimator;
+
+.field final gesture:Lradiant/gestures/queue/ComposeSwipeState$Gesture;
+
+.field final draw:Lradiant/gestures/queue/ComposeSwipeState$Draw;
+
+.field addIcon:Landroid/graphics/drawable/Drawable;
+
+.field addToPlaylistIcon:Landroid/graphics/drawable/Drawable;
+
+.field playNextIcon:Landroid/graphics/drawable/Drawable;
+
+
+# direct methods
+.method public constructor <init>()V
+    .locals 2
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    const/4 v0, 0x0
+
+    invoke-static {v0}, Landroidx/compose/runtime/PrimitiveSnapshotStateKt;->mutableFloatStateOf(F)Landroidx/compose/runtime/MutableFloatState;
+
+    move-result-object v0
+
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->translation:Landroidx/compose/runtime/MutableFloatState;
+
+    new-instance v0, Lradiant/gestures/queue/ComposeSwipeState$Gesture;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/ComposeSwipeState$Gesture;-><init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->gesture:Lradiant/gestures/queue/ComposeSwipeState$Gesture;
+
+    new-instance v1, Lradiant/gestures/queue/ComposeSwipeState$Draw;
+
+    invoke-direct {v1, p0}, Lradiant/gestures/queue/ComposeSwipeState$Draw;-><init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->draw:Lradiant/gestures/queue/ComposeSwipeState$Draw;
+
+    return-void
+.end method
+
+.method public static attach(Landroidx/compose/ui/Modifier;Ljava/lang/Object;Lradiant/gestures/queue/ComposeSwipeAction;ZLandroidx/compose/runtime/Composer;)Landroidx/compose/ui/Modifier;
+    .locals 5
+    .annotation build Landroidx/compose/runtime/Composable;
+    .end annotation
+
+    const v0, 0x4a33c921
+
+    invoke-interface {p4, v0}, Landroidx/compose/runtime/Composer;->startReplaceGroup(I)V
+
+    invoke-static {}, Landroidx/compose/ui/platform/AndroidCompositionLocals_androidKt;->getLocalView()Landroidx/compose/runtime/ProvidableCompositionLocal;
+
+    move-result-object v0
+
+    invoke-interface {p4, v0}, Landroidx/compose/runtime/Composer;->consume(Landroidx/compose/runtime/CompositionLocal;)Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Landroid/view/View;
+
+    invoke-interface {p4, p1}, Landroidx/compose/runtime/Composer;->changed(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    invoke-interface {p4}, Landroidx/compose/runtime/Composer;->rememberedValue()Ljava/lang/Object;
+
+    move-result-object v2
+
+    if-nez v1, :new_state
+
+    sget-object v3, Landroidx/compose/runtime/Composer;->Companion:Landroidx/compose/runtime/Composer$Companion;
+
+    invoke-virtual {v3}, Landroidx/compose/runtime/Composer$Companion;->getEmpty()Ljava/lang/Object;
+
+    move-result-object v3
+
+    if-ne v2, v3, :state_ready
+
+    :new_state
+    new-instance v2, Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-direct {v2}, Lradiant/gestures/queue/ComposeSwipeState;-><init>()V
+
+    invoke-interface {p4, v2}, Landroidx/compose/runtime/Composer;->updateRememberedValue(Ljava/lang/Object;)V
+
+    :state_ready
+    check-cast v2, Lradiant/gestures/queue/ComposeSwipeState;
+
+    invoke-virtual {v2, p2, p3, v0}, Lradiant/gestures/queue/ComposeSwipeState;->update(Lradiant/gestures/queue/ComposeSwipeAction;ZLandroid/view/View;)V
+
+    iget-object v1, v2, Lradiant/gestures/queue/ComposeSwipeState;->gesture:Lradiant/gestures/queue/ComposeSwipeState$Gesture;
+
+    check-cast v1, Landroidx/compose/ui/Modifier;
+
+    invoke-interface {p0, v1}, Landroidx/compose/ui/Modifier;->then(Landroidx/compose/ui/Modifier;)Landroidx/compose/ui/Modifier;
+
+    move-result-object p0
+
+    iget-object v1, v2, Lradiant/gestures/queue/ComposeSwipeState;->draw:Lradiant/gestures/queue/ComposeSwipeState$Draw;
+
+    invoke-static {p0, v1}, Landroidx/compose/ui/draw/DrawModifierKt;->drawWithContent(Landroidx/compose/ui/Modifier;Lam0/l;)Landroidx/compose/ui/Modifier;    # MARKER: R8 Lam0/l;
+
+    move-result-object p0
+
+    invoke-interface {p4}, Landroidx/compose/runtime/Composer;->endReplaceGroup()V
+
+    return-object p0
+.end method
+
+
+# virtual methods
+.method actionForOffset(F)I
+    .locals 2
+
+    const/4 v0, 0x0
+
+    int-to-float v0, v0
+
+    cmpg-float v1, p1, v0
+
+    if-ltz v1, :left
+
+    cmpl-float p1, p1, v0
+
+    if-gtz p1, :right
+
+    const/4 p1, 0x0
+
+    return p1
+
+    :left
+    const/16 p1, __RL_SWIPE_TO_QUEUE_LEFT_ACTION__
+
+    return p1
+
+    :right
+    const/16 p1, __RL_SWIPE_TO_QUEUE_RIGHT_ACTION__
+
+    return p1
+.end method
+
+.method animateReset()V
+    .locals 7
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    const/4 v1, 0x0
+
+    if-eqz v0, :read_offset
+
+    invoke-virtual {v0}, Landroid/animation/ValueAnimator;->cancel()V
+
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    :read_offset
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->translation:Landroidx/compose/runtime/MutableFloatState;
+
+    invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
+
+    move-result v0
+
+    invoke-static {v0}, Ljava/lang/Math;->abs(F)F
+
+    move-result v2
+
+    const/high16 v3, 0x3f000000 # 0.5f
+
+    cmpg-float v2, v2, v3
+
+    if-lez v2, :snap
+
+    const/4 v2, 0x2
+
+    new-array v2, v2, [F
+
+    const/4 v3, 0x0
+
+    aput v0, v2, v3
+
+    const/4 v0, 0x1
+
+    const/4 v3, 0x0
+
+    aput v3, v2, v0
+
+    invoke-static {v2}, Landroid/animation/ValueAnimator;->ofFloat([F)Landroid/animation/ValueAnimator;
+
+    move-result-object v0
+
+    const-wide/16 v4, 0xb4
+
+    invoke-virtual {v0, v4, v5}, Landroid/animation/ValueAnimator;->setDuration(J)Landroid/animation/ValueAnimator;
+
+    new-instance v2, Landroid/view/animation/DecelerateInterpolator;
+
+    const/high16 v4, 0x3fc00000 # 1.5f
+
+    invoke-direct {v2, v4}, Landroid/view/animation/DecelerateInterpolator;-><init>(F)V
+
+    invoke-virtual {v0, v2}, Landroid/animation/ValueAnimator;->setInterpolator(Landroid/animation/TimeInterpolator;)V
+
+    new-instance v2, Lradiant/gestures/queue/ComposeSwipeState$ResetAnimator;
+
+    invoke-direct {v2, p0}, Lradiant/gestures/queue/ComposeSwipeState$ResetAnimator;-><init>(Lradiant/gestures/queue/ComposeSwipeState;)V
+
+    invoke-virtual {v0, v2}, Landroid/animation/ValueAnimator;->addUpdateListener(Landroid/animation/ValueAnimator$AnimatorUpdateListener;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    invoke-virtual {v0}, Landroid/animation/ValueAnimator;->start()V
+
+    return-void
+
+    :snap
+    const/4 v3, 0x0
+
+    invoke-virtual {p0, v3}, Lradiant/gestures/queue/ComposeSwipeState;->setOffset(F)V
+
+    return-void
+.end method
+
+.method begin(FF)V
+    .locals 3
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->releaseParent()V
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    const/4 v1, 0x0
+
+    if-eqz v0, :initialize
+
+    invoke-virtual {v0}, Landroid/animation/ValueAnimator;->cancel()V
+
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    :initialize
+    iput p1, p0, Lradiant/gestures/queue/ComposeSwipeState;->downX:F
+
+    iput p2, p0, Lradiant/gestures/queue/ComposeSwipeState;->downY:F
+
+    const/4 v0, 0x0
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSwipeState;->setOffset(F)V
+
+    iget-boolean v2, p0, Lradiant/gestures/queue/ComposeSwipeState;->enabled:Z
+
+    if-eqz v2, :inactive
+
+    iget-object v2, p0, Lradiant/gestures/queue/ComposeSwipeState;->action:Lradiant/gestures/queue/ComposeSwipeAction;
+
+    if-eqz v2, :inactive
+
+    const/4 v0, 0x1
+
+    :inactive
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->tracking:Z
+
+    return-void
+.end method
+
+.method cancelGesture()V
+    .locals 1
+
+    const/4 v0, 0x0
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->tracking:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->releaseParent()V
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->animateReset()V
+
+    return-void
+.end method
+
+.method clearAnimator(Landroid/animation/ValueAnimator;)V
+    .locals 1
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    if-ne v0, p1, :done
+
+    const/4 v0, 0x0
+
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->animator:Landroid/animation/ValueAnimator;
+
+    :done
+    return-void
+.end method
+
+.method dp(F)F
+    .locals 1
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->context:Landroid/content/Context;
+
+    if-eqz v0, :done
+
+    invoke-virtual {v0}, Landroid/content/Context;->getResources()Landroid/content/res/Resources;
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Landroid/content/res/Resources;->getDisplayMetrics()Landroid/util/DisplayMetrics;
+
+    move-result-object v0
+
+    iget v0, v0, Landroid/util/DisplayMetrics;->density:F
+
+    mul-float/2addr p1, v0
+
+    :done
+    return p1
+.end method
+
+.method finish()V
+    .locals 3
+
+    iget-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->tracking:Z
+
+    if-eqz v0, :reset_only
+
+    iget-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    if-eqz v0, :not_complete
+
+    iget-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    if-eqz v0, :not_complete
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->translation:Landroidx/compose/runtime/MutableFloatState;
+
+    invoke-interface {v0}, Landroidx/compose/runtime/MutableFloatState;->getFloatValue()F
+
+    move-result v0
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSwipeState;->actionForOffset(F)I
+
+    move-result v2
+
+    goto :complete_ready
+
+    :not_complete
+    const/4 v2, 0x0
+
+    :complete_ready
+    const/4 v1, 0x0
+
+    iput-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->tracking:Z
+
+    iput-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    iput-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->releaseParent()V
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->animateReset()V
+
+    if-eqz v2, :done
+
+    invoke-static {}, Lradiant/gestures/queue/ComposeTapGuard;->suppressAfterSwipe()V
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->action:Lradiant/gestures/queue/ComposeSwipeAction;
+
+    if-eqz v0, :done
+
+    invoke-interface {v0, v2}, Lradiant/gestures/queue/ComposeSwipeAction;->invoke(I)Ljava/lang/Object;
+
+    goto :done
+
+    :reset_only
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->releaseParent()V
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->animateReset()V
+
+    :done
+    return-void
+.end method
+
+.method isCorrectDirection(F)Z
+    .locals 1
+
+    invoke-virtual {p0, p1}, Lradiant/gestures/queue/ComposeSwipeState;->actionForOffset(F)I
+
+    move-result v0
+
+    if-eqz v0, :wrong
+
+    const/4 v0, 0x1
+
+    return v0
+
+    :wrong
+    const/4 v0, 0x0
+
+    return v0
+.end method
+
+.method move(FF)V
+    .locals 8
+
+    iget-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->tracking:Z
+
+    if-eqz v0, :done
+
+    iget v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->downX:F
+
+    sub-float v0, p1, v0
+
+    iget v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->downY:F
+
+    sub-float v1, p2, v1
+
+    iget-boolean v2, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    if-nez v2, :publish
+
+    invoke-static {v0}, Ljava/lang/Math;->abs(F)F
+
+    move-result v2
+
+    invoke-static {v1}, Ljava/lang/Math;->abs(F)F
+
+    move-result v3
+
+    const/high16 v4, 0x41000000 # 8.0f
+
+    invoke-virtual {p0, v4}, Lradiant/gestures/queue/ComposeSwipeState;->dp(F)F
+
+    move-result v4
+
+    cmpg-float v5, v2, v4
+
+    if-ltz v5, :axis_ready
+
+    cmpg-float v5, v3, v4
+
+    if-gez v5, :done
+
+    :axis_ready
+    cmpg-float v5, v2, v3
+
+    if-gtz v5, :horizontal_candidate
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->cancelGesture()V
+
+    return-void
+
+    :horizontal_candidate
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSwipeState;->isCorrectDirection(F)Z
+
+    move-result v5
+
+    if-nez v5, :lock
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->cancelGesture()V
+
+    return-void
+
+    :lock
+    const/4 v5, 0x1
+
+    iput-boolean v5, p0, Lradiant/gestures/queue/ComposeSwipeState;->locked:Z
+
+    iget-object v6, p0, Lradiant/gestures/queue/ComposeSwipeState;->view:Landroid/view/View;
+
+    if-eqz v6, :publish
+
+    invoke-virtual {v6}, Landroid/view/View;->getParent()Landroid/view/ViewParent;
+
+    move-result-object v6
+
+    if-eqz v6, :publish
+
+    invoke-interface {v6, v5}, Landroid/view/ViewParent;->requestDisallowInterceptTouchEvent(Z)V
+
+    :publish
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSwipeState;->isCorrectDirection(F)Z
+
+    move-result v2
+
+    if-nez v2, :set_offset
+
+    const/4 v2, 0x0
+
+    invoke-virtual {p0, v2}, Lradiant/gestures/queue/ComposeSwipeState;->setOffset(F)V
+
+    iput-boolean v2, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    return-void
+
+    :set_offset
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/ComposeSwipeState;->setOffset(F)V
+
+    iget v2, p0, Lradiant/gestures/queue/ComposeSwipeState;->rowWidth:F
+
+    const/4 v3, 0x0
+
+    cmpg-float v4, v2, v3
+
+    if-lez v4, :done
+
+    const v4, 0x3e99999a # 0.3f
+
+    mul-float/2addr v2, v4
+
+    invoke-static {v0}, Ljava/lang/Math;->abs(F)F
+
+    move-result v0
+
+    cmpg-float v0, v0, v2
+
+    if-ltz v0, :below_threshold
+
+    const/4 v0, 0x1
+
+    goto :arm_ready
+
+    :below_threshold
+    const/4 v0, 0x0
+
+    :arm_ready
+    iget-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    if-eq v0, v1, :done
+
+    iput-boolean v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->armed:Z
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->view:Landroid/view/View;
+
+    if-eqz v0, :done
+
+    const/4 v1, 0x4
+
+    invoke-virtual {v0, v1}, Landroid/view/View;->performHapticFeedback(I)Z
+
+    :done
+    return-void
+.end method
+
+.method releaseParent()V
+    .locals 2
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->view:Landroid/view/View;
+
+    if-eqz v0, :done
+
+    invoke-virtual {v0}, Landroid/view/View;->getParent()Landroid/view/ViewParent;
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    const/4 v1, 0x0
+
+    invoke-interface {v0, v1}, Landroid/view/ViewParent;->requestDisallowInterceptTouchEvent(Z)V
+
+    :done
+    return-void
+.end method
+
+.method setOffset(F)V
+    .locals 1
+
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->translation:Landroidx/compose/runtime/MutableFloatState;
+
+    invoke-interface {v0, p1}, Landroidx/compose/runtime/MutableFloatState;->setFloatValue(F)V
+
+    return-void
+.end method
+
+.method update(Lradiant/gestures/queue/ComposeSwipeAction;ZLandroid/view/View;)V
+    .locals 4
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeSwipeState;->action:Lradiant/gestures/queue/ComposeSwipeAction;
+
+    iput-object p3, p0, Lradiant/gestures/queue/ComposeSwipeState;->view:Landroid/view/View;
+
+    invoke-virtual {p3}, Landroid/view/View;->getContext()Landroid/content/Context;
+
+    move-result-object v0
+
+    iget-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->context:Landroid/content/Context;
+
+    if-ne v0, v1, :load_resources
+
+    goto :context_ready
+
+    :load_resources
+    iput-object v0, p0, Lradiant/gestures/queue/ComposeSwipeState;->context:Landroid/content/Context;
+
+    sget v1, Lcom/aspiro/wamp/R$drawable;->ic_add_to_queue_last:I
+
+    invoke-virtual {v0, v1}, Landroid/content/Context;->getDrawable(I)Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    if-eqz v1, :store_icon
+
+    invoke-virtual {v1}, Landroid/graphics/drawable/Drawable;->mutate()Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    const/4 v2, -0x1
+
+    invoke-virtual {v1, v2}, Landroid/graphics/drawable/Drawable;->setTint(I)V
+
+    :store_icon
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->addIcon:Landroid/graphics/drawable/Drawable;
+
+    sget v1, Lcom/aspiro/wamp/R$drawable;->ic_play_next:I
+
+    invoke-virtual {v0, v1}, Landroid/content/Context;->getDrawable(I)Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    if-eqz v1, :store_play_next_icon
+
+    invoke-virtual {v1}, Landroid/graphics/drawable/Drawable;->mutate()Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    const/4 v2, -0x1
+
+    invoke-virtual {v1, v2}, Landroid/graphics/drawable/Drawable;->setTint(I)V
+
+    :store_play_next_icon
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->playNextIcon:Landroid/graphics/drawable/Drawable;
+
+    sget v1, Lcom/aspiro/wamp/R$drawable;->ic_add_to_playlist:I
+
+    invoke-virtual {v0, v1}, Landroid/content/Context;->getDrawable(I)Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    if-eqz v1, :store_add_to_playlist_icon
+
+    invoke-virtual {v1}, Landroid/graphics/drawable/Drawable;->mutate()Landroid/graphics/drawable/Drawable;
+
+    move-result-object v1
+
+    const/4 v2, -0x1
+
+    invoke-virtual {v1, v2}, Landroid/graphics/drawable/Drawable;->setTint(I)V
+
+    :store_add_to_playlist_icon
+    iput-object v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->addToPlaylistIcon:Landroid/graphics/drawable/Drawable;
+
+    :context_ready
+    if-eqz p1, :enabled_ready
+
+    invoke-interface {p1, v0}, Lradiant/gestures/queue/ComposeSwipeAction;->setContext(Landroid/content/Context;)V
+
+    :enabled_ready
+    iget-boolean v1, p0, Lradiant/gestures/queue/ComposeSwipeState;->enabled:Z
+
+    iput-boolean p2, p0, Lradiant/gestures/queue/ComposeSwipeState;->enabled:Z
+
+    if-nez v1, :was_enabled
+
+    return-void
+
+    :was_enabled
+    if-nez p2, :done
+
+    invoke-virtual {p0}, Lradiant/gestures/queue/ComposeSwipeState;->cancelGesture()V
+
+    :done
+    return-void
+.end method

patches/extension/radiant/gestures/queue/ComposeTapGuard.smali

@@ -0,0 +1,97 @@
+.class public final Lradiant/gestures/queue/ComposeTapGuard;
+.super Ljava/lang/Object;
+.implements Lam0/a;    # MARKER: R8 Lam0/a;
+
+
+# static fields
+.field private static volatile deadline:J
+
+
+# instance fields
+.field private final delegate:Lam0/a;    # MARKER: R8 Lam0/a;
+
+
+# direct methods
+.method public constructor <init>(Lam0/a;)V    # MARKER: R8 Lam0/a;
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/ComposeTapGuard;->delegate:Lam0/a;    # MARKER: R8 Lam0/a;
+
+    return-void
+.end method
+
+.method public static isSuppressed()Z
+    .locals 5
+
+    invoke-static {}, Landroid/os/SystemClock;->uptimeMillis()J
+
+    move-result-wide v0
+
+    sget-wide v2, Lradiant/gestures/queue/ComposeTapGuard;->deadline:J
+
+    cmp-long v4, v0, v2
+
+    if-ltz v4, :suppressed
+
+    const/4 v0, 0x0
+
+    return v0
+
+    :suppressed
+    const/4 v0, 0x1
+
+    return v0
+.end method
+
+.method public static suppressAfterSwipe()V
+    .locals 4
+
+    invoke-static {}, Landroid/os/SystemClock;->uptimeMillis()J
+
+    move-result-wide v0
+
+    const-wide/16 v2, 0x96
+
+    add-long/2addr v0, v2
+
+    sput-wide v0, Lradiant/gestures/queue/ComposeTapGuard;->deadline:J
+
+    return-void
+.end method
+
+.method public static wrap(Lam0/a;)Lam0/a;    # MARKER: R8 Lam0/a;
+    .locals 1
+
+    new-instance v0, Lradiant/gestures/queue/ComposeTapGuard;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/ComposeTapGuard;-><init>(Lam0/a;)V    # MARKER: R8 Lam0/a;
+
+    return-object v0
+.end method
+
+
+# virtual methods
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    invoke-static {}, Lradiant/gestures/queue/ComposeTapGuard;->isSuppressed()Z
+
+    move-result v0
+
+    if-eqz v0, :dispatch
+
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+
+    :dispatch
+    iget-object v0, p0, Lradiant/gestures/queue/ComposeTapGuard;->delegate:Lam0/a;    # MARKER: R8 Lam0/a;
+
+    invoke-interface {v0}, Lam0/a;->invoke()Ljava/lang/Object;    # MARKER: R8 Lam0/a;
+
+    move-result-object v0
+
+    return-object v0
+.end method

patches/extension/radiant/gestures/queue/DynamicMediaQueue.smali

@@ -0,0 +1,844 @@
+.class public final Lradiant/gestures/queue/DynamicMediaQueue;
+.super Ljava/lang/Object;
+.source "DynamicMediaQueue.smali"
+
+
+# direct methods
+.method public static handleCompact(Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;Lradiant/gestures/queue/DynamicMediaQueueEvent;)V    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;
+    .locals 13
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget v4, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v5, 0x1
+
+    if-lt v4, v5, :done
+
+    const/4 v5, 0x3
+
+    if-gt v4, v5, :done
+
+    iget-object v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->pageId:Ljava/lang/String;
+
+    iget-object v1, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iget-object v2, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->itemId:Ljava/lang/String;
+
+    iget v3, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->mediaType:I
+
+    if-eqz v0, :done
+
+    if-eqz v1, :done
+
+    if-eqz v2, :done
+
+    const/4 v4, 0x1
+
+    if-lt v3, v4, :done
+
+    const/4 v4, 0x4
+
+    if-gt v3, v4, :done
+
+    invoke-virtual {p0, v1}, Li60/c;->c(Ljava/lang/String;)Lc60/h;    # MARKER: R8 Li60/c; Lc60/h; c
+
+    move-result-object v4
+
+    instance-of v5, v4, Lc60/f;    # MARKER: R8 Lc60/f;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lc60/f;    # MARKER: R8 Lc60/f;
+
+    iget-object v5, v4, Lc60/f;->b:Ljava/lang/String;    # MARKER: R8 Lc60/f; b
+
+    invoke-virtual {v1, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    iget-object v1, v4, Lc60/f;->g:Ljava/util/ArrayList;    # MARKER: R8 Lc60/f; g
+
+    invoke-virtual {v1}, Ljava/util/ArrayList;->iterator()Ljava/util/Iterator;
+
+    move-result-object v1
+
+    :find_media
+    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v5
+
+    if-eqz v5, :done
+
+    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v6
+
+    instance-of v5, v6, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    if-eqz v5, :find_media
+
+    check-cast v6, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    invoke-static {v6}, Lc60/s;->a(Lc60/r;)Ljava/lang/String;    # MARKER: R8 Lc60/s; Lc60/r; a
+
+    move-result-object v5
+
+    invoke-virtual {v2, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v5
+
+    if-eqz v5, :find_media
+
+    instance-of v5, v6, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    if-eqz v5, :done
+
+    check-cast v6, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    iget-object v7, v6, Lc60/r$b;->a:Lh40/n;    # MARKER: R8 Lc60/r$b; Lh40/n; a
+
+    const/4 v5, 0x1
+
+    if-ne v3, v5, :check_mix
+
+    instance-of v5, v7, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_mix
+    const/4 v5, 0x2
+
+    if-ne v3, v5, :check_playlist
+
+    instance-of v5, v7, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_playlist
+    const/4 v5, 0x3
+
+    if-ne v3, v5, :check_track
+
+    instance-of v5, v7, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_track
+    instance-of v5, v7, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    if-eqz v5, :done
+
+    :dependencies
+    iget-object v8, p0, Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a;->b:Lcom/tidal/android/dynamicpages/ui/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/compactgridcard/a; Lcom/tidal/android/dynamicpages/ui/b; b
+
+    instance-of v5, v8, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    if-eqz v5, :done
+
+    check-cast v8, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    iget-object v5, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v5, :done
+
+    iget-object v9, v8, Lcom/tidal/android/dynamicpages/ui/c;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; b
+
+    new-instance v10, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    iget-object v11, v4, Lc60/f;->a:Ljava/lang/String;    # MARKER: R8 Lc60/f; a
+
+    iget v12, v4, Lc60/f;->d:I    # MARKER: R8 Lc60/f; d
+
+    invoke-static {v12}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v12
+
+    invoke-direct {v10, v0, v11, v12}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    const/4 v0, 0x1
+
+    if-ne v3, v0, :mix
+
+    check-cast v7, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    invoke-static {v7}, Lie0/a;->a(Lh40/a;)Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lie0/a; Lh40/a; a
+
+    move-result-object v12
+
+    invoke-static {v8}, Lradiant/gestures/queue/DynamicMediaQueue;->menu(Lcom/tidal/android/dynamicpages/ui/c;)Lh4/a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lh4/a;
+
+    move-result-object v6
+
+    if-eqz v6, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_album_to_playlist
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_album_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_album
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_album
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :mix
+    const/4 v0, 0x2
+
+    if-ne v3, v0, :playlist
+
+    check-cast v7, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    invoke-static {v7}, Lie0/g;->b(Lh40/i;)Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lie0/g; Lh40/i; b
+
+    move-result-object v12
+
+    invoke-static {v8}, Lradiant/gestures/queue/DynamicMediaQueue;->menu(Lcom/tidal/android/dynamicpages/ui/c;)Lh4/a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lh4/a;
+
+    move-result-object v6
+
+    if-eqz v6, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_mix_to_playlist
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_mix_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_mix
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_mix
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :playlist
+    const/4 v0, 0x3
+
+    if-ne v3, v0, :track
+
+    check-cast v7, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    invoke-static {v7}, Lie0/h;->a(Lh40/j;)Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lie0/h; Lh40/j; a
+
+    move-result-object v12
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_playlist_to_playlist
+
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :check_add_playlist_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_playlist
+
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append_playlist
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :track
+    check-cast v7, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    invoke-static {v7}, Lie0/i;->a(Lh40/p;)Lcom/aspiro/wamp/model/Track;    # MARKER: R8 Lie0/i; Lh40/p; a
+
+    move-result-object v12
+
+    const/4 v6, 0x0
+
+    if-eqz v9, :navigation_ready
+
+    invoke-static {v9}, Lcom/tidal/android/navigation/a;->b(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/tidal/android/navigation/NavigationInfo$Node;    # MARKER: R8 Lcom/tidal/android/navigation/a; b
+
+    move-result-object v6
+
+    :navigation_ready
+    iget-object v0, v4, Lc60/f;->e:Ljava/lang/String;    # MARKER: R8 Lc60/f; e
+
+    invoke-static {v2, v0, v6}, Lcom/aspiro/wamp/playqueue/source/model/b;->o(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; o
+
+    move-result-object v11
+
+    invoke-virtual {v11, v12}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_track_to_playlist
+
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_track_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_track
+
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append_track
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    return-void
+.end method
+
+.method public static handlePublicPlaylist(Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/PublicPlaylistListModuleManager;Lradiant/gestures/queue/DynamicMediaQueueEvent;)V
+    .locals 11
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-lt v0, v1, :done
+
+    const/4 v1, 0x3
+
+    if-gt v0, v1, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->mediaType:I
+
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :done
+
+    iget-object v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->pageId:Ljava/lang/String;
+
+    iget-object v1, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iget-object v2, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->itemId:Ljava/lang/String;
+
+    if-eqz v0, :done
+
+    if-eqz v1, :done
+
+    if-eqz v2, :done
+
+    invoke-virtual {p0, v1}, Li60/c;->c(Ljava/lang/String;)Lc60/h;    # MARKER: R8 Li60/c; Lc60/h; c
+
+    move-result-object v3
+
+    instance-of v4, v3, Lc60/v;    # MARKER: R8 Lc60/v;
+
+    if-eqz v4, :done
+
+    check-cast v3, Lc60/v;    # MARKER: R8 Lc60/v;
+
+    iget-object v4, v3, Lc60/v;->b:Ljava/lang/String;    # MARKER: R8 Lc60/v; b
+
+    invoke-virtual {v1, v4}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    iget-object v1, v3, Lc60/v;->f:Ljava/util/ArrayList;    # MARKER: R8 Lc60/v; f
+
+    invoke-virtual {v1}, Ljava/util/ArrayList;->iterator()Ljava/util/Iterator;
+
+    move-result-object v1
+
+    :find_playlist
+    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v4
+
+    if-eqz v4, :done
+
+    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v4
+
+    instance-of v5, v4, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    if-eqz v5, :find_playlist
+
+    check-cast v4, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    invoke-static {v4}, Lc60/s;->a(Lc60/r;)Ljava/lang/String;    # MARKER: R8 Lc60/s; Lc60/r; a
+
+    move-result-object v5
+
+    invoke-virtual {v2, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v5
+
+    if-eqz v5, :find_playlist
+
+    instance-of v5, v4, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    iget-object v4, v4, Lc60/r$b;->a:Lh40/n;    # MARKER: R8 Lc60/r$b; Lh40/n; a
+
+    instance-of v5, v4, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    iget-object v5, p0, Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/PublicPlaylistListModuleManager;->f:Lcom/tidal/android/dynamicpages/ui/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/b; f
+
+    instance-of v6, v5, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    if-eqz v6, :done
+
+    check-cast v5, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    iget-object v6, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v6, :done
+
+    iget-object v7, v5, Lcom/tidal/android/dynamicpages/ui/c;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; b
+
+    new-instance v8, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    iget-object v9, v3, Lc60/v;->a:Ljava/lang/String;    # MARKER: R8 Lc60/v; a
+
+    iget v10, v3, Lc60/v;->e:I    # MARKER: R8 Lc60/v; e
+
+    invoke-static {v10}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v10
+
+    invoke-direct {v8, v0, v9, v10}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    invoke-static {v4}, Lie0/h;->a(Lh40/j;)Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lie0/h; Lh40/j; a
+
+    move-result-object v4
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_playlist_to_playlist
+
+    invoke-static {v6, v4, v8, v7}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :check_add_playlist_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_playlist
+
+    invoke-static {v6, v4, v8, v7}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append_playlist
+    invoke-static {v6, v4, v8, v7}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    :done
+    return-void
+.end method
+
+.method public static handleVertical(Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/VerticalListCardModuleManager;Lradiant/gestures/queue/DynamicMediaQueueEvent;)V
+    .locals 13
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget v4, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v5, 0x1
+
+    if-lt v4, v5, :done
+
+    const/4 v5, 0x3
+
+    if-gt v4, v5, :done
+
+    iget-object v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->pageId:Ljava/lang/String;
+
+    iget-object v1, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iget-object v2, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->itemId:Ljava/lang/String;
+
+    iget v3, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->mediaType:I
+
+    if-eqz v0, :done
+
+    if-eqz v1, :done
+
+    if-eqz v2, :done
+
+    const/4 v4, 0x1
+
+    if-lt v3, v4, :done
+
+    const/4 v4, 0x4
+
+    if-gt v3, v4, :done
+
+    invoke-virtual {p0, v1}, Li60/c;->c(Ljava/lang/String;)Lc60/h;    # MARKER: R8 Li60/c; Lc60/h; c
+
+    move-result-object v4
+
+    instance-of v5, v4, Lc60/c0;    # MARKER: R8 Lc60/c0;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lc60/c0;    # MARKER: R8 Lc60/c0;
+
+    iget-object v5, v4, Lc60/c0;->b:Ljava/lang/String;    # MARKER: R8 Lc60/c0; b
+
+    invoke-virtual {v1, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    iget-object v1, v4, Lc60/c0;->g:Ljava/util/ArrayList;    # MARKER: R8 Lc60/c0; g
+
+    invoke-virtual {v1}, Ljava/util/ArrayList;->iterator()Ljava/util/Iterator;
+
+    move-result-object v1
+
+    :find_media
+    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v5
+
+    if-eqz v5, :done
+
+    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v6
+
+    instance-of v5, v6, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    if-eqz v5, :find_media
+
+    check-cast v6, Lc60/r;    # MARKER: R8 Lc60/r;
+
+    invoke-static {v6}, Lc60/s;->a(Lc60/r;)Ljava/lang/String;    # MARKER: R8 Lc60/s; Lc60/r; a
+
+    move-result-object v5
+
+    invoke-virtual {v2, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v5
+
+    if-eqz v5, :find_media
+
+    instance-of v5, v6, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    if-eqz v5, :done
+
+    check-cast v6, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    iget-object v7, v6, Lc60/r$b;->a:Lh40/n;    # MARKER: R8 Lc60/r$b; Lh40/n; a
+
+    const/4 v5, 0x1
+
+    if-ne v3, v5, :check_mix
+
+    instance-of v5, v7, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_mix
+    const/4 v5, 0x2
+
+    if-ne v3, v5, :check_playlist
+
+    instance-of v5, v7, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_playlist
+    const/4 v5, 0x3
+
+    if-ne v3, v5, :check_track
+
+    instance-of v5, v7, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    if-eqz v5, :done
+
+    goto :dependencies
+
+    :check_track
+    instance-of v5, v7, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    if-eqz v5, :done
+
+    :dependencies
+    iget-object v8, p0, Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/VerticalListCardModuleManager;->e:Lcom/tidal/android/dynamicpages/ui/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/b; e
+
+    instance-of v5, v8, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    if-eqz v5, :done
+
+    check-cast v8, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    iget-object v5, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v5, :done
+
+    iget-object v9, v8, Lcom/tidal/android/dynamicpages/ui/c;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; b
+
+    new-instance v10, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    iget-object v11, v4, Lc60/c0;->a:Ljava/lang/String;    # MARKER: R8 Lc60/c0; a
+
+    iget v12, v4, Lc60/c0;->f:I    # MARKER: R8 Lc60/c0; f
+
+    invoke-static {v12}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v12
+
+    invoke-direct {v10, v0, v11, v12}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    const/4 v0, 0x1
+
+    if-ne v3, v0, :mix
+
+    check-cast v7, Lh40/a;    # MARKER: R8 Lh40/a;
+
+    invoke-static {v7}, Lie0/a;->a(Lh40/a;)Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lie0/a; Lh40/a; a
+
+    move-result-object v12
+
+    invoke-static {v8}, Lradiant/gestures/queue/DynamicMediaQueue;->menu(Lcom/tidal/android/dynamicpages/ui/c;)Lh4/a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lh4/a;
+
+    move-result-object v6
+
+    if-eqz v6, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_album_to_playlist
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_album_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_album
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_album
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :mix
+    const/4 v0, 0x2
+
+    if-ne v3, v0, :playlist
+
+    check-cast v7, Lh40/i;    # MARKER: R8 Lh40/i;
+
+    invoke-static {v7}, Lie0/g;->b(Lh40/i;)Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lie0/g; Lh40/i; b
+
+    move-result-object v12
+
+    invoke-static {v8}, Lradiant/gestures/queue/DynamicMediaQueue;->menu(Lcom/tidal/android/dynamicpages/ui/c;)Lh4/a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lh4/a;
+
+    move-result-object v6
+
+    if-eqz v6, :done
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_mix_to_playlist
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :check_add_mix_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_mix
+
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :append_mix
+    invoke-static {v5, v12, v10, v9, v6}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :playlist
+    const/4 v0, 0x3
+
+    if-ne v3, v0, :track
+
+    check-cast v7, Lh40/j;    # MARKER: R8 Lh40/j;
+
+    invoke-static {v7}, Lie0/h;->a(Lh40/j;)Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lie0/h; Lh40/j; a
+
+    move-result-object v12
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_playlist_to_playlist
+
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :check_add_playlist_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_playlist
+
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append_playlist
+    invoke-static {v5, v12, v10, v9}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :track
+    check-cast v7, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    invoke-static {v7}, Lie0/i;->a(Lh40/p;)Lcom/aspiro/wamp/model/Track;    # MARKER: R8 Lie0/i; Lh40/p; a
+
+    move-result-object v12
+
+    const/4 v6, 0x0
+
+    if-eqz v9, :navigation_ready
+
+    invoke-static {v9}, Lcom/tidal/android/navigation/a;->b(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/tidal/android/navigation/NavigationInfo$Node;    # MARKER: R8 Lcom/tidal/android/navigation/a; b
+
+    move-result-object v6
+
+    :navigation_ready
+    iget-object v0, v4, Lc60/c0;->c:Ljava/lang/String;    # MARKER: R8 Lc60/c0; c
+
+    invoke-static {v2, v0, v6}, Lcom/aspiro/wamp/playqueue/source/model/b;->o(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; o
+
+    move-result-object v11
+
+    invoke-virtual {v11, v12}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    const/4 v1, 0x1
+
+    if-ne v0, v1, :check_add_track_to_playlist
+
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_track_to_playlist
+    const/4 v1, 0x3
+
+    if-ne v0, v1, :append_track
+
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append_track
+    invoke-static {v5, v12, v10, v11}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    return-void
+.end method
+
+.method private static menu(Lcom/tidal/android/dynamicpages/ui/c;)Lh4/a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lh4/a;
+    .locals 2
+
+    iget-object v0, p0, Lcom/tidal/android/dynamicpages/ui/c;->a:Lcom/aspiro/wamp/core/k;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; Lcom/aspiro/wamp/core/k; a
+
+    instance-of v1, v0, Lh9/p1;    # MARKER: R8 Lh9/p1;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lh9/p1;    # MARKER: R8 Lh9/p1;
+
+    iget-object v0, v0, Lh9/p1;->b:Lx40/a;    # MARKER: R8 Lh9/p1; Lx40/a; b
+
+    instance-of v1, v0, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    return-object v0
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method

patches/extension/radiant/gestures/queue/DynamicMediaQueueEvent.smali

@@ -0,0 +1,43 @@
+.class public final Lradiant/gestures/queue/DynamicMediaQueueEvent;
+.super Ljava/lang/Object;
+.source "DynamicMediaQueueEvent.smali"
+
+# interfaces
+.implements Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/verticallistcard/b;
+.implements Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/publicplaylistlist/b;
+
+
+# instance fields
+.field public final action:I
+
+.field public final context:Landroid/content/Context;
+
+.field public final itemId:Ljava/lang/String;
+
+.field public final mediaType:I
+
+.field public final moduleUuid:Ljava/lang/String;
+
+.field public final pageId:Ljava/lang/String;
+
+
+# direct methods
+.method public constructor <init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;II)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->context:Landroid/content/Context;
+
+    iput-object p2, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iput-object p4, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->itemId:Ljava/lang/String;
+
+    iput p5, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->mediaType:I
+
+    iput p6, p0, Lradiant/gestures/queue/DynamicMediaQueueEvent;->action:I
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/DynamicTrackQueue.smali

@@ -0,0 +1,189 @@
+.class public final Lradiant/gestures/queue/DynamicTrackQueue;
+.super Ljava/lang/Object;
+.source "DynamicTrackQueue.smali"
+
+
+# direct methods
+.method public static handle(Lcom/tidal/android/dynamicpages/ui/modules/tracklist/TrackListModuleManager;Lradiant/gestures/queue/DynamicTrackQueueEvent;)V
+    .locals 11
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    iget-object v0, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->pageId:Ljava/lang/String;
+
+    if-eqz v0, :done
+
+    invoke-virtual {v0}, Ljava/lang/String;->length()I
+
+    move-result v1
+
+    if-lez v1, :done
+
+    iget-object v1, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    if-eqz v1, :done
+
+    invoke-virtual {v1}, Ljava/lang/String;->length()I
+
+    move-result v2
+
+    if-lez v2, :done
+
+    iget-wide v2, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->trackId:J
+
+    const-wide/16 v4, 0x0
+
+    cmp-long v4, v2, v4
+
+    if-lez v4, :done
+
+    invoke-virtual {p0, v1}, Li60/c;->c(Ljava/lang/String;)Lc60/h;    # MARKER: R8 Li60/c; Lc60/h; c
+
+    move-result-object v4
+
+    instance-of v5, v4, Lc60/b0;    # MARKER: R8 Lc60/b0;
+
+    if-eqz v5, :done
+
+    check-cast v4, Lc60/b0;    # MARKER: R8 Lc60/b0;
+
+    iget-object v5, v4, Lc60/b0;->b:Ljava/lang/String;    # MARKER: R8 Lc60/b0; b
+
+    invoke-virtual {v1, v5}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v1
+
+    if-eqz v1, :done
+
+    iget-object v1, v4, Lc60/b0;->f:Ljava/util/ArrayList;    # MARKER: R8 Lc60/b0; f
+
+    if-eqz v1, :done
+
+    invoke-virtual {v1}, Ljava/util/ArrayList;->iterator()Ljava/util/Iterator;
+
+    move-result-object v1
+
+    :find_track
+    invoke-interface {v1}, Ljava/util/Iterator;->hasNext()Z
+
+    move-result v5
+
+    if-eqz v5, :done
+
+    invoke-interface {v1}, Ljava/util/Iterator;->next()Ljava/lang/Object;
+
+    move-result-object v5
+
+    instance-of v6, v5, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    if-eqz v6, :find_track
+
+    check-cast v5, Lc60/r$b;    # MARKER: R8 Lc60/r$b;
+
+    iget-object v5, v5, Lc60/r$b;->a:Lh40/n;    # MARKER: R8 Lc60/r$b; Lh40/n; a
+
+    instance-of v6, v5, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    if-eqz v6, :find_track
+
+    check-cast v5, Lh40/p;    # MARKER: R8 Lh40/p;
+
+    iget-wide v6, v5, Lh40/p;->a:J    # MARKER: R8 Lh40/p; a
+
+    cmp-long v6, v6, v2
+
+    if-nez v6, :find_track
+
+    iget-object v1, p0, Lcom/tidal/android/dynamicpages/ui/modules/tracklist/TrackListModuleManager;->b:Lcom/tidal/android/dynamicpages/ui/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/b; b
+
+    instance-of v2, v1, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    if-eqz v2, :done
+
+    check-cast v1, Lcom/tidal/android/dynamicpages/ui/c;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c;
+
+    iget-object v6, v1, Lcom/tidal/android/dynamicpages/ui/c;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/c; b
+
+    if-eqz v6, :done
+
+    iget-object v1, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    invoke-static {v5}, Lie0/i;->a(Lh40/p;)Lcom/aspiro/wamp/model/Track;    # MARKER: R8 Lie0/i; Lh40/p; a
+
+    move-result-object v7
+
+    if-eqz v7, :done
+
+    iget-object v2, v4, Lc60/b0;->a:Ljava/lang/String;    # MARKER: R8 Lc60/b0; a
+
+    if-eqz v2, :done
+
+    invoke-virtual {v2}, Ljava/lang/String;->length()I
+
+    move-result v3
+
+    if-lez v3, :done
+
+    new-instance v8, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    iget v3, v4, Lc60/b0;->e:I    # MARKER: R8 Lc60/b0; e
+
+    invoke-static {v3}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v3
+
+    invoke-direct {v8, v0, v2, v3}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    iget-wide v2, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->trackId:J
+
+    invoke-static {v2, v3}, Ljava/lang/String;->valueOf(J)Ljava/lang/String;
+
+    move-result-object v2
+
+    iget-object v3, v4, Lc60/b0;->c:Ljava/lang/String;    # MARKER: R8 Lc60/b0; c
+
+    if-eqz v3, :done
+
+    iget-object v10, v4, Lc60/b0;->g:Ljava/lang/String;    # MARKER: R8 Lc60/b0; g
+
+    invoke-static {v10}, Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$a;->a(Ljava/lang/String;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;    # MARKER: R8 a
+
+    move-result-object v4
+
+    invoke-static {v2, v3, v6, v4}, Lcom/aspiro/wamp/playqueue/source/model/b;->j(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; j
+
+    move-result-object v9
+
+    if-eqz v9, :done
+
+    invoke-virtual {v9, v7}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget v0, p1, Lradiant/gestures/queue/DynamicTrackQueueEvent;->action:I
+
+    const/4 v2, 0x1
+
+    if-ne v0, v2, :check_add_to_playlist
+
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_to_playlist
+    const/4 v2, 0x3
+
+    if-ne v0, v2, :append
+
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append
+    invoke-static {v1, v7, v8, v9}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    return-void
+.end method

patches/extension/radiant/gestures/queue/DynamicTrackQueueAction.smali

@@ -0,0 +1,113 @@
+.class public final Lradiant/gestures/queue/DynamicTrackQueueAction;
+.super Ljava/lang/Object;
+.source "DynamicTrackQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field private context:Landroid/content/Context;
+
+.field private final moduleUuid:Ljava/lang/String;
+
+.field private final pageId:Ljava/lang/String;
+
+.field private final trackId:J
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Ljava/lang/String;Ljava/lang/String;Lm40/e$e;)V    # MARKER: R8 Lam0/l; Lm40/e$e;
+    .locals 2
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->moduleUuid:Ljava/lang/String;
+
+    iget-wide v0, p4, Lm40/e$e;->a:J    # MARKER: R8 Lm40/e$e; a
+
+    iput-wide v0, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->trackId:J
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 8
+
+    iget-wide v1, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->trackId:J
+
+    const/4 v0, 0x3
+
+    if-eq p1, v0, :active_queue
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v0
+
+    if-nez v0, :active_queue
+
+    new-instance v0, Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b$a;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b$a;
+
+    iget-object v3, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v4, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->moduleUuid:Ljava/lang/String;
+
+    invoke-direct {v0, v1, v2, v3, v4}, Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b$a;-><init>(JLjava/lang/String;Ljava/lang/String;)V    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b$a;
+
+    goto :emit
+
+    :active_queue
+    new-instance v0, Lradiant/gestures/queue/DynamicTrackQueueEvent;
+
+    iget-object v1, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    iget-object v2, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v3, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->moduleUuid:Ljava/lang/String;
+
+    iget-wide v4, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->trackId:J
+
+    move v6, p1
+
+    invoke-direct/range {v0 .. v6}, Lradiant/gestures/queue/DynamicTrackQueueEvent;-><init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;JI)V
+
+    :emit
+    iget-object v7, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-interface {v7, v0}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/DynamicTrackQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/DynamicTrackQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/DynamicTrackQueueEvent.smali

@@ -0,0 +1,38 @@
+.class public final Lradiant/gestures/queue/DynamicTrackQueueEvent;
+.super Ljava/lang/Object;
+.source "DynamicTrackQueueEvent.smali"
+
+# interfaces
+.implements Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b;    # MARKER: R8 Lcom/tidal/android/dynamicpages/ui/modules/tracklist/b;
+
+
+# instance fields
+.field public final action:I
+
+.field public final context:Landroid/content/Context;
+
+.field public final moduleUuid:Ljava/lang/String;
+
+.field public final pageId:Ljava/lang/String;
+
+.field public final trackId:J
+
+
+# direct methods
+.method public constructor <init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;JI)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/DynamicTrackQueueEvent;->context:Landroid/content/Context;
+
+    iput-object p2, p0, Lradiant/gestures/queue/DynamicTrackQueueEvent;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/DynamicTrackQueueEvent;->moduleUuid:Ljava/lang/String;
+
+    iput-wide p4, p0, Lradiant/gestures/queue/DynamicTrackQueueEvent;->trackId:J
+
+    iput p6, p0, Lradiant/gestures/queue/DynamicTrackQueueEvent;->action:I
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/DynamicTrackResolver.smali

@@ -0,0 +1,752 @@
+.class public final Lradiant/gestures/queue/DynamicTrackResolver;
+.super Ljava/lang/Object;
+.source "DynamicTrackResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final recycler:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private currentAlbumRow(Lradiant/gestures/queue/QueueRequest;)Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+    .locals 9
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    instance-of v1, v0, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    iget-object v1, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Landroidx/recyclerview/widget/RecyclerView;
+
+    if-eqz v1, :invalid
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object v2
+
+    instance-of v1, v2, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    if-eqz v1, :invalid
+
+    check-cast v2, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    invoke-virtual {v2}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object v2
+
+    iget v3, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v3, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v2}, Ljava/util/List;->size()I
+
+    move-result v4
+
+    if-lt v3, v4, :read_row
+
+    goto :invalid
+
+    :read_row
+    invoke-interface {v2, v3}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v2
+
+    instance-of v3, v2, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    iget-object v3, v0, Lu5/b$a;->a:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a; Lu5/b$a$a; a
+
+    iget-object v4, v2, Lu5/b$a;->a:Lu5/b$a$a;    # MARKER: R8 Lu5/b$a; Lu5/b$a$a; a
+
+    if-ne v3, v4, :invalid
+
+    iget-wide v3, v0, Lu5/b$a;->b:J    # MARKER: R8 Lu5/b$a; b
+
+    iget-wide v5, v2, Lu5/b$a;->b:J    # MARKER: R8 Lu5/b$a; b
+
+    cmp-long v7, v3, v5
+
+    if-nez v7, :invalid
+
+    iget-object v3, v0, Lu5/b$a;->c:Lu5/b$a$b;    # MARKER: R8 Lu5/b$a; Lu5/b$a$b; c
+
+    iget-object v4, v2, Lu5/b$a;->c:Lu5/b$a$b;    # MARKER: R8 Lu5/b$a; Lu5/b$a$b; c
+
+    if-eqz v3, :invalid
+
+    if-eqz v4, :invalid
+
+    iget v5, v3, Lu5/b$a$b;->r:I    # MARKER: R8 Lu5/b$a$b; r
+
+    iget v6, v4, Lu5/b$a$b;->r:I    # MARKER: R8 Lu5/b$a$b; r
+
+    iget v7, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v5, v7, :invalid
+
+    if-ne v6, v7, :invalid
+
+    iget-object v5, v3, Lu5/b$a$b;->s:Ljava/lang/String;    # MARKER: R8 Lu5/b$a$b; s
+
+    iget-object v6, v4, Lu5/b$a$b;->s:Ljava/lang/String;    # MARKER: R8 Lu5/b$a$b; s
+
+    if-eq v5, v6, :module_valid
+
+    if-eqz v5, :invalid
+
+    invoke-virtual {v5, v6}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v5
+
+    if-eqz v5, :invalid
+
+    :module_valid
+    iget-object v5, v4, Lu5/b$a$b;->g:Lcom/aspiro/wamp/model/Availability;    # MARKER: R8 Lu5/b$a$b; g
+
+    invoke-interface {v5}, Lcom/aspiro/wamp/model/Availability;->isAvailable()Z
+
+    move-result v5
+
+    if-eqz v5, :invalid
+
+    iget-boolean v5, v4, Lu5/b$a$b;->p:Z    # MARKER: R8 Lu5/b$a$b; p
+
+    if-nez v5, :invalid
+
+    return-object v2
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method private constructor <init>(Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private currentRow(Lradiant/gestures/queue/QueueRequest;)Lo6/b;    # MARKER: R8 Lo6/b;
+    .locals 8
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    instance-of v1, v0, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    iget-object v1, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Landroidx/recyclerview/widget/RecyclerView;
+
+    if-eqz v1, :invalid
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object v2
+
+    instance-of v1, v2, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    if-eqz v1, :invalid
+
+    check-cast v2, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    invoke-virtual {v2}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object v2
+
+    iget v3, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v3, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v2}, Ljava/util/List;->size()I
+
+    move-result v4
+
+    if-lt v3, v4, :read_row
+
+    goto :invalid
+
+    :read_row
+    invoke-interface {v2, v3}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v2
+
+    instance-of v3, v2, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    iget-object v3, v0, Lo6/b;->a:Lo6/i;    # MARKER: R8 Lo6/b; Lo6/i; a
+
+    iget-object v4, v2, Lo6/b;->a:Lo6/i;    # MARKER: R8 Lo6/b; Lo6/i; a
+
+    if-ne v3, v4, :invalid
+
+    iget-wide v3, v0, Lo6/b;->b:J    # MARKER: R8 Lo6/b; b
+
+    iget-wide v5, v2, Lo6/b;->b:J    # MARKER: R8 Lo6/b; b
+
+    cmp-long v7, v3, v5
+
+    if-nez v7, :invalid
+
+    iget-object v3, v0, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    iget-object v4, v2, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    if-eqz v3, :invalid
+
+    if-eqz v4, :invalid
+
+    iget v5, v3, Lo6/b$a;->d:I    # MARKER: R8 Lo6/b$a; d
+
+    iget v6, v4, Lo6/b$a;->d:I    # MARKER: R8 Lo6/b$a; d
+
+    iget v7, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v5, v7, :invalid
+
+    if-ne v6, v7, :invalid
+
+    iget v5, v3, Lo6/b$a;->o:I    # MARKER: R8 Lo6/b$a; o
+
+    iget v6, v4, Lo6/b$a;->o:I    # MARKER: R8 Lo6/b$a; o
+
+    if-ne v5, v6, :invalid
+
+    iget-object v5, v3, Lo6/b$a;->q:Ljava/lang/String;    # MARKER: R8 Lo6/b$a; q
+
+    iget-object v6, v4, Lo6/b$a;->q:Ljava/lang/String;    # MARKER: R8 Lo6/b$a; q
+
+    if-eq v5, v6, :valid
+
+    if-eqz v5, :invalid
+
+    invoke-virtual {v5, v6}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v5
+
+    if-eqz v5, :invalid
+
+    :valid
+    return-object v2
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method private currentTrack(Lradiant/gestures/queue/QueueRequest;)Lcom/aspiro/wamp/model/Track;
+    .locals 7
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/DynamicTrackResolver;->currentRow(Lradiant/gestures/queue/QueueRequest;)Lo6/b;    # MARKER: R8 Lo6/b;
+
+    move-result-object v0
+
+    if-eqz v0, :invalid
+
+    iget-object v1, v0, Lo6/b;->a:Lo6/i;    # MARKER: R8 Lo6/b; Lo6/i; a
+
+    iget-object v2, v0, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    iget-object v3, v1, Lo6/i;->p:Ljava/util/LinkedHashMap;    # MARKER: R8 Lo6/i; p
+
+    iget-object v4, v2, Lo6/b$a;->q:Ljava/lang/String;    # MARKER: R8 Lo6/b$a; q
+
+    invoke-virtual {v3, v4}, Ljava/util/LinkedHashMap;->get(Ljava/lang/Object;)Ljava/lang/Object;
+
+    move-result-object v3
+
+    instance-of v4, v3, Lcom/aspiro/wamp/dynamicpages/data/model/collection/TrackCollectionModule;
+
+    if-eqz v4, :invalid
+
+    check-cast v3, Lcom/aspiro/wamp/dynamicpages/data/model/collection/TrackCollectionModule;
+
+    invoke-virtual {v3}, Lcom/aspiro/wamp/dynamicpages/data/model/collection/MediaItemCollectionModule;->getFilteredPagedListItems()Ljava/util/List;
+
+    move-result-object v3
+
+    iget v4, v2, Lo6/b$a;->o:I    # MARKER: R8 Lo6/b$a; o
+
+    if-gez v4, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v3}, Ljava/util/List;->size()I
+
+    move-result v5
+
+    if-lt v4, v5, :read_track
+
+    goto :invalid
+
+    :read_track
+    invoke-interface {v3, v4}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v3
+
+    instance-of v4, v3, Lcom/aspiro/wamp/model/Track;
+
+    if-eqz v4, :invalid
+
+    check-cast v3, Lcom/aspiro/wamp/model/Track;
+
+    invoke-virtual {v3}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+
+    move-result v4
+
+    iget v5, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v4, v5, :invalid
+
+    iget-object v1, v1, Lo6/i;->g:Lcom/aspiro/wamp/model/AvailabilityInteractor;    # MARKER: R8 Lo6/i; g
+
+    invoke-interface {v1, v3}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getAvailability(Lcom/aspiro/wamp/model/MediaItem;)Lcom/aspiro/wamp/model/Availability$MediaItem;
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/Availability$MediaItem;->isAvailable()Z
+
+    move-result v1
+
+    if-eqz v1, :invalid
+
+    return-object v3
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method private resolveAlbum(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    iget-object v0, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    if-ne v0, p1, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    const/4 v0, -0x1
+
+    if-ne p2, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object p1
+
+    if-gez p2, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {p1}, Ljava/util/List;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_row
+
+    goto :invalid
+
+    :read_row
+    invoke-interface {p1, p2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    iget-object v0, p1, Lu5/b$a;->c:Lu5/b$a$b;    # MARKER: R8 Lu5/b$a; Lu5/b$a$b; c
+
+    if-eqz v0, :invalid
+
+    iget-object v1, v0, Lu5/b$a$b;->g:Lcom/aspiro/wamp/model/Availability;    # MARKER: R8 Lu5/b$a$b; g
+
+    invoke-interface {v1}, Lcom/aspiro/wamp/model/Availability;->isAvailable()Z
+
+    move-result v1
+
+    if-eqz v1, :invalid
+
+    iget-boolean v1, v0, Lu5/b$a$b;->p:Z    # MARKER: R8 Lu5/b$a$b; p
+
+    if-nez v1, :invalid
+
+    iget v0, v0, Lu5/b$a$b;->r:I    # MARKER: R8 Lu5/b$a$b; r
+
+    new-instance v1, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v1, p2, p1, v0}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    return-object v1
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method
+
+.method public static install(Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    new-instance v0, Lradiant/gestures/queue/DynamicTrackResolver;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/DynamicTrackResolver;-><init>(Landroidx/recyclerview/widget/RecyclerView;)V
+
+    invoke-static {p0, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 9
+
+    iget v8, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    instance-of v1, v0, Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    if-eqz v1, :dynamic_track
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/DynamicTrackResolver;->currentAlbumRow(Lradiant/gestures/queue/QueueRequest;)Lu5/b$a;    # MARKER: R8 Lu5/b$a;
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    new-instance v1, Lradiant/gestures/queue/AlbumItemQueueAction;
+
+    invoke-direct {v1, v0}, Lradiant/gestures/queue/AlbumItemQueueAction;-><init>(Lu5/b$a;)V    # MARKER: R8 Lu5/b$a;
+
+    iget-object v2, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v2}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v2
+
+    check-cast v2, Landroidx/recyclerview/widget/RecyclerView;
+
+    if-eqz v2, :done
+
+    invoke-virtual {v2}, Landroid/view/View;->getContext()Landroid/content/Context;
+
+    move-result-object v2
+
+    invoke-virtual {v1, v2}, Lradiant/gestures/queue/AlbumItemQueueAction;->setContext(Landroid/content/Context;)V
+
+    invoke-virtual {v1, v8}, Lradiant/gestures/queue/AlbumItemQueueAction;->invoke(I)Ljava/lang/Object;
+
+    return-void
+
+    :dynamic_track
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/DynamicTrackResolver;->currentRow(Lradiant/gestures/queue/QueueRequest;)Lo6/b;    # MARKER: R8 Lo6/b;
+
+    move-result-object v0
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/DynamicTrackResolver;->currentTrack(Lradiant/gestures/queue/QueueRequest;)Lcom/aspiro/wamp/model/Track;
+
+    move-result-object v1
+
+    if-eqz v0, :done
+
+    if-eqz v1, :done
+
+    const/4 v2, 0x3
+
+    if-eq v8, v2, :append
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v2
+
+    if-nez v2, :append
+
+    iget-object v2, v0, Lo6/b;->a:Lo6/i;    # MARKER: R8 Lo6/b; Lo6/i; a
+
+    iget-object v3, v0, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    iget v4, v3, Lo6/b$a;->o:I    # MARKER: R8 Lo6/b$a; o
+
+    iget-object v5, v3, Lo6/b$a;->q:Ljava/lang/String;    # MARKER: R8 Lo6/b$a; q
+
+    invoke-virtual {v2, v4, v5}, Lo6/i;->e(ILjava/lang/String;)V    # MARKER: R8 Lo6/i; e
+
+    goto :done
+
+    :append
+    iget-object v0, v0, Lo6/b;->a:Lo6/i;    # MARKER: R8 Lo6/b; Lo6/i; a
+
+    iget-object v2, v0, Lo6/i;->p:Ljava/util/LinkedHashMap;    # MARKER: R8 Lo6/i; p
+
+    iget-object v3, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    check-cast v3, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    iget-object v3, v3, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    iget-object v3, v3, Lo6/b$a;->q:Ljava/lang/String;    # MARKER: R8 Lo6/b$a; q
+
+    invoke-virtual {v2, v3}, Ljava/util/LinkedHashMap;->get(Ljava/lang/Object;)Ljava/lang/Object;
+
+    move-result-object v2
+
+    check-cast v2, Lcom/aspiro/wamp/dynamicpages/data/model/collection/TrackCollectionModule;
+
+    new-instance v3, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getPageId()Ljava/lang/String;
+
+    move-result-object v4
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getId()Ljava/lang/String;
+
+    move-result-object v5
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getPosition()I
+
+    move-result v6
+
+    invoke-static {v6}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v6
+
+    invoke-direct {v3, v4, v5, v6}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+
+    move-result v4
+
+    invoke-static {v4}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+
+    move-result-object v4
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getTitle()Ljava/lang/String;
+
+    move-result-object v5
+
+    iget-object v6, v0, Lo6/i;->m:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lo6/i; m
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/dynamicpages/data/model/Module;->getSelfLink()Ljava/lang/String;
+
+    move-result-object v7
+
+    invoke-static {v7}, Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$a;->a(Ljava/lang/String;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;    # MARKER: R8 a
+
+    move-result-object v7
+
+    invoke-static {v4, v5, v6, v7}, Lcom/aspiro/wamp/playqueue/source/model/b;->j(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; j
+
+    move-result-object v4
+
+    invoke-virtual {v4, v1}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+
+    iget-object v5, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v5}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v5
+
+    check-cast v5, Landroidx/recyclerview/widget/RecyclerView;
+
+    if-eqz v5, :done
+
+    invoke-virtual {v5}, Landroid/view/View;->getContext()Landroid/content/Context;
+
+    move-result-object v5
+
+    const/4 v0, 0x1
+
+    if-ne v8, v0, :check_add_to_playlist
+
+    invoke-static {v5, v1, v3, v4}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :check_add_to_playlist
+    const/4 v0, 0x3
+
+    if-ne v8, v0, :append_track
+
+    invoke-static {v5, v1, v3, v4}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+
+    goto :done
+
+    :append_track
+    invoke-static {v5, v1, v3, v4}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    instance-of v0, p2, Lv6/e$a;    # MARKER: R8 Lv6/e$a;
+
+    if-eqz v0, :dynamic_holder
+
+    invoke-direct {p0, p1, p2}, Lradiant/gestures/queue/DynamicTrackResolver;->resolveAlbum(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+
+    move-result-object p1
+
+    return-object p1
+
+    :dynamic_holder
+    instance-of v0, p2, Lp7/a$a;    # MARKER: R8 Lp7/a$a;
+
+    if-eqz v0, :invalid
+
+    iget-object v0, p0, Lradiant/gestures/queue/DynamicTrackResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    if-ne v0, p1, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    const/4 v0, -0x1
+
+    if-ne p2, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lcom/tidal/android/core/adapterdelegate/c;    # MARKER: R8 Lcom/tidal/android/core/adapterdelegate/c;
+
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object p1
+
+    if-gez p2, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {p1}, Ljava/util/List;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_row
+
+    goto :invalid
+
+    :read_row
+    invoke-interface {p1, p2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lo6/b;    # MARKER: R8 Lo6/b;
+
+    iget-object v0, p1, Lo6/b;->c:Lo6/b$a;    # MARKER: R8 Lo6/b; Lo6/b$a; c
+
+    if-eqz v0, :invalid
+
+    iget v0, v0, Lo6/b$a;->d:I    # MARKER: R8 Lo6/b$a; d
+
+    new-instance v1, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v1, p2, p1, v0}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    invoke-direct {p0, v1}, Lradiant/gestures/queue/DynamicTrackResolver;->currentTrack(Lradiant/gestures/queue/QueueRequest;)Lcom/aspiro/wamp/model/Track;
+
+    move-result-object p1
+
+    if-eqz p1, :invalid
+
+    return-object v1
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/FavoriteTracksResolver.smali

@@ -0,0 +1,132 @@
+.class public final Lradiant/gestures/queue/FavoriteTracksResolver;
+.super Ljava/lang/Object;
+.source "FavoriteTracksResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final fragment:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private constructor <init>(Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/FavoriteTracksResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method public static install(Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    new-instance v0, Lradiant/gestures/queue/FavoriteTracksResolver;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/FavoriteTracksResolver;-><init>(Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;)V
+
+    invoke-static {p1, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 3
+
+    iget-object v0, p0, Lradiant/gestures/queue/FavoriteTracksResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;
+
+    if-eqz v0, :done
+
+    iget v1, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    iget-object v2, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    check-cast v2, Lcom/aspiro/wamp/model/FavoriteTrack;
+
+    iget p1, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-virtual {v0, v1, v2, p1}, Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;->Z(ILcom/aspiro/wamp/model/FavoriteTrack;I)V    # MARKER: R8 Z
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    instance-of p1, p2, Ln8/d;    # MARKER: R8 Ln8/d;
+
+    if-eqz p1, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p1
+
+    const/4 v0, -0x1
+
+    if-ne p1, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    check-cast p2, Ln8/d;    # MARKER: R8 Ln8/d;
+
+    iget-object p2, p2, Ln8/d;->f:Lcom/aspiro/wamp/model/MediaItem;    # MARKER: R8 Ln8/d; f
+
+    instance-of v0, p2, Lcom/aspiro/wamp/model/FavoriteTrack;
+
+    if-eqz v0, :invalid
+
+    check-cast p2, Lcom/aspiro/wamp/model/FavoriteTrack;
+
+    iget-object v0, p0, Lradiant/gestures/queue/FavoriteTracksResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;
+
+    if-eqz v0, :invalid
+
+    invoke-virtual {v0, p1, p2}, Lcom/aspiro/wamp/mycollection/subpages/favoritetracks/FavoriteTracksFragment;->Y(ILcom/aspiro/wamp/model/FavoriteTrack;)Z    # MARKER: R8 Y
+
+    move-result v0
+
+    if-eqz v0, :invalid
+
+    invoke-virtual {p2}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+
+    move-result v0
+
+    new-instance v1, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v1, p1, p2, v0}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    return-object v1
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/FeedResolver.smali

@@ -0,0 +1,667 @@
+.class public final Lradiant/gestures/queue/FeedResolver;
+.super Ljava/lang/Object;
+.source "FeedResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final fragment:Ljava/lang/ref/WeakReference;
+
+.field private final recycler:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private constructor <init>(Lcom/tidal/android/feature/feed/ui/FeedView;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/FeedResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p2}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/FeedResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private availabilityInteractor()Lcom/aspiro/wamp/model/AvailabilityInteractor;
+    .locals 2
+
+    iget-object v0, p0, Lradiant/gestures/queue/FeedResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/tidal/android/feature/feed/ui/FeedView;
+
+    if-eqz v0, :invalid
+
+    iget-object v0, v0, Lcom/tidal/android/feature/feed/ui/FeedView;->d:Lv70/b;    # MARKER: R8 Lv70/b; d
+
+    instance-of v1, v0, Lcom/tidal/android/feature/feed/ui/c;    # MARKER: R8 Lcom/tidal/android/feature/feed/ui/c;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lcom/tidal/android/feature/feed/ui/c;    # MARKER: R8 Lcom/tidal/android/feature/feed/ui/c;
+
+    iget-object v0, v0, Lcom/tidal/android/feature/feed/ui/c;->c:Lz70/a;    # MARKER: R8 Lcom/tidal/android/feature/feed/ui/c; Lz70/a; c
+
+    if-eqz v0, :invalid
+
+    iget-object v0, v0, Lz70/a;->c:Lcom/aspiro/wamp/model/AvailabilityInteractor;    # MARKER: R8 Lz70/a; c
+
+    return-object v0
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method private current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+    .locals 10
+
+    if-eqz p1, :invalid
+
+    iget-object v8, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    iget-object v0, p0, Lradiant/gestures/queue/FeedResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/tidal/android/feature/feed/ui/FeedView;
+
+    if-eqz v0, :invalid
+
+    iget-object v1, p0, Lradiant/gestures/queue/FeedResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Landroidx/recyclerview/widget/RecyclerView;
+
+    if-eqz v1, :invalid
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object v2
+
+    instance-of v3, v2, La50/b;    # MARKER: R8 La50/b;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, La50/b;    # MARKER: R8 La50/b;
+
+    iget-object v2, v2, La50/b;->b:Ljava/util/ArrayList;    # MARKER: R8 La50/b; b
+
+    iget v3, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v3, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-virtual {v2}, Ljava/util/ArrayList;->size()I
+
+    move-result v4
+
+    if-lt v3, v4, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-virtual {v2, v3}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
+
+    move-result-object v2
+
+    invoke-direct {p0}, Lradiant/gestures/queue/FeedResolver;->availabilityInteractor()Lcom/aspiro/wamp/model/AvailabilityInteractor;
+
+    move-result-object v4
+
+    if-eqz v4, :invalid
+
+    instance-of v3, v2, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    if-eqz v3, :mix
+
+    instance-of v3, v8, Lcom/aspiro/wamp/model/Album;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    iget-boolean v3, v2, Lb80/a;->c:Z    # MARKER: R8 Lb80/a; c
+
+    if-eqz v3, :invalid
+
+    check-cast v8, Lcom/aspiro/wamp/model/Album;
+
+    iget-object v5, v2, Lb80/a;->a:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lb80/a; a
+
+    invoke-virtual {v8}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result v6
+
+    invoke-virtual {v5}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result v7
+
+    if-ne v6, v7, :invalid
+
+    iget v6, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v7, v6, :invalid
+
+    invoke-interface {v4, v5}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getAvailability(Lcom/aspiro/wamp/model/Album;)Lcom/aspiro/wamp/model/Availability$Album;
+
+    move-result-object v4
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/model/Availability$Album;->isAvailable()Z
+
+    move-result v4
+
+    if-eqz v4, :invalid
+
+    return-object v2
+
+    :mix
+    instance-of v3, v2, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    if-eqz v3, :playlist
+
+    instance-of v3, v8, Lcom/aspiro/wamp/mix/model/Mix;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    check-cast v8, Lcom/aspiro/wamp/mix/model/Mix;
+
+    iget-object v5, v2, Lb80/c;->a:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lb80/c; a
+
+    invoke-virtual {v8}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v6
+
+    invoke-virtual {v5}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v7
+
+    invoke-virtual {v6, v7}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v6
+
+    if-eqz v6, :invalid
+
+    invoke-virtual {v7}, Ljava/lang/String;->hashCode()I
+
+    move-result v6
+
+    iget v8, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v6, v8, :invalid
+
+    invoke-interface {v4, v7}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getMixAvailability(Ljava/lang/String;)Lcom/aspiro/wamp/model/Availability$Mix;
+
+    move-result-object v4
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/model/Availability$Mix;->isAvailable()Z
+
+    move-result v4
+
+    if-eqz v4, :invalid
+
+    return-object v2
+
+    :playlist
+    instance-of v3, v2, Lb80/d;    # MARKER: R8 Lb80/d;
+
+    if-eqz v3, :invalid
+
+    instance-of v3, v8, Lcom/aspiro/wamp/model/Playlist;
+
+    if-eqz v3, :invalid
+
+    check-cast v2, Lb80/d;    # MARKER: R8 Lb80/d;
+
+    check-cast v8, Lcom/aspiro/wamp/model/Playlist;
+
+    iget-object v5, v2, Lb80/d;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lb80/d; a
+
+    invoke-virtual {v8}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v6
+
+    invoke-virtual {v5}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v7
+
+    invoke-virtual {v6, v7}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v6
+
+    if-eqz v6, :invalid
+
+    invoke-virtual {v7}, Ljava/lang/String;->hashCode()I
+
+    move-result v6
+
+    iget v8, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v6, v8, :invalid
+
+    invoke-virtual {v5}, Lcom/aspiro/wamp/model/Playlist;->getNumberOfItems()I
+
+    move-result v6
+
+    if-lez v6, :invalid
+
+    const-string v6, "NOT_READY"
+
+    invoke-virtual {v5}, Lcom/aspiro/wamp/model/Playlist;->getStatus()Ljava/lang/String;
+
+    move-result-object v8
+
+    invoke-virtual {v6, v8}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v6
+
+    if-nez v6, :invalid
+
+    invoke-static {v7}, Ljava/util/UUID;->fromString(Ljava/lang/String;)Ljava/util/UUID;
+
+    move-result-object v6
+
+    invoke-interface {v4, v6}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getPlaylistAvailability(Ljava/util/UUID;)Lcom/aspiro/wamp/model/Availability$Playlist;
+
+    move-result-object v4
+
+    invoke-virtual {v4}, Lcom/aspiro/wamp/model/Availability$Playlist;->isAvailable()Z
+
+    move-result v4
+
+    if-eqz v4, :invalid
+
+    return-object v2
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method public static install(Lcom/tidal/android/feature/feed/ui/FeedView;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    new-instance v0, Lradiant/gestures/queue/FeedResolver;
+
+    invoke-direct {v0, p0, p1}, Lradiant/gestures/queue/FeedResolver;-><init>(Lcom/tidal/android/feature/feed/ui/FeedView;Landroidx/recyclerview/widget/RecyclerView;)V
+
+    invoke-static {p1, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 9
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/FeedResolver;->current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    iget-object v1, p0, Lradiant/gestures/queue/FeedResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    iget p0, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Lcom/tidal/android/feature/feed/ui/FeedView;
+
+    if-eqz v1, :done
+
+    invoke-virtual {v1}, Landroidx/fragment/app/Fragment;->getContext()Landroid/content/Context;
+
+    move-result-object v3
+
+    if-eqz v3, :done
+
+    iget-object v2, v1, Lcom/tidal/android/feature/feed/ui/FeedView;->c:La80/c;    # MARKER: R8 La80/c; c
+
+    if-eqz v2, :done
+
+    instance-of v4, v0, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    if-eqz v4, :mix
+
+    check-cast v0, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    iget-object v7, v0, Lb80/a;->a:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lb80/a; a
+
+    iget v8, v0, Lb80/a;->g:I    # MARKER: R8 Lb80/a; g
+
+    const/4 v4, 0x1
+
+    goto :metadata
+
+    :mix
+    instance-of v4, v0, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    if-eqz v4, :playlist
+
+    check-cast v0, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    iget-object v7, v0, Lb80/c;->a:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lb80/c; a
+
+    iget v8, v0, Lb80/c;->c:I    # MARKER: R8 Lb80/c; c
+
+    const/4 v4, 0x2
+
+    goto :metadata
+
+    :playlist
+    check-cast v0, Lb80/d;    # MARKER: R8 Lb80/d;
+
+    iget-object v7, v0, Lb80/d;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lb80/d; a
+
+    iget v8, v0, Lb80/d;->c:I    # MARKER: R8 Lb80/d; c
+
+    const/4 v4, 0x3
+
+    :metadata
+    invoke-static {v8}, Lcom/tidal/android/feature/feed/ui/viewstates/UpdatedIntervals$a;->a(I)Ljava/lang/String;    # MARKER: R8 a
+
+    move-result-object v8
+
+    iget-object v0, v2, La80/c;->a:Ljava/lang/String;    # MARKER: R8 La80/c; a
+
+    new-instance p1, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    invoke-direct {p1, v0, v8}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;Ljava/lang/String;)V
+
+    iget-object v5, v2, La80/c;->e:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 La80/c; e
+
+    const/4 v0, 0x3
+
+    if-ne v4, v0, :collection
+
+    check-cast v7, Lcom/aspiro/wamp/model/Playlist;
+
+    const/4 v0, 0x3
+
+    if-eq p0, v0, :add_to_playlist_playlist
+
+    const/4 v0, 0x1
+
+    if-ne p0, v0, :append_playlist
+
+    invoke-static {v3, v7, p1, v5}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append_playlist
+    invoke-static {v3, v7, p1, v5}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :add_to_playlist_playlist
+    invoke-static {v3, v7, p1, v5}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :collection
+    iget-object v6, v2, La80/c;->b:Lx40/a;    # MARKER: R8 La80/c; Lx40/a; b
+
+    instance-of v0, v6, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    if-eqz v0, :done
+
+    check-cast v6, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    const/4 v0, 0x1
+
+    if-ne v4, v0, :queue_mix
+
+    check-cast v7, Lcom/aspiro/wamp/model/Album;
+
+    const/4 v0, 0x3
+
+    if-eq p0, v0, :add_to_playlist_album
+
+    const/4 v0, 0x1
+
+    if-ne p0, v0, :append_album
+
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v7
+
+    goto :retain
+
+    :append_album
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v7
+
+    goto :retain
+
+    :add_to_playlist_album
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :queue_mix
+    check-cast v7, Lcom/aspiro/wamp/mix/model/Mix;
+
+    const/4 v0, 0x3
+
+    if-eq p0, v0, :add_to_playlist_mix
+
+    const/4 v0, 0x1
+
+    if-ne p0, v0, :append_mix
+
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v7
+
+    goto :retain
+
+    :append_mix
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v7
+
+    goto :retain
+
+    :add_to_playlist_mix
+    invoke-static {v3, v7, p1, v5, v6}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :retain
+    if-eqz v7, :done
+
+    iget-object v0, v1, Lcom/tidal/android/feature/feed/ui/FeedView;->f:Lio/reactivex/disposables/CompositeDisposable;    # MARKER: R8 f
+
+    invoke-virtual {v0, v7}, Lio/reactivex/disposables/CompositeDisposable;->add(Lio/reactivex/disposables/Disposable;)Z
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 7
+
+    iget-object v0, p0, Lradiant/gestures/queue/FeedResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    if-ne v0, p1, :invalid
+
+    instance-of v0, p2, Lw70/c$a;    # MARKER: R8 Lw70/c$a;
+
+    if-eqz v0, :mix_holder
+
+    const/4 v5, 0x1
+
+    goto :has_holder
+
+    :mix_holder
+
+    instance-of v0, p2, Lw70/h$a;    # MARKER: R8 Lw70/h$a;
+
+    if-eqz v0, :playlist_holder
+
+    const/4 v5, 0x2
+
+    goto :has_holder
+
+    :playlist_holder
+
+    instance-of v0, p2, Lw70/k$a;    # MARKER: R8 Lw70/k$a;
+
+    if-eqz v0, :invalid
+
+    const/4 v5, 0x3
+
+    :has_holder
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    if-gez p2, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, La50/b;    # MARKER: R8 La50/b;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, La50/b;    # MARKER: R8 La50/b;
+
+    iget-object p1, p1, La50/b;->b:Ljava/util/ArrayList;    # MARKER: R8 La50/b; b
+
+    invoke-virtual {p1}, Ljava/util/ArrayList;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-virtual {p1, p2}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    if-eqz v0, :mix
+
+    const/4 v0, 0x1
+
+    if-ne v5, v0, :invalid
+
+    check-cast p1, Lb80/a;    # MARKER: R8 Lb80/a;
+
+    iget-object v1, p1, Lb80/a;->a:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lb80/a; a
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result v2
+
+    goto :request
+
+    :mix
+    instance-of v0, p1, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    if-eqz v0, :playlist
+
+    const/4 v0, 0x2
+
+    if-ne v5, v0, :invalid
+
+    check-cast p1, Lb80/c;    # MARKER: R8 Lb80/c;
+
+    iget-object v1, p1, Lb80/c;->a:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lb80/c; a
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v2
+
+    invoke-virtual {v2}, Ljava/lang/String;->hashCode()I
+
+    move-result v2
+
+    goto :request
+
+    :playlist
+    instance-of v0, p1, Lb80/d;    # MARKER: R8 Lb80/d;
+
+    if-eqz v0, :invalid
+
+    const/4 v0, 0x3
+
+    if-ne v5, v0, :invalid
+
+    check-cast p1, Lb80/d;    # MARKER: R8 Lb80/d;
+
+    iget-object v1, p1, Lb80/d;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lb80/d; a
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v2
+
+    invoke-virtual {v2}, Ljava/lang/String;->hashCode()I
+
+    move-result v2
+
+    :request
+    new-instance v3, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v3, p2, v1, v2}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    invoke-direct {p0, v3}, Lradiant/gestures/queue/FeedResolver;->current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+
+    move-result-object v4
+
+    if-eqz v4, :invalid
+
+    return-object v3
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/MyAlbumsResolver.smali

@@ -0,0 +1,273 @@
+.class public final Lradiant/gestures/queue/MyAlbumsResolver;
+.super Ljava/lang/Object;
+.source "MyAlbumsResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final fragment:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private constructor <init>(Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/MyAlbumsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private current(Lradiant/gestures/queue/QueueRequest;)Lzc/a;    # MARKER: R8 Lzc/a;
+    .locals 7
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p0, Lradiant/gestures/queue/MyAlbumsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;
+
+    if-eqz v0, :invalid
+
+    iget-object v1, v0, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;->h:Lad/f;    # MARKER: R8 Lad/f; h
+
+    if-eqz v1, :invalid
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;->N()La50/d;    # MARKER: R8 La50/d; N
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object v0
+
+    iget v1, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v1, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v0}, Ljava/util/List;->size()I
+
+    move-result v2
+
+    if-lt v1, v2, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {v0, v1}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    instance-of v1, v0, Lzc/a;    # MARKER: R8 Lzc/a;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lzc/a;    # MARKER: R8 Lzc/a;
+
+    iget-boolean v1, v0, Lzc/a;->k:Z    # MARKER: R8 Lzc/a; k
+
+    if-eqz v1, :invalid
+
+    iget-object v1, v0, Lzc/a;->b:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lzc/a; b
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result v1
+
+    iget v2, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v1, v2, :invalid
+
+    return-object v0
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method public static install(Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    new-instance v0, Lradiant/gestures/queue/MyAlbumsResolver;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/MyAlbumsResolver;-><init>(Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;)V
+
+    invoke-static {p1, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 7
+
+    iget v6, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/MyAlbumsResolver;->current(Lradiant/gestures/queue/QueueRequest;)Lzc/a;    # MARKER: R8 Lzc/a;
+
+    move-result-object p1
+
+    if-eqz p1, :done
+
+    iget-object v0, p0, Lradiant/gestures/queue/MyAlbumsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;
+
+    if-eqz v0, :done
+
+    iget-object v1, v0, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;->c:Lfd/c;    # MARKER: R8 Lfd/c; c
+
+    if-eqz v1, :done
+
+    iget-object v2, v1, Lfd/c;->a:Lx40/a;    # MARKER: R8 Lfd/c; Lx40/a; a
+
+    instance-of v3, v2, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    if-eqz v3, :done
+
+    check-cast v2, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    invoke-virtual {v0}, Landroidx/fragment/app/Fragment;->getContext()Landroid/content/Context;
+
+    move-result-object v3
+
+    iget-object v4, p1, Lzc/a;->b:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lzc/a; b
+
+    iget-object v5, v1, Lfd/c;->d:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;    # MARKER: R8 Lfd/c; d
+
+    iget-object p0, v1, Lfd/c;->c:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lfd/c; c
+
+    const/4 v1, 0x3
+
+    if-eq v6, v1, :add_to_playlist
+
+    const/4 v1, 0x1
+
+    if-ne v6, v1, :append
+
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object p1
+
+    goto :retain
+
+    :append
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object p1
+
+    goto :retain
+
+    :add_to_playlist
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :retain
+    if-eqz p1, :done
+
+    iget-object v0, v0, Lcom/aspiro/wamp/mycollection/subpages/albums/myalbums/MyAlbumsView;->j:Lio/reactivex/disposables/CompositeDisposable;    # MARKER: R8 j
+
+    invoke-virtual {v0, p1}, Lio/reactivex/disposables/CompositeDisposable;->add(Lio/reactivex/disposables/Disposable;)Z
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 6
+
+    instance-of v0, p2, Lbd/d$a;    # MARKER: R8 Lbd/d$a;
+
+    if-eqz v0, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    const/4 v0, -0x1
+
+    if-ne p2, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, La50/d;    # MARKER: R8 La50/d;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, La50/d;    # MARKER: R8 La50/d;
+
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object p1
+
+    invoke-interface {p1}, Ljava/util/List;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {p1, p2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lzc/a;    # MARKER: R8 Lzc/a;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lzc/a;    # MARKER: R8 Lzc/a;
+
+    iget-boolean v0, p1, Lzc/a;->k:Z    # MARKER: R8 Lzc/a; k
+
+    if-eqz v0, :invalid
+
+    iget-object v0, p1, Lzc/a;->b:Lcom/aspiro/wamp/model/Album;    # MARKER: R8 Lzc/a; b
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result v1
+
+    new-instance v2, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v2, p2, v0, v1}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    return-object v2
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/MyMixesAndRadioResolver.smali

@@ -0,0 +1,328 @@
+.class public final Lradiant/gestures/queue/MyMixesAndRadioResolver;
+.super Ljava/lang/Object;
+.source "MyMixesAndRadioResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final fragment:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private constructor <init>(Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/MyMixesAndRadioResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private current(Lradiant/gestures/queue/QueueRequest;)Lve/a;    # MARKER: R8 Lve/a;
+    .locals 6
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    instance-of v1, v0, Lcom/aspiro/wamp/mix/model/Mix;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lcom/aspiro/wamp/mix/model/Mix;
+
+    iget-object v1, p0, Lradiant/gestures/queue/MyMixesAndRadioResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;
+
+    if-eqz v1, :invalid
+
+    iget-object v2, v1, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;->c:Lpe/f;    # MARKER: R8 Lpe/f; c
+
+    if-eqz v2, :invalid
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;->N()La50/d;    # MARKER: R8 La50/d; N
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object v1
+
+    iget v2, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v2, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v1}, Ljava/util/List;->size()I
+
+    move-result v3
+
+    if-lt v2, v3, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {v1, v2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v1
+
+    instance-of v2, v1, Lve/a;    # MARKER: R8 Lve/a;
+
+    if-eqz v2, :invalid
+
+    check-cast v1, Lve/a;    # MARKER: R8 Lve/a;
+
+    iget-boolean v2, v1, Lve/a;->f:Z    # MARKER: R8 Lve/a; f
+
+    if-eqz v2, :invalid
+
+    iget-object v2, v1, Lve/a;->c:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lve/a; c
+
+    if-eqz v2, :invalid
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v0
+
+    iget-object v3, v1, Lve/a;->a:Ljava/lang/String;    # MARKER: R8 Lve/a; a
+
+    invoke-virtual {v3, v0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v4
+
+    if-eqz v4, :invalid
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v2
+
+    invoke-virtual {v3, v2}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v2
+
+    if-eqz v2, :invalid
+
+    invoke-virtual {v3}, Ljava/lang/String;->hashCode()I
+
+    move-result v2
+
+    iget v3, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    if-ne v2, v3, :invalid
+
+    return-object v1
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method public static install(Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    new-instance v0, Lradiant/gestures/queue/MyMixesAndRadioResolver;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/MyMixesAndRadioResolver;-><init>(Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;)V
+
+    invoke-static {p1, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 8
+
+    iget v7, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/MyMixesAndRadioResolver;->current(Lradiant/gestures/queue/QueueRequest;)Lve/a;    # MARKER: R8 Lve/a;
+
+    move-result-object p1
+
+    if-eqz p1, :done
+
+    iget-object v0, p0, Lradiant/gestures/queue/MyMixesAndRadioResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;
+
+    if-eqz v0, :done
+
+    iget-object v1, v0, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;->c:Lpe/f;    # MARKER: R8 Lpe/f; c
+
+    if-eqz v1, :done
+
+    iget-object v2, v1, Lpe/f;->a:Lx40/a;    # MARKER: R8 Lpe/f; Lx40/a; a
+
+    instance-of v3, v2, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    if-eqz v3, :done
+
+    check-cast v2, Lh4/a;    # MARKER: R8 Lh4/a;
+
+    invoke-virtual {v0}, Landroidx/fragment/app/Fragment;->getContext()Landroid/content/Context;
+
+    move-result-object v3
+
+    iget-object v4, p1, Lve/a;->c:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lve/a; c
+
+    new-instance v5, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;
+
+    const-string v6, "mycollection_mixes_and_radio"
+
+    invoke-direct {v5, v6}, Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;-><init>(Ljava/lang/String;)V
+
+    iget-object p0, v1, Lpe/f;->b:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lpe/f; b
+
+    const/4 v1, 0x3
+
+    if-eq v7, v1, :add_to_playlist
+
+    const/4 v1, 0x1
+
+    if-ne v7, v1, :append
+
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object p1
+
+    goto :retain
+
+    :append
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object p1
+
+    goto :retain
+
+    :add_to_playlist
+    invoke-static {v3, v4, v5, p0, v2}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+
+    goto :done
+
+    :retain
+    if-eqz p1, :done
+
+    iget-object v0, v0, Lcom/aspiro/wamp/mycollection/subpages/mixesandradios/MyMixesAndRadioView;->h:Lio/reactivex/disposables/CompositeDisposable;    # MARKER: R8 h
+
+    invoke-virtual {v0, p1}, Lio/reactivex/disposables/CompositeDisposable;->add(Lio/reactivex/disposables/Disposable;)Z
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    instance-of v0, p2, Lqe/c$a;    # MARKER: R8 Lqe/c$a;
+
+    if-eqz v0, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    const/4 v0, -0x1
+
+    if-ne p2, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, La50/d;    # MARKER: R8 La50/d;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, La50/d;    # MARKER: R8 La50/d;
+
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object p1
+
+    if-gez p2, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {p1}, Ljava/util/List;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {p1, p2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lve/a;    # MARKER: R8 Lve/a;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lve/a;    # MARKER: R8 Lve/a;
+
+    iget-boolean v0, p1, Lve/a;->f:Z    # MARKER: R8 Lve/a; f
+
+    if-eqz v0, :invalid
+
+    iget-object v0, p1, Lve/a;->c:Lcom/aspiro/wamp/mix/model/Mix;    # MARKER: R8 Lve/a; c
+
+    if-eqz v0, :invalid
+
+    iget-object v1, p1, Lve/a;->a:Ljava/lang/String;    # MARKER: R8 Lve/a; a
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object v2
+
+    invoke-virtual {v1, v2}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v2
+
+    if-eqz v2, :invalid
+
+    invoke-virtual {v1}, Ljava/lang/String;->hashCode()I
+
+    move-result v2
+
+    new-instance v3, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v3, p2, v0, v2}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    return-object v3
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/MyPlaylistsResolver.smali

@@ -0,0 +1,312 @@
+.class public final Lradiant/gestures/queue/MyPlaylistsResolver;
+.super Ljava/lang/Object;
+.source "MyPlaylistsResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+
+# instance fields
+.field private final fragment:Ljava/lang/ref/WeakReference;
+
+
+# direct methods
+.method private constructor <init>(Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+
+    iput-object v0, p0, Lradiant/gestures/queue/MyPlaylistsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private current(Lradiant/gestures/queue/QueueRequest;)Lcf/b;    # MARKER: R8 Lcf/b;
+    .locals 6
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    instance-of v1, v0, Lcom/aspiro/wamp/model/Playlist;
+
+    if-eqz v1, :invalid
+
+    check-cast v0, Lcom/aspiro/wamp/model/Playlist;
+
+    iget-object v1, p0, Lradiant/gestures/queue/MyPlaylistsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v1
+
+    check-cast v1, Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;
+
+    if-eqz v1, :invalid
+
+    iget-object v2, v1, Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;->j:Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/h;    # MARKER: R8 Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/h; j
+
+    if-eqz v2, :invalid
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;->N()La50/d;    # MARKER: R8 La50/d; N
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object v1
+
+    iget v2, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    if-gez v2, :check_size
+
+    goto :invalid
+
+    :check_size
+    invoke-interface {v1}, Ljava/util/List;->size()I
+
+    move-result v3
+
+    if-lt v2, v3, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {v1, v2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object v1
+
+    instance-of v2, v1, Lcf/b;    # MARKER: R8 Lcf/b;
+
+    if-eqz v2, :invalid
+
+    check-cast v1, Lcf/b;    # MARKER: R8 Lcf/b;
+
+    iget-boolean v2, v1, Lcf/b;->h:Z    # MARKER: R8 Lcf/b; h
+
+    if-eqz v2, :invalid
+
+    iget-boolean v2, v1, Lcf/b;->f:Z    # MARKER: R8 Lcf/b; f
+
+    if-eqz v2, :check_playlist
+
+    const-string v2, "NOT_READY"
+
+    iget-object v3, v1, Lcf/b;->g:Ljava/lang/String;    # MARKER: R8 Lcf/b; g
+
+    invoke-virtual {v2, v3}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v2
+
+    if-nez v2, :invalid
+
+    :check_playlist
+    iget-object v2, v1, Lcf/b;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lcf/b; a
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/model/Playlist;->getNumberOfItems()I
+
+    move-result v3
+
+    if-lez v3, :invalid
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v2
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v0
+
+    invoke-virtual {v2, v0}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v0
+
+    if-eqz v0, :invalid
+
+    return-object v1
+
+    :invalid
+    const/4 v0, 0x0
+
+    return-object v0
+.end method
+
+.method public static install(Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 1
+
+    if-eqz p0, :done
+
+    if-eqz p1, :done
+
+    new-instance v0, Lradiant/gestures/queue/MyPlaylistsResolver;
+
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/MyPlaylistsResolver;-><init>(Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;)V
+
+    invoke-static {p1, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 6
+
+    iget v5, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/MyPlaylistsResolver;->current(Lradiant/gestures/queue/QueueRequest;)Lcf/b;    # MARKER: R8 Lcf/b;
+
+    move-result-object p1
+
+    if-eqz p1, :done
+
+    iget-object v0, p0, Lradiant/gestures/queue/MyPlaylistsResolver;->fragment:Ljava/lang/ref/WeakReference;
+
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;
+
+    if-eqz v0, :done
+
+    iget-object v1, v0, Lcom/aspiro/wamp/mycollection/subpages/playlists/myplaylists/MyPlaylistsView;->d:Lhf/c;    # MARKER: R8 Lhf/c; d
+
+    if-eqz v1, :done
+
+    invoke-virtual {v0}, Landroidx/fragment/app/Fragment;->getContext()Landroid/content/Context;
+
+    move-result-object v2
+
+    iget-object v3, p1, Lcf/b;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lcf/b; a
+
+    iget-object v4, v1, Lhf/c;->e:Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;    # MARKER: R8 Lhf/c; e
+
+    iget-object p0, v1, Lhf/c;->d:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 Lhf/c; d
+
+    const/4 v0, 0x3
+
+    if-eq v5, v0, :add_to_playlist
+
+    const/4 v0, 0x1
+
+    if-ne v5, v0, :append
+
+    invoke-static {v2, v3, v4, p0}, Lradiant/gestures/queue/QueueExecutor;->playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :append
+    invoke-static {v2, v3, v4, p0}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    goto :done
+
+    :add_to_playlist
+    invoke-static {v2, v3, v4, p0}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    instance-of v0, p2, Ldf/d$a;    # MARKER: R8 Ldf/d$a;
+
+    if-eqz v0, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+
+    move-result p2
+
+    const/4 v0, -0x1
+
+    if-ne p2, v0, :has_position
+
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+
+    move-result-object p1
+
+    instance-of v0, p1, La50/d;    # MARKER: R8 La50/d;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, La50/d;    # MARKER: R8 La50/d;
+
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/ListAdapter;->getCurrentList()Ljava/util/List;
+
+    move-result-object p1
+
+    invoke-interface {p1}, Ljava/util/List;->size()I
+
+    move-result v0
+
+    if-lt p2, v0, :read_item
+
+    goto :invalid
+
+    :read_item
+    invoke-interface {p1, p2}, Ljava/util/List;->get(I)Ljava/lang/Object;
+
+    move-result-object p1
+
+    instance-of v0, p1, Lcf/b;    # MARKER: R8 Lcf/b;
+
+    if-eqz v0, :invalid
+
+    check-cast p1, Lcf/b;    # MARKER: R8 Lcf/b;
+
+    iget-boolean v0, p1, Lcf/b;->h:Z    # MARKER: R8 Lcf/b; h
+
+    if-eqz v0, :invalid
+
+    iget-boolean v0, p1, Lcf/b;->f:Z    # MARKER: R8 Lcf/b; f
+
+    if-eqz v0, :check_playlist
+
+    const-string v0, "NOT_READY"
+
+    iget-object v1, p1, Lcf/b;->g:Ljava/lang/String;    # MARKER: R8 Lcf/b; g
+
+    invoke-virtual {v0, v1}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+
+    move-result v0
+
+    if-nez v0, :invalid
+
+    :check_playlist
+    iget-object v0, p1, Lcf/b;->a:Lcom/aspiro/wamp/model/Playlist;    # MARKER: R8 Lcf/b; a
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/Playlist;->getNumberOfItems()I
+
+    move-result v1
+
+    if-lez v1, :invalid
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/Playlist;->getUuid()Ljava/lang/String;
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Ljava/lang/String;->hashCode()I
+
+    move-result v2
+
+    new-instance v3, Lradiant/gestures/queue/QueueRequest;
+
+    invoke-direct {v3, p2, v0, v2}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+
+    return-object v3
+
+    :invalid
+    const/4 p1, 0x0
+
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/PlaylistItemsResolver.smali

@@ -0,0 +1,416 @@
+.class public final Lradiant/gestures/queue/PlaylistItemsResolver;
+.super Ljava/lang/Object;
+.source "PlaylistItemsResolver.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/QueueRowResolver;
+
+# instance fields
+.field private final recycler:Ljava/lang/ref/WeakReference;
+
+# direct methods
+.method private constructor <init>(Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;)V
+    .locals 1
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    new-instance v0, Ljava/lang/ref/WeakReference;
+    invoke-direct {v0, p1}, Ljava/lang/ref/WeakReference;-><init>(Ljava/lang/Object;)V
+    iput-object v0, p0, Lradiant/gestures/queue/PlaylistItemsResolver;->recycler:Ljava/lang/ref/WeakReference;
+
+    return-void
+.end method
+
+.method private current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+    .locals 7
+
+    if-eqz p1, :invalid
+
+    iget-object v0, p1, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    iget-object v1, p0, Lradiant/gestures/queue/PlaylistItemsResolver;->recycler:Ljava/lang/ref/WeakReference;
+    invoke-virtual {v1}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+    move-result-object v1
+    check-cast v1, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;
+    if-eqz v1, :invalid
+
+    invoke-virtual {v1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+    move-result-object v2
+    instance-of v3, v2, La50/b;    # MARKER: R8 La50/b;
+    if-eqz v3, :invalid
+    check-cast v2, La50/b;    # MARKER: R8 La50/b;
+    iget-object v2, v2, La50/b;->b:Ljava/util/ArrayList;    # MARKER: R8 La50/b; b
+
+    iget v3, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+    if-gez v3, :check_size
+    goto :invalid
+
+    :check_size
+    invoke-virtual {v2}, Ljava/util/ArrayList;->size()I
+    move-result v4
+    if-lt v3, v4, :read_item
+    goto :invalid
+
+    :read_item
+    invoke-virtual {v2, v3}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
+    move-result-object v2
+
+    instance-of v3, v0, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;
+    if-eqz v3, :captured_podcast
+    instance-of v3, v2, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;
+    if-eqz v3, :invalid
+    goto :member
+
+    :captured_podcast
+    instance-of v3, v0, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;
+    if-eqz v3, :captured_suggestion
+    instance-of v3, v2, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;
+    if-eqz v3, :invalid
+
+    :member
+    move-object v3, v0
+    check-cast v3, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;
+    move-object v4, v2
+    check-cast v4, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;
+
+    invoke-interface {v4}, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;->getShouldHideItem()Z
+    move-result v5
+    if-nez v5, :invalid
+
+    invoke-interface {v4}, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;->getAvailability()Lcom/aspiro/wamp/model/Availability$MediaItem;
+    move-result-object v5
+    invoke-virtual {v5}, Lcom/aspiro/wamp/model/Availability$MediaItem;->isAvailable()Z
+    move-result v5
+    if-eqz v5, :invalid
+
+    invoke-interface {v3}, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;->getUuid()Ljava/lang/String;
+    move-result-object v5
+    invoke-interface {v4}, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;->getUuid()Ljava/lang/String;
+    move-result-object v6
+    if-eq v5, v6, :member_identity
+    if-eqz v5, :invalid
+    invoke-virtual {v5, v6}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z
+    move-result v5
+    if-eqz v5, :invalid
+
+    :member_identity
+    invoke-static {v0}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object v0
+    invoke-static {v2}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object v3
+    if-eqz v0, :invalid
+    if-eqz v3, :invalid
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/MediaItem;->getIndex()I
+    move-result v4
+    invoke-virtual {v3}, Lcom/aspiro/wamp/model/MediaItem;->getIndex()I
+    move-result v5
+    if-ne v4, v5, :invalid
+    goto :check_track
+
+    :captured_suggestion
+    instance-of v3, v0, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz v3, :invalid
+    instance-of v3, v2, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz v3, :invalid
+
+    move-object v3, v2
+    check-cast v3, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    invoke-virtual {v3}, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;->getAvailability()Lcom/aspiro/wamp/model/Availability;
+    move-result-object v3
+    invoke-interface {v3}, Lcom/aspiro/wamp/model/Availability;->isAvailable()Z
+    move-result v3
+    if-eqz v3, :invalid
+
+    invoke-static {v0}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object v0
+    invoke-static {v2}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object v3
+    if-eqz v0, :invalid
+    if-eqz v3, :invalid
+
+    :check_track
+    invoke-virtual {v0}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+    move-result v4
+    invoke-virtual {v3}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+    move-result v5
+    if-ne v4, v5, :invalid
+    iget v6, p1, Lradiant/gestures/queue/QueueRequest;->id:I
+    if-ne v5, v6, :invalid
+
+    iget-object v4, v1, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;->d:Lcom/aspiro/wamp/model/AvailabilityInteractor;    # MARKER: R8 d
+    if-eqz v4, :invalid
+    invoke-interface {v4, v3}, Lcom/aspiro/wamp/model/AvailabilityInteractor;->getAvailability(Lcom/aspiro/wamp/model/MediaItem;)Lcom/aspiro/wamp/model/Availability$MediaItem;
+    move-result-object v4
+    invoke-virtual {v4}, Lcom/aspiro/wamp/model/Availability$MediaItem;->isAvailable()Z
+    move-result v4
+    if-eqz v4, :invalid
+
+    return-object v2
+
+    :invalid
+    const/4 v0, 0x0
+    return-object v0
+.end method
+
+.method public static install(Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;)V
+    .locals 1
+
+    if-eqz p0, :done
+    new-instance v0, Lradiant/gestures/queue/PlaylistItemsResolver;
+    invoke-direct {v0, p0}, Lradiant/gestures/queue/PlaylistItemsResolver;-><init>(Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;)V
+    invoke-static {p0, v0}, Lradiant/gestures/queue/SwipeToQueue;->install(Landroidx/recyclerview/widget/RecyclerView;Lradiant/gestures/queue/QueueRowResolver;)V
+
+    :done
+    return-void
+.end method
+
+.method private playlistIndex(Lradiant/gestures/queue/QueueRequest;)I
+    .locals 6
+
+    iget-object v0, p0, Lradiant/gestures/queue/PlaylistItemsResolver;->recycler:Ljava/lang/ref/WeakReference;
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+    move-result-object v0
+    check-cast v0, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;
+    if-eqz v0, :invalid
+
+    invoke-virtual {v0}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+    move-result-object v0
+    instance-of v1, v0, La50/b;    # MARKER: R8 La50/b;
+    if-eqz v1, :invalid
+    check-cast v0, La50/b;    # MARKER: R8 La50/b;
+    iget-object v0, v0, La50/b;->b:Ljava/util/ArrayList;    # MARKER: R8 La50/b; b
+
+    iget v1, p1, Lradiant/gestures/queue/QueueRequest;->position:I
+    const/4 v2, 0x0
+    const/4 v3, 0x0
+
+    :loop
+    if-ge v2, v1, :done
+    invoke-virtual {v0, v2}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
+    move-result-object v4
+    instance-of v5, v4, Lcom/aspiro/wamp/playlist/viewmodel/item/PlaylistItemViewModel;
+    if-eqz v5, :next
+    add-int/lit8 v3, v3, 0x1
+
+    :next
+    add-int/lit8 v2, v2, 0x1
+    goto :loop
+
+    :done
+    return v3
+
+    :invalid
+    const/4 v0, -0x1
+    return v0
+.end method
+
+.method private static track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    .locals 1
+
+    instance-of v0, p0, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;
+    if-eqz v0, :podcast
+    check-cast p0, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;
+    invoke-virtual {p0}, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;->getTrack()Lcom/aspiro/wamp/model/Track;
+    move-result-object p0
+    return-object p0
+
+    :podcast
+    instance-of v0, p0, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;
+    if-eqz v0, :suggestion
+    check-cast p0, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;
+    invoke-virtual {p0}, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;->getItem()Lcom/aspiro/wamp/model/MediaItemParent;
+    move-result-object p0
+    invoke-virtual {p0}, Lcom/aspiro/wamp/model/MediaItemParent;->getMediaItem()Lcom/aspiro/wamp/model/MediaItem;
+    move-result-object p0
+    instance-of v0, p0, Lcom/aspiro/wamp/model/Track;
+    if-eqz v0, :invalid
+    check-cast p0, Lcom/aspiro/wamp/model/Track;
+    return-object p0
+
+    :suggestion
+    instance-of v0, p0, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz v0, :invalid
+    check-cast p0, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    invoke-virtual {p0}, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;->getTrack()Lcom/aspiro/wamp/model/Track;
+    move-result-object p0
+    return-object p0
+
+    :invalid
+    const/4 p0, 0x0
+    return-object p0
+.end method
+
+# virtual methods
+.method public execute(Lradiant/gestures/queue/QueueRequest;)V
+    .locals 9
+
+    iget v8, p1, Lradiant/gestures/queue/QueueRequest;->action:I
+
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/PlaylistItemsResolver;->current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+    move-result-object v0
+    if-eqz v0, :done
+    invoke-static {v0}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object v1
+    if-eqz v1, :done
+
+    iget-object v2, p0, Lradiant/gestures/queue/PlaylistItemsResolver;->recycler:Ljava/lang/ref/WeakReference;
+    invoke-virtual {v2}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+    move-result-object v2
+    check-cast v2, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;
+    if-eqz v2, :done
+
+    const/4 v3, 0x3
+
+    if-eq v8, v3, :build_source
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+    move-result v3
+    if-eqz v3, :play
+
+    :build_source
+    instance-of v3, v0, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz v3, :append_member
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+    move-result v3
+    invoke-static {v3}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
+    move-result-object v3
+    sget v4, Lcom/aspiro/wamp/R$string;->recommended_tracks:I
+    invoke-static {v4}, Lcom/aspiro/wamp/util/h0;->c(I)Ljava/lang/String;    # MARKER: R8 Lcom/aspiro/wamp/util/h0; c
+    move-result-object v4
+    iget-object v5, v2, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;->h:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 h
+    sget-object v6, Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$None;->INSTANCE:Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType$None;
+    invoke-static {v3, v4, v5, v6}, Lcom/aspiro/wamp/playqueue/source/model/b;->j(Ljava/lang/String;Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;Lcom/aspiro/wamp/playqueue/source/model/ItemSource$NavigationType;)Lcom/aspiro/wamp/playqueue/source/model/ItemSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; j
+    move-result-object v7
+    invoke-virtual {v7, v1}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+    sget-object v6, Lcom/aspiro/wamp/playlist/ui/items/ModuleMetadata$Suggestions;->INSTANCE:Lcom/aspiro/wamp/playlist/ui/items/ModuleMetadata$Suggestions;
+    goto :append
+
+    :append_member
+    iget-object v3, v2, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;->c:Lcom/aspiro/wamp/playlist/ui/items/a;    # MARKER: R8 Lcom/aspiro/wamp/playlist/ui/items/a; c
+    if-eqz v3, :done
+    invoke-interface {v3}, Lcom/aspiro/wamp/playlist/ui/items/a;->k()Lcom/aspiro/wamp/playlist/viewmodel/PlaylistCollectionViewModel;    # MARKER: R8 Lcom/aspiro/wamp/playlist/ui/items/a; k
+    move-result-object v3
+    invoke-virtual {v3}, Lcom/aspiro/wamp/playlist/viewmodel/PlaylistCollectionViewModel;->getPlaylist()Lcom/aspiro/wamp/model/Playlist;
+    move-result-object v3
+    if-eqz v3, :done
+    iget-object v4, v2, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;->h:Lcom/tidal/android/navigation/NavigationInfo;    # MARKER: R8 h
+    if-eqz v4, :member_nav_ready
+    invoke-static {v4}, Lcom/tidal/android/navigation/a;->b(Lcom/tidal/android/navigation/NavigationInfo;)Lcom/tidal/android/navigation/NavigationInfo$Node;    # MARKER: R8 Lcom/tidal/android/navigation/a; b
+    move-result-object v4
+    :member_nav_ready
+    invoke-static {v3, v4}, Lcom/aspiro/wamp/playqueue/source/model/b;->f(Lcom/aspiro/wamp/model/Playlist;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/playqueue/source/model/PlaylistSource;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/source/model/b; f
+    move-result-object v7
+    invoke-virtual {v7, v1}, Lcom/aspiro/wamp/playqueue/source/model/Source;->addSourceItem(Lcom/aspiro/wamp/model/MediaItem;)V
+    sget-object v6, Lcom/aspiro/wamp/playlist/ui/items/ModuleMetadata$Items;->INSTANCE:Lcom/aspiro/wamp/playlist/ui/items/ModuleMetadata$Items;
+
+    :append
+    invoke-virtual {v2}, Landroid/view/View;->getContext()Landroid/content/Context;
+    move-result-object v3
+    const/4 v0, 0x3
+
+    if-eq v8, v0, :add_to_playlist
+
+    const/4 v0, 0x1
+
+    if-ne v8, v0, :append_track
+
+    invoke-static {v3, v1, v6, v7}, Lradiant/gestures/queue/QueueExecutor;->playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    goto :done
+
+    :append_track
+    invoke-static {v3, v1, v6, v7}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+    goto :done
+
+    :add_to_playlist
+    invoke-static {v3, v1, v6, v7}, Lradiant/gestures/queue/QueueExecutor;->addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+    goto :done
+
+    :play
+    iget-object v3, v2, Lcom/aspiro/wamp/playlist/ui/items/PlaylistItemCollectionView;->c:Lcom/aspiro/wamp/playlist/ui/items/a;    # MARKER: R8 Lcom/aspiro/wamp/playlist/ui/items/a; c
+    if-eqz v3, :done
+    instance-of v0, v0, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz v0, :play_member
+    invoke-interface {v3, v1}, Lcom/aspiro/wamp/playlist/ui/items/a;->c(Lcom/aspiro/wamp/model/Track;)V    # MARKER: R8 Lcom/aspiro/wamp/playlist/ui/items/a; c
+    goto :done
+
+    :play_member
+    invoke-direct {p0, p1}, Lradiant/gestures/queue/PlaylistItemsResolver;->playlistIndex(Lradiant/gestures/queue/QueueRequest;)I
+    move-result v0
+    if-gez v0, :start_member
+    goto :done
+    :start_member
+    invoke-interface {v3, v0}, Lcom/aspiro/wamp/playlist/ui/items/a;->i(I)V    # MARKER: R8 Lcom/aspiro/wamp/playlist/ui/items/a; i
+
+    :done
+    return-void
+.end method
+
+.method public resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+    .locals 5
+
+    iget-object v0, p0, Lradiant/gestures/queue/PlaylistItemsResolver;->recycler:Ljava/lang/ref/WeakReference;
+    invoke-virtual {v0}, Ljava/lang/ref/Reference;->get()Ljava/lang/Object;
+    move-result-object v0
+    if-ne v0, p1, :invalid
+
+    invoke-virtual {p2}, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->getBindingAdapterPosition()I
+    move-result v0
+    const/4 v1, -0x1
+    if-ne v0, v1, :has_position
+    goto :invalid
+
+    :has_position
+    invoke-virtual {p1}, Landroidx/recyclerview/widget/RecyclerView;->getAdapter()Landroidx/recyclerview/widget/RecyclerView$Adapter;
+    move-result-object p1
+    instance-of v1, p1, La50/b;    # MARKER: R8 La50/b;
+    if-eqz v1, :invalid
+    check-cast p1, La50/b;    # MARKER: R8 La50/b;
+    iget-object p1, p1, La50/b;->b:Ljava/util/ArrayList;    # MARKER: R8 La50/b; b
+    invoke-virtual {p1}, Ljava/util/ArrayList;->size()I
+    move-result v1
+    if-lt v0, v1, :read_item
+    goto :invalid
+
+    :read_item
+    invoke-virtual {p1, v0}, Ljava/util/ArrayList;->get(I)Ljava/lang/Object;
+    move-result-object p1
+
+    instance-of v1, p2, Lij/q$a;    # MARKER: R8 Lij/q$a;
+    if-eqz v1, :podcast_holder
+    instance-of v1, p1, Lcom/aspiro/wamp/playlist/viewmodel/item/TrackViewModel;
+    if-eqz v1, :invalid
+    goto :create
+
+    :podcast_holder
+    instance-of v1, p2, Lij/a0$a;    # MARKER: R8 Lij/a0$a;
+    if-eqz v1, :suggestion_holder
+    instance-of v1, p1, Lcom/aspiro/wamp/playlist/viewmodel/item/PodcastTrackViewModel;
+    if-eqz v1, :invalid
+    goto :create
+
+    :suggestion_holder
+    instance-of p2, p2, Lij/j0$a;    # MARKER: R8 Lij/j0$a;
+    if-eqz p2, :invalid
+    instance-of p2, p1, Lcom/aspiro/wamp/playlist/viewmodel/item/SuggestedTrackViewModel;
+    if-eqz p2, :invalid
+
+    :create
+    invoke-static {p1}, Lradiant/gestures/queue/PlaylistItemsResolver;->track(Ljava/lang/Object;)Lcom/aspiro/wamp/model/Track;
+    move-result-object p2
+    if-eqz p2, :invalid
+    invoke-virtual {p2}, Lcom/aspiro/wamp/model/MediaItem;->getId()I
+    move-result v1
+    new-instance v2, Lradiant/gestures/queue/QueueRequest;
+    invoke-direct {v2, v0, p1, v1}, Lradiant/gestures/queue/QueueRequest;-><init>(ILjava/lang/Object;I)V
+    invoke-direct {p0, v2}, Lradiant/gestures/queue/PlaylistItemsResolver;->current(Lradiant/gestures/queue/QueueRequest;)Ljava/lang/Object;
+    move-result-object p1
+    if-eqz p1, :invalid
+    return-object v2
+
+    :invalid
+    const/4 p1, 0x0
+    return-object p1
+.end method

patches/extension/radiant/gestures/queue/PublicPlaylistQueueAction.smali

@@ -0,0 +1,125 @@
+.class public final Lradiant/gestures/queue/PublicPlaylistQueueAction;
+.super Ljava/lang/Object;
+.source "PublicPlaylistQueueAction.smali"
+
+# interfaces
+.implements Lradiant/gestures/queue/ComposeSwipeAction;
+
+
+# instance fields
+.field private final callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+.field private context:Landroid/content/Context;
+
+.field private final itemId:Ljava/lang/String;
+
+.field private final moduleUuid:Ljava/lang/String;
+
+.field private final pageId:Ljava/lang/String;
+
+
+# direct methods
+.method public constructor <init>(Lam0/l;Ljava/lang/String;Ljava/lang/String;Lm40/e$d;)V    # MARKER: R8 Lam0/l; Lm40/e$d;
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput-object p1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    iput-object p2, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->pageId:Ljava/lang/String;
+
+    iput-object p3, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->moduleUuid:Ljava/lang/String;
+
+    iget-object p1, p4, Lm40/e$d;->a:Ljava/lang/String;    # MARKER: R8 Lm40/e$d; a
+
+    iput-object p1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->itemId:Ljava/lang/String;
+
+    return-void
+.end method
+
+
+# virtual methods
+.method public invoke(I)Ljava/lang/Object;
+    .locals 7
+
+    iget-object v0, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    if-eqz v0, :done
+
+    iget-object v1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->context:Landroid/content/Context;
+
+    if-eqz v1, :done
+
+    iget-object v4, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->itemId:Ljava/lang/String;
+
+    if-eqz v4, :done
+
+    new-instance v0, Lradiant/gestures/queue/DynamicMediaQueueEvent;
+
+    iget-object v2, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->pageId:Ljava/lang/String;
+
+    iget-object v3, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->moduleUuid:Ljava/lang/String;
+
+    const/4 v5, 0x3
+
+    move v6, p1
+
+    invoke-direct/range {v0 .. v6}, Lradiant/gestures/queue/DynamicMediaQueueEvent;-><init>(Landroid/content/Context;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;II)V
+
+    iget-object v1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->callback:Lam0/l;    # MARKER: R8 Lam0/l;
+
+    invoke-interface {v1, v0}, Lam0/l;->invoke(Ljava/lang/Object;)Ljava/lang/Object;    # MARKER: R8 Lam0/l;
+
+    :done
+    sget-object v0, Lkotlin/u;->a:Lkotlin/u;    # MARKER: R8 Lkotlin/u;
+
+    return-object v0
+.end method
+
+.method public invoke()Ljava/lang/Object;
+    .locals 1
+
+    const/4 v0, 0x2
+
+    invoke-virtual {p0, v0}, Lradiant/gestures/queue/PublicPlaylistQueueAction;->invoke(I)Ljava/lang/Object;
+
+    move-result-object v0
+
+    return-object v0
+.end method
+
+.method public setContext(Landroid/content/Context;)V
+    .locals 0
+
+    iput-object p1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->context:Landroid/content/Context;
+
+    return-void
+.end method
+
+.method public stableKey()Ljava/lang/String;
+    .locals 3
+
+    new-instance v0, Ljava/lang/StringBuilder;
+
+    const-string v1, "ppl:"
+
+    invoke-direct {v0, v1}, Ljava/lang/StringBuilder;-><init>(Ljava/lang/String;)V
+
+    iget-object v1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->moduleUuid:Ljava/lang/String;
+
+    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+
+    const/16 v1, 0x3a
+
+    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder;
+
+    iget-object v1, p0, Lradiant/gestures/queue/PublicPlaylistQueueAction;->itemId:Ljava/lang/String;
+
+    invoke-virtual {v0, v1}, Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder;
+
+    invoke-virtual {v0}, Ljava/lang/StringBuilder;->toString()Ljava/lang/String;
+
+    move-result-object v0
+
+    return-object v0
+.end method

patches/extension/radiant/gestures/queue/QueueExecutor.smali

@@ -0,0 +1,732 @@
+.class public final Lradiant/gestures/queue/QueueExecutor;
+.super Ljava/lang/Object;
+.source "QueueExecutor.smali"
+
+
+# direct methods
+.method private static activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+    .locals 1
+
+    :unwrap
+    instance-of v0, p0, Landroidx/fragment/app/FragmentActivity;
+
+    if-nez v0, :ready
+
+    instance-of v0, p0, Landroid/content/ContextWrapper;
+
+    if-eqz v0, :invalid
+
+    check-cast p0, Landroid/content/ContextWrapper;
+
+    invoke-virtual {p0}, Landroid/content/ContextWrapper;->getBaseContext()Landroid/content/Context;
+
+    move-result-object v0
+
+    if-eq v0, p0, :invalid
+
+    move-object p0, v0
+
+    goto :unwrap
+
+    :ready
+    check-cast p0, Landroidx/fragment/app/FragmentActivity;
+
+    return-object p0
+
+    :invalid
+    const/4 p0, 0x0
+
+    return-object p0
+.end method
+
+.method public static addToPlaylistAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+    .locals 2
+
+    if-eqz p1, :done
+
+    if-eqz p2, :done
+
+    if-eqz p4, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    iget-object v0, p4, Lh4/a;->b:Lo3/a$a;    # MARKER: R8 Lh4/a; Lo3/a$a; b
+
+    if-eqz v0, :done
+
+    invoke-interface {v0, p1, p2, p3}, Lo3/a$a;->a(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lo3/a;    # MARKER: R8 Lo3/a$a; Lo3/a; a
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    iget-object v0, v0, Lo3/a;->l:Lcom/aspiro/wamp/module/album/AlbumProvider;    # MARKER: R8 Lo3/a; l
+
+    if-eqz v0, :done
+
+    new-instance v1, Lc3/h;    # MARKER: R8 Lc3/h;
+
+    invoke-direct {v1, p1, v0, p2, p3}, Lc3/h;-><init>(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/module/album/AlbumProvider;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V    # MARKER: R8 Lc3/h;
+
+    invoke-virtual {v1, p0}, Lc3/h;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lc3/h; b
+
+    :done
+    return-void
+.end method
+
+.method public static addToPlaylistMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)V    # MARKER: R8 Lh4/a;
+    .locals 1
+
+    if-eqz p1, :done
+
+    if-eqz p2, :done
+
+    if-eqz p4, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    iget-object v0, p4, Lh4/a;->h:Lu3/a$a;    # MARKER: R8 Lh4/a; Lu3/a$a; h
+
+    if-eqz v0, :done
+
+    invoke-interface {v0, p1, p2, p3}, Lu3/a$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lu3/a;    # MARKER: R8 Lu3/a$a; Lu3/a; a
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    iget-object v0, v0, Lu3/a;->j:Lj3/k$a;    # MARKER: R8 Lu3/a; Lj3/k$a; j
+
+    if-eqz v0, :done
+
+    invoke-interface {v0, p1, p2, p3}, Lj3/k$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/k;    # MARKER: R8 Lj3/k$a; Lj3/k; a
+
+    move-result-object v0
+
+    if-eqz v0, :done
+
+    invoke-virtual {v0, p0}, Lj3/k;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lj3/k; b
+
+    :done
+    return-void
+.end method
+
+.method public static addToPlaylistPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+    .locals 1
+
+    if-eqz p1, :done
+
+    if-eqz p2, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    new-instance v0, Lcom/aspiro/wamp/contextmenu/item/playlist/f;    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/f;
+
+    invoke-direct {v0, p1, p2, p3}, Lcom/aspiro/wamp/contextmenu/item/playlist/f;-><init>(Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/f;
+
+    invoke-virtual {v0, p0}, Lcom/aspiro/wamp/contextmenu/item/playlist/f;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/f; b
+
+    :done
+    return-void
+.end method
+
+.method public static addToPlaylistTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V
+    .locals 1
+
+    if-eqz p1, :done
+
+    if-eqz p2, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    new-instance v0, Lm3/d;    # MARKER: R8 Lm3/d;
+
+    invoke-direct {v0, p1, p2, p3}, Lm3/d;-><init>(Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)V    # MARKER: R8 Lm3/d;
+
+    invoke-virtual {v0, p0}, Lm3/d;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lm3/d; b
+
+    :done
+    return-void
+.end method
+
+.method public static album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+    .locals 8
+
+    const/4 v0, 0x0
+
+    if-eqz p1, :done
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v1
+
+    check-cast v1, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    invoke-virtual {v1}, Le5/z$n2;->r2()Lcom/aspiro/wamp/playqueue/g1;    # MARKER: R8 Le5/z$n2; Lcom/aspiro/wamp/playqueue/g1; r2
+
+    move-result-object v2
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/playqueue/g1;->a()Lcom/aspiro/wamp/player/d;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/g1; Lcom/aspiro/wamp/player/d; a
+
+    move-result-object v2
+
+    invoke-virtual {v2}, Lcom/aspiro/wamp/player/d;->b()Lcom/aspiro/wamp/model/MediaItemParent;    # MARKER: R8 Lcom/aspiro/wamp/player/d; b
+
+    move-result-object v2
+
+    if-eqz v2, :play
+
+    if-eqz p4, :done
+
+    :unwrap_context
+    instance-of v2, p0, Landroidx/fragment/app/FragmentActivity;
+
+    if-nez v2, :has_activity
+
+    instance-of v2, p0, Landroid/content/ContextWrapper;
+
+    if-eqz v2, :done
+
+    move-object v2, p0
+
+    check-cast v2, Landroid/content/ContextWrapper;
+
+    invoke-virtual {v2}, Landroid/content/ContextWrapper;->getBaseContext()Landroid/content/Context;
+
+    move-result-object v2
+
+    if-eq v2, p0, :done
+
+    move-object p0, v2
+
+    goto :unwrap_context
+
+    :has_activity
+
+    iget-object v2, p4, Lh4/a;->b:Lo3/a$a;    # MARKER: R8 Lh4/a; Lo3/a$a; b
+
+    invoke-interface {v2, p1, p2, p3}, Lo3/a$a;->a(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lo3/a;    # MARKER: R8 Lo3/a$a; Lo3/a; a
+
+    move-result-object v2
+
+    iget-object v2, v2, Lo3/a;->e:Lc3/i$a;    # MARKER: R8 Lo3/a; Lc3/i$a; e
+
+    invoke-interface {v2, p1, p2, p3}, Lc3/i$a;->a(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lc3/i;    # MARKER: R8 Lc3/i$a; Lc3/i; a
+
+    move-result-object p1
+
+    check-cast p0, Landroidx/fragment/app/FragmentActivity;
+
+    invoke-virtual {p1, p0}, Lc3/i;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lc3/i; b
+
+    goto :done
+
+    :play
+    invoke-virtual {v1}, Le5/z$n2;->u3()Lcom/aspiro/wamp/playback/f;    # MARKER: R8 Le5/z$n2; Lcom/aspiro/wamp/playback/f; u3
+
+    move-result-object p0
+
+    invoke-virtual {p1}, Lcom/aspiro/wamp/model/Album;->getId()I
+
+    move-result p1
+
+    const/4 p2, 0x1
+
+    invoke-virtual {p0, p1, p3, p2, v0}, Lcom/aspiro/wamp/playback/f;->a(ILcom/tidal/android/navigation/NavigationInfo;ZLjava/lang/String;)Lhu/akarnokd/rxjava/interop/f;    # MARKER: R8 Lcom/aspiro/wamp/playback/f; Lhu/akarnokd/rxjava/interop/f; a
+
+    move-result-object v0
+
+    :done
+    return-object v0
+.end method
+
+.method public static hasActiveQueue()Z
+    .locals 2
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v0
+
+    check-cast v0, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    invoke-virtual {v0}, Le5/z$n2;->r2()Lcom/aspiro/wamp/playqueue/g1;    # MARKER: R8 Le5/z$n2; Lcom/aspiro/wamp/playqueue/g1; r2
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/playqueue/g1;->a()Lcom/aspiro/wamp/player/d;    # MARKER: R8 Lcom/aspiro/wamp/playqueue/g1; Lcom/aspiro/wamp/player/d; a
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/player/d;->b()Lcom/aspiro/wamp/model/MediaItemParent;    # MARKER: R8 Lcom/aspiro/wamp/player/d; b
+
+    move-result-object v0
+
+    if-eqz v0, :empty
+
+    const/4 v0, 0x1
+
+    return v0
+
+    :empty
+    const/4 v0, 0x0
+
+    return v0
+.end method
+
+.method public static mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+    .locals 4
+
+    const/4 v0, 0x0
+
+    if-eqz p1, :done
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-eqz v1, :play
+
+    if-eqz p4, :done
+
+    :unwrap_context
+    instance-of v1, p0, Landroidx/fragment/app/FragmentActivity;
+
+    if-nez v1, :has_activity
+
+    instance-of v1, p0, Landroid/content/ContextWrapper;
+
+    if-eqz v1, :done
+
+    move-object v1, p0
+
+    check-cast v1, Landroid/content/ContextWrapper;
+
+    invoke-virtual {v1}, Landroid/content/ContextWrapper;->getBaseContext()Landroid/content/Context;
+
+    move-result-object v1
+
+    if-eq v1, p0, :done
+
+    move-object p0, v1
+
+    goto :unwrap_context
+
+    :has_activity
+
+    iget-object v1, p4, Lh4/a;->h:Lu3/a$a;    # MARKER: R8 Lh4/a; Lu3/a$a; h
+
+    invoke-interface {v1, p1, p2, p3}, Lu3/a$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lu3/a;    # MARKER: R8 Lu3/a$a; Lu3/a; a
+
+    move-result-object v1
+
+    iget-object v1, v1, Lu3/a;->e:Lj3/n$a;    # MARKER: R8 Lu3/a; Lj3/n$a; e
+
+    invoke-interface {v1, p1, p2, p3}, Lj3/n$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/n;    # MARKER: R8 Lj3/n$a; Lj3/n; a
+
+    move-result-object p1
+
+    check-cast p0, Landroidx/fragment/app/FragmentActivity;
+
+    invoke-virtual {p1, p0}, Lj3/n;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lj3/n; b
+
+    goto :done
+
+    :play
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object p0
+
+    invoke-virtual {p0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object p0
+
+    check-cast p0, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    invoke-virtual {p0}, Le5/z$n2;->x3()Lcom/aspiro/wamp/playback/e0;    # MARKER: R8 Le5/z$n2; Lcom/aspiro/wamp/playback/e0; x3
+
+    move-result-object p0
+
+    invoke-virtual {p1}, Lcom/aspiro/wamp/mix/model/Mix;->getId()Ljava/lang/String;
+
+    move-result-object p1
+
+    const/4 p2, 0x1
+
+    invoke-virtual {p0, p1, p3, p2, v0}, Lcom/aspiro/wamp/playback/e0;->a(Ljava/lang/String;Lcom/tidal/android/navigation/NavigationInfo;ZLjava/lang/String;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lcom/aspiro/wamp/playback/e0; a
+
+    move-result-object v0
+
+    :done
+    return-object v0
+.end method
+
+.method public static playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+    .locals 4
+
+    if-eqz p1, :done
+
+    invoke-virtual {p1}, Lcom/aspiro/wamp/model/Playlist;->getNumberOfItems()I
+
+    move-result v0
+
+    if-lez v0, :done
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v0
+
+    check-cast v0, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-eqz v1, :play
+
+    :unwrap_context
+    instance-of v1, p0, Landroidx/fragment/app/FragmentActivity;
+
+    if-nez v1, :has_activity
+
+    instance-of v1, p0, Landroid/content/ContextWrapper;
+
+    if-eqz v1, :done
+
+    move-object v1, p0
+
+    check-cast v1, Landroid/content/ContextWrapper;
+
+    invoke-virtual {v1}, Landroid/content/ContextWrapper;->getBaseContext()Landroid/content/Context;
+
+    move-result-object v1
+
+    if-eq v1, p0, :done
+
+    move-object p0, v1
+
+    goto :unwrap_context
+
+    :has_activity
+
+    iget-object v1, v0, Le5/z$n2;->w8:Ldagger/internal/f;    # MARKER: R8 Le5/z$n2; Ldagger/internal/f; w8
+
+    invoke-interface {v1}, Lql0/a;->get()Ljava/lang/Object;    # MARKER: R8 Lql0/a;
+
+    move-result-object v1
+
+    check-cast v1, Lcom/aspiro/wamp/contextmenu/item/playlist/h$a;    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/h$a;
+
+    invoke-interface {v1, p1, p2, p3}, Lcom/aspiro/wamp/contextmenu/item/playlist/h$a;->a(Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/contextmenu/item/playlist/h;    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/h$a; Lcom/aspiro/wamp/contextmenu/item/playlist/h; a
+
+    move-result-object p2
+
+    check-cast p0, Landroidx/fragment/app/FragmentActivity;
+
+    invoke-virtual {p2, p0}, Lcom/aspiro/wamp/contextmenu/item/playlist/h;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/h; b
+
+    goto :done
+
+    :play
+    invoke-virtual {v0}, Le5/z$n2;->y3()Lcom/aspiro/wamp/playback/k0;    # MARKER: R8 Le5/z$n2; Lcom/aspiro/wamp/playback/k0; y3
+
+    move-result-object p0
+
+    invoke-virtual {p0, p1, p3}, Lcom/aspiro/wamp/playback/k0;->c(Lcom/aspiro/wamp/model/Playlist;Lcom/tidal/android/navigation/NavigationInfo;)V    # MARKER: R8 Lcom/aspiro/wamp/playback/k0; c
+
+    :done
+    return-void
+.end method
+
+.method public static playNextAlbum(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+    .locals 3
+
+    const/4 v0, 0x0
+
+    if-eqz p1, :done
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-eqz v1, :play
+
+    if-eqz p4, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    iget-object v1, p4, Lh4/a;->b:Lo3/a$a;    # MARKER: R8 Lh4/a; Lo3/a$a; b
+
+    invoke-interface {v1, p1, p2, p3}, Lo3/a$a;->a(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lo3/a;    # MARKER: R8 Lo3/a$a; Lo3/a; a
+
+    move-result-object v1
+
+    iget-object v1, v1, Lo3/a;->d:Lc3/l$a;    # MARKER: R8 Lo3/a; Lc3/l$a; d
+
+    invoke-interface {v1, p1, p2, p3}, Lc3/l$a;->a(Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lc3/l;    # MARKER: R8 Lc3/l$a; Lc3/l; a
+
+    move-result-object p1
+
+    invoke-virtual {p1, p0}, Lc3/l;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lc3/l; b
+
+    goto :done
+
+    :play
+    invoke-static {p0, p1, p2, p3, p4}, Lradiant/gestures/queue/QueueExecutor;->album(Landroid/content/Context;Lcom/aspiro/wamp/model/Album;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v0
+
+    :done
+    return-object v0
+.end method
+
+.method public static playNextMix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+    .locals 2
+
+    const/4 v0, 0x0
+
+    if-eqz p1, :done
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-eqz v1, :play
+
+    if-eqz p4, :done
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    iget-object v1, p4, Lh4/a;->h:Lu3/a$a;    # MARKER: R8 Lh4/a; Lu3/a$a; h
+
+    invoke-interface {v1, p1, p2, p3}, Lu3/a$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lu3/a;    # MARKER: R8 Lu3/a$a; Lu3/a; a
+
+    move-result-object v1
+
+    iget-object v1, v1, Lu3/a;->d:Lj3/q$a;    # MARKER: R8 Lu3/a; Lj3/q$a; d
+
+    invoke-interface {v1, p1, p2, p3}, Lj3/q$a;->a(Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lj3/q;    # MARKER: R8 Lj3/q$a; Lj3/q; a
+
+    move-result-object p1
+
+    invoke-virtual {p1, p0}, Lj3/q;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lj3/q; b
+
+    goto :done
+
+    :play
+    invoke-static {p0, p1, p2, p3, p4}, Lradiant/gestures/queue/QueueExecutor;->mix(Landroid/content/Context;Lcom/aspiro/wamp/mix/model/Mix;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;Lh4/a;)Lio/reactivex/disposables/Disposable;    # MARKER: R8 Lh4/a;
+
+    move-result-object v0
+
+    :done
+    return-object v0
+.end method
+
+.method public static playNextPlaylist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+    .locals 2
+
+    if-eqz p1, :done
+
+    invoke-virtual {p1}, Lcom/aspiro/wamp/model/Playlist;->getNumberOfItems()I
+
+    move-result v0
+
+    if-lez v0, :done
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v0
+
+    if-eqz v0, :play
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v0
+
+    invoke-virtual {v0}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v0
+
+    check-cast v0, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    iget-object v0, v0, Le5/z$n2;->v8:Ldagger/internal/f;    # MARKER: R8 Le5/z$n2; Ldagger/internal/f; v8
+
+    invoke-interface {v0}, Lql0/a;->get()Ljava/lang/Object;    # MARKER: R8 Lql0/a;
+
+    move-result-object v0
+
+    check-cast v0, Lcom/aspiro/wamp/contextmenu/item/playlist/u$a;    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/u$a;
+
+    invoke-interface {v0, p1, p2, p3}, Lcom/aspiro/wamp/contextmenu/item/playlist/u$a;->a(Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)Lcom/aspiro/wamp/contextmenu/item/playlist/u;    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/u$a; Lcom/aspiro/wamp/contextmenu/item/playlist/u; a
+
+    move-result-object p1
+
+    invoke-virtual {p1, p0}, Lcom/aspiro/wamp/contextmenu/item/playlist/u;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lcom/aspiro/wamp/contextmenu/item/playlist/u; b
+
+    goto :done
+
+    :play
+    invoke-static {p0, p1, p2, p3}, Lradiant/gestures/queue/QueueExecutor;->playlist(Landroid/content/Context;Lcom/aspiro/wamp/model/Playlist;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/tidal/android/navigation/NavigationInfo;)V
+
+    :done
+    return-void
+.end method
+
+.method public static playNextTrack(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+    .locals 2
+
+    const/4 v0, 0x0
+
+    if-eqz p1, :done
+
+    invoke-static {}, Lradiant/gestures/queue/QueueExecutor;->hasActiveQueue()Z
+
+    move-result v1
+
+    if-eqz v1, :play
+
+    invoke-static {p0}, Lradiant/gestures/queue/QueueExecutor;->activity(Landroid/content/Context;)Landroidx/fragment/app/FragmentActivity;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v1
+
+    check-cast v1, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    iget-object v1, v1, Le5/z$n2;->K9:Ldagger/internal/f;    # MARKER: R8 Le5/z$n2; Ldagger/internal/f; K9
+
+    invoke-interface {v1}, Lql0/a;->get()Ljava/lang/Object;    # MARKER: R8 Lql0/a;
+
+    move-result-object v1
+
+    check-cast v1, Lm3/i$a;    # MARKER: R8 Lm3/i$a;
+
+    invoke-interface {v1, p1, p2, p3}, Lm3/i$a;->a(Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Lm3/i;    # MARKER: R8 Lm3/i$a; Lm3/i; a
+
+    move-result-object p1
+
+    invoke-virtual {p1, p0}, Lm3/i;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lm3/i; b
+
+    const/4 v0, 0x1
+
+    goto :done
+
+    :play
+    invoke-static {p0, p1, p2, p3}, Lradiant/gestures/queue/QueueExecutor;->track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+
+    move-result v0
+
+    :done
+    return v0
+.end method
+
+.method public static track(Landroid/content/Context;Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Z
+    .locals 2
+
+    const/4 v0, 0x0
+
+    :unwrap_context
+    instance-of v1, p0, Landroidx/fragment/app/FragmentActivity;
+
+    if-nez v1, :has_activity
+
+    instance-of v1, p0, Landroid/content/ContextWrapper;
+
+    if-eqz v1, :done
+
+    move-object v1, p0
+
+    check-cast v1, Landroid/content/ContextWrapper;
+
+    invoke-virtual {v1}, Landroid/content/ContextWrapper;->getBaseContext()Landroid/content/Context;
+
+    move-result-object v1
+
+    if-eq v1, p0, :done
+
+    move-object p0, v1
+
+    goto :unwrap_context
+
+    :has_activity
+
+    invoke-static {}, Lcom/aspiro/wamp/App$a;->a()Lcom/aspiro/wamp/App;    # MARKER: R8 a
+
+    move-result-object v1
+
+    invoke-virtual {v1}, Lcom/aspiro/wamp/App;->e()Le5/c;    # MARKER: R8 Le5/c; e
+
+    move-result-object v1
+
+    check-cast v1, Le5/z$n2;    # MARKER: R8 Le5/z$n2;
+
+    iget-object v1, v1, Le5/z$n2;->k9:Ldagger/internal/f;    # MARKER: R8 Le5/z$n2; Ldagger/internal/f; k9
+
+    invoke-interface {v1}, Lql0/a;->get()Ljava/lang/Object;    # MARKER: R8 Lql0/a;
+
+    move-result-object v1
+
+    check-cast v1, Lm3/f$a;    # MARKER: R8 Lm3/f$a;
+
+    invoke-interface {v1, p1, p2, p3}, Lm3/f$a;->a(Lcom/aspiro/wamp/model/Track;Lcom/aspiro/wamp/eventtracking/model/ContextualMetadata;Lcom/aspiro/wamp/playqueue/source/model/Source;)Lm3/f;    # MARKER: R8 Lm3/f$a; Lm3/f; a
+
+    move-result-object p1
+
+    check-cast p0, Landroidx/fragment/app/FragmentActivity;
+
+    invoke-virtual {p1, p0}, Lm3/f;->b(Landroidx/fragment/app/FragmentActivity;)V    # MARKER: R8 Lm3/f; b
+
+    const/4 v0, 0x1
+
+    :done
+    return v0
+.end method

patches/extension/radiant/gestures/queue/QueueRequest.smali

@@ -0,0 +1,38 @@
+.class public final Lradiant/gestures/queue/QueueRequest;
+.super Ljava/lang/Object;
+.source "QueueRequest.smali"
+
+# static fields
+.field public static final ACTION_NONE:I = 0x0
+
+.field public static final ACTION_PLAY_NEXT:I = 0x1
+
+.field public static final ACTION_ADD_TO_QUEUE:I = 0x2
+
+.field public static final ACTION_ADD_TO_PLAYLIST:I = 0x3
+
+
+# instance fields
+.field public action:I
+
+.field public final id:I
+
+.field public final media:Ljava/lang/Object;
+
+.field public final position:I
+
+
+# direct methods
+.method public constructor <init>(ILjava/lang/Object;I)V
+    .locals 0
+
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    iput p1, p0, Lradiant/gestures/queue/QueueRequest;->position:I
+
+    iput-object p2, p0, Lradiant/gestures/queue/QueueRequest;->media:Ljava/lang/Object;
+
+    iput p3, p0, Lradiant/gestures/queue/QueueRequest;->id:I
+
+    return-void
+.end method

patches/extension/radiant/gestures/queue/QueueRowResolver.smali

@@ -0,0 +1,11 @@
+.class public interface abstract Lradiant/gestures/queue/QueueRowResolver;
+.super Ljava/lang/Object;
+.source "QueueRowResolver.smali"
+
+
+# virtual methods
+.method public abstract execute(Lradiant/gestures/queue/QueueRequest;)V
+.end method
+
+.method public abstract resolve(Landroidx/recyclerview/widget/RecyclerView;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;)Lradiant/gestures/queue/QueueRequest;
+.end method

patches/extension/radiant/gestures/queue/QueueSwipeRemove.smali

@@ -0,0 +1,224 @@
+.class public final Lradiant/gestures/queue/QueueSwipeRemove;
+.super Ljava/lang/Object;
+.source "QueueSwipeRemove.smali"
+
+
+# direct methods
+.method public static draw(Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;Landroid/graphics/Canvas;Landroidx/recyclerview/widget/RecyclerView$ViewHolder;FIZ)V
+    .locals 10
+
+    const/4 v0, 0x1
+
+    if-ne p4, v0, :done
+
+    iget-object v0, p2, Landroidx/recyclerview/widget/RecyclerView$ViewHolder;->itemView:Landroid/view/View;
+
+    const/4 v1, 0x0
+
+    int-to-float v1, v1
+
+    cmpg-float v2, p3, v1
+
+    invoke-virtual {v0}, Landroid/view/View;->getTop()I
+
+    move-result v3
+
+    invoke-virtual {v0}, Landroid/view/View;->getBottom()I
+
+    move-result v4
+
+    if-gez v2, :right_swipe
+
+    # left swipe
+    invoke-virtual {v0}, Landroid/view/View;->getRight()I
+
+    move-result v1
+
+    float-to-int v2, p3
+
+    add-int/2addr v2, v1
+
+    goto :bounds_ready
+
+    :right_swipe
+    cmpl-float v1, p3, v1
+
+    if-lez v1, :done
+
+    # right swipe
+    invoke-virtual {v0}, Landroid/view/View;->getLeft()I
+
+    move-result v2
+
+    float-to-int v1, p3
+
+    add-int/2addr v1, v2
+
+    :bounds_ready
+    sub-int v5, v1, v2
+
+    if-lez v5, :done
+
+    iget-object v6, p0, Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;->c:Landroid/graphics/drawable/ColorDrawable;    # MARKER: R8 c
+
+    invoke-virtual {v6, v2, v3, v1, v4}, Landroid/graphics/drawable/Drawable;->setBounds(IIII)V
+
+    invoke-virtual {v0}, Landroid/view/View;->getWidth()I
+
+    move-result v7
+
+    if-lez v7, :draw_background
+
+    # 30% threshold
+    mul-int/lit8 v8, v7, 0x3
+
+    div-int/lit8 v8, v8, 0xa
+
+    if-lez v8, :draw_background
+
+    if-eqz p5, :draw_alpha
+
+    if-lt v5, v8, :below_threshold
+
+    const/4 v9, 0x1
+
+    goto :update_haptic
+
+    :below_threshold
+    const/4 v9, 0x0
+
+    :update_haptic
+    iget-boolean p2, p0, Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;->i:Z    # MARKER: R8 i
+
+    if-eq v9, p2, :draw_alpha
+
+    iput-boolean v9, p0, Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;->i:Z    # MARKER: R8 i
+
+    # CLOCK_TICK
+    const/4 p2, 0x4
+
+    invoke-virtual {v0, p2}, Landroid/view/View;->performHapticFeedback(I)Z
+
+    :draw_alpha
+    const/16 v9, 0x40
+
+    mul-int/2addr v9, v5
+
+    div-int/2addr v9, v8
+
+    const/16 v8, 0x40
+
+    invoke-static {v9, v8}, Ljava/lang/Math;->min(II)I
+
+    move-result v8
+
+    add-int/lit16 v8, v8, 0xbf
+
+    invoke-virtual {v6, v8}, Landroid/graphics/drawable/Drawable;->setAlpha(I)V
+
+    :draw_background
+    invoke-virtual {v6, p1}, Landroid/graphics/drawable/ColorDrawable;->draw(Landroid/graphics/Canvas;)V
+
+    iget-object v6, p0, Lcom/aspiro/wamp/nowplaying/view/playqueue/touchmanagement/ItemTouchHelperCallbackImpl;->h:Landroid/graphics/drawable/Drawable;    # MARKER: R8 h
+
+    if-eqz v6, :done
+
+    invoke-virtual {v6}, Landroid/graphics/drawable/Drawable;->getIntrinsicWidth()I
+
+    move-result v7
+
+    invoke-virtual {v6}, Landroid/graphics/drawable/Drawable;->getIntrinsicHeight()I
+
+    move-result v8
+
+    if-lez v7, :done
+
+    if-lez v8, :done
+
+    sub-int v9, v4, v3
+
+    sub-int/2addr v9, v8
+
+    div-int/lit8 v9, v9, 0x2
+
+    const/4 p2, 0x0
+
+    int-to-float p2, p2
+
+    cmpg-float p2, p3, p2
+
+    if-gez p2, :right_icon
+
+    sub-int p2, v1, v9
+
+    sub-int p4, p2, v7
+
+    add-int p2, v5, v7
+
+    div-int/lit8 p2, p2, 0x2
+
+    sub-int p2, v1, p2
+
+    invoke-static {p2, p4}, Ljava/lang/Math;->max(II)I
+
+    move-result p2
+
+    goto :icon_positioned
+
+    :right_icon
+    add-int p2, v2, v9
+
+    sub-int p4, v5, v7
+
+    div-int/lit8 p4, p4, 0x2
+
+    add-int/2addr p4, v2
+
+    invoke-static {p4, p2}, Ljava/lang/Math;->min(II)I
+
+    move-result p2
+
+    :icon_positioned
+    add-int p4, p2, v7
+
+    invoke-virtual {p1}, Landroid/graphics/Canvas;->save()I
+
+    move-result v7
+
+    invoke-virtual {p1, v2, v3, v1, v4}, Landroid/graphics/Canvas;->clipRect(IIII)Z
+
+    add-int v2, v3, v9
+
+    add-int v3, v2, v8
+
+    invoke-virtual {v6, p2, v2, p4, v3}, Landroid/graphics/drawable/Drawable;->setBounds(IIII)V
+
+    const/16 v8, 0xff
+
+    invoke-virtual {v6, v8}, Landroid/graphics/drawable/Drawable;->setAlpha(I)V
+
+    invoke-virtual {v6, p1}, Landroid/graphics/drawable/Drawable;->draw(Landroid/graphics/Canvas;)V
+
+    invoke-virtual {p1, v7}, Landroid/graphics/Canvas;->restoreToCount(I)V
+
+    :done
+    return-void
+.end method
+
+.method public static setRemoveDuration(Landroidx/recyclerview/widget/RecyclerView;)V
+    .locals 2
+
+    invoke-virtual {p0}, Landroidx/recyclerview/widget/RecyclerView;->getItemAnimator()Landroidx/recyclerview/widget/RecyclerView$ItemAnimator;
+
+    move-result-object p0
+
+    if-eqz p0, :done
+
+    # 80ms (faster animation, native is 120ms)
+    const-wide/16 v0, 0x50
+
+    invoke-virtual {p0, v0, v1}, Landroidx/recyclerview/widget/RecyclerView$ItemAnimator;->setRemoveDuration(J)V
+
+    :done
+    return-void
+.end method