Naviganto

Additional

Language
Java
Version
N/A
Created
Oct 26, 2016
Updated
Jan 14, 2018 (Retired)
Owner
Jorge Garrido (FireZenk)
Contributors
Jorge Garrido (FireZenk)
Bence Stumpf (stumi01)
2
Activity
Badge
Generate
Download
Source code
APK file

Blurb

Naviganto

A small routing library for Android

GRADLE:

 repositories {
      ...
      maven { url 'https://github.com/FireZenk/maven-repo/raw/master/'}
 }
 dependencies {
   ...
   provided 'javax.annotation:javax.annotation-api:1.2'
   provided 'com.squareup:javapoet:1.8.0'

   def NVersion = '3.0.1'
   compile "org.firezenk.naviganto:annotations:$NVersion"
   compile "org.firezenk.naviganto:processor:$NVersion"
   compile "org.firezenk.naviganto:library:$NVersion"
 }

DESCRIPTION:

Naviganto consists of 5 main classes:

  • Naviganto which is in charge of navigate between views (Activity or View).
  • Route that contains the desired route.
  • @RoutableActivity and @RoutableView to use auto-routes.
  • Routable the interface that is implemented for each of our custom Routes.

Additionally, two custom exceptions are provided for make the debugging easier:

  • ParameterNotFoundException launched when not found a path parameter that we need.
  • NotEnoughParametersException which is launched if the route has not received all the necessary parameters.

USAGE

1. Route to the target view

There are two cases when using the router:

  • Route to a another Activity
  • Route to a different View inside the Activity
// Navigate to another Activity; Bundle for custom routes or Object[] for auto-routes
Naviganto.get().routeTo(this, new Route<>(DetailRoute.class, bundle));

// Or if you need a result for your previous Activity
Naviganto.get().routeTo(this, new Route<>(DetailRoute.class, bundle, requestCode));
// Navigate to a View; Bundle for custom routes or Object[] for auto-routes
Naviganto.get().routeTo(this, new Route<>(ProductRoute.class, bundle, placeholder));

// Or if you need a result for your previous Activity
Naviganto.get().routeTo(this, new Route<>(ProductRoute.class, bundle, placeholder, requestCode));

As we can see the only difference is that if we need to navigate to a View, we need to serve a placeholder. Besides this, in our Activity have to specify the following (to enable "back button" navigation):

@Override public void onBackPressed() {
 if (!Naviganto.get().back(this))
  super.onBackPressed();
}

In all the above cases should be understood this as Context

2. Mark the target view as Route

Finally, to implement a route, there are two ways to use this library since version 2.0:

1 - Use auto-routes (remember to rebuild to generate the routes):

@RoutableActivity(params = {...}, requestCode = ...) // for Activities {parameter types separated by commas}, define requestCode as -1 if you don't need it (generates SomeActivityRoute.java)
public class SomeActivity extends AppCompatActivity {

}

@RoutableView(params = {...}, requestCode = ...) // for Views {Parameter types separated by commas}, define requestCode as -1 if you don't need it (generates SomeViewRoute.java)
class SomeView extends FrameLayout {

}

2 - Or implement your custom routes from the Routable like this:

public class MyCustomRoute<C extends Context, B extends Bundle> implements Routable<C, B> {

 @Override public void route(@NonNull Context context, @NonNull Bundle parameters, @Nullable Object viewParent)
      throws ParameterNotFoundException, NotEnoughParametersException {
  // How to opening our Activity or View
 }
}

Sample Auto-route and Routable implementations:

Auto-route for Activity

Implementation for Activity

Auto-route for View

Implementation for View

ADDITIONAL NOTES

  • No, it is not contemplated the use of fragments, although it is possible (using View sample)
  • I recommend to use auto-routes (available since version 2.0) because you can avoid to use Parcelables
  • User .clearHistory() if you need to clear all the navigation history
  • There is some more self documented functions here
  • For more info an samples, see sample module

CHANGES

See CHANGES.md