Jak uzyskać dostęp do rejestru połączeń w systemie Android?

Odpowiedzi:

69

To służy do uzyskiwania dostępu do historii połączeń telefonicznych:

Od Jellybean (4.1) potrzebujesz następujących uprawnień:
<uses-permission android:name="android.permission.READ_CALL_LOG" />

Kod:

 Uri allCalls = Uri.parse("content://call_log/calls");
 Cursor c = managedQuery(allCalls, null, null, null, null);

String num= c.getString(c.getColumnIndex(CallLog.Calls.NUMBER));// for  number
String name= c.getString(c.getColumnIndex(CallLog.Calls.CACHED_NAME));// for name
String duration = c.getString(c.getColumnIndex(CallLog.Calls.DURATION));// for duration
int type = Integer.parseInt(c.getString(c.getColumnIndex(CallLog.Calls.TYPE)));// for call type, Incoming or out going.
— Abhinav Singh Maurya
źródło
11
Nie zapomnij włączyć tego uprawnienia: <używa-pozwolenia android: name = "android.permission.READ_CALL_LOG" /> jest to metoda uzyskiwania dziennika połączeń:
— Aziz
Nie wiem, ale teoretycznie mogę powiedzieć, że wszystkie wiadomości są przechowywane w tej samej bazie danych. Więc tak, może uzyskać dostęp do wszystkich wiadomości urządzenia, niezależnie od podwójnej karty SIM lub jednej karty SIM. Sprawdź ten kod i daj mi znać, jeśli nie działa z podwójną kartą SIM. Zrobię trochę badań i rozwoju i dostarczę ci do tego kod.
— Abhinav Singh Maurya
1
get name zawsze zwróci null, bądź ostrożny
— vuhung3990
@Abhinav Singh Maurya, czy możesz mi pomóc uzyskać dziennik połączeń photo_uri z dzienników połączeń, ponieważ nie mogę uzyskać dziennika połączeń photo_uri z rejestru połączeń
— Sagar
1
managedQuery () przestarzałe użyj tego zamiast tego Cursor cursor = context.getContentResolver (). query (CallLog.Calls.CONTENT_URI, null, null, null, CallLog.Calls.DATE + "DESC");
— Sai Gopi Me
67

Jest to metoda używana do pobierania dziennika połączeń. Po prostu umieść tę metodę w swojej klasie i pobierz listę dziennika połączeń.

Sprawdź to 

private String getCallDetails() {

        StringBuffer sb = new StringBuffer();
        Cursor managedCursor = managedQuery(CallLog.Calls.CONTENT_URI, null,
                null, null, null);
        int number = managedCursor.getColumnIndex(CallLog.Calls.NUMBER);
        int type = managedCursor.getColumnIndex(CallLog.Calls.TYPE);
        int date = managedCursor.getColumnIndex(CallLog.Calls.DATE);
        int duration = managedCursor.getColumnIndex(CallLog.Calls.DURATION);
        sb.append("Call Details :");
        while (managedCursor.moveToNext()) {
            String phNumber = managedCursor.getString(number);
            String callType = managedCursor.getString(type);
            String callDate = managedCursor.getString(date);
            Date callDayTime = new Date(Long.valueOf(callDate));
            String callDuration = managedCursor.getString(duration);
            String dir = null;
            int dircode = Integer.parseInt(callType);
            switch (dircode) {
            case CallLog.Calls.OUTGOING_TYPE:
                dir = "OUTGOING";
                break;

            case CallLog.Calls.INCOMING_TYPE:
                dir = "INCOMING";
                break;

            case CallLog.Calls.MISSED_TYPE:
                dir = "MISSED";
                break;
            }
            sb.append("\nPhone Number:--- " + phNumber + " \nCall Type:--- "
                    + dir + " \nCall Date:--- " + callDayTime
                    + " \nCall duration in sec :--- " + callDuration);
            sb.append("\n----------------------------------");
        }
        managedCursor.close();
        return sb.toString();

    }

wyjście wygląda

wprowadź opis obrazu tutaj

— Dwivedi Ji
źródło
Otrzymuję błąd w managedQuery (CallLog.Calls.CONTENT_URI, null, null, null, null);
— Sunil Parmar
5
Użyłem contentResolver.query (CallLog.Calls.CONTENT_URI, null, null, null, null);
— Sunil Parmar
@Dwivedi Ji - To trochę stary post - Twoja metoda działa, ale załadowanie wszystkich moich dzienników połączeń zajmuje co najmniej 10 sekund.
— TheDevMan
@TheDevMan, przepraszam za niedogodności, tak, masz rację, wkrótce zaktualizuję moją odpowiedź,
— Dwivedi Ji
Dzięki, poczekam na twoją odpowiedź!
— TheDevMan
48

używaj tej metody z dowolnego miejsca z kontekstem 

