Ringkasan framework Telecom

Framework Android Telecom (juga dikenal sebagai "Telecom") mengelola panggilan audio dan video di perangkat yang didukung Android. Hal ini termasuk panggilan berbasis SIM, seperti panggilan yang menggunakan framework telepon, dan panggilan VoIP yang menerapkan ConnectionService API.

Komponen utama yang dikelola Telecom adalah ConnectionService dan InCallService.

Implementasi ConnectionService menggunakan teknologi seperti VoIP untuk menghubungkan panggilan ke pihak lain. Implementasi ConnectionService yang paling umum pada ponsel adalah ConnectionService telepon. Menghubungkan panggilan operator.

Implementasi InCallService menyediakan antarmuka pengguna ke panggilan yang dikelola oleh Telecom dan memungkinkan pengguna mengontrol serta berinteraksi dengan panggilan ini. Implementasi InCallService yang paling umum adalah aplikasi telepon yang dipaketkan dengan perangkat.

Telekomunikasi bertindak sebagai switchboard. Library ini merutekan panggilan yang disediakan implementasi ConnectionService ke antarmuka pengguna panggilan yang disediakan oleh implementasi InCallService.

Anda mungkin ingin menerapkan Telecom API karena alasan berikut:

Membuat aplikasi telepon pengganti

Untuk membuat pengganti aplikasi telepon default di perangkat Android, terapkan InCallService API. Implementasi Anda harus memenuhi persyaratan berikut:

  • Aplikasi tidak boleh memiliki kemampuan panggilan, dan harus hanya terdiri dari antarmuka pengguna untuk panggilan.
  • Library ini harus menangani semua panggilan yang diketahui framework Telecom, dan tidak membuat asumsi tentang sifat panggilan. Misalnya, aplikasi tidak boleh mengasumsikan panggilan adalah panggilan telepon berbasis SIM, atau mengimplementasikan pembatasan panggilan yang didasarkan pada satu ConnectionService apa pun, seperti penerapan pembatasan telepon untuk panggilan video.

Untuk mengetahui informasi selengkapnya, lihat InCallService.

Mengintegrasikan solusi panggilan

Untuk mengintegrasikan solusi panggilan ke Android, Anda memiliki opsi berikut:

  • Terapkan ConnectionService API yang dikelola sendiri: Opsi ini ideal untuk developer aplikasi panggilan mandiri yang tidak ingin menampilkan panggilan dalam aplikasi telepon default, atau menampilkan panggilan lain di antarmuka pengguna.

    Saat menggunakan ConnectionService yang dikelola sendiri, Anda membantu aplikasi untuk beroperasi tidak hanya dengan panggilan telepon native di perangkat, tetapi juga dengan aplikasi panggilan mandiri lainnya yang menerapkan API ini. ConnectionService API yang dikelola sendiri juga mengelola pemilihan rute dan fokus audio. Untuk mengetahui detailnya, lihat Mem-build aplikasi panggilan.

  • Implementasikan ConnectionService API terkelola: Opsi ini memfasilitasi pengembangan solusi panggilan yang mengandalkan aplikasi ponsel perangkat yang sudah ada guna menyediakan antarmuka pengguna untuk panggilan. Contohnya mencakup implementasi pihak ketiga untuk layanan panggilan SIP dan panggilan VoIP. Untuk detail selengkapnya, lihat getDefaultDialerPackage().

    ConnectionService saja hanya menyediakan sarana untuk menghubungkan panggilan. Aplikasi ini tidak memiliki antarmuka pengguna terkait.

  • Terapkan InCallService dan ConnectionService API: Opsi ini ideal jika Anda ingin membuat solusi panggilan berbasis ConnectionService sendiri, lengkap dengan antarmuka penggunanya sendiri, dan juga menampilkan semua panggilan Android lainnya dalam antarmuka pengguna yang sama. Saat Anda menggunakan pendekatan ini, penerapan InCallService tidak boleh membuat asumsi tentang sumber panggilan yang ditampilkan. Selain itu, implementasi ConnectionService Anda harus terus berfungsi tanpa aplikasi ponsel default ditetapkan ke InCallService kustom Anda.

Saring panggilan

Perangkat yang menjalankan Android 10 (API level 29) atau yang lebih baru memungkinkan aplikasi Anda mengidentifikasi panggilan dari nomor yang tidak ada di buku alamat pengguna sebagai potensi panggilan spam. Pengguna dapat memilih untuk menolak panggilan spam secara diam-diam. Untuk memberikan transparansi yang lebih besar kepada pengguna saat mereka melewatkan panggilan, informasi tentang panggilan yang diblokir ini dicatat ke dalam log panggilan. Penggunaan Android 10 API menghilangkan persyaratan untuk mendapatkan izin READ_CALL_LOG dari pengguna untuk menyediakan fungsi penyaringan panggilan dan ID penelepon.

