Download de SimpleAndroidBridge - SimpleAndroidBridge download do código -fonte

Simplendroidbridge

Construa uma ponte! Integração perfeita entre Android e WebApps

Construa sem esforço uma ponte robusta entre o seu Android e WebApp com a Biblioteca SimpleAndroidbridge. Esta biblioteca permite renderizar um aplicativo da Web em um Android WebView e criar um JSInterface para ativar a comunicação suave entre as duas plataformas. Compartilhe objetos, promessas e funções de retorno de chamada complexos, enquanto seu aplicativo da Web permanece responsivo e eficiente.

✓ Compartilhar objetos - Android ⇄ Web

✓ Compartilhar promessas - Android ⇄ Web

✓ Funções de retorno de chamada - Android ← web

✓ Funções de chamada não bloqueando - Android ⇄ web

✓ Tipo de segurança com o TypeScript - Android + Web

Características

Compartilhar objetos complexos com facilidade

A ponte JavaScript embutida no Android SDK suporta apenas tipos primitivos. Com o Simplendroidbridge, você pode compartilhar objetos complexos entre Android e Web com facilidade. Basta definir os tipos como argumentos ou retornar valores em suas funções nativas do Android, e a biblioteca converterá automaticamente objetos JavaScript em objetos Kotlin e vice -versa.

 // Kotlin
class AndroidNativeInterface ( val contactService : ContactService ): DefaultJSInterface( " Android " ) {

    @NativeCall( CallType . FULL_SYNC )
    fun searchContact ( contactFilter : ContactFilter ): List < Contact > {
        return contactService.search(contactFilter)
    }
}

data class ContactFilter ( val surname : String? = null , val firstname : String? = null )
data class Contact ( val surname : String? = null , val fistname : String? = null ,
    val mail : String? = null , val phonenumber : String? = null )

 // Javascript
console . log ( Bridge . interfaces . Android . searchContact ( { surname : "Pitt" } ) )

Promessas facilitadas

A ponte JavaScript no Android SDK executa funções de maneira bloqueadora, fazendo com que o aplicativo da Web congelasse até que a função nativa retorne. No entanto, com esta biblioteca, você pode definir um tipo de devolução de promessa, permitindo a execução sem bloqueio. Ao utilizar a função 'Doinbackground', o código Android é executado em um encadeamento de segundo plano, impedindo que o aplicativo da Web seja bloqueado.

 // Kotlin
class AndroidNativeInterface ( val contactService : ContactService ): DefaultJSInterface( " Android " ) {

    @NativeCall( CallType . FULL_PROMISE )
    fun searchContact ( contactFilter : ContactFilter ) = doInBackground< List < Contact >> { promise ->
        try {
            promise.resolve(contactService.search(contactFilter))
        } catch (e : Exception ) {
            promise.reject(e)
        }
    }
}

data class ContactFilter ( val surname : String? = null , val firstname : String? = null )
data class Contact ( val surname : String? = null , val fistname : String? = null ,
    val mail : String? = null , val phonenumber : String? = null )

 // Javascript
Bridge . interfaces . Android . searchContact ( { surname : "Pitt" } ) . then ( ( list ) => {
    console . log ( list ) ;
} ) ;

Funções de retorno de chamada

Se você conhece o JavaScript, provavelmente não é estranho às funções de retorno de chamada. O Simplendroidbridge leva esse conceito um passo adiante, permitindo que você injete essas funções de retorno de chamada JavaScript diretamente na camada Android, criando assim uma interação perfeita entre seu aplicativo da Web e Android.

 // Kotlin
class AndroidNativeInterface ( val button : Button ): DefaultJSInterface( " Android " ) {

    @NativeCall( CallType . FULL_SYNC )
    fun registerOnClickAction ( jsFunction : JSFunction ) {
        button.setOnClickListener { jsFunction() }
    }
}

 // Javascript
Bridge . interfaces . Android . registerOnClickAction ( ( ) => {
    console . log ( "Button Clicked!" )
} )

Para passar um argumento para uma função JavaScript, use o tipo JSFunctionWithArg , que é projetado especificamente para aceitar um argumento.

 // Kotlin
