Introdução à estrutura de roteamento Alibaba

Os saltos de página do Android geralmente são feitos especificando diretamente o nome do componente com uma intenção, mas quando vários módulos são desenvolvidos, esse método faz com que o acoplamento de cada módulo seja sério, o código é muito invasivo e o objetivo da separação completa dos módulos não pode ser alcançado. É necessário usar a intenção implícita para concluir o salto da página, ou seja, o roteamento da página. ARouter é uma solução de roteamento Android.

Simples de usar

1. Adicione dependências e configuração

android {
    defaultConfig {
    ...
    javaCompileOptions {
        annotationProcessorOptions {
        arguments = [ moduleName : project.getName() ]
        }
    }
    }
}

dependencies {
    // 替换成最新版本, 需要注意的是api
    // 要与compiler匹配使用，均使用最新版可以保证兼容
    compile 'com.alibaba:arouter-api:x.x.x'
    annotationProcessor 'com.alibaba:arouter-compiler:x.x.x'
    ...
}
// 旧版本gradle插件(< 2.2)，可以使用apt插件，配置方法见文末'其他#4'
// Kotlin配置参考文末'其他#5'

2. Adicione anotações

// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级，/xx/xx
@Route(path = "/test/activity")
public class YourActivity extend Activity {
    ...
}

3. Inicialize o SDK

if (isDebug()) {           // 这两行必须写在init之前，否则这些配置在init过程中将无效
    ARouter.openLog();     // 打印日志
    ARouter.openDebug();   // 开启调试模式(如果在InstantRun模式下运行，必须开启调试模式！线上版本需要关闭,否则有安全风险)
}
ARouter.init(mApplication); // 尽可能早，推荐在Application中初始化

4. Iniciar operação de roteamento

// 1. 应用内简单的跳转(通过URL跳转在'进阶用法'中)
ARouter.getInstance().build("/test/activity").navigation();

// 2. 跳转并携带参数
ARouter.getInstance().build("/test/1")
    .withLong("key1", 666L)
    .withString("key3", "888")
    .withObject("key4", new Test("Jack", "Rose"))
    .navigation();

Observe que, se você deseja passar um objeto customizado, precisa implementar serialização e desserialização json:

@Route(path = "/service/json")
public class JsonServiceImpl implements SerializationService {
    @Override
    public void init(Context context) {

    }

    @Override
    public <T> T json2Object(String text, Class<T> clazz) {
        return JSON.parseObject(text, clazz);
    }

    @Override
    public String object2Json(Object instance) {
        return JSON.toJSONString(instance);
    }
}

Salto de URL

O salto de página do ARouter também suporta o salto de uri, desde que o caminho esteja correto, você pode pular para a interface de destino, para que também possamos pular da seguinte maneira ao pular para a interface:

Uri uri = Uri.parse("arouter://m.aliyun.com/test/Main2Activity");
ARouter.getInstance().build(uri).navigation();

O esquema e o host podem ser especificados arbitrariamente de acordo com nossas necessidades.

A maneira mais importante de usá-lo é ao pular da página da Web para o APP:

// 新建一个Activity用于监听Schame事件,之后直接把url传递给ARouter即可
public class SchameFilterActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Uri uri = getIntent().getData();
    ARouter.getInstance().build(uri).navigation();
    finish();
    }
}

AndroidManifest.xml
<activity android:name=".activity.SchameFilterActivity">
    <!-- Schame -->
    <intent-filter>
        <data
        android:host="m.aliyun.com"
        android:scheme="arouter"/>

        <action android:name="android.intent.action.VIEW"/>

        <category android:name="android.intent.category.DEFAULT"/>
        <category android:name="android.intent.category.BROWSABLE"/>
    </intent-filter>
</activity>

Dessa forma, qualquer pessoa que pule da página da Web para o APP passará o filtro SchameFilterActivity e, em seguida, passará para a Atividade real.