Anda menggunakan implementasi CallScreeningService untuk menyaring panggilan. Panggil fungsi onScreenCall() untuk semua panggilan masuk atau keluar baru saat nomor tersebut tidak ada dalam daftar kontak pengguna. Anda dapat memeriksa objek Call.Details untuk mengetahui informasi tentang panggilan. Secara khusus, fungsi getCallerNumberVerificationStatus() menyertakan informasi dari penyedia jaringan tentang angka lainnya. Jika status verifikasi gagal, ini adalah indikasi yang baik bahwa panggilan berasal dari nomor yang tidak valid atau kemungkinan panggilan spam.

Kotlin

class ScreeningService : CallScreeningService() {
    // This function is called when an ingoing or outgoing call
    // is from a number not in the user's contacts list
    override fun onScreenCall(callDetails: Call.Details) {
        // Can check the direction of the call
        val isIncoming = callDetails.callDirection == Call.Details.DIRECTION_INCOMING

        if (isIncoming) {
            // the handle (e.g. phone number) that the Call is currently connected to
            val handle: Uri = callDetails.handle

            // determine if you want to allow or reject the call
            when (callDetails.callerNumberVerificationStatus) {
                Connection.VERIFICATION_STATUS_FAILED -> {
                    // Network verification failed, likely an invalid/spam call.
                }
                Connection.VERIFICATION_STATUS_PASSED -> {
                    // Network verification passed, likely a valid call.
                }
                else -> {
                    // Network could not perform verification.
                    // This branch matches Connection.VERIFICATION_STATUS_NOT_VERIFIED.
                }
            }
        }
    }
}

Java

class ScreeningService extends CallScreeningService {
    @Override
    public void onScreenCall(@NonNull Call.Details callDetails) {
        boolean isIncoming = callDetails.getCallDirection() == Call.Details.DIRECTION_INCOMING;

        if (isIncoming) {
            Uri handle = callDetails.getHandle();

            switch (callDetails.getCallerNumberVerificationStatus()) {
                case Connection.VERIFICATION_STATUS_FAILED:
                    // Network verification failed, likely an invalid/spam call.
                    break;
                case Connection.VERIFICATION_STATUS_PASSED:
                    // Network verification passed, likely a valid call.
                    break;
                default:
                    // Network could not perform verification.
                    // This branch matches Connection.VERIFICATION_STATUS_NOT_VERIFIED
            }
        }
    }
}

Tetapkan fungsi onScreenCall() untuk memanggil respondToCall() guna memberi tahu sistem cara merespons panggilan baru. Fungsi ini menggunakan parameter CallResponse yang dapat Anda gunakan untuk memberi tahu sistem agar memblokir panggilan, menolak seolah-olah pengguna melakukannya, atau membisukannya. Anda juga dapat memberi tahu sistem untuk melewati penambahan panggilan ini ke log panggilan perangkat sepenuhnya.

Kotlin

// Tell the system how to respond to the incoming call
// and if it should notify the user of the call.
val response = CallResponse.Builder()
    // Sets whether the incoming call should be blocked.
    .setDisallowCall(false)
    // Sets whether the incoming call should be rejected as if the user did so manually.
    .setRejectCall(false)
    // Sets whether ringing should be silenced for the incoming call.
    .setSilenceCall(false)
    // Sets whether the incoming call should not be displayed in the call log.
    .setSkipCallLog(false)
    // Sets whether a missed call notification should not be shown for the incoming call.
    .setSkipNotification(false)
    .build()

// Call this function to provide your screening response.
respondToCall(callDetails, response)

Java

// Tell the system how to respond to the incoming call
// and if it should notify the user of the call.
CallResponse.Builder response = new CallResponse.Builder();
// Sets whether the incoming call should be blocked.
response.setDisallowCall(false);
// Sets whether the incoming call should be rejected as if the user did so manually.
response.setRejectCall(false);
// Sets whether ringing should be silenced for the incoming call.
response.setSilenceCall(false);
// Sets whether the incoming call should not be displayed in the call log.
response.setSkipCallLog(false);
// Sets whether a missed call notification should not be shown for the incoming call.
response.setSkipNotification(false);

// Call this function to provide your screening response.
respondToCall(callDetails, response.build());

Anda harus mendaftarkan implementasi CallScreeningService dalam file manifes dengan filter intent dan izin yang sesuai agar sistem dapat memicu dengan benar.

<service
    android:name=".ScreeningService"
    android:permission="android.permission.BIND_SCREENING_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.CallScreeningService" />
    </intent-filter>
</service>

Mengalihkan panggilan

