Name the ways to transfer data between two…

Intents: Used to launch components of another application and pass data via Intent.putExtra(). Supports passing primitive types, String, Parcelable, and Serializable objects.

// Sending data
val intent = Intent("com.example.ANOTHER_APP_ACTION")
intent.putExtra("key", "value")
startActivity(intent)

// Receiving data in another app (in Activity)
val data = intent.getStringExtra("key")

Content Providers: Provide structured access to shared data (e.g., contacts, media). Apps can query, insert, update, and delete data via URI. Requires implementation of ContentProvider in the data source app.

// Example of querying contact data (system ContentProvider)
val cursor = contentResolver.query(
    ContactsContract.Contacts.CONTENT_URI,
    null,
    null,
    null,
    null
)
// ... cursor processing
cursor?.close()

Binder (AIDL): Android Interface Definition Language. Used for inter-process communication (IPC) between two apps. Allows defining a service interface that can be called from another process. Complex to implement, suitable for high-load scenarios or two-way communication.

// Example AIDL interface (in .aidl file)
package com.example.myapp;

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

// Binders are generated from AIDL and used for connection.
// Example of a client using an AIDL service
private var remoteService: IRemoteService? = null
private val connection = object : ServiceConnection {
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        remoteService = IRemoteService.Stub.asInterface(service)
        // Now you can call remoteService methods
    }

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

File Sharing: Via shared directories accessible to both apps (e.g., external storage) or by providing temporary access to files via FileProvider. Requires read/write permissions.

// Example of providing temporary access 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)

Broadcast Receivers: Apps can send and receive broadcast messages. Data is passed via Intent in the Broadcast. Suitable for notifying other apps about events, not for two-way data transfer.

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

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

Sockets: Used for network interaction between apps on the same device (localhost) or over a network. Requires lower-level implementation of network protocols.
Shared Preferences / Databases (limited): Technically possible to use a shared SharedPreferences file or SQLite database located in a shared directory. However, this is not reliable or secure, as it requires careful permission management and synchronization, and can be unsafe. Usually not recommended for data transfer between independent apps.

Name the ways to transfer data between two applications.