Os links de salto da página da Web são os seguintes:

<a href="router://m.aliyun.com/test/Main2Activity">跳转</a>

Você também pode adicionar parâmetros atrás da página da web:

<a href="router://m.aliyun.com/test/Main2Activity?name=xuyu">跳转</a>

Em seguida, inicialize os parâmetros pelos seguintes métodos:

@Route(path = "/test/Main2Activity")
public class Main2Activity extends AppCompatActivity
{
    @Autowired
    String name;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);

        ARouter.getInstance().inject(this);
        Log.e("Main2Activity", name + "");

    }
}

Observe que os parâmetros obtidos dessa maneira são passados ​​através do URL, que são os parâmetros transportados pelos dados, não diretamente transportados pela intenção.O método de aquisição original é o seguinte:

getIntent().getData().getQueryParameter("name");

Mas os dados obtidos pela maneira original do salto ARouter estarão vazios. O salto uri pode ser obtido da seguinte maneira:

getIntent().getStringExtra(ARouter.RAW_URI)

De fato, o ARouter envia a cadeia de caracteres da interface do usuário para a próxima interface através do pacote.

Bloqueio de página

Primeiro defina um interceptador:

@Interceptor(priority = 8, name = "测试用拦截器")
public class TestInterceptor implements IInterceptor
{
    @Override
    public void process(Postcard postcard, InterceptorCallback callback)
    {
//        callback.onContinue(postcard);
        callback.onInterrupt(new RuntimeException("我觉得有点异常"));
    }

    @Override
    public void init(Context context)
    {

    }
}

Em seguida, especifique o interceptador na atividade:

@Route(path = "/test/SecondActivity",priority = 8)

Dessa maneira, ao pular para esta atividade, o interceptador será interceptado para decidir se deseja transferir para continuar o salto:

ARouter.getInstance().build("/test/SecondActivity").navigation(FirstActivity.this, new NavigationCallback()
{

    @Override
    public void onInterrupt(Postcard postcard)
    {
        Log.e("FirstActivity", "onInterrupt" + (postcard != null ? postcard.toString() : "null"));
    }
});

Você também pode configurar mais informações adicionais na página de destino para o interceptador processar.Por exemplo, uma interface pode precisar fazer login e vincular um número de telefone celular, você pode escrever da seguinte maneira:

//用二进制最低位判断是否登录，次高位判断是否绑定手机号
@Route(path = "/test/SecondActivity",priority = 8,extra=3)

Então julgue no interceptador:

//获取目标页面的extras，注意这里不可以使用postcard.getExtras()
//他是获取传到目标页面bundle信息的方法
int extra=postcard.getExtra()
if(((extra & 2) > 0) & ((extra & 1) > 0));
{
    //目标界面需要登录且绑定手机号
}
if((extra & 2) > 0)
{
    //目标界面仅需要绑定手机号（业务上不应该有这个状态）
}
if((extra & 1) > 0)
{
    //目标界面需要仅登录
}

Gerenciamento de grupo

ARouter gerencia o caminho de roteamento da página em grupos.Por padrão, o caminho que escrevemos é o nome do grupo, por exemplo: o
@Route(path = "/test/SecondActivity")nome do grupo é test, o que também explica por que o caminho anterior deve ser gravado em pelo menos dois níveis, porque o nome do grupo é adicionado Para caminhos específicos, um pacote será inicializado apenas quando um determinado caminho no pacote for acessado pela primeira vez.

Também pode ser agrupado manualmente da seguinte maneira:

@Route(path = "/test/1", group = "app")

Após formular o grupo, você deve especificar o salto do grupo:

ARouter.getInstance().build("/test/1", "app").navigation();

O ARouter não recomenda a especificação manual de grupos.

Nota: O ARouter permite vários grupos em um módulo, mas não permite o mesmo grupo em vários módulos, o que levará a conflitos no arquivo de mapeamento.