> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-rn-guide-message-privately.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Call Logs

> Display CometChat Calls SDK v5 call logs on Android with call history, participants, call type, duration, and status details.

Retrieve call history for your application. Call logs provide detailed information about past calls including duration, participants, recordings, and status.

## Fetch Call Logs

Use `CallLogRequest` to fetch call logs with pagination support. The builder pattern allows you to filter results by various criteria.

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    val callLogRequest = CallLogRequest.CallLogRequestBuilder()
        .setLimit(30)
        .build()

    callLogRequest.fetchNext(object : CometChatCalls.CallbackListener<List<CallLog>>() {
        override fun onSuccess(callLogs: List<CallLog>) {
            for (callLog in callLogs) {
                Log.d(TAG, "Session: ${callLog.sessionID}")
                Log.d(TAG, "Duration: ${callLog.totalDuration}")
                Log.d(TAG, "Status: ${callLog.status}")
            }
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "Error: ${e.message}")
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    CallLogRequest callLogRequest = new CallLogRequest.CallLogRequestBuilder()
        .setLimit(30)
        .build();

    callLogRequest.fetchNext(new CometChatCalls.CallbackListener<List<CallLog>>() {
        @Override
        public void onSuccess(List<CallLog> callLogs) {
            for (CallLog callLog : callLogs) {
                Log.d(TAG, "Session: " + callLog.getSessionID());
                Log.d(TAG, "Duration: " + callLog.getTotalDuration());
                Log.d(TAG, "Status: " + callLog.getStatus());
            }
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "Error: " + e.getMessage());
        }
    });
    ```
  </Tab>
</Tabs>

## CallLogRequestBuilder

Configure the request using the builder methods:

| Method                     | Type    | Description                                                      |
| -------------------------- | ------- | ---------------------------------------------------------------- |
| `setLimit(int)`            | int     | Number of call logs to fetch per request (default: 30, max: 100) |
| `setSessionType(String)`   | String  | Filter by call type: `video` or `audio`                          |
| `setCallStatus(String)`    | String  | Filter by call status                                            |
| `setHasRecording(boolean)` | boolean | Filter calls that have recordings                                |
| `setCallCategory(String)`  | String  | Filter by category: `call` or `meet`                             |
| `setCallDirection(String)` | String  | Filter by direction: `incoming` or `outgoing`                    |
| `setUid(String)`           | String  | Filter calls with a specific user                                |
| `setGuid(String)`          | String  | Filter calls with a specific group                               |

### Filter Examples

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    // Fetch only video calls
    val videoCallsRequest = CallLogRequest.CallLogRequestBuilder()
        .setSessionType("video")
        .setLimit(20)
        .build()

    // Fetch calls with recordings
    val recordedCallsRequest = CallLogRequest.CallLogRequestBuilder()
        .setHasRecording(true)
        .build()

    // Fetch missed incoming calls
    val missedCallsRequest = CallLogRequest.CallLogRequestBuilder()
        .setCallStatus("missed")
        .setCallDirection("incoming")
        .build()

    // Fetch calls with a specific user
    val userCallsRequest = CallLogRequest.CallLogRequestBuilder()
        .setUid("user_id")
        .build()
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    // Fetch only video calls
    CallLogRequest videoCallsRequest = new CallLogRequest.CallLogRequestBuilder()
        .setSessionType("video")
        .setLimit(20)
        .build();

    // Fetch calls with recordings
    CallLogRequest recordedCallsRequest = new CallLogRequest.CallLogRequestBuilder()
        .setHasRecording(true)
        .build();

    // Fetch missed incoming calls
    CallLogRequest missedCallsRequest = new CallLogRequest.CallLogRequestBuilder()
        .setCallStatus("missed")
        .setCallDirection("incoming")
        .build();

    // Fetch calls with a specific user
    CallLogRequest userCallsRequest = new CallLogRequest.CallLogRequestBuilder()
        .setUid("user_id")
        .build();
    ```
  </Tab>
</Tabs>

## Pagination

Use `fetchNext()` and `fetchPrevious()` for pagination:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    // Fetch next page
    callLogRequest.fetchNext(object : CometChatCalls.CallbackListener<List<CallLog>>() {
        override fun onSuccess(callLogs: List<CallLog>) {
            // Handle next page
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "Error: ${e.message}")
        }
    })

    // Fetch previous page
    callLogRequest.fetchPrevious(object : CometChatCalls.CallbackListener<List<CallLog>>() {
        override fun onSuccess(callLogs: List<CallLog>) {
            // Handle previous page
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "Error: ${e.message}")
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    // Fetch next page
    callLogRequest.fetchNext(new CometChatCalls.CallbackListener<List<CallLog>>() {
        @Override
        public void onSuccess(List<CallLog> callLogs) {
            // Handle next page
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "Error: " + e.getMessage());
        }
    });

    // Fetch previous page
    callLogRequest.fetchPrevious(new CometChatCalls.CallbackListener<List<CallLog>>() {
        @Override
        public void onSuccess(List<CallLog> callLogs) {
            // Handle previous page
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "Error: " + e.getMessage());
        }
    });
    ```
  </Tab>
</Tabs>

## CallLog Object

Each `CallLog` object contains detailed information about a call:

| Property                 | Type                   | Description                            |
| ------------------------ | ---------------------- | -------------------------------------- |
| `sessionID`              | String                 | Unique identifier for the call session |
| `initiator`              | CallEntity             | User who initiated the call            |
| `receiver`               | CallEntity             | User or group that received the call   |
| `receiverType`           | String                 | `user` or `group`                      |
| `type`                   | String                 | Call type: `video` or `audio`          |
| `status`                 | String                 | Final status of the call               |
| `callCategory`           | String                 | Category: `call` or `meet`             |
| `initiatedAt`            | long                   | Timestamp when call was initiated      |
| `endedAt`                | long                   | Timestamp when call ended              |
| `totalDuration`          | String                 | Human-readable duration (e.g., "5:30") |
| `totalDurationInMinutes` | double                 | Duration in minutes                    |
| `totalAudioMinutes`      | double                 | Audio duration in minutes              |
| `totalVideoMinutes`      | double                 | Video duration in minutes              |
| `totalParticipants`      | int                    | Number of participants                 |
| `hasRecording`           | boolean                | Whether the call was recorded          |
| `recordings`             | List\<Recording>       | List of recording objects              |
| `participantInfoList`    | List\<ParticipantInfo> | List of participant details            |

## Access Recordings

If a call has recordings, access them through the `recordings` property:

<Tabs>
  <Tab title="Kotlin">
    ```kotlin theme={null}
    callLogRequest.fetchNext(object : CometChatCalls.CallbackListener<List<CallLog>>() {
        override fun onSuccess(callLogs: List<CallLog>) {
            for (callLog in callLogs) {
                if (callLog.isHasRecording) {
                    callLog.recordings?.forEach { recording ->
                        Log.d(TAG, "Recording ID: ${recording.rid}")
                        Log.d(TAG, "Recording URL: ${recording.recordingURL}")
                        Log.d(TAG, "Duration: ${recording.duration} seconds")
                    }
                }
            }
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "Error: ${e.message}")
        }
    })
    ```
  </Tab>

  <Tab title="Java">
    ```java theme={null}
    callLogRequest.fetchNext(new CometChatCalls.CallbackListener<List<CallLog>>() {
        @Override
        public void onSuccess(List<CallLog> callLogs) {
            for (CallLog callLog : callLogs) {
                if (callLog.isHasRecording()) {
                    for (Recording recording : callLog.getRecordings()) {
                        Log.d(TAG, "Recording ID: " + recording.getRid());
                        Log.d(TAG, "Recording URL: " + recording.getRecordingURL());
                        Log.d(TAG, "Duration: " + recording.getDuration() + " seconds");
                    }
                }
            }
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "Error: " + e.getMessage());
        }
    });
    ```
  </Tab>
</Tabs>

<Accordion title="Call Status Values">
  | Status       | Description                         |
  | ------------ | ----------------------------------- |
  | `ongoing`    | Call is currently in progress       |
  | `busy`       | Receiver was busy                   |
  | `rejected`   | Call was rejected                   |
  | `cancelled`  | Call was cancelled by initiator     |
  | `ended`      | Call ended normally                 |
  | `missed`     | Call was missed                     |
  | `initiated`  | Call was initiated but not answered |
  | `unanswered` | Call was not answered               |
</Accordion>

<Accordion title="Call Category Values">
  | Category | Description               |
  | -------- | ------------------------- |
  | `call`   | Direct call between users |
  | `meet`   | Meeting/conference call   |
</Accordion>

<Accordion title="Call Direction Values">
  | Direction  | Description                |
  | ---------- | -------------------------- |
  | `incoming` | Call received by the user  |
  | `outgoing` | Call initiated by the user |
</Accordion>