private static String getCallDetails(Context context) {
    StringBuffer stringBuffer = new StringBuffer();
    Cursor cursor = context.getContentResolver().query(CallLog.Calls.CONTENT_URI,
            null, null, null, CallLog.Calls.DATE + " DESC");
    int number = cursor.getColumnIndex(CallLog.Calls.NUMBER);
    int type = cursor.getColumnIndex(CallLog.Calls.TYPE);
    int date = cursor.getColumnIndex(CallLog.Calls.DATE);
    int duration = cursor.getColumnIndex(CallLog.Calls.DURATION);       
    while (cursor.moveToNext()) {
        String phNumber = cursor.getString(number);
        String callType = cursor.getString(type);
        String callDate = cursor.getString(date);
        Date callDayTime = new Date(Long.valueOf(callDate));
        String callDuration = cursor.getString(duration);
        String dir = null;
        int dircode = Integer.parseInt(callType);
        switch (dircode) {
        case CallLog.Calls.OUTGOING_TYPE:
            dir = "OUTGOING";
            break;
        case CallLog.Calls.INCOMING_TYPE:
            dir = "INCOMING";
            break;

        case CallLog.Calls.MISSED_TYPE:
            dir = "MISSED";
            break;
        }
        stringBuffer.append("\nPhone Number:--- " + phNumber + " \nCall Type:--- "
                + dir + " \nCall Date:--- " + callDayTime
                + " \nCall duration in sec :--- " + callDuration);
        stringBuffer.append("\n----------------------------------");
    }
    cursor.close();
    return stringBuffer.toString();
}
— ingyesid
źródło
7
Ponieważ managedQuery jest teraz przestarzałe, więc ta odpowiedź jest najbardziej odpowiednia.
— abhi
16

Ten post jest trochę stary, ale oto kolejne łatwe rozwiązanie do uzyskiwania danych związanych z Calldostawcą zawartości dzienników w systemie Android:

Użyj tej biblioteki: https://github.com/EverythingMe/easy-content-providers

Odbieraj wszystkie połączenia:

CallsProvider callsProvider = new CallsProvider(context);
List<Call> calls = callsProvider.getCalls().getList();

Każde wezwanie ma wszystkie pola, więc możesz uzyskać wszelkie potrzebne informacje:
data połączenia, czas trwania, numer, typ (PRZYCHODZĄCE, WYCHODZĄCE, NIEODEBRANE), przeczytane, ...

Działa z Listlub Cursori jest przykładowa aplikacja, aby zobaczyć, jak wygląda i działa.

W rzeczywistości istnieje wsparcie dla wszystkich dostawców treści na Androida, takich jak: Kontakty, SMS-y, Kalendarz, ... Pełna dokumentacja ze wszystkimi opcjami: https://github.com/EverythingMe/easy-content-providers/wiki/Android-providers

Mam nadzieję, że to też pomogło :)

— sromku
źródło
Hej, sprawdziłem twoje rozwiązanie, jest dobre. Jedyny problem, z którym się zmagam, to to, jak dodać zależność do mojego projektu zaćmienia?
— Aradhna
@aradhna biblioteka korzysta z gradle i została zbudowana z Android Studio. Myślę, że trzeba będzie trochę zmodyfikować, żeby działał na Eclipse
— sromku
9

w moim projekcie otrzymuję błąd int htc device.now ten kod jest uniwersalny. Myślę, że to dla ciebie pomoc. 

    public class CustomContentObserver extends ContentObserver {        
    public CustomContentObserver(Handler handler) {
        super(handler);
        System.out.println("Content obser");
    }     

    public void onChange(boolean selfChange) {
         super.onChange(selfChange);
         String lastCallnumber;

         currentDate = sdfcur.format(calender.getTime());
         System.out.println("Content obser onChange()");
         Log.d("PhoneService", "custom StringsContentObserver.onChange( " + selfChange + ")");
        //if(!callFlag){                   
         String[] projection = new String[]{CallLog.Calls.NUMBER,
                    CallLog.Calls.TYPE,
                    CallLog.Calls.DURATION,
                    CallLog.Calls.CACHED_NAME,
                    CallLog.Calls._ID};

            Cursor c;   
            c=mContext.getContentResolver().query(CallLog.Calls.CONTENT_URI, projection, null, null, CallLog.Calls._ID + " DESC");
            if(c.getCount()!=0){
                c.moveToFirst();
                 lastCallnumber = c.getString(0);
                 String type=c.getString(1);
                 String duration=c.getString(2);
                 String name=c.getString(3);
                 String id=c.getString(4);
                 System.out.println("CALLLLing:"+lastCallnumber+"Type:"+type);

                 Database db=new Database(mContext);
                 Cursor cur =db.getFirstRecord(lastCallnumber);
                 final String endCall=lastCallnumber;
                 //checking incoming/outgoing call
                 if(type.equals("3")){
                    //missed call
                    }else if(type.equals("1")){
                    //incoming call

                 }else if(type.equals("2")){
                    //outgoing call
                 }                  

            }
            c.close();
    }

}
— Ostry
źródło
2

