Add variable storage locations & batch adding

Signed-off-by: Nikolaos Karaolidis <nick@karaolidis.com>

LICENSE

@@ -1,674 +0,0 @@
-                    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>.

android/app/build.gradle

@@ -79,7 +79,7 @@ android {
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode 1
-        versionName "1.0"
+        versionName "0.0.3"
     }
     signingConfigs {
         debug {

package-lock.json

@@ -1,17 +1,18 @@
 {
   "name": "@karaolidis/terminally-online",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@karaolidis/terminally-online",
-      "version": "0.0.1",
+      "version": "0.0.3",
       "hasInstallScript": true,
       "dependencies": {
         "@bankify/redux-persist-realm": "^0.1.3",
         "@likashefqet/react-native-image-zoom": "^1.3.0",
         "@react-native-clipboard/clipboard": "^1.11.2",
+        "@react-native-community/hooks": "^3.0.0",
         "@react-navigation/bottom-tabs": "^6.5.8",
         "@react-navigation/native": "^6.1.7",
         "@react-navigation/native-stack": "^6.9.13",
@@ -4112,6 +4113,15 @@
         "node": ">= 4.0.0"
       }
     },
+    "node_modules/@react-native-community/hooks": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@react-native-community/hooks/-/hooks-3.0.0.tgz",
+      "integrity": "sha512-g2OyxXHfwIytXUJitBR6Z/ISoOfp0WKx5FOv+NqJ/CrWjRDcTw6zXE5I1C9axfuh30kJqzWchVfCDrkzZYTxqg==",
+      "peerDependencies": {
+        "react": ">=17.0.2",
+        "react-native": ">=0.65"
+      }
+    },
     "node_modules/@react-native/assets-registry": {
       "version": "0.72.0",
       "resolved": "https://registry.npmjs.org/@react-native/assets-registry/-/assets-registry-0.72.0.tgz",
@@ -18759,6 +18769,12 @@
         "joi": "^17.2.1"
       }
     },
