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