Aby uzyskać historię tylko połączeń przychodzących, poniższy kod pomoże ci :)

private void getCallDetailsAgil() {

    StringBuffer sb = new StringBuffer();
    Cursor managedCursor = managedQuery(CallLog.Calls.CONTENT_URI, null, null, null, null);
    int number = managedCursor.getColumnIndex(CallLog.Calls.NUMBER);
    int type = managedCursor.getColumnIndex(CallLog.Calls.TYPE);
    int date = managedCursor.getColumnIndex(CallLog.Calls.DATE);
    int duration = managedCursor.getColumnIndex(CallLog.Calls.DURATION);
    sb.append("Call Details :");
    while (managedCursor.moveToNext()) {
        String phNumber = managedCursor.getString(number);
        String callType = managedCursor.getString(type);
        String callDate = managedCursor.getString(date);
        Date callDayTime = new Date(Long.valueOf(callDate));
        String callDuration = managedCursor.getString(duration);
        String dir = null;
        int dircode = Integer.parseInt(callType);


        switch (dircode) {
            case CallLog.Calls.OUTGOING_TYPE:
                dir = "OUTGOING";
                break;

            case CallLog.Calls.INCOMING_TYPE:
                dir = "INCOMING";
                sb.append("\nPhone Number:--- " + phNumber + " \nCall Type:--- " + dir + " \nCall Date:--- " + callDayTime + " \nCall duration in sec :--- " + callDuration);
                sb.append("\n----------------------------------");
                miss_cal.setText(sb);
                break;

            case CallLog.Calls.MISSED_TYPE:
                dir = "MISSED";
                break;
        }
    }

    managedCursor.close();
}
— Agilanbu
źródło
2

Aby uzyskać historię połączeń przychodzących, wychodzących i nieodebranych, miej nadzieję, że ten kod ci pomoże :)

Wywołaj ten kod w swoim wątku w tle.

StringBuffer sb = new StringBuffer();

String[] projection = new String[] {
    CallLog.Calls.CACHED_NAME,
    CallLog.Calls.NUMBER,
    CallLog.Calls.TYPE,
    CallLog.Calls.DATE,
    CallLog.Calls.DURATION
};

sb.append("Call Details :");

// String strOrder = android.provider.CallLog.Calls.DATE + " DESC";