class AndroidNativeInterface ( val button : Button ): DefaultJSInterface( " Android " ) {

    var i = 0
    
    @NativeCall( CallType . FULL_SYNC )
    fun registerOnClickAction ( jsFunction : JSFunctionWithArg < Int >) {
        button.setOnClickListener { jsFunction( ++ i) }
    }
}

 // Javascript
Bridge . interfaces . Android . registerOnClickAction ( ( i ) => {
    console . log ( "Button Clicked! " + i )
} )

Para passar vários argumentos para uma função, considere criar uma classe de dados.

Para funções que precisam retornar um resultado à camada Android, você pode usar o JSFunctionWithPromise para funções sem argumentos ou JSFunctionWithPromiseAndArg para funções que aceitam um argumento.

 // Kotlin
class AndroidNativeInterface ( val button : Button ): DefaultJSInterface( " Android " ) {

    @NativeCall( CallType . FULL_SYNC )
    fun registerOnClickAction ( jsFunction : JSFunctionWithPromiseAndArg < Add , Int >) {
        button.setOnClickListener {
            val add = Add (( Math .random() * 10 ).toInt(), ( Math .random() * 10 ).toInt())
            jsFunction(add)
                .then{ Log .d( " AndroidNativeInterface " , " Web calculated: ${add.a} + ${add.b} = $it " ) }
                . catch { Log .e( " AndroidNativeInterface " , " ERROR IN WEB LAYER: $it " ) }
        }
    }
    
    data class Add ( a : Int , b : Int )
}

 // Javascript
Bridge . interfaces . Android . registerOnClickAction ( ( add ) => {
    return new Promise ( ( resolve ) => { resolve ( add . a + add . b ) } )
} )

OBSERVAÇÃO

Para liberar uma JSFunction e limpar sua ligação, basta chamar a função close . JSFunction implementa a interface AutoCloseable , permitindo que você utilize os blocos de Try-With-RESOURCES ou AutoCloseable.use {} para gerenciar automaticamente o ciclo de vida da função e garantir a limpeza adequada.

function.use { it() }

Além disso, se o seu aplicativo da Web ou o WebView suportará a recarga, é recomendável adicionar um Afterinitializelistener à ponte. Este ouvinte ajudará a lançar quaisquer JSFunctions disponíveis, garantindo um estado limpo após a inicialização.

Diferentes tipos de chamadas nativas

Esta biblioteca suporta diferentes tipos de chamadas nativas que permitem decidir como chamar o código nativo.

Sincronização completa

O tipo de chamada CallType.FULL_SYNC chama o código nativo de maneira bloqueadora, fazendo com que a execução do JavaScript pause até que a função Android nativa retorne. Como resultado, a visualização da Web permanece sem resposta até a execução nativa estar concluída. (Não recomendado para tarefas de longa duração)

 // Kotlin
@NativeCall( CallType . FULL_SYNC )
fun searchContact ( contactFilter : ContactFilter ): List < Contact > {
    return contactService.search(contactFilter)
}

 // Javascript
console . log ( Bridge . interfaces . Android . searchContact ( { surname : "Pitt" } ) )

Promessa da Web

O tipo CallType.WEB_PROMISE Chamada funciona de maneira semelhante à chamada FULL_SYNC , com a principal diferença é que a chamada JavaScript retorna uma promessa. No entanto, a função Android nativa ainda é invocada de maneira bloqueadora. (Recomendado se você não tiver certeza sobre a duração da tarefa e pode precisar migrar para FULL_PROMISE no futuro)

 // Kotlin
@NativeCall( CallType . WEB_PROMISE )
fun searchContact ( contactFilter : ContactFilter ): List < Contact > {
    return contactService.search(contactFilter)
}

 // Javascript
Bridge . interfaces . Android . searchContact ( { surname : "Pitt" } ) . then ( ( list ) => {
    console . log ( list ) ;
} ) ;

Promessa completa

O tipo de chamada CallType.FULL_PROMISE permite executar o código Android nativo em um encadeamento de segundo plano, permitindo que a execução do JavaScript continue ininterrupta. Como resultado, a visualização da Web permanece responsiva e gratuita para executar suas tarefas. (Recomendado para tarefas de longa duração)

 // Kotlin
