Nommez les méthodes de transfert de données entre…

Intentions : Utilisées pour lancer des composants d'une autre application et transférer des données via Intent.putExtra(). Supportent le transfert de types primitifs, String, Parcelable et objets Serializable.

// Envoyer des données
val intent = Intent("com.example.ANOTHER_APP_ACTION")
intent.putExtra("key", "value")
startActivity(intent)

// Recevoir des données dans une autre application (dans l'Activity)
val data = intent.getStringExtra("key")

Content Providers : Fournissent un accès structuré à des données partagées (par exemple, contacts, médias). Les applications peuvent demander, insérer, mettre à jour et supprimer des données via URI. Nécessite la mise en œuvre de ContentProvider dans l'application source de données.
```
// Exemple de requête de données de contacts (ContentProvider système)
val cursor = contentResolver.query(
    ContactsContract.Contacts.CONTENT_URI,
    null,
    null,
    null,
    null
)
// ... traitement du curseur
cursor?.close()
```

Binder (AIDL) : Langage de définition d'interfaces Android. Utilisé pour l'interaction inter-processus (IPC) entre deux applications. Permet de définir une interface de service qui peut être appelée depuis un autre processus. Complexe à implémenter, adapté aux scénarios à haute charge ou à la communication bidirectionnelle.

// Exemple d'interface AIDL (dans un fichier .aidl)
package com.example.myapp;

interface IRemoteService {
    String getData();
    void setData(String value);
}

// Les binders sont générés à partir d'AIDL et utilisés pour la liaison.
// Exemple de client utilisant un service AIDL
private var remoteService: IRemoteService? = null
private val connection = object : ServiceConnection {
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        remoteService = IRemoteService.Stub.asInterface(service)
        // Maintenant, vous pouvez appeler les méthodes de remoteService
    }

    override fun onServiceDisconnected(className: ComponentName) {
        remoteService = null
    }
}

Partage de fichiers : Via des répertoires communs accessibles aux deux applications (par exemple, stockage externe) ou en fournissant un accès temporaire aux fichiers via FileProvider. Nécessite des permissions de lecture/écriture.

// Exemple de fourniture d'accès temporaire via FileProvider
val fileUri = FileProvider.getUriForFile(context, "com.example.myapp.fileprovider", file)
val intent = Intent(Intent.ACTION_VIEW)
intent.setDataAndType(fileUri, "image/*")
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
startActivity(intent)

Récepteurs de Broadcast : Les applications peuvent envoyer et recevoir des messages broadcast. Les données sont transmises via Intent dans le Broadcast. Approprié pour notifier d'autres applications d'événements, pas pour un transfert bidirectionnel de données.

// Envoyer un Broadcast
val intent = Intent("com.example.MY_CUSTOM_ACTION")
intent.putExtra("data", "some_info")
sendBroadcast(intent)

// Recevoir un Broadcast (dans BroadcastReceiver)
class MyReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val data = intent.getStringExtra("data")
        // ...
    }
}

Sockets : Utilisés pour l'interaction réseau entre applications sur un même appareil (localhost) ou via le réseau. Nécessite une implémentation de protocoles réseau de bas niveau.
Préférences Partagées / Bases de Données (limité) : Techniquement, il est possible d'utiliser un fichier partagé de SharedPreferences ou une base de données SQLite située dans un répertoire accessible publiquement. Cependant, ce n'est pas une méthode fiable et sécurisée, car elle nécessite une gestion minutieuse des permissions et de la synchronisation, et peut être non sécurisée. Généralement, non recommandé pour le transfert de données entre applications indépendantes.

Nommez les méthodes de transfert de données entre deux applications.