Cursor managedCursor =  getApplicationContext().getContentResolver().query(CallLog.Calls.CONTENT_URI, projection, null, null, null);
while (managedCursor.moveToNext()) {
    String name = managedCursor.getString(0); //name
    String number = managedCursor.getString(1); // number
    String type = managedCursor.getString(2); // type 
    String date = managedCursor.getString(3); // time 
    @SuppressLint("SimpleDateFormat") 
    SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm");
    String dateString = formatter.format(new Date(Long.parseLong(date)));

    String duration = managedCursor.getString(4); // duration

    String dir = null;
    int dircode = Integer.parseInt(type);
    switch (dircode) {
        case CallLog.Calls.OUTGOING_TYPE:
            dir = "OUTGOING";
            break;
        case CallLog.Calls.INCOMING_TYPE:
            dir = "INCOMING";
            break;
        case CallLog.Calls.MISSED_TYPE:
            dir = "MISSED";
            break;
    }

sb.append("\nPhone Name :-- "+name+"  Number:--- " + number + " \nCall Type:--- " + dir + " \nCall Date:--- " + dateString + " \nCall duration in sec :--- " + duration);
sb.append("\n----------------------------------");
— Saurabh Gaddelpalliwar
źródło
1

Użyj poniższego kodu:

private void getCallDeatils() {
    StringBuffer stringBuffer = new StringBuffer();
    Cursor managedCursor = getActivity().managedQuery(CallLog.Calls.CONTENT_URI, null, null, null, null);
    int number = managedCursor.getColumnIndex(CallLog.Calls.NUMBER);
    int type = managedCursor.getColumnIndex(CallLog.Calls.TYPE);
    int date = managedCursor.getColumnIndex(CallLog.Calls.DATE);

    int duration = managedCursor.getColumnIndex(CallLog.Calls.DURATION);
    stringBuffer.append("Call Deatils");
    while (managedCursor.moveToNext()) {
        String phNumber = managedCursor.getString(number);
        String callType = managedCursor.getString(type);
        String callDate = managedCursor.getString(date);
        Date callDayTime = new Date(Long.valueOf(callDate));
        DateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
        String reportDate = df.format(callDayTime);
        String callDuration = managedCursor.getString(duration);
        String dir = null;
        int dircode = Integer.parseInt(callType);
        switch (dircode) {
            case CallLog.Calls.OUTGOING_TYPE:
                dir = "OUTGOING";
                break;

            case CallLog.Calls.INCOMING_TYPE:
                dir = "INCOMING";

                break;

            case CallLog.Calls.MISSED_TYPE:
                dir = "MISSED";
                break;

        }
        stringBuffer.append("\nPhone Number:--- " + phNumber + " \nCall Type:--- " + dir + " \nCall Date:--- " +callDate + " \nCall duration in sec :--- " + callDuration);
        stringBuffer.append("\n----------------------------------");

        logs.add(new LogClass(phNumber,dir,reportDate,callDuration));




    }
— Rohan Lodhi
źródło
0

Jeśli używamy Kotlina, jest krótszy. Przykład klasy, która odpowiada na udostępnienie dzienników połączeń:

import android.content.Context
import android.database.Cursor
import android.provider.CallLog.Calls.*

class CallsLoader {

    fun getCallLogs(context: Context): List<List<String?>> {
        val c = context.applicationContext
        val projection = arrayOf(CACHED_NAME, NUMBER, TYPE, DATE, DURATION)

        val cursor = c.contentResolver.query(
             CONTENT_URI,
             projection,
             null,
             null,
             null,
             null
          )

         return cursorToMatrix(cursor)
     }

    private fun cursorToMatrix(cursor: Cursor?): List<List<String?>> {
        val matrix = mutableListOf<List<String?>>()
        cursor?.use {
             while (it.moveToNext()) {
                 val list = listOf(
                    it.getStringFromColumn(CACHED_NAME),
                    it.getStringFromColumn(NUMBER),
                    it.getStringFromColumn(TYPE),
                    it.getStringFromColumn(DATE),
                    it.getStringFromColumn(DURATION)
                 )

                 matrix.add(list.toList())
             }
          }

          return matrix
      }

     private fun Cursor.getStringFromColumn(columnName: String) =
        getString(getColumnIndex(columnName))
}

Możemy również przekonwertować kursor na mapę:

fun getCallLogs(context: Context): Map<String, Array<String?>> {
    val c = context.applicationContext
    val projection = arrayOf(CACHED_NAME, NUMBER, TYPE, DATE, DURATION)

    val cursor = c.contentResolver.query(
        CONTENT_URI,
        projection,
        null,
        null,
        null,
        null
    )

    return cursorToMap(cursor)
}

private fun cursorToMap(cursor: Cursor?): Map<String, Array<String?>> {
    val arraySize = cursor?.count ?: 0
    val map = mapOf(
        CACHED_NAME to Array<String?>(arraySize) { "" },
        NUMBER to Array<String?>(arraySize) { "" },
        TYPE to Array<String?>(arraySize) { "" },
        DATE to Array<String?>(arraySize) { "" },
        DURATION to Array<String?>(arraySize) { "" }
    )

    cursor?.use {
        for (i in 0 until arraySize) {
            it.moveToNext()

            map[CACHED_NAME]?.set(i, it.getStringFromColumn(CACHED_NAME))
            map[NUMBER]?.set(i, it.getStringFromColumn(NUMBER))
            map[TYPE]?.set(i, it.getStringFromColumn(TYPE))
            map[DATE]?.set(i, it.getStringFromColumn(DATE))
            map[DURATION]?.set(i, it.getStringFromColumn(DURATION))
        }
    }

    return map
}
— Artem Botnev
źródło
0

Przed rozważeniem włączenia uprawnień Czytaj dziennik połączeń lub Czytaj SMS-y do swojej aplikacji, zdecydowanie radzę zapoznać się z tą polityką Google Play Market: https://support.google.com/googleplay/android-developer/answer/9047303 ? hl = en

Te uprawnienia są bardzo wrażliwe i będziesz musiał udowodnić, że Twoja aplikacja ich potrzebuje. Ale nawet jeśli naprawdę ich potrzebuje, zespół pomocy technicznej Google Play może z łatwością odrzucić Twoją prośbę bez odpowiednich wyjaśnień.

To właśnie mi się przytrafiło. Po dostarczeniu wszystkich potrzebnych informacji wraz z filmem demonstracyjnym mojego wniosku został odrzucony z wyjaśnieniem, że moje „konto nie jest upoważnione do zapewniania rozwiązania określonego przypadku użycia w mojej aplikacji” (lista przypadków użycia, które mogą uznać za wyjątek jest wymieniony na tej stronie z zasadami). Nie podano linku do jakiegokolwiek oświadczenia politycznego, które wyjaśniałoby, co to wszystko oznacza. Po prostu ocenili, że moja aplikacja nie działa bez odpowiedniego wyjaśnienia.

Życzę powodzenia z twoimi aplikacjami, ale bądź ostrożny.

— dpetruha
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.