@NativeCall( CallType . FULL_PROMISE )
fun searchContact ( contactFilter : ContactFilter ) = doInBackground< List < Contact >> { promise ->
    try {
        promise.resolve(contactService.search(contactFilter))
    } catch (e : Exception ) {
        promise.reject(e)
    }
}

 // Javascript
Bridge . interfaces . Android . searchContact ( { surname : "Pitt" } ) . then ( ( list ) => {
    console . log ( list ) ;
} ) ;

Configurar

Adicione a biblioteca ao seu projeto Android

Adicione o Maven Central ao bloco de repositórios.

 repositories {
    google()
    mavenCentral()
}

Adicione a biblioteca ao bloco de dependências.

 dependencies {
    implementation ' com.github.andycandy-de:simple-android-bridge:1.1.1 '
}

Crie uma interface JavaScript

 class AndroidNativeInterface : DefaultJSInterface ( " Android " ) {

    @NativeCall( CallType . FULL_SYNC )
    fun helloFullSync ( name : String ): String {
        return " hello $name "
    }

    @NativeCall( CallType . WEB_PROMISE )
    fun helloWebPromise ( name : String ): String {
        return " hello $name "
    }

    @NativeCall( CallType . FULL_PROMISE )
    fun helloFullPromise ( name : String ) = doInBackground< String > { promise ->
        promise.resolve( " hello $name " )
    }
}

Crie a ponte e adicione a interface

 val bridge = Bridge (applicationContext, webView)
bridge.addJSInterface( AndroidNativeInterface ())

Inicialize a ponte (JavaScript ou Android)

Código Android

 // Bridge can be initialized by calling the 'init' function inside
// the 'onPageStarted' function of a WebViewClient

webView.webViewClient = object : WebViewClient () {

    override fun onPageStarted ( view : WebView ? , url : String? , favicon : Bitmap ? ) {
        bridge. init ()
    }
}

Código JavaScript

 // Bridge can be initialized by calling the 'init' function in
// Javascript. Register function to 'Bridge.afterInitialize' to
// start the webapp after the bridge is initialized.

function startApp ( f ) {
    if ( Bridge . initialized ) {
        f ( )
    } else {
        Bridge . afterInitialize = f
    }
}

Bridge . init ( )

startApp ( ( ) => {
    // Start your webapp
} ) ;

Acesse a interface no webApp

 console . log ( Bridge . interfaces . Android . helloFullSync ( "Web" ) )

Licença

MIT Licença

A permissão é concedida, gratuita, a qualquer pessoa que obtenha uma cópia deste software e arquivos de documentação associados (o "software"), para lidar com o software sem restrição, inclusive sem limitação os direitos de usar, copiar, modificar, mesclar, publicar, distribuir, mobilizar o software e/ou vender cópias do software e permitir que as pessoas a quem

O aviso de direitos autorais acima e este aviso de permissão devem ser incluídos em todas as cópias ou em partes substanciais do software.

O software é fornecido "como está", sem garantia de qualquer tipo, expresso ou implícito, incluindo, entre outros, as garantias de comercialização, aptidão para uma finalidade específica e não innoculação. Em nenhum caso os autores ou detentores de direitos autorais serão responsáveis por qualquer reclamação, danos ou outro passivo, seja em uma ação de contrato, delito ou não, decorrente de, fora ou em conexão com o software ou o uso ou outras negociações no software.

Expandir

SimpleAndroidBridge

Simplendroidbridge

Características

Compartilhar objetos complexos com facilidade

Promessas facilitadas

Funções de retorno de chamada

Diferentes tipos de chamadas nativas

Sincronização completa

Promessa da Web

Promessa completa

Configurar

Adicione a biblioteca ao seu projeto Android

Crie uma interface JavaScript

Crie a ponte e adicione a interface

Inicialize a ponte (JavaScript ou Android)

Acesse a interface no webApp

Licença

Google Dorks

shepherd

mongo express

hidusbf

Free Algorithms Books

markdownpedia

chat.petals.dev

GPT Prompt Templates

GPTyped

Google Dorks

shepherd

mongo express

Google Dorks

shepherd

mongo express