Navigating in Compose: Conditions
Navigating concerning screens is a widespread act in an Android app… while, as
Zach Klippenstein mentioned,
“screen” is a fairly amorphous phrase. The natural way, we want to be in a position to navigate
to distinct “screens” when people screens are applied as composables.
How we do this is a highly contentious topic.
Approximately speaking, there appears to be to be 4 major categories of answers:
Use the official Jetpack Navigation for Compose
Use some kind of wrapper or helper all around Navigation for Compose —
is an example
Use Jetpack Navigation, but use the “classic” implementation rather of Navigation
for Compose, using fragments to wrap your display screen-level composables
Use some separate navigation implementation, these types of as Adriel Café’s Voyager library
I can’t explain to you what to use. I can explain to you that you really should arrive up with a established
of standards for judging various navigation methods. Dependent on a survey of a bunch
of navigation answers, here are some standards that you may well want to take into consideration.
If your navigation answer does not support forward navigation to N destinations,
or if it does not support back stacks (e.g., a
goBack() purpose to pop a vacation spot
off the stack and return to where you experienced been right before), use something else.
Compile-Time Form Basic safety
A person key position of employing Kotlin, and Java in advance of it, is style basic safety. The extra type
safety we get, the much more likely it is that we will uncover issues at compile-time,
relatively than only through testing or by the application likely 💥 for your users.
When you notify the navigation option where to navigate to in ahead navigation,
you may well want to desire solutions where the identifier is a thing that is form secure.
Some remedies use strings or integers to identify routes or destinations. That can make
it incredibly straightforward to do some definitely frightening things, like compute a destination utilizing math.
Usually, primitives-as-identifiers offer you minimal compile-time safety. You could desire
methods that use enums,
sealed class, marker interfaces, or other matters that
identify what are and are not legitimate alternatives.
(and if you are asking oneself “what about deeplinks?”, that is protected a bit later on)
Commonly, our screens have to have data, whether an identifier (e.g., key crucial) or
the precise info itself. So, we want to be ready to go that details from prior
screens. All else being equivalent, you may want to choose options that present compile-time
type basic safety, so you do not wind up in circumstances where by you provide a string and the receiver
is anticipating an
Int in its place.
A linked conditions is “content safety”. You might want to desire remedies where your
code can just move the data, with out obtaining to worry about whether it complies with
any resolution-particular constraints. For instance, if the solution necessitates you to URL-encode
strings to be in a position to move them safely, that is not great, as you will ignore to do this from
time to time. Preferably, the solution handles individuals sorts of things for you.
…For Return Values
At minimum for modal places, this kind of as dialogs, we usually want to go back some
sort of “result”. For illustration, we show a dialog to let the user to decide a little something,
and we need to have the past display screen to come across out what the person selected. At times, there
are ways of accomplishing this exterior of a navigation alternative, this sort of as the dialog
updating some shared facts representation (e.g., shared Jetpack
ViewModel) in which
the previous screen finds out about success reactively. But, if the navigation alternative
you are looking at features return values, and you intend to use them, you may well want
to desire ones where by these return values are also style-protected and written content-protected.
IOW, ahead-navigation arguments should really not get all the basic safety appreciate.
Assist for Configuration Modify and System Demise
Like it or not, configuration variations are real. Birds, potentially not.
One particular way or an additional, your application requirements to be in a position to cope with configuration adjustments,
and your navigation solution should be capable cope as effectively, to support your app.
This consists of both retaining the navigation knowledge by itself across configuration alterations
and, ideally, possessing a pattern for application details for your screens to survive as properly
(e.g., Navigation for Compose’s for every-route
Linked is process loss of life:
The consumer takes advantage of your app for a though
The consumer receives distracted by some not-a-bird for a when, and your app’s UI moves to the background
Though in the qualifications, Android terminates your process to free up procedure RAM
The consumer returns to your application after your approach dies, but in a fair time period of time
(past I realized, the limit was 30 minutes, while that price may perhaps have improved in excess of the decades)
Android is going to want to not only convey up your app, but fake that your approach
experienced been about all that time. That is the place “saved occasion state” arrives into participate in,
and ideally your navigation resolution advertises guidance for this, so your back again-stack
and so on get restored alongside with your UI.
Hooks For Stuff You May possibly Use
Only you know what your application is heading to need to do in terms of its UI. Or possibly
your designers know, or your item professionals. Or, hey, perhaps you are just spraying
pixels around like Jackson Pollock sprayed paint.
Who am I to decide?
Irrespective, there may be some things that you want in your app’s UI or move that
tie into what you will want out of your navigation option.
Lots of applications use these sorts of UI constructs. It may possibly not be necessary that they be handled
through a navigation alternative — you may well be in a position to product them as staying “internal implementation”
of a screen, for illustration. But, it would be fantastic to get a sense of what patterns
are proven, if any, for a particular navigation remedy to tie into these
kinds of UI constructs. For instance, if you need to have to ready to not only navigate to a display screen, but
to a particular tab or web site within that monitor, it would be nice if the navigation
alternative supported that. Potentially not vital, but great.
And, for some of these UI constructs, you may be seeking to have numerous back again stacks. For case in point,
you might want to have it so that back navigation in just a tab takes you to former content material
within just that tab, rather than going again to other tabs that the user beforehand frequented.
Support for several back stacks would seem to be a bit of an highly developed element, so if this
is significant to you, see what prospect navigation solutions give.
Deeplinks are common. Listed here, by “deeplink”, I not only signify conditions exactly where a vacation spot
is activated from exterior of the application, this kind of as from a hyperlink on a World wide web website page. I also mean
scenarios where by a location is established at runtime based mostly on facts from an outside
supply, this kind of as a server-driven “tip of the day” card that steers customers to distinct
screens within the app.
If you think that you will have to have these types of issues, it will be helpful if your navigation
option supports them right. That guidance may well not be required — just as your
other app code can navigate to destinations, your “oh, hey, I obtained a deeplink” code
can navigate to destinations. On the other hand, a navigation solution may well simplify that,
notably for circumstances in which the deeplink is from outside the house of the application and you need
to make your mind up what to do with the presently-managing app and its current again stack.
When analyzing deeplink guidance, just one criteria that I will strongly propose is:
deeplinks need to be choose-in. Not each individual monitor in your app ought to be instantly
reachable by some outside bash just by currently being tied into some navigation method
— that can direct to some stability difficulties.
Also, contemplate how information in the deeplink will get mapped to your arguments (at minimum
for routes that consider arguments). Some navigation answers will check out to handle
that instantly for you, but be wary of remedies that use deeplinks as an justification
to be weak on kind basic safety. Ideally, there must be an unambiguous way to convert pieces
of a deeplink (e.g., path segments, query parameters) to navigation arguments, but
in a way that boundaries any “stringly typed” logic to deeplinks them selves and does not
crack style security somewhere else.
Your designers could possibly call for a unique way to transition from display screen X to screen
Y, these as a slide, a fade, a slide-and-fade, a fireworks-design explosion destroying
X with Y showing up guiding it, and so forth. Ideally, the navigation remedy would manage
these types of transitions, especially if you have to have to management the back-navigation
changeover as perfectly (e.g., the exploded fireworks in some way reassembling them selves into a monitor,
for the reason that that appears like pleasurable).
Does the library have distinct documentation? Does it feel to be taken care of? Does it
have a apparent way of finding assist? Does it have a license that is suitable with
your venture? These are all popular criteria for any library, and navigation alternatives
are no exception.
Over and above that, navigation options have a few particular matters that you could possibly want to
look at, these types of as:
How easily can you guidance navigation where the destinations may well reside in various
modules? Notably for tasks that go with a “feature module” progress model,
it is likely that you have to have a display in module A to be equipped to navigate to a screen in
Are there clear designs for employing
@Preview? In theory, a navigation resolution
ought to not get in the way of applying
@Previewfor monitor-amount composables, but it would
be agonizing if it did.
Does the option do the job for development targets over and above Android? Probably you are not
arranging on Compose for Desktop or Compose for Net or
Compose for iOS or
Compose for Consoles. If you are, you
are going to want to think about if and how navigation ties into your Kotlin/Multiplatform
This is not a total checklist — if there are issues that you assume are quite well-known
that I skipped, attain out!