Téléchargement SimpleAndroidBridge - Téléchargement du code source SimpleAndroidBridge

Simplendroidbridge

Construisez un pont! Intégration transparente entre Android et WebApps

Construisez sans effort un pont robuste entre votre Android et WebApp avec la bibliothèque SimpleDroidbridge. Cette bibliothèque vous permet de rendre une application Web dans un Android WebView et de créer une JSInterface pour permettre une communication fluide entre les deux plates-formes. Partagez des objets complexes, des promesses et des fonctions de rappel, tout en étant votre application Web réactive et efficace.

✓ Partagez des objets - Android ⇄ Web

✓ Partager Promise - Android ⇄ Web

✓ Fonctions de rappel - Android ← Web

✓ Fonctions d'appel non bloquantes - Android ⇄ Web

✓ Tapez la sécurité avec TypeScript - Android + Web

Caractéristiques

Partagez facilement des objets complexes

Le pont JavaScript intégré dans le SDK Android ne prend en charge que les types primitifs. Avec SimplendroidBridge, vous pouvez partager facilement des objets complexes entre Android et Web. Définissez simplement les types comme des arguments ou des valeurs de retour dans vos fonctions natives Android, et la bibliothèque convertira automatiquement les objets JavaScript en objets Kotlin et 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" } ) )

Les promesses ont été rendues faciles

Le pont JavaScript dans le SDK Android exécute les fonctions de manière bloquante, ce qui fait que l'application Web se fige jusqu'à ce que la fonction native revienne. Cependant, avec cette bibliothèque, vous pouvez définir un type de retour de promesse, permettant une exécution non bloquante. En utilisant la fonction «Doinbackground», le code Android est exécuté dans un thread d'arrière-plan, empêchant l'application Web d'être bloquée.

 // 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 ) ;
} ) ;

Fonctions de rappel

Si vous connaissez JavaScript, vous n'êtes probablement pas étranger aux fonctions de rappel. Simplendroidbridge pousse ce concept un peu plus loin, vous permettant d'injecter ces fonctions de rappel JavaScript directement dans la couche Android, créant ainsi une interaction transparente entre votre application Web et 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!" )
} )

Pour passer un argument à une fonction JavaScript, utilisez le type JSFunctionWithArg , qui est spécialement conçu pour accepter un argument.

 // 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 )
} )

Pour transmettre plusieurs arguments à une fonction, envisagez de créer une classe de données.

Pour les fonctions qui doivent renvoyer un résultat à la couche Android, vous pouvez utiliser JSFunctionWithPromise pour les fonctions sans arguments ou JSFunctionWithPromiseAndArg pour les fonctions qui acceptent un argument.

 // 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 ) } )
} )

NOTE

Pour libérer une JSFunction et effacer sa liaison, appelez simplement la fonction close . JSFunction implémente l'interface AutoCloseable , vous permettant d'utiliser des blocs TRY-With-Resources ou AutoCloseable.use {} Blocks pour gérer automatiquement le cycle de vie de la fonction et assurer un nettoyage approprié.

function.use { it() }

De plus, si votre application Web ou WebView prend en charge le rechargement, il est recommandé d'ajouter un AftersinitializeListener au pont. Cet auditeur aidera à publier toutes les JSFunctions disponibles, assurant un état propre après initialisation.

Différents types d'appels natifs

Cette bibliothèque prend en charge différents types d'appels natifs qui vous permettent de décider comment appeler le code natif.

Synchronisation complète

Le type d'appel CallType.FULL_SYNC invoque le code natif de manière bloquante, ce qui fait que l'exécution JavaScript s'arrête jusqu'à ce que la fonction Android native revienne. En conséquence, la vue Web reste insensible jusqu'à ce que l'exécution native soit terminée. (Non recommandé pour les tâches de longue date)

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

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

Promesse Web

Le type d'appel CallType.WEB_PROMISE fonctionne de manière similaire à l'appel FULL_SYNC , la différence clé étant que l'appel JavaScript renvoie une promesse. Cependant, la fonction Android native est toujours invoquée de manière bloquante. (Recommandé si vous êtes incertain de la durée de la tâche et que vous pourriez avoir besoin de migrer vers FULL_PROMISE à l'avenir)

 // 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 ) ;
} ) ;

Promesse complète

Le type d'appel CallType.FULL_PROMISE vous permet d'exécuter du code Android natif dans un thread d'arrière-plan, permettant à l'exécution de JavaScript de continuer sans interruption. En conséquence, la vue Web reste réactive et libre d'effectuer ses tâches. (Recommandé pour les tâches de longue date)

 // 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 ) ;
} ) ;

Installation

Ajoutez la bibliothèque à votre projet Android

Ajouter Maven Central au bloc des référentiels.

 repositories {
    google()
    mavenCentral()
}

Ajoutez la bibliothèque au bloc des dépendances.

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

Créer une 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 " )
    }
}

Créez le pont et ajoutez l'interface

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

Initialiser le pont (JavaScript ou Android)

Code 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 ()
    }
}

Code 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
} ) ;

Accéder à l'interface dans le webapp

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

Licence

Licence MIT

L'autorisation est accordée gratuitement à toute personne qui obtient une copie de ce logiciel et des fichiers de documentation associés (le "logiciel"), pour traiter le logiciel sans restriction, y compris sans limiter les droits d'utilisation, de copie, de modification, de fusion, de publication, de distribution, de sublince et / ou de vendre des copies des conditions suivantes.

L'avis de droit d'auteur ci-dessus et le présent avis d'autorisation sont inclus dans toutes les copies ou des parties substantielles du logiciel.

Le logiciel est fourni "tel quel", sans garantie d'aucune sorte, express ou implicite, y compris, mais sans s'y limiter, les garanties de qualité marchande, d'adéquation à un usage particulier et de non-contrefaçon. En aucun cas, les auteurs ou les détenteurs de droits d'auteur ne seront pas responsables de toute réclamation, dommage ou autre responsabilité, que ce soit dans une action de contrat, de délit ou autre, découlant de, hors du logiciel ou de l'utilisation ou d'autres relations dans le logiciel.

Développer

SimpleAndroidBridge

Simplendroidbridge

Caractéristiques

Partagez facilement des objets complexes

Les promesses ont été rendues faciles

Fonctions de rappel

Différents types d'appels natifs

Synchronisation complète

Promesse Web

Promesse complète

Installation

Ajoutez la bibliothèque à votre projet Android

Créer une interface JavaScript

Créez le pont et ajoutez l'interface

Initialiser le pont (JavaScript ou Android)

Accéder à l'interface dans le webapp

Licence

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