+    "@react-native-community/hooks": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@react-native-community/hooks/-/hooks-3.0.0.tgz",
+      "integrity": "sha512-g2OyxXHfwIytXUJitBR6Z/ISoOfp0WKx5FOv+NqJ/CrWjRDcTw6zXE5I1C9axfuh30kJqzWchVfCDrkzZYTxqg==",
+      "requires": {}
+    },
     "@react-native/assets-registry": {
       "version": "0.72.0",
       "resolved": "https://registry.npmjs.org/@react-native/assets-registry/-/assets-registry-0.72.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karaolidis/terminally-online",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": true,
   "scripts": {
     "postinstall": "patch-package",
@@ -17,6 +17,7 @@
     "@bankify/redux-persist-realm": "^0.1.3",
     "@likashefqet/react-native-image-zoom": "^1.3.0",
     "@react-native-clipboard/clipboard": "^1.11.2",
+    "@react-native-community/hooks": "^3.0.0",
     "@react-navigation/bottom-tabs": "^6.5.8",
     "@react-navigation/native": "^6.1.7",
     "@react-navigation/native-stack": "^6.9.13",

src/app.tsx

@@ -1,5 +1,11 @@
 import React, { useEffect, useState } from 'react';
-import { AppState, StatusBar, useColorScheme } from 'react-native';
+import {
+  AppState,
+  StatusBar,
+  useColorScheme,
+  StyleSheet,
+  UIManager,
+} from 'react-native';
 import { PaperProvider } from 'react-native-paper';
 import { SafeAreaProvider } from 'react-native-safe-area-context';
 import { RealmProvider } from '@realm/react';
@@ -13,8 +19,12 @@ import NavigationContainer from './navigation';
 import { store, persistor, validateSettings } from './state';
 import { LoadingView } from './components';
 import { Welcome } from './screens';
-import styles from './styles';
-import { DimensionsProvider } from './contexts';
+
+const appStyles = StyleSheet.create({
+  gestureHandler: {
+    flex: 1,
+  },
+});
 
 const App = () => {
   const [showWelcome, setShowWelcome] = useState(false);
@@ -23,6 +33,7 @@ const App = () => {
   const theme = isDarkMode ? darkTheme : lightTheme;
 
   const onBeforeLift = async () => {
+    UIManager.setLayoutAnimationEnabledExperimental(true);
     await store.dispatch(validateSettings());
     const { settings } = store.getState();
     if (!settings.storageUri) {
@@ -43,32 +54,30 @@ const App = () => {
   }, []);
 
   return (
-    <PaperProvider theme={theme}>
-      <DimensionsProvider>
-        <ReduxProvider store={store}>
+    <ReduxProvider store={store}>
+      <RealmProvider schema={[Meme, Tag]}>
+        <PaperProvider theme={theme}>
           <PersistGate
             loading={<LoadingView />}
             persistor={persistor}
             onBeforeLift={onBeforeLift}>
-            <RealmProvider schema={[Meme, Tag]}>
-              <GestureHandlerRootView style={styles.flex}>
-                <SafeAreaProvider>
-                  <StatusBar
-                    barStyle={isDarkMode ? 'light-content' : 'dark-content'}
-                    backgroundColor={theme.colors.background}
-                  />
-                  {showWelcome ? (
-                    <Welcome onWelcomeComplete={() => setShowWelcome(false)} />
-                  ) : (
-                    <NavigationContainer />
-                  )}
-                </SafeAreaProvider>
-              </GestureHandlerRootView>
-            </RealmProvider>
+            <GestureHandlerRootView style={appStyles.gestureHandler}>
+              <SafeAreaProvider>
+                <StatusBar
+                  barStyle={isDarkMode ? 'light-content' : 'dark-content'}
+                  backgroundColor={theme.colors.background}
+                />
+                {showWelcome ? (
+                  <Welcome onWelcomeComplete={() => setShowWelcome(false)} />
+                ) : (
+                  <NavigationContainer />
+                )}
+              </SafeAreaProvider>
+            </GestureHandlerRootView>
           </PersistGate>
-        </ReduxProvider>
-      </DimensionsProvider>
-    </PaperProvider>
+        </PaperProvider>
+      </RealmProvider>
+    </ReduxProvider>
   );
 };
 

src/components/floatingActionButton.tsx

@@ -3,8 +3,8 @@ import { Keyboard, StyleSheet } from 'react-native';
 import { FAB } from 'react-native-paper';
 import { ParamListBase, useNavigation } from '@react-navigation/native';
 import { NativeStackNavigationProp } from '@react-navigation/native-stack';
-import { pickSingle } from 'react-native-document-picker';
-import { ORIENTATION, useDimensions } from '../contexts';
+import { pick } from 'react-native-document-picker';
+import { useDeviceOrientation } from '@react-native-community/hooks';
 import { ROUTE } from '../types';
 import { allowedMimeTypes, noOp } from '../utilities';
 
@@ -22,7 +22,7 @@ const floatingActionButtonStyles = StyleSheet.create({
 const FloatingActionButton = ({ visible = true }: { visible?: boolean }) => {
   const { navigate } =
     useNavigation<NativeStackNavigationProp<ParamListBase>>();
-  const { orientation } = useDimensions();
+  const orientation = useDeviceOrientation();
 
   const [state, setState] = useState(false);
   const [keyboardOpen, setKeyboardOpen] = useState(false);
@@ -65,12 +65,15 @@ const FloatingActionButton = ({ visible = true }: { visible?: boolean }) => {
       onStateChange={({ open }) => setState(open)}
       onPress={async () => {
         if (!state) return;
-        const file = await pickSingle({ type: allowedMimeTypes }).catch(noOp);
-        if (!file) return;
-        navigate(ROUTE.ADD_MEME, { file });
+        const files = await pick({
+          type: allowedMimeTypes,
+          allowMultiSelection: true,
+        }).catch(noOp);
+        if (!files) return;
+        navigate(ROUTE.ADD_MEME, { files });
       }}
       style={
-        orientation === ORIENTATION.PORTRAIT
+        orientation === 'portrait'
           ? floatingActionButtonStyles.fab
           : floatingActionButtonStyles.fabLandscape
       }

src/components/hideableHeader.tsx

@@ -1,8 +1,7 @@
 import React, { useEffect, useRef } from 'react';
 import { Animated, StyleSheet } from 'react-native';
-import { ORIENTATION, useDimensions } from '../contexts';
-import styles from '../styles';
 import { useTheme } from 'react-native-paper';
+import { useDeviceOrientation } from '@react-native-community/hooks';
 
 const hideableHeaderStyles = StyleSheet.create({
   headerView: {
@@ -11,6 +10,13 @@ const hideableHeaderStyles = StyleSheet.create({
     left: 0,
     right: 0,
     zIndex: 1,
+    paddingHorizontal: '4%',
+  },
+  headerViewPortrait: {
+    paddingTop: '4%',
+  },
+  headerViewLandscape: {
+    paddingTop: '2%',
   },
 });
 
@@ -22,7 +28,7 @@ const HideableHeader = ({
   children: React.ReactNode;
 }) => {
   const { colors } = useTheme();
-  const { orientation } = useDimensions();
+  const orientation = useDeviceOrientation();
 
   const headerAnim = useRef(new Animated.Value(visible ? 1 : 0)).current;
 
@@ -38,10 +44,9 @@ const HideableHeader = ({
     <Animated.View
       style={[
         hideableHeaderStyles.headerView,
-        orientation === ORIENTATION.PORTRAIT
-          ? styles.paddingTop
-          : styles.smallPaddingTop,
-        styles.paddingHorizontal,
+        orientation === 'portrait'
+          ? hideableHeaderStyles.headerViewPortrait
+          : hideableHeaderStyles.headerViewLandscape,
         {
           transform: [
             {

src/components/index.ts

@@ -2,7 +2,6 @@ export {
   MemesList,
   MemeEditor,
   MemesHeader,
-  MemeTagSearchModal,
   MemeTagSelector,
   MemeViewItem,
 } from './memes';
@@ -11,3 +10,4 @@ export { default as FloatingActionButton } from './floatingActionButton';
 export { default as HideableBottomNavigationBar } from './hideableBottomNavigationBar';
 export { default as HideableHeader } from './hideableHeader';
 export { default as LoadingView } from './loadingView';
+export { default as storageLocationChangeDialog } from './storageLocationChangeDialog';

src/components/loadingView.tsx

@@ -1,19 +1,21 @@
 import React from 'react';
-import { ActivityIndicator, View } from 'react-native';
+import { ActivityIndicator, StyleSheet, View } from 'react-native';
 import { useTheme } from 'react-native-paper';
-import styles from '../styles';
+
+const loadingViewStyles = StyleSheet.create({
+  view: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    flex: 1,
+  },
+});
 
 const LoadingView = () => {
   const { colors } = useTheme();
 
   return (
     <View
-      style={[
-        styles.centered,
-        styles.flex,
-        styles.fullSize,
-        { backgroundColor: colors.background },
-      ]}>
+      style={[loadingViewStyles.view, { backgroundColor: colors.background }]}>
       <ActivityIndicator size="large" color={colors.primary} />
     </View>
   );

src/components/memes/index.ts

@@ -1,6 +1,6 @@
 export { default as MemesList } from './memesList/memesList';
 export { default as MemeEditor } from './memeEditor';
+export { default as MemeFail } from './memeFail';
 export { default as MemesHeader } from './memesHeader';
-export { default as MemeTagSearchModal } from './memeTagSearchModal';
-export { default as MemeTagSelector } from './memeTagSelector';
+export { default as MemeTagSelector } from './memeTagSelector/memeTagSelector';
 export { default as MemeViewItem } from './memeViewItem';

src/components/memes/memeEditor.tsx

@@ -1,9 +1,10 @@
-import React, { useEffect, useState } from 'react';
-import { HelperText, TextInput } from 'react-native-paper';
+import React, { useEffect } from 'react';
+import { HelperText, Text, TextInput, useTheme } from 'react-native-paper';
 import { Image } from 'react-native';
-import { useDimensions } from '../../contexts';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { useImageDimensions } from '@react-native-community/hooks/lib/useImageDimensions';
 import LoadingView from '../loadingView';
-import { MemeTagSelector } from '.';
+import { MemeFail, MemeTagSelector } from '.';
 import { Tag } from '../../database';
 import { StringValidationResult, validateMemeTitle } from '../../utilities';
 
@@ -12,6 +13,10 @@ const memeEditorStyles = {
     marginBottom: 15,
     borderRadius: 5,
   },
+  uri: {
+    marginBottom: 15,
+    marginHorizontal: 5,
+  },
   memeTagSelector: {
     marginBottom: 10,
   },
@@ -22,41 +27,30 @@ const memeEditorStyles = {
 
 const MemeEditor = ({
   memeUri,
+  memeFilename,
+  memeError,
+  setMemeError,
   memeTitle,
   setMemeTitle,
   memeTags,
   setMemeTags,
 }: {
   memeUri: string;
+  memeFilename?: string;
+  memeError: Error | undefined;
+  setMemeError: (error: Error | undefined) => void;
   memeTitle: StringValidationResult;
   setMemeTitle: (name: StringValidationResult) => void;
   memeTags: Map<string, Tag>;
   setMemeTags: (tags: Map<string, Tag>) => void;
 }) => {
-  const { dimensions } = useDimensions();
+  const { width } = useSafeAreaFrame();
+  const { colors } = useTheme();
 
-  const [imageWidth, setImageWidth] = useState<number>();
-  const [imageHeight, setImageHeight] = useState<number>();
+  const { dimensions, loading, error } = useImageDimensions({ uri: memeUri });
+  useEffect(() => setMemeError(error), [error, setMemeError]);
 
-  useEffect(() => {
-    // eslint-disable-next-line unicorn/no-useless-undefined
-    setImageWidth(undefined);
-    // eslint-disable-next-line unicorn/no-useless-undefined
-    setImageHeight(undefined);
-
-    Image.getSize(memeUri, (width, height) => {
-      const paddedWidth = dimensions.width * 0.92;
-      const paddedHeight = Math.max(
-        Math.min((paddedWidth / width) * height, 500),
-        100,
-      );
-
-      setImageWidth(paddedWidth);
-      setImageHeight(paddedHeight);
-    });
-  }, [memeUri, dimensions.width]);
-
-  if (!imageWidth || !imageHeight) return <LoadingView />;
+  if (!memeError && (loading || !dimensions)) return <LoadingView />;
 
   return (
     <>
@@ -71,17 +65,42 @@ const MemeEditor = ({
       <HelperText type="error" visible={!memeTitle.valid}>
         {memeTitle.error}
       </HelperText>
-      <Image
-        source={{ uri: memeUri }}
-        style={[
-          {
-            width: imageWidth,
-            height: imageHeight,
-          },
-          memeEditorStyles.image,
-        ]}
-        resizeMode="contain"
-      />
+      {memeError || !dimensions ? (
+        <MemeFail
+          style={[
+            {
+              width: width * 0.92,
+              height: width * 0.92,
+            },
+            memeEditorStyles.image,
+          ]}
+          iconSize={50}
+        />
+      ) : (
+        <Image
+          source={{ uri: memeUri }}
+          style={[
+            {
+              width: width * 0.92,
+              height: Math.max(
+                Math.min(
+                  ((width * 0.92) / dimensions.width) * dimensions.height,
+                  500,
+                ),
+                100,
+              ),
+            },
+            memeEditorStyles.image,
+          ]}
+          resizeMode="contain"
+        />
+      )}
+      <Text
+        variant="bodySmall"
+        style={[memeEditorStyles.uri, { color: colors.onSurfaceDisabled }]}
+        numberOfLines={1}>
+        {memeFilename}
+      </Text>
       <MemeTagSelector
         memeTags={memeTags}
         setMemeTags={setMemeTags}

src/components/memes/memeFail.tsx

@@ -0,0 +1,41 @@
+import React, { ComponentProps } from 'react';
+import { StyleSheet, View } from 'react-native';
+import { useTheme } from 'react-native-paper';
+import FontAwesome5 from 'react-native-vector-icons/FontAwesome5';
+import { rgbToRgba } from '../../utilities';
+
+const memeFailStyles = StyleSheet.create({
+  view: {
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+});
+
+const MemeFail = ({
+  iconSize,
+  ...props
+}: {
+  iconSize?: number;
+} & ComponentProps<typeof View>) => {
+  const { colors } = useTheme();
+
+  return (
+    <View
+      {...props}
+      style={[
+        props.style,
+        memeFailStyles.view,
+        {
+          backgroundColor: rgbToRgba(colors.error, 0.2),
+        },
+      ]}>
+      <FontAwesome5
+        name="exclamation-triangle"
+        size={iconSize}
+        color={colors.error}
+      />
+    </View>
+  );
+};
+
+export default MemeFail;

src/components/memes/memeTagSelector/memeTagSearchModal.tsx

@@ -1,13 +1,13 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { TagChip } from '../tags';
-import { Tag } from '../../database';
+import React, { useRef, useState } from 'react';
 import { useQuery, useRealm } from '@realm/react';
-import { TAG_SORT, tagSortQuery } from '../../types';
 import { Chip, Modal, Portal, Searchbar, useTheme } from 'react-native-paper';
-import { StyleSheet } from 'react-native';
-import styles from '../../styles';
+import { LayoutAnimation, StyleSheet } from 'react-native';
 import { FlashList } from '@shopify/flash-list';
-import { validateTagName } from '../../utilities';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { TAG_SORT, tagSortQuery } from '../../../types';
+import { TagChip } from '../../tags';
+import { Tag } from '../../../database';
+import { validateTagName } from '../../../utilities';
 
 const memeTagSearchModalStyles = StyleSheet.create({
   modal: {
@@ -16,6 +16,7 @@ const memeTagSearchModalStyles = StyleSheet.create({
     padding: 10,
     borderTopLeftRadius: 20,
     borderTopRightRadius: 20,
+    width: '100%',
   },
   searchbar: {
     marginBottom: 12,
@@ -25,6 +26,22 @@ const memeTagSearchModalStyles = StyleSheet.create({
   },
 });
 
+const tagLayoutAnimation = {
+  duration: 150,
+  create: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+  update: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+  delete: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+};
+
 const MemeTagSearchModal = ({
   visible,
   setVisible,
@@ -36,6 +53,7 @@ const MemeTagSearchModal = ({
   memeTags: Map<string, Tag>;
   setMemeTags: (tags: Map<string, Tag>) => void;
 }) => {
+  const { width } = useSafeAreaFrame();
   const { colors } = useTheme();
   const realm = useRealm();
 
@@ -44,13 +62,10 @@ const MemeTagSearchModal = ({
   const [search, setSearch] = useState('');
   const [tagName, setTagName] = useState(validateTagName(search));
 
-  useEffect(() => {
-    setTagName(validateTagName(search));
-  }, [search]);
-
   const handleSearch = (newSearch: string) => {
     flashListRef.current?.scrollToOffset({ offset: 0 });
     setSearch(newSearch);
+    setTagName(validateTagName(newSearch));
   };
 
   const tags = useQuery<Tag>(
@@ -76,6 +91,8 @@ const MemeTagSearchModal = ({
     const id = tag.id.toHexString();
     memeTags.delete(id) || memeTags.set(id, tag);
     setMemeTags(new Map(memeTags));
+    flashListRef.current?.prepareForLayoutAnimationRender();
+    LayoutAnimation.configureNext(tagLayoutAnimation);
   };
 
   const handleCreateTag = (name: string) => {
@@ -88,6 +105,8 @@ const MemeTagSearchModal = ({
     if (!tag) return;
     memeTags.set(tag.id.toHexString(), tag);
     setMemeTags(new Map(memeTags));
+    flashListRef.current?.prepareForLayoutAnimationRender();
+    LayoutAnimation.configureNext(tagLayoutAnimation);
   };
 
   return (
@@ -95,11 +114,10 @@ const MemeTagSearchModal = ({
       <Modal
         visible={visible}
         contentContainerStyle={[
+          memeTagSearchModalStyles.modal,
           {
             backgroundColor: colors.surface,
           },
-          styles.fullWidth,
-          memeTagSearchModalStyles.modal,
         ]}
         onDismiss={() => setVisible(false)}>
         <Searchbar
@@ -113,8 +131,13 @@ const MemeTagSearchModal = ({
           ref={flashListRef}
           data={tags}
           extraData={memeTags}
+          keyExtractor={tag => tag.id.toHexString()}
           horizontal
           estimatedItemSize={120}
+          estimatedListSize={{
+            width: width - 10,
+            height: 34.5,
+          }}
           showsHorizontalScrollIndicator={false}
           keyboardShouldPersistTaps={'always'}
           renderItem={({ item: tag }) => (
@@ -135,6 +158,7 @@ const MemeTagSearchModal = ({
               Create Tag #{tagName.valid ? tagName.parsed : 'newTag'}
             </Chip>
           )}
+          fadingEdgeLength={50}
         />
       </Modal>
     </Portal>

src/components/memes/memeTagSelector/memeTagSelector.tsx

@@ -1,11 +1,11 @@
-import React, { ComponentProps, useState } from 'react';
-import { StyleSheet, View } from 'react-native';
+import React, { ComponentProps, useRef, useState } from 'react';
+import { LayoutAnimation, StyleSheet, View } from 'react-native';
 import { Chip } from 'react-native-paper';
-import { TagChip } from '../tags';
-import { Tag } from '../../database';
-import { useDimensions } from '../../contexts';
-import { MemeTagSearchModal } from '.';
 import { FlashList } from '@shopify/flash-list';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { TagChip } from '../../tags';
+import { Tag } from '../../../database';
+import MemeTagSearchModal from './memeTagSearchModal';
 
 const memeTagSelectorStyles = StyleSheet.create({
   tagChip: {
@@ -13,6 +13,22 @@ const memeTagSelectorStyles = StyleSheet.create({
   },
 });
 
+const tagLayoutAnimation = {
+  duration: 150,
+  create: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+  update: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+  delete: {
+    type: LayoutAnimation.Types.easeInEaseOut,
+    property: LayoutAnimation.Properties.opacity,
+  },
+};
+
 const MemeTagSelector = ({
   memeTags,
   setMemeTags,
@@ -21,23 +37,28 @@ const MemeTagSelector = ({
   memeTags: Map<string, Tag>;
   setMemeTags: (tags: Map<string, Tag>) => void;
 } & ComponentProps<typeof View>) => {
-  const { dimensions } = useDimensions();
+  const { width } = useSafeAreaFrame();
+
+  const flashListRef = useRef<FlashList<Tag>>(null);
 
   const [flashListMargin, setFlashListMargin] = useState(0);
   const [tagSearchModalVisible, setTagSearchModalVisible] = useState(false);
 
   const handleTagPress = (tag: Tag) => {
     const id = tag.id.toHexString();
-    memeTags.delete(id) || memeTags.set(id, tag);
+    memeTags.delete(id);
     setMemeTags(new Map(memeTags));
+    flashListRef.current?.prepareForLayoutAnimationRender();
+    LayoutAnimation.configureNext(tagLayoutAnimation);
   };
 
   return (
     <>
       <View {...props}>
         <FlashList
+          ref={flashListRef}
           data={[...memeTags.values()]}
-          extraData={memeTags}
+          keyExtractor={tag => tag.id.toHexString()}
           horizontal
           estimatedItemSize={120}
           showsHorizontalScrollIndicator={false}
@@ -55,7 +76,7 @@ const MemeTagSelector = ({
               onPress={() => setTagSearchModalVisible(true)}
               onLayout={event =>
                 setFlashListMargin(
-                  dimensions.width * 0.92 - event.nativeEvent.layout.width,
+                  width * 0.92 - event.nativeEvent.layout.width,
                 )
               }
               style={{
@@ -64,6 +85,7 @@ const MemeTagSelector = ({
               Add Tag
             </Chip>
           )}
+          fadingEdgeLength={50}
         />
       </View>
       <MemeTagSearchModal

src/components/memes/memeViewItem.tsx

@@ -1,50 +1,68 @@
-import React, { useEffect, useState } from 'react';
-import { ActivityIndicator, useTheme } from 'react-native-paper';
+import React from 'react';
 import { ImageZoom } from '@likashefqet/react-native-image-zoom';
+import { StyleSheet, View } from 'react-native';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { useImageDimensions } from '@react-native-community/hooks';
+import { AndroidScoped } from 'react-native-file-access';
+import LoadingView from '../loadingView';
 import { Meme } from '../../database';
-import { useDimensions } from '../../contexts';
-import { Image, View } from 'react-native';
-import styles from '../../styles';
+import MemeFail from './memeFail';
+import { useSelector } from 'react-redux';
+import { RootState } from '../../state';
+
+const memeViewItemStyles = StyleSheet.create({
+  view: {
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+});
 
 const MemeViewItem = ({ meme }: { meme: Meme }) => {
-  const { dimensions } = useDimensions();
-  const { colors } = useTheme();
+  const { height, width } = useSafeAreaFrame();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
 
-  const [imageWidth, setImageWidth] = useState<number>();
-  const [imageHeight, setImageHeight] = useState<number>();
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
 
-  useEffect(() => {
-    Image.getSize(meme.uri, (width, height) => {
-      const ratio = width / height;
-      const screenRatio = dimensions.width / dimensions.height - 160;
+  const { dimensions, loading, error } = useImageDimensions({ uri });
 
-      if (ratio > screenRatio) {
-        setImageWidth(dimensions.width);
-        setImageHeight(dimensions.width / ratio);
-      } else {
-        setImageWidth(dimensions.height * ratio);
-        setImageHeight(dimensions.height);
-      }
-    });
-  }, [meme.uri, dimensions.width, dimensions.height]);
+  if (!error && (loading || !dimensions)) {
+    return (
+      <View style={{ width, height }}>
+        <LoadingView />
+      </View>
+    );
+  }
 
   return (
-    <View
-      style={[
-        {
-          width: dimensions.width,
-          height: dimensions.height - 160,
-          backgroundColor: colors.background,
-        },
-        styles.centered,
-      ]}>
-      {imageWidth && imageHeight ? (
-        <ImageZoom
-          source={{ uri: meme.uri }}
-          style={{ width: imageWidth, height: imageHeight }}
+    <View style={[{ width, height }, memeViewItemStyles.view]}>
+      {error || !dimensions ? (
+        <MemeFail
+          style={{
+            width: Math.min(width, height - 128),
+            height: Math.min(width, height - 128),
+          }}
+          iconSize={50}
         />
       ) : (
-        <ActivityIndicator size="large" color={colors.primary} />
+        <ImageZoom
+          source={{ uri }}
+          style={
+            dimensions.aspectRatio > width / (height - 128)
+              ? {
+                  width,
+                  height: width / (dimensions.width / dimensions.height),
+                }
+              : {
+                  width:
+                    (height - 128) * (dimensions.width / dimensions.height),
+                  height: height - 128,
+                }
+          }
+          minScale={0.5}
+        />
       )}
     </View>
   );

src/components/memes/memesHeader.tsx

@@ -19,14 +19,23 @@ import {
   toggleMemesFavoritesOnly,
   toggleMemesSortDirection,
 } from '../../state';
-import styles from '../../styles';
 import { MEME_SORT, SORT_DIRECTION } from '../../types';
 import { getSortIcon, getViewIcon } from '../../utilities';
 
 const memesHeaderStyles = StyleSheet.create({
   buttonView: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
     height: 50,
   },
+  buttonSection: {
+    flexDirection: 'row',
+    alignItems: 'center',
+  },
+  sortButton: {
+    flexDirection: 'row-reverse',
+  },
 });
 
 const MemesHeader = ({
@@ -78,13 +87,8 @@ const MemesHeader = ({
         value={search}
         onChangeText={setSearch}
       />
-      <View
-        style={[
-          styles.flexRowSpaceBetween,
-          styles.alignCenter,
-          memesHeaderStyles.buttonView,
-        ]}>
-        <View style={[styles.flexRow, styles.alignCenter]}>
+      <View style={memesHeaderStyles.buttonView}>
+        <View style={memesHeaderStyles.buttonSection}>
           <Menu
             visible={sortMenuVisible}
             onDismiss={() => setSortMenuVisible(false)}
@@ -92,7 +96,7 @@ const MemesHeader = ({
               <Button
                 onPress={() => setSortMenuVisible(true)}
                 icon={getSortIcon(sort, sortDirection)}
-                contentStyle={styles.flexRowReverse}
+                contentStyle={memesHeaderStyles.sortButton}
                 compact>
                 Sort By: {sort}
               </Button>
@@ -112,7 +116,7 @@ const MemesHeader = ({
             })}
           </Menu>
         </View>
-        <View style={[styles.flexRow, styles.alignCenter]}>
+        <View style={memesHeaderStyles.buttonSection}>
           <IconButton
             icon={getViewIcon(view)}
             iconColor={colors.primary}

src/components/memes/memesList/memesGridItem.tsx

@@ -1,9 +1,13 @@
-import React, { useState } from 'react';
-import { Image, TouchableHighlight, View } from 'react-native';
+import React from 'react';
+import { Image, TouchableHighlight } from 'react-native';
 import { useSelector } from 'react-redux';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { useImageDimensions } from '@react-native-community/hooks';
+import { AndroidScoped } from 'react-native-file-access';
 import { Meme } from '../../../database';
-import { useDimensions } from '../../../contexts';
 import { RootState } from '../../../state';
+import { MemeFail } from '..';
+import { getFontAwesome5IconSize } from '../../../utilities';
 
 const MemesGridItem = ({
   meme,
@@ -14,33 +18,43 @@ const MemesGridItem = ({
   index: number;
   focusMeme: (index: number) => void;
 }) => {
-  const { dimensions } = useDimensions();
+  const { width } = useSafeAreaFrame();
   const gridColumns = useSelector(
     (state: RootState) => state.settings.gridColumns,
   );
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
 
-  const [imageWidth, setImageWidth] = useState<number>();
-  const [imageHeight, setImageHeight] = useState<number>();
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
 
-  Image.getSize(meme.uri, () => {
-    const paddedWidth = (dimensions.width * 0.92 - 5) / gridColumns;
-    setImageWidth(paddedWidth);
-    setImageHeight(paddedWidth);
-  });
+  const { dimensions, loading, error } = useImageDimensions({ uri });
+
+  if (!error && (loading || !dimensions)) return <></>;
 
   return (
-    <>
-      {imageWidth && imageHeight && (
-        <View>
-          <TouchableHighlight onPress={() => focusMeme(index)}>
-            <Image
-              source={{ uri: meme.uri }}
-              style={[{ width: imageWidth, height: imageHeight }]}
-            />
-          </TouchableHighlight>
-        </View>
+    <TouchableHighlight onPress={() => focusMeme(index)}>
+      {error ? (
+        <MemeFail
+          style={{
+            width: (width * 0.92 - 5) / gridColumns,
+            height: (width * 0.92 - 5) / gridColumns,
+          }}
+          iconSize={getFontAwesome5IconSize(gridColumns)}
+        />
+      ) : (
+        <Image
+          source={{ uri }}
+          style={[
+            {
+              width: (width * 0.92 - 5) / gridColumns,
+              height: (width * 0.92 - 5) / gridColumns,
+            },
+          ]}
+        />
       )}
-    </>
+    </TouchableHighlight>
   );
 };
 

src/components/memes/memesList/memesList.tsx

@@ -7,45 +7,42 @@ import {
 } from 'react-native';
 import { useSelector } from 'react-redux';
 import { Divider, HelperText } from 'react-native-paper';
-import { useDimensions, ORIENTATION } from '../../../contexts';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
 import { Meme } from '../../../database';
 import { RootState } from '../../../state';
 import { VIEW } from '../../../types';
 import { getFlashListItemHeight } from '../../../utilities';
-import styles from '../../../styles';
 import MemesMasonryItem from './memesMasonryItem';
 import MemesGridItem from './memesGridItem';
 import MemesListItem from './memesListItem';
 
-const memesMasonryListStyles = StyleSheet.create({
+const sharedMemesListStyles = StyleSheet.create({
   flashList: {
     paddingBottom: 100,
-    // Needed to prevent fucky MasonryFlashList, see https://github.com/Shopify/flash-list/issues/876
-    paddingHorizontal: 0.1,
   },
   helperText: {
+    textAlign: 'center',
     marginVertical: 15,
   },
 });
 
+const memesMasonryListStyles = StyleSheet.create({
+  flashList: {
+    // Needed to prevent fucky MasonryFlashList, see https://github.com/Shopify/flash-list/issues/876
+    paddingHorizontal: 0.1,
+  },
+});
+
 const memesGridListStyles = StyleSheet.create({
   flashList: {
-    paddingBottom: 100,
     paddingHorizontal: 2.5,
   },
-  helperText: {
-    marginVertical: 12.5,
-  },
 });
 
 const memesListListStyles = StyleSheet.create({
   flashList: {
-    paddingBottom: 100,
     paddingHorizontal: 5,
   },
-  helperText: {
-    marginVertical: 15,
-  },
 });
 
 const MemesList = ({
@@ -61,7 +58,7 @@ const MemesList = ({
   handleScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
   focusMeme: (index: number) => void;
 }) => {
-  const { dimensions, orientation } = useDimensions();
+  const { height, width } = useSafeAreaFrame();
   const view = useSelector((state: RootState) => state.memes.view);
   const masonryColumns = useSelector(
     (state: RootState) => state.settings.masonryColumns,
@@ -70,10 +67,6 @@ const MemesList = ({
     (state: RootState) => state.settings.gridColumns,
   );
 
-  const extraFlashListPadding =
-    flashListPadding +
-    dimensions.height * (orientation === ORIENTATION.PORTRAIT ? 0.02 : 0.04);
-
   return (
     <>
       {view === VIEW.MASONRY && (
@@ -82,8 +75,8 @@ const MemesList = ({
           data={memes}
           estimatedItemSize={getFlashListItemHeight(masonryColumns)}
           estimatedListSize={{
-            height: dimensions.height,
-            width: dimensions.width * 0.92,
+            height,
+            width: width * 0.92,
           }}
           numColumns={masonryColumns}
           showsVerticalScrollIndicator={false}
@@ -91,17 +84,17 @@ const MemesList = ({
             <MemesMasonryItem meme={meme} index={index} focusMeme={focusMeme} />
           )}
           contentContainerStyle={{
-            paddingTop: extraFlashListPadding,
+            paddingTop: flashListPadding,
+            ...sharedMemesListStyles.flashList,
             ...memesMasonryListStyles.flashList,
           }}
           ListEmptyComponent={() => (
-            <HelperText
-              type={'info'}
-              style={[memesMasonryListStyles.helperText, styles.centerText]}>
+            <HelperText type={'info'} style={sharedMemesListStyles.helperText}>
               No memes found
             </HelperText>
           )}
           onScroll={handleScroll}
+          fadingEdgeLength={100}
         />
       )}
       {view === VIEW.GRID && (
@@ -110,8 +103,8 @@ const MemesList = ({
           data={memes}
           estimatedItemSize={getFlashListItemHeight(gridColumns)}
           estimatedListSize={{
-            height: dimensions.height,
-            width: dimensions.width * 0.92,
+            height: height,
+            width: width * 0.92,
           }}
           numColumns={gridColumns}
           showsVerticalScrollIndicator={false}
@@ -119,17 +112,17 @@ const MemesList = ({
             <MemesGridItem meme={meme} index={index} focusMeme={focusMeme} />
           )}
           contentContainerStyle={{
-            paddingTop: extraFlashListPadding + 2.5,
+            paddingTop: flashListPadding,
+            ...sharedMemesListStyles.flashList,
             ...memesGridListStyles.flashList,
           }}
           ListEmptyComponent={() => (
-            <HelperText
-              type={'info'}
-              style={[memesGridListStyles.helperText, styles.centerText]}>
+            <HelperText type={'info'} style={sharedMemesListStyles.helperText}>
               No memes found
             </HelperText>
           )}
           onScroll={handleScroll}
+          fadingEdgeLength={100}
         />
       )}
       {view === VIEW.LIST && (
@@ -138,8 +131,8 @@ const MemesList = ({
           data={memes}
           estimatedItemSize={50}
           estimatedListSize={{
-            height: dimensions.height,
-            width: dimensions.width * 0.92,
+            height: height,
+            width: width * 0.92,
           }}
           showsVerticalScrollIndicator={false}
           renderItem={({ item: meme, index }) => (
@@ -147,17 +140,17 @@ const MemesList = ({
           )}
           ItemSeparatorComponent={() => <Divider />}
           contentContainerStyle={{
-            paddingTop: extraFlashListPadding,
+            paddingTop: flashListPadding,
+            ...sharedMemesListStyles.flashList,
             ...memesListListStyles.flashList,
           }}
           ListEmptyComponent={() => (
-            <HelperText
-              type={'info'}
-              style={[memesListListStyles.helperText, styles.centerText]}>
+            <HelperText type={'info'} style={sharedMemesListStyles.helperText}>
               No memes found
             </HelperText>
           )}
           onScroll={handleScroll}
+          fadingEdgeLength={100}
         />
       )}
     </>

src/components/memes/memesList/memesListItem.tsx

@@ -1,24 +1,36 @@
-import React, { useState } from 'react';
+import React from 'react';
 import { Image, StyleSheet, View } from 'react-native';
 import { Text, TouchableRipple } from 'react-native-paper';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { useImageDimensions } from '@react-native-community/hooks';
+import { AndroidScoped } from 'react-native-file-access';
+import { useSelector } from 'react-redux';
 import { Meme } from '../../../database';
-import styles from '../../../styles';
-import { useDimensions } from '../../../contexts';
+import { MemeFail } from '..';
+import { RootState } from '../../../state';
 
 const memesListItemStyles = StyleSheet.create({
   view: {
+    flexDirection: 'row',
     paddingVertical: 10,
   },
   image: {
+    height: 75,
+    width: 75,
     borderRadius: 5,
   },
   detailsView: {
+    flexDirection: 'column',
     marginLeft: 10,
   },
   text: {
     marginRight: 5,
     marginBottom: 5,
   },
+  tagsView: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+  },
 });
 
 const MemesListItem = ({
@@ -30,71 +42,61 @@ const MemesListItem = ({
   index: number;
   focusMeme: (index: number) => void;
 }) => {
-  const { dimensions } = useDimensions();
+  const { width } = useSafeAreaFrame();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
 
-  const [imageWidth, setImageWidth] = useState<number>();
-  const [imageHeight, setImageHeight] = useState<number>();
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
 
-  Image.getSize(meme.uri, () => {
-    const paddedWidth = 75;
-    setImageWidth(paddedWidth);
-    setImageHeight(paddedWidth);
-  });
+  const { dimensions, loading, error } = useImageDimensions({ uri });
+
+  if (!error && (loading || !dimensions)) return <></>;
 
   return (
-    <>
-      {imageWidth && imageHeight && (
-        <TouchableRipple
-          onPress={() => focusMeme(index)}
-          style={[memesListItemStyles.view, styles.flexRow]}>
-          <>
-            <View style={{ width: imageWidth, height: imageHeight }}>
-              <Image
-                source={{ uri: meme.uri }}
+    <TouchableRipple
+      onPress={() => focusMeme(index)}
+      style={memesListItemStyles.view}>
+      <>
+        {error ? (
+          <MemeFail style={memesListItemStyles.image} />
+        ) : (
+          <Image source={{ uri }} style={memesListItemStyles.image} />
+        )}
+        <View
+          style={[
+            memesListItemStyles.detailsView,
+            {
+              width: width * 0.92 - 75 - 10,
+            },
+          ]}>
+          <Text variant="titleMedium" style={memesListItemStyles.text}>
+            {meme.title}
+          </Text>
+          <Text variant="labelSmall" style={memesListItemStyles.text}>
+            {meme.dateModified.toLocaleDateString()} • {meme.size / 1000}
+            KB
+          </Text>
+          <View style={memesListItemStyles.tagsView}>
+            {meme.tags.map(tag => (
+              <Text
+                variant="labelMedium"
+                key={tag.id.toHexString()}
                 style={[
-                  { width: imageWidth, height: imageHeight },
-                  memesListItemStyles.image,
+                  {
+                    color: tag.color,
+                  },
+                  memesListItemStyles.text,
                 ]}
-              />
-            </View>
-            <View
-              style={[
-                memesListItemStyles.detailsView,
-                styles.flexColumn,
-                {
-                  width: dimensions.width * 0.92 - imageWidth - 10,
-                },
-              ]}>
-              <Text variant="titleMedium" style={memesListItemStyles.text}>
-                {meme.title}
+                numberOfLines={1}>
+                #{tag.name}
               </Text>
-              <View style={styles.flexRow}>
-                <Text variant="labelSmall" style={memesListItemStyles.text}>
-                  {meme.dateModified.toLocaleDateString()} • {meme.size / 1000}
-                  KB
-                </Text>
-              </View>
-              <View style={[styles.flexRow, styles.flexWrap]}>
-                {meme.tags.map(tag => (
-                  <Text
-                    variant="labelMedium"
-                    key={tag.id.toHexString()}
-                    style={[
-                      {
-                        color: tag.color,
-                      },
-                      memesListItemStyles.text,
-                    ]}
-                    numberOfLines={1}>
-                    #{tag.name}
-                  </Text>
-                ))}
-              </View>
-            </View>
-          </>
-        </TouchableRipple>
-      )}
-    </>
+            ))}
+          </View>
+        </View>
+      </>
+    </TouchableRipple>
   );
 };
 

src/components/memes/memesList/memesMasonryItem.tsx

@@ -1,9 +1,13 @@
-import React, { useState } from 'react';
+import React from 'react';
 import { Image, StyleSheet, TouchableHighlight } from 'react-native';
 import { useSelector } from 'react-redux';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { AndroidScoped } from 'react-native-file-access';
+import { useImageDimensions } from '@react-native-community/hooks';
 import { Meme } from '../../../database';
-import { useDimensions } from '../../../contexts';
 import { RootState } from '../../../state';
+import { MemeFail } from '..';
+import { getFontAwesome5IconSize } from '../../../utilities';
 
 const memeMasonryItemStyles = StyleSheet.create({
   view: {
@@ -24,36 +28,50 @@ const MemesMasonryItem = ({
   index: number;
   focusMeme: (index: number) => void;
 }) => {
-  const { dimensions } = useDimensions();
+  const { width } = useSafeAreaFrame();
   const masonryColumns = useSelector(
     (state: RootState) => state.settings.masonryColumns,
   );
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
 
-  const [imageWidth, setImageWidth] = useState<number>();
-  const [imageHeight, setImageHeight] = useState<number>();
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
 
-  Image.getSize(meme.uri, (width, height) => {
-    const paddedWidth = (dimensions.width * 0.92) / masonryColumns - 5;
-    setImageWidth(paddedWidth);
-    setImageHeight((paddedWidth / width) * height);
-  });
+  const { dimensions, loading, error } = useImageDimensions({ uri });
+
+  if (!error && (loading || !dimensions)) return <></>;
 
   return (
-    <>
-      {imageWidth && imageHeight && (
-        <TouchableHighlight
-          onPress={() => focusMeme(index)}
-          style={memeMasonryItemStyles.view}>
-          <Image
-            source={{ uri: meme.uri }}
-            style={[
-              memeMasonryItemStyles.image,
-              { width: imageWidth, height: imageHeight },
-            ]}
-          />
-        </TouchableHighlight>
+    <TouchableHighlight
+      onPress={() => focusMeme(index)}
+      style={memeMasonryItemStyles.view}>
+      {error || !dimensions ? (
+        <MemeFail
+          style={[
+            memeMasonryItemStyles.image,
+            {
+              width: (width * 0.92) / masonryColumns - 5,
+              height: (width * 0.92) / masonryColumns - 5,
+            },
+          ]}
+          iconSize={getFontAwesome5IconSize(masonryColumns)}
+        />
+      ) : (
+        <Image
+          source={{ uri }}
+          style={[
+            memeMasonryItemStyles.image,
+            {
+              width: (width * 0.92) / masonryColumns - 5,
+              height:
+                ((width * 0.92) / masonryColumns - 5) / dimensions.aspectRatio,
+            },
+          ]}
+        />
       )}
-    </>
+    </TouchableHighlight>
   );
 };
 

src/components/storageLocationChangeDialog.tsx

@@ -0,0 +1,100 @@
+import React, { useEffect, useState } from 'react';
+import { StyleSheet } from 'react-native';
+import { Dialog, ProgressBar, Text } from 'react-native-paper';
+import { openDocumentTree } from 'react-native-scoped-storage';
+import { useDispatch, useSelector } from 'react-redux';
+import { AndroidScoped, FileSystem } from 'react-native-file-access';
+import { RootState, setStorageUri } from '../state';
+import { clearPermissions, isPermissionForPath, noOp } from '../utilities';
+
+const storageLocationChangeDialogStyles = StyleSheet.create({
+  progressBar: {
+    marginVertical: 15,
+  },
+});
+
+const StorageLocationChangeDialog = ({
+  visible,
+  setVisible,
+  setSnackbarVisible,
+  setSnackbarMessage,
+}: {
+  visible: boolean;
+  setVisible: (visible: boolean) => void;
+  setSnackbarVisible: (visible: boolean) => void;
+  setSnackbarMessage: (message: string) => void;
+}) => {
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
+  const dispatch = useDispatch();
+
+  const [progress, setProgress] = useState(0);
+
+  useEffect(() => {
+    const selectNewStorageUri = async () => {
+      const uri = await openDocumentTree(true).catch(noOp);
+
+      if (!uri) {
+        setVisible(false);
+        return;
+      }
+
+      const newStorageUri = uri.uri;
+
+      if (isPermissionForPath(storageUri, newStorageUri)) {
+        setSnackbarMessage('Folder already selected.');
+        setSnackbarVisible(true);
+        setVisible(false);
+        return;
+      }
+
+      const files = await FileSystem.ls(storageUri);
+      let filesCopied = 0;
+
+      await Promise.all(
+        files.map(async file => {
+          const oldUri = AndroidScoped.appendPath(storageUri, file);
+          const newUri = AndroidScoped.appendPath(newStorageUri, file);
+
+          // You may be wondering, why cp and unlink instead of mv?
+          // That's because Android is a fuck and does not allow moving across different scoped storage paths.
+          await FileSystem.cp(oldUri, newUri).catch(noOp);
+          await FileSystem.unlink(oldUri).catch(noOp);
+
+          filesCopied++;
+          setProgress(filesCopied / files.length);
+        }),
+      );
+
+      await dispatch(setStorageUri(newStorageUri));
+      await clearPermissions([newStorageUri]);
+
+      setVisible(false);
+      setProgress(0);
+    };
+
+    if (visible) void selectNewStorageUri();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [visible]);
+
+  return (
+    <Dialog
+      visible={visible}
+      onDismiss={() => setVisible(false)}
+      dismissable={false}
+      dismissableBackButton={false}>
+      <Dialog.Title>Change Storage Location</Dialog.Title>
+      <Dialog.Content>
+        <Text>Copying files. Do not close the app.</Text>
+        <ProgressBar
+          animatedValue={progress}
+          style={storageLocationChangeDialogStyles.progressBar}
+        />
+      </Dialog.Content>
+    </Dialog>
+  );
+};
+
+export default StorageLocationChangeDialog;

src/components/tags/tagChip.tsx

@@ -14,11 +14,13 @@ const tagChipStyles = StyleSheet.create({
 const TagChip = ({
   tag,
   active = true,
+  elevated = false,
   onPress,
   ...props
 }: {
   tag: Tag;
   active?: boolean;
+  elevated?: boolean;
   onPress?: () => void;
 } & Omit<ComponentProps<typeof Chip>, 'children'>) => {
   const theme = useTheme();
@@ -45,6 +47,7 @@ const TagChip = ({
         );
       }}
       compact
+      elevated={elevated}
       theme={chipTheme}
       mode={active ? 'flat' : 'outlined'}
       style={[tagChipStyles.chip, props.style]}

src/components/tags/tagPreview.tsx

@@ -2,11 +2,14 @@ import React, { useMemo } from 'react';
 import { StyleSheet, View } from 'react-native';
 import FontAwesome5 from 'react-native-vector-icons/FontAwesome5';
 import { Chip, useTheme } from 'react-native-paper';
-import styles from '../../styles';
-import { useDimensions } from '../../contexts';
 import { getContrastColor } from '../../utilities';
 
 const tagPreviewStyles = StyleSheet.create({
+  view: {
+    flexDirection: 'row',
+    justifyContent: 'center',
+    margin: '10%',
+  },
   chip: {
     padding: 5,
   },
@@ -17,7 +20,6 @@ const tagPreviewStyles = StyleSheet.create({
 
 const TagPreview = ({ name, color }: { name: string; color: string }) => {
   const theme = useTheme();
-  const { responsive } = useDimensions();
 
   const chipTheme = useMemo(() => {
     return {
@@ -32,14 +34,7 @@ const TagPreview = ({ name, color }: { name: string; color: string }) => {
   const contrastColor = getContrastColor(color);
 
   return (
-    <View
-      style={[
-        styles.justifyCenter,
-        styles.flexRow,
-        {
-          margin: responsive.verticalScale(50),
-        },
-      ]}>
+    <View style={tagPreviewStyles.view}>
       <Chip
         icon={() => {
           return <FontAwesome5 name="tag" size={14} color={contrastColor} />;

src/components/tags/tagsHeader.tsx

@@ -1,7 +1,6 @@
 import React, { ComponentProps, useState } from 'react';
 import { StyleSheet, View } from 'react-native';
 import { Button, Divider, Menu, Searchbar } from 'react-native-paper';
-import styles from '../../styles';
 import { useDispatch, useSelector } from 'react-redux';
 import {
   RootState,
@@ -14,8 +13,13 @@ import { getSortIcon } from '../../utilities';
 
 const tagsHeaderStyles = StyleSheet.create({
   buttonView: {
+    alignItems: 'center',
+    flexDirection: 'row',
     height: 50,
   },
+  sortButton: {
+    flexDirection: 'row-reverse',
+  },
 });
 
 const TagsHeader = ({
@@ -57,12 +61,7 @@ const TagsHeader = ({
           setSearch(value);
         }}
       />
-      <View
-        style={[
-          styles.flexRow,
-          styles.alignCenter,
-          tagsHeaderStyles.buttonView,
-        ]}>
+      <View style={tagsHeaderStyles.buttonView}>
         <Menu
           visible={sortMenuVisible}
           onDismiss={() => setSortMenuVisible(false)}
@@ -70,7 +69,7 @@ const TagsHeader = ({
             <Button
               onPress={() => setSortMenuVisible(true)}
               icon={getSortIcon(sort, sortDirection)}
-              contentStyle={styles.flexRowReverse}
+              contentStyle={tagsHeaderStyles.sortButton}
               compact>
               Sort By: {sort}
             </Button>

src/contexts/dimensions.tsx

@@ -1,97 +0,0 @@
-import React, {
-  ReactNode,
-  createContext,
-  useContext,
-  useEffect,
-  useMemo,
-  useState,
-} from 'react';
-import { Dimensions, ScaledSize } from 'react-native';
-
-const guidelineBaseWidth = 350;
-const guidelineBaseHeight = 680;
-
-enum ORIENTATION {
-  PORTRAIT = 'portrait',
-  LANDSCAPE = 'landscape',
-}
-
-interface ScaleFunctions {
-  horizontalScale: (size: number) => number;
-  verticalScale: (size: number) => number;
-  moderateHorizontalScale: (size: number, factor?: number) => number;
-  moderateVerticalScale: (size: number, factor?: number) => number;
-}
-
-interface DimensionsContext {
-  orientation: ORIENTATION;
-  dimensions: ScaledSize;
-  responsive: ScaleFunctions;
-}
-
-const createScaleFunctions = (dimensionsIn: ScaledSize) => {
-  const horizontalScale = (size: number) =>
-    (dimensionsIn.width / guidelineBaseWidth) * size;
-  const verticalScale = (size: number) =>
-    (dimensionsIn.height / guidelineBaseHeight) * size;
-  const moderateHorizontalScale = (size: number, factor = 0.5) =>
-    size + (horizontalScale(size) - size) * factor;
-  const moderateVerticalScale = (size: number, factor = 0.5) =>
-    size + (verticalScale(size) - size) * factor;
-
-  return {
-    horizontalScale,
-    verticalScale,
-    moderateHorizontalScale,
-    moderateVerticalScale,
-  };
-};
-
-const DimensionsContext = createContext<DimensionsContext | undefined>(
-  undefined,
-);
-
-const DimensionsProvider = ({ children }: { children: ReactNode }) => {
-  const [dimensions, setDimensions] = useState(Dimensions.get('window'));
-
-  const orientation = useMemo(() => {
-    return dimensions.width > dimensions.height
-      ? ORIENTATION.LANDSCAPE
-      : ORIENTATION.PORTRAIT;
-  }, [dimensions]);
-
-  const responsiveScale = createScaleFunctions(dimensions);
-
-  useEffect(() => {
-    const onChange = ({ window }: { window: ScaledSize }) => {
-      setDimensions(window);
-    };
-
-    const subscription = Dimensions.addEventListener('change', onChange);
-
-    return () => {
-      subscription.remove();
-    };
-  }, []);
-
-  return (
-    <DimensionsContext.Provider
-      value={{
-        orientation,
-        dimensions,
-        responsive: responsiveScale,
-      }}>
-      {children}
-    </DimensionsContext.Provider>
-  );
-};
-
-const useDimensions = (): DimensionsContext => {
-  const context = useContext(DimensionsContext);
-  if (!context) {
-    throw new Error('useDimensions must be used within a DimensionsProvider');
-  }
-  return context;
-};
-
-export { ORIENTATION, DimensionsProvider, useDimensions };

src/contexts/index.ts

@@ -1 +0,0 @@
-export { ORIENTATION, DimensionsProvider, useDimensions } from './dimensions';

src/database/meme.ts

@@ -21,7 +21,7 @@ const memeTypePlural = {
 class Meme extends Object<Meme> {
   id!: BSON.UUID;
   type!: MEME_TYPE;
-  uri!: string;
+  filename!: string;
   mimeType!: string;
   size!: number;
   title!: string;
@@ -39,7 +39,7 @@ class Meme extends Object<Meme> {
     properties: {
       id: { type: 'uuid', default: () => new BSON.UUID() },
       type: { type: 'string', indexed: true },
-      uri: 'string',
+      filename: 'string',
       mimeType: 'string',
       size: 'int',
       title: 'string',

src/screens/addMeme.tsx

@@ -1,165 +0,0 @@
-import React, { useCallback, useRef, useState } from 'react';
-import { Appbar, Button, useTheme } from 'react-native-paper';
-import { useNavigation } from '@react-navigation/native';
-import { ORIENTATION, useDimensions } from '../contexts';
-import { ScrollView, StyleSheet, View } from 'react-native';
-import { NativeStackScreenProps } from '@react-navigation/native-stack';
-import { useRealm } from '@realm/react';
-import { BSON } from 'realm';
-import { AndroidScoped, FileSystem } from 'react-native-file-access';
-import { useSelector } from 'react-redux';
-import { extension } from 'react-native-mime-types';
-import styles from '../styles';
-import { ROUTE, RootStackParamList } from '../types';
-import { Meme, Tag } from '../database';
-import { RootState } from '../state';
-import { allowedMimeTypes, getMemeType, validateMemeTitle } from '../utilities';
-import { MemeEditor } from '../components';
-import {
-  DocumentPickerResponse,
-  pickSingle,
-} from 'react-native-document-picker';
-
-const addMemeStyles = StyleSheet.create({
-  saveAndAddButton: {
-    flex: 1,
-    marginRight: 5,
-  },
-  saveButton: {
-    flex: 1,
-    marginLeft: 5,
-  },
-});
-
-const AddMeme = ({
-  route,
-}: NativeStackScreenProps<RootStackParamList, ROUTE.ADD_MEME>) => {
-  const { goBack } = useNavigation();
-  const { colors } = useTheme();
-  const { orientation } = useDimensions();
-  const realm = useRealm();
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const storageUri = useSelector(
-    (state: RootState) => state.settings.storageUri,
-  )!;
-
-  const file = useRef(route.params.file);
-
-  const [memeUri, setMemeUri] = useState(file.current.uri);
-  const [memeTitle, setMemeTitle] = useState(validateMemeTitle('New Meme'));
-  const [memeIsFavorite, setMemeIsFavorite] = useState(false);
-  const [memeTags, setMemeTags] = useState(new Map<string, Tag>());
-
-  const [isSaving, setIsSaving] = useState(false);
-  const [isSavingAndAddingAnother, setIsSavingAndAddingAnother] =
-    useState(false);
-
-  const handleSave = useCallback(async () => {
-    const uuid = new BSON.UUID();
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const mimeType = file.current.type!;
-    const memeType = getMemeType(mimeType);
-
-    const fileExtension = extension(mimeType) as string;
-    if (!fileExtension) goBack();
-
-    const uri = AndroidScoped.appendPath(
-      storageUri,
-      `${uuid.toHexString()}.${fileExtension}`,
-    );
-
-    await FileSystem.cp(file.current.uri, uri);
-    const { size } = await FileSystem.stat(uri);
-
-    realm.write(() => {
-      const meme: Meme | undefined = realm.create<Meme>(Meme.schema.name, {
-        id: uuid,
-        type: memeType,
-        uri,
-        mimeType,
-        size,
-        title: memeTitle.parsed,
-        isFavorite: memeIsFavorite,
-        tags: [...memeTags.values()],
-        tagsLength: memeTags.size,
-      });
-
-      memeTags.forEach(tag => {
-        tag.dateModified = new Date();
-        tag.memes.push(meme);
-        tag.memesLength = tag.memes.length;
-      });
-    });
-  }, [goBack, memeIsFavorite, memeTags, memeTitle.parsed, realm, storageUri]);
-
-  return (
-    <>
-      <Appbar.Header>
-        <Appbar.BackAction onPress={() => goBack()} />
-        <Appbar.Content title={'Add Meme'} />
-        <Appbar.Action
-          icon={memeIsFavorite ? 'heart' : 'heart-outline'}
-          onPress={() => setMemeIsFavorite(!memeIsFavorite)}
-        />
-      </Appbar.Header>
-      <ScrollView
-        contentContainerStyle={[
-          orientation === ORIENTATION.PORTRAIT
-            ? styles.paddingVertical
-            : styles.smallPaddingVertical,
-          styles.paddingHorizontal,
-          styles.flexGrow,
-          styles.flexColumnSpaceBetween,
-          { backgroundColor: colors.background },
-        ]}>
-        <View style={[styles.flex, styles.justifyStart]}>
-          <MemeEditor
-            memeUri={memeUri}
-            memeTitle={memeTitle}
-            setMemeTitle={setMemeTitle}
-            memeTags={memeTags}
-            setMemeTags={setMemeTags}
-          />
-        </View>
-        <View style={[styles.flexRow, styles.fullWidth]}>
-          <Button
-            mode="contained-tonal"
-            icon="plus"
-            onPress={async () => {
-              setIsSavingAndAddingAnother(true);
-              await handleSave();
-              setIsSavingAndAddingAnother(false);
-              file.current = (await pickSingle({
-                type: allowedMimeTypes,
-              }).catch(goBack)) as DocumentPickerResponse;
-              setMemeUri(file.current.uri);
-              setMemeTitle(validateMemeTitle('New Meme'));
-              setMemeIsFavorite(false);
-              setMemeTags(new Map<string, Tag>());
-            }}
-            disabled={!memeTitle.valid || isSaving || isSavingAndAddingAnother}
-            loading={isSavingAndAddingAnother}
-            style={addMemeStyles.saveAndAddButton}>
-            Save & Add
-          </Button>
-          <Button
-            mode="contained"
-            icon="floppy"
-            onPress={async () => {
-              setIsSaving(true);
-              await handleSave();
-              setIsSaving(false);
-              goBack();
-            }}
-            disabled={!memeTitle.valid || isSaving || isSavingAndAddingAnother}
-            loading={isSaving}
-            style={addMemeStyles.saveButton}>
-            Save
-          </Button>
-        </View>
-      </ScrollView>
-    </>
-  );
-};
-
-export default AddMeme;

src/screens/editMeme.tsx

@@ -1,120 +0,0 @@
-import React, { useCallback, useState } from 'react';
-import { ScrollView, View } from 'react-native';
-import { Appbar, Button, useTheme } from 'react-native-paper';
-import { useNavigation } from '@react-navigation/native';
-import { NativeStackScreenProps } from '@react-navigation/native-stack';
-import { useObject, useRealm } from '@realm/react';
-import { BSON } from 'realm';
-import { ORIENTATION, useDimensions } from '../contexts';
-import styles from '../styles';
-import { RootStackParamList, ROUTE } from '../types';
-import { Tag, Meme } from '../database';
-import { deleteMeme, favoriteMeme, validateMemeTitle } from '../utilities';
-import { MemeEditor } from '../components';
-
-const EditMeme = ({
-  route,
-}: NativeStackScreenProps<RootStackParamList, ROUTE.EDIT_MEME>) => {
-  const { goBack } = useNavigation();
-  const { colors } = useTheme();
-  const { orientation } = useDimensions();
-  const realm = useRealm();
-
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const meme = useObject<Meme>(
-    Meme.schema.name,
-    BSON.UUID.createFromHexString(route.params.id),
-  )!;
-
-  const [memeTitle, setMemeTitle] = useState(validateMemeTitle(meme.title));
-  const [memeTags, setMemeTags] = useState(
-    new Map<string, Tag>(meme.tags.map(tag => [tag.id.toHexString(), tag])),
-  );
-
-  const [isSaving, setIsSaving] = useState(false);
-
-  const handleSave = useCallback(() => {
-    realm.write(() => {
-      meme.tags.forEach(tag => {
-        if (!memeTags.has(tag.id.toHexString())) {
-          tag.memes.slice(tag.memes.indexOf(meme), 1);
-          tag.memesLength -= 1;
-          tag.dateModified = new Date();
-        }
-      });
-
-      memeTags.forEach(tag => {
-        if (!meme.tags.some(memeTag => memeTag.id.equals(tag.id))) {
-          tag.memes.push(meme);
-          tag.memesLength = tag.memes.length;
-          tag.dateModified = new Date();
-        }
-      });
-
-      meme.title = memeTitle.parsed;
-      // @ts-expect-error - Realm is a fuck
-      meme.tags = [...memeTags.values()];
-      meme.tagsLength = memeTags.size;
-      meme.dateModified = new Date();
-    });
-  }, [meme, memeTags, memeTitle.parsed, realm]);
-
-  return (
-    <>
-      <Appbar.Header>
-        <Appbar.BackAction onPress={() => goBack()} />
-        <Appbar.Content title={'Edit Meme'} />
-        <Appbar.Action
-          icon={meme.isFavorite ? 'heart' : 'heart-outline'}
-          onPress={() => favoriteMeme(realm, meme)}
-        />
-        <Appbar.Action
-          icon="delete"
-          onPress={async () => {
-            setIsSaving(true);
-            await deleteMeme(realm, meme);
-            setIsSaving(false);
-            goBack();
-          }}
-        />
-      </Appbar.Header>
-      <ScrollView
-        contentContainerStyle={[
-          orientation === ORIENTATION.PORTRAIT
-            ? styles.paddingVertical
-            : styles.smallPaddingVertical,
-          styles.paddingHorizontal,
-          styles.flexGrow,
-          styles.flexColumnSpaceBetween,
-          { backgroundColor: colors.background },
-        ]}>
-        <View style={[styles.flex, styles.justifyStart]}>
-          <MemeEditor
-            memeUri={meme.uri}
-            memeTitle={memeTitle}
-            setMemeTitle={setMemeTitle}
-            memeTags={memeTags}
-            setMemeTags={setMemeTags}
-          />
-        </View>
-        <View style={[styles.flex, styles.justifyEnd]}>
-          <Button
-            mode="contained"
-            icon="floppy"
-            onPress={() => {
-              setIsSaving(true);
-              handleSave();
-              setIsSaving(false);
-              goBack();
-            }}
-            disabled={!memeTitle.valid || isSaving}
-            loading={isSaving}>
-            Save
-          </Button>
-        </View>
-      </ScrollView>
-    </>
-  );
-};
-
-export default EditMeme;

src/screens/editors/addMeme.tsx

@@ -0,0 +1,210 @@
+import React, { useCallback, useRef, useState } from 'react';
+import { Appbar, Banner, Button, useTheme } from 'react-native-paper';
+import { useNavigation } from '@react-navigation/native';
+import { ScrollView, View } from 'react-native';
+import { NativeStackScreenProps } from '@react-navigation/native-stack';
+import { useRealm } from '@realm/react';
+import { BSON } from 'realm';
+import { AndroidScoped, FileSystem } from 'react-native-file-access';
+import { useSelector } from 'react-redux';
+import { extension } from 'react-native-mime-types';
+import { useDeviceOrientation } from '@react-native-community/hooks';
+import { DocumentPickerResponse, pick } from 'react-native-document-picker';
+import { ROUTE, RootStackParamList } from '../../types';
+import { Meme, Tag } from '../../database';
+import { RootState } from '../../state';
+import {
+  allowedMimeTypes,
+  getMemeType,
+  validateMemeTitle,
+} from '../../utilities';
+import { MemeEditor } from '../../components';
+import editorStyles from './editorStyles';
+
+const AddMeme = ({
+  route,
+}: NativeStackScreenProps<RootStackParamList, ROUTE.ADD_MEME>) => {
+  const { goBack } = useNavigation();
+  const { colors } = useTheme();
+  const orientation = useDeviceOrientation();
+  const realm = useRealm();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
+
+  const [index, setIndex] = useState(0);
+  const files = useRef(route.params.files);
+  const file = useRef(files.current[index]);
+  const isLastFile = index === files.current.length - 1;
+
+  const [memeUri, setMemeUri] = useState(file.current.uri);
+  const [memeFilename, setMemeFilename] = useState(
+    file.current.name ?? undefined,
+  );
+  const [memeError, setMemeError] = useState<Error>();
+  const [memeTitle, setMemeTitle] = useState(validateMemeTitle('New Meme'));
+  const [memeIsFavorite, setMemeIsFavorite] = useState(false);
+  const [memeTags, setMemeTags] = useState(new Map<string, Tag>());
+
+  const [isSaving, setIsSaving] = useState(false);
+  const [isSavingAndAddingMore, setIsSavingAndAddingMore] = useState(false);
+
+  const saveMeme = useCallback(async () => {
+    const uuid = new BSON.UUID();
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const mimeType = file.current.type!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const memeType = getMemeType(mimeType)!;
+
+    const fileExtension = extension(mimeType) as string;
+    if (!fileExtension) goBack();
+
+    const filename = `${uuid.toHexString()}-${Math.round(
+      Date.now() / 1000,
+    )}.${fileExtension}`;
+    const uri = AndroidScoped.appendPath(storageUri, filename);
+
+    await FileSystem.cp(file.current.uri, uri);
+    const { size } = await FileSystem.stat(uri);
+
+    realm.write(() => {
+      const meme: Meme | undefined = realm.create<Meme>(Meme.schema.name, {
+        id: uuid,
+        type: memeType,
+        filename,
+        mimeType,
+        size,
+        title: memeTitle.parsed,
+        isFavorite: memeIsFavorite,
+        tags: [...memeTags.values()],
+        tagsLength: memeTags.size,
+      });
+
+      memeTags.forEach(tag => {
+        tag.dateModified = new Date();
+        tag.memes.push(meme);
+        tag.memesLength = tag.memes.length;
+      });
+    });
+  }, [goBack, memeIsFavorite, memeTags, memeTitle.parsed, realm, storageUri]);
+
+  const handleSave = useCallback(async () => {
+    setIsSaving(true);
+    await saveMeme();
+    setIsSaving(false);
+    goBack();
+  }, [goBack, saveMeme]);
+
+  const handleSaveAndNext = useCallback(async () => {
+    setIsSaving(true);
+    await saveMeme();
+    setIsSaving(false);
+
+    setIndex(index + 1);
+    file.current = files.current[index + 1];
+
+    setMemeUri(file.current.uri);
+    setMemeFilename(file.current.name ?? undefined);
+    setMemeTitle(validateMemeTitle('New Meme'));
+    setMemeIsFavorite(false);
+    setMemeTags(new Map<string, Tag>());
+  }, [index, saveMeme]);
+
+  const handleSaveAndAddMore = useCallback(async () => {
+    setIsSavingAndAddingMore(true);
+    await saveMeme();
+    setIsSavingAndAddingMore(false);
+
+    setIndex(0);
+    files.current = (await pick({
+      type: allowedMimeTypes,
+      allowMultiSelection: true,
+    }).catch(goBack)) as DocumentPickerResponse[];
+    file.current = files.current[0];
+
+    setMemeUri(file.current.uri);
+    setMemeFilename(file.current.name ?? undefined);
+    setMemeTitle(validateMemeTitle('New Meme'));
+    setMemeIsFavorite(false);
+    setMemeTags(new Map<string, Tag>());
+  }, [goBack, saveMeme]);
+
+  return (
+    <>
+      <Appbar.Header>
+        <Appbar.BackAction onPress={() => goBack()} />
+        <Appbar.Content title={'Add Meme'} />
+        <Appbar.Action
+          icon={memeIsFavorite ? 'heart' : 'heart-outline'}
+          onPress={() => setMemeIsFavorite(!memeIsFavorite)}
+        />
+      </Appbar.Header>
+      <Banner
+        visible={!!memeError}
+        actions={[
+          {
+            label: 'Cancel',
+            onPress: goBack,
+          },
+        ]}>
+        The selected URI appears to be broken. This may have been caused by the
+        file being corrupted or unsupported.
+      </Banner>
+      <ScrollView
+        contentContainerStyle={[
+          editorStyles.scrollView,
+          orientation === 'portrait'
+            ? editorStyles.scrollViewPortrait
+            : editorStyles.scrollViewLandscape,
+          { backgroundColor: colors.background },
+        ]}>
+        <View style={editorStyles.editorView}>
+          <MemeEditor
+            memeUri={memeUri}
+            memeFilename={memeFilename}
+            memeError={memeError}
+            setMemeError={setMemeError}
+            memeTitle={memeTitle}
+            setMemeTitle={setMemeTitle}
+            memeTags={memeTags}
+            setMemeTags={setMemeTags}
+          />
+        </View>
+        <View style={editorStyles.saveButtonView}>
+          <Button
+            mode="contained-tonal"
+            icon="plus"
+            onPress={handleSaveAndAddMore}
+            disabled={
+              !memeTitle.valid ||
+              isSaving ||
+              isSavingAndAddingMore ||
+              !!memeError ||
+              !isLastFile
+            }
+            loading={isSavingAndAddingMore}
+            style={editorStyles.saveAndAddButton}>
+            Save & Add More
+          </Button>
+          <Button
+            mode="contained"
+            icon="floppy"
+            onPress={isLastFile ? handleSave : handleSaveAndNext}
+            disabled={
+              !memeTitle.valid ||
+              isSaving ||
+              isSavingAndAddingMore ||
+              !!memeError
+            }
+            loading={isSaving}
+            style={editorStyles.saveButton}>
+            {isLastFile ? 'Save' : 'Save & Next'}
+          </Button>
+        </View>
+      </ScrollView>
+    </>
+  );
+};
+
+export default AddMeme;

src/screens/editors/addTag.tsx

@@ -1,33 +1,22 @@
 import React, { useCallback, useState } from 'react';
-import { ScrollView, StyleSheet, View } from 'react-native';
+import { ScrollView, View } from 'react-native';
 import { Appbar, Button, useTheme } from 'react-native-paper';
 import { useNavigation } from '@react-navigation/native';
 import { useRealm } from '@realm/react';
-import styles from '../styles';
+import { useDeviceOrientation } from '@react-native-community/hooks';
 import {
   generateRandomColor,
   validateColor,
   validateTagName,
-} from '../utilities';
-import { ORIENTATION, useDimensions } from '../contexts';
-import { Tag } from '../database';
-import { TagEditor } from '../components';
-
-const addTagStyles = StyleSheet.create({
-  saveAndAddButton: {
-    flex: 1,
-    marginRight: 5,
-  },
-  saveButton: {
-    flex: 1,
-    marginLeft: 5,
-  },
-});
+} from '../../utilities';
+import { Tag } from '../../database';
+import { TagEditor } from '../../components';
+import editorStyles from './editorStyles';
 
 const AddTag = () => {
   const { goBack } = useNavigation();
   const { colors } = useTheme();
-  const { orientation } = useDimensions();
+  const orientation = useDeviceOrientation();
   const realm = useRealm();
 
   const [tagName, setTagName] = useState(validateTagName('newTag'));
@@ -37,10 +26,9 @@ const AddTag = () => {
 
   // Although saving tags is instantaneous, we still want to show a loading
   // indicator to prevent the user from spamming the save button.
-  const [isSavingAndAddingAnother, setIsSavingAndAddingAnother] =
-    useState(false);
+  const [isSavingAndAddingMore, setIsSavingAndAddingMore] = useState(false);
 
-  const handleSave = useCallback(() => {
+  const saveTag = useCallback(() => {
     realm.write(() => {
       realm.create(Tag.schema.name, {
         name: tagName.parsed,
@@ -49,6 +37,19 @@ const AddTag = () => {
     });
   }, [realm, tagColor.parsed, tagName.parsed]);
 
+  const handleSave = useCallback(() => {
+    saveTag();
+    goBack();
+  }, [goBack, saveTag]);
+
+  const handleSaveAndAddMore = useCallback(() => {
+    setIsSavingAndAddingMore(true);
+    saveTag();
+    setTimeout(() => setIsSavingAndAddingMore(false), 250);
+    setTagName(validateTagName('newTag'));
+    setTagColor(validateColor(generateRandomColor()));
+  }, [saveTag]);
+
   return (
     <>
       <Appbar.Header>
@@ -57,15 +58,13 @@ const AddTag = () => {
       </Appbar.Header>
       <ScrollView
         contentContainerStyle={[
-          orientation === ORIENTATION.PORTRAIT
-            ? styles.paddingVertical
-            : styles.smallPaddingVertical,
-          styles.paddingHorizontal,
-          styles.flexGrow,
-          styles.flexColumnSpaceBetween,
+          editorStyles.scrollView,
+          orientation === 'portrait'
+            ? editorStyles.scrollViewPortrait
+            : editorStyles.scrollViewLandscape,
           { backgroundColor: colors.background },
         ]}>
-        <View style={[styles.flex, styles.justifyStart]}>
+        <View style={editorStyles.editorView}>
           <TagEditor
             tagName={tagName}
             setTagName={setTagName}
@@ -73,31 +72,22 @@ const AddTag = () => {
             setTagColor={setTagColor}
           />
         </View>
-        <View style={[styles.flexRow, styles.fullWidth]}>
+        <View style={editorStyles.saveButtonView}>
           <Button
             mode="contained-tonal"
             icon="plus"
-            onPress={() => {
-              setIsSavingAndAddingAnother(true);
-              handleSave();
-              setTimeout(() => setIsSavingAndAddingAnother(false), 250);
-              setTagName(validateTagName('newTag'));
-              setTagColor(validateColor(generateRandomColor()));
-            }}
-            disabled={!tagName.valid || isSavingAndAddingAnother}
-            loading={isSavingAndAddingAnother}
-            style={addTagStyles.saveAndAddButton}>
+            onPress={handleSaveAndAddMore}
+            disabled={!tagName.valid || isSavingAndAddingMore}
+            loading={isSavingAndAddingMore}
+            style={editorStyles.saveAndAddButton}>
             Save & Add
           </Button>
           <Button
             mode="contained"
             icon="floppy"
-            onPress={() => {
-              handleSave();
-              goBack();
-            }}
-            disabled={!tagName.valid || isSavingAndAddingAnother}
-            style={addTagStyles.saveButton}>
+            onPress={handleSave}
+            disabled={!tagName.valid || isSavingAndAddingMore}
+            style={editorStyles.saveButton}>
             Save
           </Button>
         </View>

src/screens/editors/editMeme.tsx

@@ -0,0 +1,197 @@
+import React, { useCallback, useState } from 'react';
+import { ScrollView, View } from 'react-native';
+import { Appbar, Banner, Button, useTheme } from 'react-native-paper';
+import { useNavigation } from '@react-navigation/native';
+import { NativeStackScreenProps } from '@react-navigation/native-stack';
+import { useObject, useRealm } from '@realm/react';
+import { useDeviceOrientation } from '@react-native-community/hooks';
+import { BSON } from 'realm';
+import { RootStackParamList, ROUTE } from '../../types';
+import { pickSingle } from 'react-native-document-picker';
+import { AndroidScoped, FileSystem } from 'react-native-file-access';
+import { extension } from 'react-native-mime-types';
+import { useSelector } from 'react-redux';
+import { Tag, Meme } from '../../database';
+import {
+  StringValidationResult,
+  allowedMimeTypes,
+  deleteMeme,
+  favoriteMeme,
+  getMemeType,
+  noOp,
+  validateMemeTitle,
+} from '../../utilities';
+import { MemeEditor } from '../../components';
+import editorStyles from './editorStyles';
+import { RootState } from '../../state';
+
+const EditMeme = ({
+  route,
+}: NativeStackScreenProps<RootStackParamList, ROUTE.EDIT_MEME>) => {
+  const { goBack } = useNavigation();
+  const { colors } = useTheme();
+  const orientation = useDeviceOrientation();
+  const realm = useRealm();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
+
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const meme = useObject<Meme>(
+    Meme.schema.name,
+    BSON.UUID.createFromHexString(route.params.id),
+  )!;
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
+
+  const [hasChanges, setHasChanges] = useState(false);
+
+  const [memeError, setMemeError] = useState<Error>();
+  const [memeTitle, setMemeTitle] = useState(validateMemeTitle(meme.title));
+  const [memeTags, setMemeTags] = useState(
+    new Map<string, Tag>(meme.tags.map(tag => [tag.id.toHexString(), tag])),
+  );
+
+  const handleMemeTitleChange = useCallback((title: StringValidationResult) => {
+    setMemeTitle(title);
+    setHasChanges(true);
+  }, []);
+
+  const handleMemeTagsChange = useCallback((tags: Map<string, Tag>) => {
+    setMemeTags(tags);
+    setHasChanges(true);
+  }, []);
+
+  const [isSaving, setIsSaving] = useState(false);
+
+  const handleSave = useCallback(() => {
+    setIsSaving(true);
+
+    realm.write(() => {
+      meme.tags.forEach(tag => {
+        if (!memeTags.has(tag.id.toHexString())) {
+          tag.memes.slice(tag.memes.indexOf(meme), 1);
+          tag.memesLength -= 1;
+          tag.dateModified = new Date();
+        }
+      });
+
+      memeTags.forEach(tag => {
+        if (!meme.tags.some(memeTag => memeTag.id.equals(tag.id))) {
+          tag.memes.push(meme);
+          tag.memesLength = tag.memes.length;
+          tag.dateModified = new Date();
+        }
+      });
+
+      meme.title = memeTitle.parsed;
+      // @ts-expect-error - Realm is a fuck
+      meme.tags = [...memeTags.values()];
+      meme.tagsLength = memeTags.size;
+      meme.dateModified = new Date();
+    });
+
+    setIsSaving(false);
+    goBack();
+  }, [goBack, meme, memeTags, memeTitle.parsed, realm]);
+
+  const handleDelete = useCallback(async () => {
+    setIsSaving(true);
+    await deleteMeme(realm, storageUri, meme);
+    setIsSaving(false);
+    goBack();
+  }, [goBack, meme, realm, storageUri]);
+
+  const handleFixUri = useCallback(async () => {
+    const file = await pickSingle({ type: allowedMimeTypes }).catch(noOp);
+    if (!file) return;
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const mimeType = file.type!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const memeType = getMemeType(mimeType)!;
+
+    const fileExtension = extension(mimeType) as string;
+    if (!fileExtension) return;
+
+    const filename = `${meme.id.toHexString()}-${
+      Date.now() / 1000
+    }.${fileExtension}`;
+    const newUri = AndroidScoped.appendPath(storageUri, filename);
+
+    await FileSystem.cp(file.uri, newUri);
+    const { size } = await FileSystem.stat(newUri);
+
+    realm.write(() => {
+      meme.filename = filename;
+      meme.type = memeType;
+      meme.mimeType = mimeType;
+      meme.size = size;
+    });
+  }, [meme, realm, storageUri]);
+
+  return (
+    <>
+      <Appbar.Header>
+        <Appbar.BackAction onPress={() => goBack()} />
+        <Appbar.Content title={'Edit Meme'} />
+        <Appbar.Action
+          icon={meme.isFavorite ? 'heart' : 'heart-outline'}
+          onPress={() => favoriteMeme(realm, meme)}
+        />
+        <Appbar.Action icon="delete" onPress={handleDelete} />
+      </Appbar.Header>
+      <Banner
+        visible={!!memeError}
+        actions={[
+          {
+            label: 'Fix URI',
+            onPress: handleFixUri,
+          },
+          {
+            label: 'Delete Meme',
+            onPress: handleDelete,
+          },
+        ]}>
+        The URI for this meme appears to be broken. This may have been caused by
+        the file being moved or deleted.
+      </Banner>
+      <ScrollView
+        contentContainerStyle={[
+          editorStyles.scrollView,
+          orientation === 'portrait'
+            ? editorStyles.scrollViewPortrait
+            : editorStyles.scrollViewLandscape,
+          { backgroundColor: colors.background },
+        ]}>
+        <View style={editorStyles.editorView}>
+          <MemeEditor
+            memeUri={uri}
+            memeFilename={meme.filename}
+            memeError={memeError}
+            setMemeError={setMemeError}
+            memeTitle={memeTitle}
+            setMemeTitle={handleMemeTitleChange}
+            memeTags={memeTags}
+            setMemeTags={handleMemeTagsChange}
+          />
+        </View>
+        <View style={editorStyles.saveButtonView}>
+          <Button
+            mode="contained"
+            icon="floppy"
+            onPress={handleSave}
+            disabled={
+              !memeTitle.valid || !hasChanges || isSaving || !!memeError
+            }
+            loading={isSaving}
+            style={editorStyles.soloSaveButton}>
+            Save
+          </Button>
+        </View>
+      </ScrollView>
+    </>
+  );
+};
+
+export default EditMeme;

src/screens/editors/editTag.tsx

@@ -5,19 +5,24 @@ import { useNavigation } from '@react-navigation/native';
 import { NativeStackScreenProps } from '@react-navigation/native-stack';
 import { BSON } from 'realm';
 import { useObject, useRealm } from '@realm/react';
-import { TagEditor } from '../components';
-import styles from '../styles';
-import { ORIENTATION, useDimensions } from '../contexts';
-import { ROUTE, RootStackParamList } from '../types';
-import { Tag } from '../database';
-import { deleteTag, validateColor, validateTagName } from '../utilities';
+import { useDeviceOrientation } from '@react-native-community/hooks';
+import { TagEditor } from '../../components';
+import { ROUTE, RootStackParamList } from '../../types';
+import { Tag } from '../../database';
+import {
+  StringValidationResult,
+  deleteTag,
+  validateColor,
+  validateTagName,
+} from '../../utilities';
+import editorStyles from './editorStyles';
 
 const EditTag = ({
   route,
 }: NativeStackScreenProps<RootStackParamList, ROUTE.EDIT_TAG>) => {
   const { goBack } = useNavigation();
   const { colors } = useTheme();
-  const { orientation } = useDimensions();
+  const orientation = useDeviceOrientation();
   const realm = useRealm();
 
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -26,16 +31,29 @@ const EditTag = ({
     BSON.UUID.createFromHexString(route.params.id),
   )!;
 
+  const [hasChanges, setHasChanges] = useState(false);
   const [tagName, setTagName] = useState(validateTagName(tag.name));
   const [tagColor, setTagColor] = useState(validateColor(tag.color));
 
+  const handleTagNameChange = useCallback((name: StringValidationResult) => {
+    setTagName(name);
+    setHasChanges(true);
+  }, []);
+
+  const handleTagColorChange = useCallback((color: StringValidationResult) => {
+    setTagColor(color);
+    setHasChanges(true);
+  }, []);
+
   const handleSave = useCallback(() => {
     realm.write(() => {
       tag.name = tagName.parsed;
       tag.color = tagColor.parsed;
       tag.dateModified = new Date();
     });
-  }, [realm, tag, tagColor.parsed, tagName.parsed]);
+
+    goBack();
+  }, [goBack, realm, tag, tagColor.parsed, tagName.parsed]);
 
   return (
     <>
@@ -52,32 +70,28 @@ const EditTag = ({
       </Appbar.Header>
       <ScrollView
         contentContainerStyle={[
-          orientation === ORIENTATION.PORTRAIT
-            ? styles.paddingVertical
-            : styles.smallPaddingVertical,
-          styles.paddingHorizontal,
-          styles.flexGrow,
-          styles.flexColumnSpaceBetween,
+          editorStyles.scrollView,
+          orientation === 'portrait'
+            ? editorStyles.scrollViewPortrait
+            : editorStyles.scrollViewLandscape,
           { backgroundColor: colors.background },
         ]}
         nestedScrollEnabled>
-        <View style={[styles.flex, styles.justifyStart]}>
+        <View style={editorStyles.editorView}>
           <TagEditor
             tagName={tagName}
-            setTagName={setTagName}
+            setTagName={handleTagNameChange}
             tagColor={tagColor}
-            setTagColor={setTagColor}
+            setTagColor={handleTagColorChange}
           />
         </View>
-        <View style={[styles.flex, styles.justifyEnd]}>
+        <View style={editorStyles.saveButtonView}>
           <Button
             mode="contained"
             icon="floppy"
-            onPress={() => {
-              handleSave();
-              goBack();
-            }}
-            disabled={!tagName.valid || !tagColor.valid}>
+            onPress={handleSave}
+            disabled={!tagName.valid || !tagColor.valid || !hasChanges}
+            style={editorStyles.soloSaveButton}>
             Save
           </Button>
         </View>

src/screens/editors/editorStyles.ts

@@ -0,0 +1,37 @@
+import { StyleSheet } from 'react-native';
+
+const editorStyles = StyleSheet.create({
+  scrollView: {
+    flexGrow: 1,
+    flexDirection: 'column',
+    justifyContent: 'space-between',
+    paddingHorizontal: '4%',
+  },
+  scrollViewPortrait: {
+    paddingVertical: '4%',
+  },
+  scrollViewLandscape: {
+    paddingVertical: '2%',
+  },
+  editorView: {
+    flex: 1,
+    justifyContent: 'flex-start',
+  },
+  saveButtonView: {
+    flexDirection: 'row',
+    width: '100%',
+  },
+  saveAndAddButton: {
+    flex: 1,
+    marginRight: 5,
+  },
+  saveButton: {
+    flex: 1,
+    marginLeft: 5,
+  },
+  soloSaveButton: {
+    flex: 1,
+  },
+});
+
+export default editorStyles;

src/screens/index.ts

@@ -1,7 +1,7 @@
-export { default as AddMeme } from './addMeme';
-export { default as AddTag } from './addTag';
-export { default as EditMeme } from './editMeme';
-export { default as EditTag } from './editTag';
+export { default as AddMeme } from './editors/addMeme';
+export { default as AddTag } from './editors/addTag';
+export { default as EditMeme } from './editors/editMeme';
+export { default as EditTag } from './editors/editTag';
 export { default as Memes } from './memes';
 export { default as MemeView } from './memeView';
 export { default as Settings } from './settings';

src/screens/memeView.tsx

@@ -1,12 +1,13 @@
 import React, { useRef, useState } from 'react';
 import { NativeStackScreenProps } from '@react-navigation/native-stack';
-import { StyleSheet, View } from 'react-native';
+import { StyleSheet } from 'react-native';
 import { useQuery, useRealm } from '@realm/react';
 import { FlashList } from '@shopify/flash-list';
 import { Appbar, Portal, Snackbar } from 'react-native-paper';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
+import { NavigationProp, useNavigation } from '@react-navigation/native';
 import { RootStackParamList, ROUTE } from '../types';
 import { Meme } from '../database';
-import { useDimensions } from '../contexts';
 import { MemeViewItem } from '../components';
 import {
   copyMeme,
@@ -16,27 +17,43 @@ import {
   multipleIdQuery,
   shareMeme,
 } from '../utilities';
-import { NavigationProp, useNavigation } from '@react-navigation/native';
-import styles from '../styles';
+import { useSelector } from 'react-redux';
+import { RootState } from '../state';
 
 const memeViewStyles = StyleSheet.create({
+  // eslint-disable-next-line react-native/no-color-literals
+  header: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    zIndex: 1,
+    backgroundColor: 'transparent',
+  },
+  // eslint-disable-next-line react-native/no-color-literals
   footer: {
     position: 'absolute',
     bottom: 0,
     left: 0,
     right: 0,
-    height: 80,
+    backgroundColor: 'transparent',
+    flexDirection: 'row',
+    justifyContent: 'space-evenly',
   },
   snackbar: {
-    marginBottom: 90,
+    marginBottom: 64,
   },
 });
 
 const MemeView = ({
   route,
 }: NativeStackScreenProps<RootStackParamList, ROUTE.MEME_VIEW>) => {
-  const { orientation, dimensions } = useDimensions();
+  const { height, width } = useSafeAreaFrame();
   const navigation = useNavigation<NavigationProp<RootStackParamList>>();
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
   const realm = useRealm();
 
   const { ids } = route.params;
@@ -55,46 +72,55 @@ const MemeView = ({
 
   return (
     <>
-      <Appbar.Header>
+      <Appbar.Header style={memeViewStyles.header}>
         <Appbar.BackAction onPress={() => navigation.goBack()} />
         <Appbar.Content title={memes[index].title} />
       </Appbar.Header>
-      <View>
-        <FlashList
-          ref={flashListRef}
-          key={orientation}
-          data={memes}
-          initialScrollIndex={index}
-          onScroll={event => {
-            const newIndex = Math.round(
-              event.nativeEvent.contentOffset.x /
-                event.nativeEvent.layoutMeasurement.width,
-            );
-            if (newIndex !== index) setIndex(newIndex);
-          }}
-          estimatedItemSize={dimensions.width}
-          pagingEnabled
-          horizontal
-          showsHorizontalScrollIndicator={false}
-          estimatedListSize={{
-            height: dimensions.height - 160,
-            width: dimensions.width,
-          }}
-          renderItem={({ item: meme }) => <MemeViewItem meme={meme} />}
-        />
-      </View>
-      <Appbar style={[memeViewStyles.footer, styles.flexRowSpaceEvenly]}>
+      <FlashList
+        ref={flashListRef}
+        key={height}
+        data={memes}
+        initialScrollIndex={index}
+        onScroll={event => {
+          const newIndex = Math.round(
+            event.nativeEvent.contentOffset.x /
+              event.nativeEvent.layoutMeasurement.width,
+          );
+          if (newIndex !== index) setIndex(newIndex);
+        }}
+        estimatedItemSize={width}
+        estimatedListSize={{ height, width }}
+        pagingEnabled
+        horizontal
+        showsHorizontalScrollIndicator={false}
+        renderItem={({ item: meme }) => <MemeViewItem meme={meme} />}
+      />
+      <Appbar style={memeViewStyles.footer}>
         <Appbar.Action
           icon={memes[index].isFavorite ? 'heart' : 'heart-outline'}
           onPress={() => favoriteMeme(realm, memes[index])}
         />
-        <Appbar.Action icon="share" onPress={() => shareMeme(memes[index])} />
+        <Appbar.Action
+          icon="share"
+          onPress={() => {
+            shareMeme(realm, storageUri, memes[index]).catch(() => {
+              setSnackbarMessage('Failed to share meme!');
+              setSnackbarVisible(true);
+            });
+          }}
+        />
         <Appbar.Action
           icon="content-copy"
-          onPress={() => {
-            copyMeme(memes[index]);
-            setSnackbarMessage('Meme copied!');
-            setSnackbarVisible(true);
+          onPress={async () => {
+            await copyMeme(realm, storageUri, memes[index])
+              .then(() => {
+                setSnackbarMessage('Meme copied!');
+                setSnackbarVisible(true);
+              })
+              .catch(() => {
+                setSnackbarMessage('Failed to copy meme!');
+                setSnackbarVisible(true);
+              });
           }}
         />
         <Appbar.Action
@@ -112,7 +138,7 @@ const MemeView = ({
                 index: index - 1,
               });
             }
-            void deleteMeme(realm, memes[index]);
+            void deleteMeme(realm, storageUri, memes[index]);
             if (memes.length === 1) navigation.goBack();
           }}
         />

src/screens/memes.tsx

@@ -3,7 +3,9 @@ import {
   BackHandler,
   NativeScrollEvent,
   NativeSyntheticEvent,
+  StyleSheet,
   View,
+  useWindowDimensions,
 } from 'react-native';
 import { useQuery } from '@realm/react';
 import { useTheme } from 'react-native-paper';
@@ -15,16 +17,26 @@ import {
   useNavigation,
 } from '@react-navigation/native';
 import { NativeStackNavigationProp } from '@react-navigation/native-stack';
-import styles from '../styles';
 import { ROUTE, SORT_DIRECTION, memesSortQuery } from '../types';
 import { RootState, setNavVisible } from '../state';
 import { Meme } from '../database';
 import { HideableHeader, MemesHeader, MemesList } from '../components';
+import { useDeviceOrientation } from '@react-native-community/hooks';
+
+const memesStyles = StyleSheet.create({
+  listView: {
+    paddingHorizontal: '4%',
+    width: '100%',
+    height: '100%',
+  },
+});
 
 const Memes = () => {
   const { colors } = useTheme();
   const { navigate } =
     useNavigation<NativeStackNavigationProp<ParamListBase>>();
+  const { height } = useWindowDimensions();
+  const orientation = useDeviceOrientation();
   const sort = useSelector((state: RootState) => state.memes.sort);
   const sortDirection = useSelector(
     (state: RootState) => state.memes.sortDirection,
@@ -124,34 +136,35 @@ const Memes = () => {
   );
 
   return (
-    <View
-      style={[
-        styles.paddingHorizontal,
-        styles.fullSize,
-        { backgroundColor: colors.background },
-      ]}>
+    <>
       <HideableHeader visible={navVisisble}>
         <MemesHeader
           search={search}
           setSearch={setSearch}
           onLayout={event => {
-            setFlashListPadding(event.nativeEvent.layout.height);
+            setFlashListPadding(
+              event.nativeEvent.layout.height +
+                height * (orientation === 'portrait' ? 0.02 : 0.04),
+            );
           }}
         />
       </HideableHeader>
-      <MemesList
-        memes={memes}
-        flashListRef={flashListRef}
-        flashListPadding={flashListPadding}
-        handleScroll={handleScroll}
-        focusMeme={(index: number) => {
-          navigate(ROUTE.MEME_VIEW, {
-            ids: memes.map(meme => meme.id.toHexString()),
-            index,
-          });
-        }}
-      />
-    </View>
+      <View
+        style={[memesStyles.listView, { backgroundColor: colors.background }]}>
+        <MemesList
+          memes={memes}
+          flashListRef={flashListRef}
+          flashListPadding={flashListPadding}
+          handleScroll={handleScroll}
+          focusMeme={(index: number) => {
+            navigate(ROUTE.MEME_VIEW, {
+              ids: memes.map(meme => meme.id.toHexString()),
+              index,
+            });
+          }}
+        />
+      </View>
+    </>
   );
 };
 

src/screens/settings.tsx

@@ -10,31 +10,42 @@ import {
   Text,
   useTheme,
 } from 'react-native-paper';
-import { openDocumentTree } from 'react-native-scoped-storage';
 import { useDispatch, useSelector } from 'react-redux';
 import type {} from 'redux-thunk/extend-redux';
-import styles from '../styles';
 import {
   RootState,
   setGridColumns,
   setMasonryColumns,
   setNoMedia,
-  setStorageUri,
 } from '../state';
-import { ORIENTATION, useDimensions } from '../contexts';
+import StorageLocationChangeDialog from '../components/storageLocationChangeDialog';
+import { useRealm } from '@realm/react';
+import { FileSystem, FileStat } from 'react-native-file-access';
+import { Meme } from '../database';
 
 const settingsStyles = StyleSheet.create({
+  scrollView: {
+    paddingHorizontal: '4%',
+  },
   snackbar: {
     marginBottom: 90,
   },
   marginBottom: {
     marginBottom: 15,
   },
+  columnSegmentedButtons: {
+    marginBottom: 15,
+    paddingHorizontal: '2%',
+  },
+  hideMediaSwitch: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    paddingHorizontal: '2%',
+  },
 });
 
 const Settings = () => {
   const { colors } = useTheme();
-  const { orientation } = useDimensions();
   const noMedia = useSelector((state: RootState) => state.settings.noMedia);
   const masonryColumns = useSelector(
     (state: RootState) => state.settings.masonryColumns,
@@ -42,114 +53,119 @@ const Settings = () => {
   const gridColumns = useSelector(
     (state: RootState) => state.settings.gridColumns,
   );
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  const storageUri = useSelector(
+    (state: RootState) => state.settings.storageUri,
+  )!;
   const dispatch = useDispatch();
+  const realm = useRealm();
 
-  const [isOptimizingDatabase, setIsOptimizingDatabase] = useState(false);
   const [snackbarVisible, setSnackbarVisible] = useState(false);
   const [snackbarMessage, setSnackbarMessage] = useState('');
 
-  const optimizeDatabase = () => {
-    setIsOptimizingDatabase(true);
-    // TODO: clean up missing / extra files
-    setSnackbarMessage('Database optimized!');
+  const [
+    storageLocationChangeDialogVisible,
+    setStorageLocationChangeDialogVisible,
+  ] = useState(false);
+
+  const refreshMemeMetadata = async () => {
+    const stat = await FileSystem.statDir(storageUri);
+
+    const statMap = new Map<string, FileStat>();
+    stat.forEach(s => statMap.set(s.filename, s));
+
+    const memes = realm.objects<Meme>(Meme.schema.name);
+
+    realm.write(() => {
+      memes.forEach(meme => {
+        const fileStat = statMap.get(meme.filename);
+        meme.size = fileStat?.size ?? 0;
+      });
+    });
+
+    setSnackbarMessage('Meme metadata refreshed.');
     setSnackbarVisible(true);
-    setIsOptimizingDatabase(false);
   };
 
   return (
     <>
       <ScrollView
         contentContainerStyle={[
-          orientation === ORIENTATION.PORTRAIT
-            ? styles.paddingTop
-            : styles.smallPaddingTop,
-          styles.paddingHorizontal,
+          settingsStyles.scrollView,
           { backgroundColor: colors.background },
         ]}>
-        <View>
-          <List.Section>
-            <List.Subheader>Views</List.Subheader>
-            <Text
-              style={[
-                settingsStyles.marginBottom,
-                styles.smallPaddingHorizontal,
-              ]}>
-              Masonry Columns
-            </Text>
-            <SegmentedButtons
-              value={masonryColumns.toString()}
-              onValueChange={value => {
-                void dispatch(
-                  setMasonryColumns(Number.parseInt(value) as 1 | 2 | 3 | 4),
-                );
-              }}
-              buttons={[
-                { label: '1', value: '1' },
-                { label: '2', value: '2' },
-                { label: '3', value: '3' },
-                { label: '4', value: '4' },
-              ]}
-              style={settingsStyles.marginBottom}
-            />
-            <Text
-              style={[
-                settingsStyles.marginBottom,
-                styles.smallPaddingHorizontal,
-              ]}>
-              Grid Columns
-            </Text>
-            <SegmentedButtons
-              value={gridColumns.toString()}
-              onValueChange={value => {
-                void dispatch(
-                  setGridColumns(Number.parseInt(value) as 1 | 2 | 3 | 4),
-                );
-              }}
-              buttons={[
-                { label: '1', value: '1' },
-                { label: '2', value: '2' },
-                { label: '3', value: '3' },
-                { label: '4', value: '4' },
-              ]}
-            />
-          </List.Section>
-          <List.Section>
-            <List.Subheader>Media Storage</List.Subheader>
-            <Button
-              mode="elevated"
-              style={settingsStyles.marginBottom}
-              onPress={async () => {
-                const { uri } = await openDocumentTree(true);
-                void dispatch(setStorageUri(uri));
-              }}>
-              Change External Storage Path
-            </Button>
-            <View
-              style={[
-                styles.flexRowSpaceBetween,
-                styles.smallPaddingHorizontal,
-              ]}>
-              <Text>Hide media from gallery</Text>
-              <Switch
-                value={noMedia}
-                onValueChange={value => {
-                  void dispatch(setNoMedia(value));
-                }}
-              />
-            </View>
-          </List.Section>
-        </View>
         <List.Section>
-          <List.Subheader>Database</List.Subheader>
+          <List.Subheader>Views</List.Subheader>
+          <Text style={settingsStyles.columnSegmentedButtons}>
+            Masonry Columns
+          </Text>
+          <SegmentedButtons
+            value={masonryColumns.toString()}
+            onValueChange={value => {
+              void dispatch(
+                setMasonryColumns(Number.parseInt(value) as 1 | 2 | 3 | 4),
+              );
+            }}
+            buttons={[
+              { label: '1', value: '1' },
+              { label: '2', value: '2' },
+              { label: '3', value: '3' },
+              { label: '4', value: '4' },
+            ]}
+            style={settingsStyles.marginBottom}
+          />
+          <Text style={settingsStyles.columnSegmentedButtons}>
+            Grid Columns
+          </Text>
+          <SegmentedButtons
+            value={gridColumns.toString()}
+            onValueChange={value => {
+              void dispatch(
+                setGridColumns(Number.parseInt(value) as 1 | 2 | 3 | 4),
+              );
+            }}
+            buttons={[
+              { label: '1', value: '1' },
+              { label: '2', value: '2' },
+              { label: '3', value: '3' },
+              { label: '4', value: '4' },
+            ]}
+          />
+        </List.Section>
+        <List.Section>
+          <List.Subheader>Storage</List.Subheader>
           <Button
             mode="elevated"
-            loading={isOptimizingDatabase}
-            onPress={optimizeDatabase}>
-            Optimize Database Now
+            style={settingsStyles.marginBottom}
+            onPress={() => setStorageLocationChangeDialogVisible(true)}>
+            Change Storage Location
           </Button>
+          <Button
+            mode="elevated"
+            style={settingsStyles.marginBottom}
+            onPress={refreshMemeMetadata}>
+            Refresh Meme Metadata
+          </Button>
+          <View style={settingsStyles.hideMediaSwitch}>
+            <Text>Hide media from gallery</Text>
+            <Switch
+              value={noMedia}
+              onValueChange={value => {
+                void dispatch(setNoMedia(value));
+              }}
+            />
+          </View>
         </List.Section>
       </ScrollView>
       <Portal>
+        <Portal>
+          <StorageLocationChangeDialog
+            visible={storageLocationChangeDialogVisible}
+            setVisible={setStorageLocationChangeDialogVisible}
+            setSnackbarVisible={setSnackbarVisible}
+            setSnackbarMessage={setSnackbarMessage}
+          />
+        </Portal>
         <Snackbar
           visible={snackbarVisible}
           onDismiss={() => setSnackbarVisible(false)}

src/screens/tags.tsx

@@ -11,25 +11,32 @@ import { useQuery } from '@realm/react';
 import { useDispatch, useSelector } from 'react-redux';
 import { FlashList } from '@shopify/flash-list';
 import { useFocusEffect } from '@react-navigation/native';
+import { useDeviceOrientation } from '@react-native-community/hooks';
+import { useSafeAreaFrame } from 'react-native-safe-area-context';
 import { HideableHeader, TagRow, TagsHeader } from '../components';
 import { Tag } from '../database';
-import styles from '../styles';
 import { RootState, setNavVisible } from '../state';
 import { SORT_DIRECTION, tagSortQuery } from '../types';
-import { ORIENTATION, useDimensions } from '../contexts';
 
 const tagsStyles = StyleSheet.create({
+  listView: {
+    paddingHorizontal: '4%',
+    width: '100%',
+    height: '100%',
+  },
   flashList: {
     paddingBottom: 100,
   },
   helperText: {
     marginVertical: 15,
+    textAlign: 'center',
   },
 });
 
 const Tags = () => {
   const { colors } = useTheme();
-  const { dimensions, orientation } = useDimensions();
+  const { height, width } = useSafeAreaFrame();
+  const orientation = useDeviceOrientation();
   const sort = useSelector((state: RootState) => state.tags.sort);
   const sortDirection = useSelector(
     (state: RootState) => state.tags.sortDirection,
@@ -102,12 +109,7 @@ const Tags = () => {
   );
 
   return (
-    <View
-      style={[
-        styles.paddingHorizontal,
-        styles.fullSize,
-        { backgroundColor: colors.background },
-      ]}>
+    <>
       <HideableHeader visible={navVisisble}>
         <TagsHeader
           search={search}
@@ -117,34 +119,35 @@ const Tags = () => {
           }}
         />
       </HideableHeader>
-      <FlashList
-        ref={flashListRef}
-        data={tags}
-        estimatedItemSize={50}
-        estimatedListSize={{
-          height: dimensions.height,
-          width: dimensions.width * 0.92,
-        }}
-        showsVerticalScrollIndicator={false}
-        renderItem={({ item: tag }) => <TagRow tag={tag} />}
-        contentContainerStyle={{
-          paddingTop:
-            flashListPadding +
-            dimensions.height *
-              (orientation === ORIENTATION.PORTRAIT ? 0.02 : 0.04),
-          ...tagsStyles.flashList,
-        }}
-        ItemSeparatorComponent={() => <Divider />}
-        ListEmptyComponent={() => (
-          <HelperText
-            type={'info'}
-            style={[tagsStyles.helperText, styles.centerText]}>
-            No tags found
-          </HelperText>
-        )}
-        onScroll={handleScroll}
-      />
-    </View>
+      <View
+        style={[tagsStyles.listView, { backgroundColor: colors.background }]}>
+        <FlashList
+          ref={flashListRef}
+          data={tags}
+          estimatedItemSize={50}
+          estimatedListSize={{
+            height,
+            width: width * 0.92,
+          }}
+          showsVerticalScrollIndicator={false}
+          renderItem={({ item: tag }) => <TagRow tag={tag} />}
+          contentContainerStyle={{
+            paddingTop:
+              flashListPadding +
+              height * (orientation === 'portrait' ? 0.02 : 0.04),
+            ...tagsStyles.flashList,
+          }}
+          ItemSeparatorComponent={() => <Divider />}
+          ListEmptyComponent={() => (
+            <HelperText type={'info'} style={tagsStyles.helperText}>
+              No tags found
+            </HelperText>
+          )}
+          onScroll={handleScroll}
+          fadingEdgeLength={100}
+        />
+      </View>
+    </>
   );
 };
 

src/screens/welcome.tsx

@@ -3,14 +3,19 @@ import { StyleSheet, View } from 'react-native';
 import { Button, Text, useTheme } from 'react-native-paper';
 import { useDispatch } from 'react-redux';
 import { openDocumentTree } from 'react-native-scoped-storage';
-import styles from '../styles';
 import { noOp } from '../utilities';
 import { setStorageUri } from '../state';
-import { ORIENTATION, useDimensions } from '../contexts';
 
 const welcomeStyles = StyleSheet.create({
+  view: {
+    paddingHorizontal: '4%',
+    alignItems: 'center',
+    justifyContent: 'center',
+    flex: 1,
+  },
   text: {
     marginBottom: 30,
+    textAlign: 'center',
   },
   button: {
     marginBottom: 100,
@@ -19,7 +24,6 @@ const welcomeStyles = StyleSheet.create({
 
 const Welcome = ({ onWelcomeComplete }: { onWelcomeComplete: () => void }) => {
   const { colors } = useTheme();
-  const { orientation } = useDimensions();
   const dispatch = useDispatch();
 
   const selectStorageLocation = async () => {
@@ -30,20 +34,8 @@ const Welcome = ({ onWelcomeComplete }: { onWelcomeComplete: () => void }) => {
   };
 
   return (
-    <View
-      style={[
-        orientation === ORIENTATION.PORTRAIT
-          ? styles.paddingTop
-          : styles.smallPaddingTop,
-        styles.paddingHorizontal,
-        styles.centered,
-        styles.flex,
-        styles.fullSize,
-        { backgroundColor: colors.background },
-      ]}>
-      <Text
-        variant="displayMedium"
-        style={[welcomeStyles.text, styles.centerText]}>
+    <View style={[welcomeStyles.view, { backgroundColor: colors.background }]}>
+      <Text variant="displayMedium" style={welcomeStyles.text}>
         Welcome to Terminally Online!
       </Text>
       <Button

src/styles.tsx

@@ -1,95 +0,0 @@
-import { StyleSheet } from 'react-native';
-
-const styles = StyleSheet.create({
-  smallPadding: {
-    padding: '2%',
-  },
-  smallPaddingHorizontal: {
-    paddingHorizontal: '2%',
-  },
-  smallPaddingVertical: {
-    paddingVertical: '2%',
-  },
-  smallPaddingTop: {
-    paddingTop: '2%',
-  },
-  padding: {
-    padding: '4%',
-  },
-  paddingHorizontal: {
-    paddingHorizontal: '4%',
-  },
-  paddingVertical: {
-    paddingVertical: '4%',
-  },
-  paddingTop: {
-    paddingTop: '4%',
-  },
-  centered: {
-    justifyContent: 'center',
-    alignItems: 'center',
-  },
-  alignCenter: {
-    alignItems: 'center',
-  },
-  justifyCenter: {
-    justifyContent: 'center',
-  },
-  centerText: {
-    textAlign: 'center',
-  },
-  centerSelf: {
-    alignSelf: 'center',
-  },
-  flex: {
-    flex: 1,
-  },
-  flexGrow: {
-    flexGrow: 1,
-  },
-  flexShrink: {
-    flexShrink: 1,
-  },
-  flexRow: {
-    flexDirection: 'row',
-  },
-  flexRowSpaceBetween: {
-    flexDirection: 'row',
-    justifyContent: 'space-between',
-  },
-  flexRowSpaceEvenly: {
-    flexDirection: 'row',
-    justifyContent: 'space-evenly',
-  },
-  flexColumn: {
-    flexDirection: 'column',
-  },
-  flexColumnSpaceBetween: {
-    flexDirection: 'column',
-    justifyContent: 'space-between',
-  },
-  flexRowReverse: {
-    flexDirection: 'row-reverse',
-  },
-  flexWrap: {
-    flexWrap: 'wrap',
-  },
-  justifyStart: {
-    justifyContent: 'flex-start',
-  },
-  justifyEnd: {
-    justifyContent: 'flex-end',
-  },
-  fullWidth: {
-    width: '100%',
-  },
-  fullHeight: {
-    height: '100%',
-  },
-  fullSize: {
-    width: '100%',
-    height: '100%',
-  },
-});
-
-export default styles;

src/types/route.ts

@@ -18,7 +18,7 @@ interface MemeViewRouteParams {
 }
 
 interface AddMemeRouteParams {
-  file: DocumentPickerResponse;
+  files: DocumentPickerResponse[];
 }
 
 interface EditMemeRouteParams {

src/utilities/dimensions.ts

@@ -1,9 +1,35 @@
 const getFlashListItemHeight = (numColumns: number) => {
-  const A = 500;
-  const B = 300;
-  const C = 1;
-  const height = A - B * Math.log(numColumns + C);
-  return Math.max(Math.round(height), 0);
+  switch (numColumns) {
+    case 1: {
+      return 350;
+    }
+    case 2: {
+      return 180;
+    }
+    case 3: {
+      return 120;
+    }
+    case 4: {
+      return 90;
+    }
+  }
 };
 
-export { getFlashListItemHeight };
+const getFontAwesome5IconSize = (numColumns: number) => {
+  switch (numColumns) {
+    case 1: {
+      return 40;
+    }
+    case 2: {
+      return 30;
+    }
+    case 3: {
+      return 20;
+    }
+    case 4: {
+      return 14;
+    }
+  }
+};
+
+export { getFlashListItemHeight, getFontAwesome5IconSize };

src/utilities/filesystem.ts

@@ -11,7 +11,7 @@ const allowedGifMimeTypes = ['image/gif'];
 
 const allowedMimeTypes = [...allowedImageMimeTypes, ...allowedGifMimeTypes];
 
-const getMemeType = (mimeType: string) => {
+const getMemeType = (mimeType: string): MEME_TYPE | undefined => {
   switch (mimeType) {
     case 'image/bmp':
     case 'image/jpeg':

src/utilities/index.ts

@@ -8,7 +8,7 @@ export {
 } from './color';
 export { packageName, appName, fileProvider, noOp } from './constants';
 export { multipleIdQuery } from './database';
-export { getFlashListItemHeight } from './dimensions';
+export { getFlashListItemHeight, getFontAwesome5IconSize } from './dimensions';
 export {
   allowedImageMimeTypes,
   allowedGifMimeTypes,
@@ -23,7 +23,10 @@ export {
   editMeme,
   deleteMeme,
 } from './meme';
-export { isPermissionForPath, clearPermissions } from './permissions';
+export {
+  isPermissionForPath,
+  clearPermissions,
+} from './permissions';
 export { deleteTag } from './tag';
 export {
   type StringValidationResult,

src/utilities/meme.ts

@@ -1,10 +1,10 @@
 import { NavigationProp } from '@react-navigation/native';
-import { Dirs, FileSystem } from 'react-native-file-access';
-import { extension } from 'react-native-mime-types';
+import { AndroidScoped, Dirs, FileSystem } from 'react-native-file-access';
 import Share from 'react-native-share';
 import Clipboard from '@react-native-clipboard/clipboard';
 import { Meme } from '../database';
 import { ROUTE, RootStackParamList } from '../types';
+import { noOp } from './constants';
 
 const favoriteMeme = (realm: Realm, meme: Meme) => {
   realm.write(() => {
@@ -12,10 +12,20 @@ const favoriteMeme = (realm: Realm, meme: Meme) => {
   });
 };
 
-const shareMeme = async (meme: Meme) => {
-  const fileExtension = extension(meme.mimeType) as string;
-  const cacheUri = `${Dirs.CacheDir}/${meme.id.toHexString()}.${fileExtension}`;
-  await FileSystem.cp(meme.uri, cacheUri);
+const shareMeme = async (realm: Realm, storageUri: string, meme: Meme) => {
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
+  const cacheUri = `${Dirs.CacheDir}/${meme.filename}`;
+
+  realm.write(() => {
+    meme.dateUsed = new Date();
+    meme.timesUsed += 1;
+    meme.tags.forEach(tag => {
+      tag.dateUsed = new Date();
+      tag.timesUsed += 1;
+    });
+  });
+
+  await FileSystem.cp(uri, cacheUri);
   await Share.open({
     url: `file://${cacheUri}`,
     type: meme.mimeType,
@@ -23,8 +33,22 @@ const shareMeme = async (meme: Meme) => {
   });
 };
 
-const copyMeme = (meme: Meme) => {
-  Clipboard.setURI(meme.uri);
+const copyMeme = async (realm: Realm, storageUri: string, meme: Meme) => {
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
+
+  const exists = await FileSystem.exists(uri);
+  if (!exists) throw new Error('File does not exist');
+
+  realm.write(() => {
+    meme.dateUsed = new Date();
+    meme.timesUsed += 1;
+    meme.tags.forEach(tag => {
+      tag.dateUsed = new Date();
+      tag.timesUsed += 1;
+    });
+  });
+
+  Clipboard.setURI(uri);
 };
 
 const editMeme = (
@@ -34,8 +58,10 @@ const editMeme = (
   navigation.navigate(ROUTE.EDIT_MEME, { id: meme.id.toHexString() });
 };
 
-const deleteMeme = async (realm: Realm, meme: Meme) => {
-  await FileSystem.unlink(meme.uri);
+const deleteMeme = async (realm: Realm, storageUri: string, meme: Meme) => {
+  const uri = AndroidScoped.appendPath(storageUri, meme.filename);
+
+  await FileSystem.unlink(uri).catch(noOp);
 
   realm.write(() => {
     for (const tag of meme.tags) {

src/utilities/permissions.ts

@@ -4,7 +4,7 @@ import {
 } from 'react-native-scoped-storage';
 
 const isPermissionForPath = (permission: string, path: string) => {
-  return path.startsWith(permission + '/');
+  return path.startsWith(permission + '/') || path === permission;
 };
 
 const clearPermissions = async (excepts: string[] = []) => {