Entries

All the data sent by someone to an Inbox is called an Entry. In Threads and Stores, a user must be assigned to the Module to send data. In Inboxes, however, anyone who has Inbox ID can send a reply (assuming they have the Bridge URL and Solution ID).

Inboxes allow users to receive encrypted entries, either from external or internal sources.

• Internal sources are people who have access to an Inbox, or are simply registered in a given Context. Those users are known to your application, and their entries can be linked to their accounts.

• External sources are people from the outside; they do not have an account linked with your app. For example, someone who fills out an online contact form without the need to create an account.

About Entries

The structure of an entry and a brief description of its elements is outlined in the following table:

Define Data Structure

Inbox's architecture does not require you to use a specific data structure inside the entries. Before working with Inboxes, define the structure of your entries.

Example: Form with Text Answer

{
    “content”: {
        "answer": USER_PROVIDED_TEXT
    },
    “version”:number,
    “type”: "text_answer",
}

The type field allows future support for different types of entries like: "select_answer", or "multi_select". And in case of changing the schema, you can always distinguish between them using "version" field.

Remember that this is only an example and you should consider your app's requirements and limitations.

Sending Entries Using Public API

Public submissions require using connectPublic function, provided by the Connection class, to establish a public connection to the platform. After connecting, create an InboxApi instance, which allows to operate on Inboxes.

val connection = Connection.connectPublic(
    solutionId,
    bridgeUrl,
)
val publicInboxApi = InboxApi(connection)

Assuming you need some kind of structure in entries, define a data struct InboxPublicEntryData, and its instance: Define structure of data sending to Inbox entry:

@Serializable
data class InboxPublicEntryData(
    val name: String,
    val surname: String,
    val email: String,
    val comment : String
)

Now, having established public connection and inboxApi, you can send data to the Inbox:

val inboxID = "INBOX_ID"
val inboxPublicEntryData = InboxPublicEntryData(
    "NAME",
    "SURNAME",
    "EMAIL",
    "COMMENT"
)

publicInboxApi.prepareEntry(
    inboxID,
    Json.encodeToString(inboxPublicEntryData).encodeToByteArray(),
).let {
    publicInboxApi.sendEntry(it)
}

Listing Entries

Created entries can be listed by non-public connections created using PrivmxEndpoint class.

val inboxID = "INBOX_ID"
val startIndex = 0L
val pageSize = 100L

val entriesPagingList = inboxApi.listEntries(
    inboxID,
    startIndex,
    pageSize,
    SortOrder.DESC
)

val entries = entriesPagingList.readItems.map {
    EntryItem(
        it,
        Json.decodeFromString(it.data.decodeToString())
    )
}

Reading Files from Entries

Files from Entries can be read by non-public connections created using PrivmxEndpoint class.

val entryID = "ENTRY_ID"
val inboxEntry = inboxApi.readEntry(entryID)

val files: List<File> = inboxEntry.files
val filesContent: List<ByteArray> = files.map { file ->
    inboxApi.openFile(file.info.fileId)
        .let { fileHandle ->
            var fileContent = ByteArray(0)
            do {
                val chunk = inboxApi.readFromFile(fileHandle, StoreFileStream.OPTIMAL_SEND_SIZE)
                fileContent += chunk
            } while (chunk.size.toLong() == StoreFileStream.OPTIMAL_SEND_SIZE)
            inboxApi.closeFile(fileHandle)
            fileContent
        }
}