Perangkat yang menjalankan Android 10 atau yang lebih tinggi mengelola intent panggilan secara berbeda dari perangkat yang menjalankan Android 9 atau yang lebih rendah. Pada Android 10 dan yang lebih tinggi, siaran ACTION_NEW_OUTGOING_CALL tidak digunakan lagi dan diganti dengan CallRedirectionService API. CallRedirectionService menyediakan antarmuka yang dapat Anda gunakan untuk mengubah panggilan keluar yang dilakukan oleh platform Android. Misalnya, aplikasi pihak ketiga mungkin membatalkan panggilan dan mengalihkannya melalui VoIP.

Kotlin

class RedirectionService : CallRedirectionService() {
    override fun onPlaceCall(
        handle: Uri,
        initialPhoneAccount: PhoneAccountHandle,
        allowInteractiveResponse: Boolean
    ) {
        // Determine if the call should proceed, be redirected, or cancelled.
        val callShouldProceed = true
        val callShouldRedirect = false
        when {
            callShouldProceed -> {
                placeCallUnmodified()
            }
            callShouldRedirect -> {
                // Update the URI to point to a different phone number or modify the
                // PhoneAccountHandle and redirect.
                redirectCall(handle, initialPhoneAccount, true)
            }
            else -> {
                cancelCall()
            }
        }
    }
}

Java

class RedirectionService extends CallRedirectionService {
    @Override
    public void onPlaceCall(
            @NonNull Uri handle,
            @NonNull PhoneAccountHandle initialPhoneAccount,
            boolean allowInteractiveResponse
    ) {
        // Determine if the call should proceed, be redirected, or cancelled.
        // Your app should implement this logic to determine the redirection.
        boolean callShouldProceed = true;
        boolean callShouldRedirect = false;
        if (callShouldProceed) {
            placeCallUnmodified();
        } else if (callShouldRedirect) {
            // Update the URI to point to a different phone number or modify the
            // PhoneAccountHandle and redirect.
            redirectCall(handle, initialPhoneAccount, true);
        } else {
            cancelCall();
        }
    }
}

Anda harus mendaftarkan layanan ini dalam manifes agar sistem dapat memulainya dengan benar.

<service
    android:name=".RedirectionService"
    android:permission="android.permission.BIND_CALL_REDIRECTION_SERVICE">
    <intent-filter>
        <action android:name="android.telecom.CallRedirectionService"/>
    </intent-filter>
</service>

Untuk menggunakan layanan pengalihan, aplikasi Anda harus meminta peran pengalihan panggilan dari RoleManager. Langkah ini akan menanyakan pengguna apakah mereka ingin mengizinkan aplikasi Anda menangani pengalihan panggilan. Jika aplikasi Anda tidak diberi peran ini, layanan pengalihan tidak akan digunakan.

Sebaiknya periksa apakah aplikasi Anda memiliki peran ini saat pengguna meluncurkan aplikasi agar Anda dapat memintanya sesuai kebutuhan. Anda meluncurkan intent yang dibuat oleh RoleManager, jadi pastikan Anda mengganti fungsi onActivityResult() untuk menangani pilihan pengguna.

Kotlin

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Tell the system that you want your app to handle call redirects. This
        // is done by using the RoleManager to register your app to handle redirects.
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
            val roleManager = getSystemService(Context.ROLE_SERVICE) as RoleManager
            // Check if the app needs to register call redirection role.
            val shouldRequestRole = roleManager.isRoleAvailable(RoleManager.ROLE_CALL_REDIRECTION) &&
                    !roleManager.isRoleHeld(RoleManager.ROLE_CALL_REDIRECTION)
            if (shouldRequestRole) {
                val intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_REDIRECTION)
                startActivityForResult(intent, REDIRECT_ROLE_REQUEST_CODE)
            }
        }
    }

    companion object {
        private const val REDIRECT_ROLE_REQUEST_CODE = 1
    }
}

Java

class MainActivity extends AppCompatActivity {
    private static final int REDIRECT_ROLE_REQUEST_CODE = 0;

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

        // Tell the system that you want your app to handle call redirects. This
        // is done by using the RoleManager to register your app to handle redirects.
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
            RoleManager roleManager = (RoleManager) getSystemService(Context.ROLE_SERVICE);
            // Check if the app needs to register call redirection role.
            boolean shouldRequestRole = roleManager.isRoleAvailable(RoleManager.ROLE_CALL_REDIRECTION) &&
                    !roleManager.isRoleHeld(RoleManager.ROLE_CALL_REDIRECTION);
            if (shouldRequestRole) {
                Intent intent = roleManager.createRequestRoleIntent(RoleManager.ROLE_CALL_REDIRECTION);
                startActivityForResult(intent, REDIRECT_ROLE_REQUEST_CODE);
            }
        }
    }
}