### Install Targets and Files

Source: https://github.com/kde/akonadi/blob/master/src/xml/CMakeLists.txt

Defines installation rules for the library, executable, headers, and schema files.

```cmake
install(TARGETS KPim6AkonadiXml EXPORT KPim6AkonadiTargets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})

install(
    TARGETS
        akonadi2xml
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)

install(
    FILES
        ${CMAKE_CURRENT_BINARY_DIR}/akonadi-xml_export.h
        ${AkonadiXml_HEADERS}
    DESTINATION ${AkonadiXml_INSTALL_INCLUDEDIR}/akonadi
    COMPONENT Devel
)
install(FILES ${AkonadiXml_CC_HEADERS} DESTINATION ${AkonadiXml_INSTALL_INCLUDEDIR}/Akonadi COMPONENT Devel)

install(FILES akonadi-xml.xsd DESTINATION ${KDE_INSTALL_DATADIR_KF}/akonadi/)
```

--------------------------------

### Configure Installation Paths

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Sets installation directories for DBus interfaces and include files.

```cmake
if(IS_ABSOLUTE "${KDE_INSTALL_DBUSINTERFACEDIR}")
    set(AKONADI_DBUS_INTERFACES_INSTALL_DIR "${KDE_INSTALL_DBUSINTERFACEDIR}")
else()
    set(AKONADI_DBUS_INTERFACES_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${KDE_INSTALL_DBUSINTERFACEDIR}")
endif()

if(IS_ABSOLUTE "${KDE_INSTALL_INCLUDEDIR}/KPim6")
    set(AKONADI_INCLUDE_DIR "${KDE_INSTALL_INCLUDEDIR}/KPim6")
else()
    set(AKONADI_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/${KDE_INSTALL_INCLUDEDIR}/KPim6")
endif()
```

--------------------------------

### Install ClangBuildAnalyzer

Source: https://github.com/kde/akonadi/blob/master/readme-build-ftime.txt

Build and install the ClangBuildAnalyzer tool from source.

```bash
git clone https://github.com/aras-p/ClangBuildAnalyzer
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=<path> ../
make install
```

--------------------------------

### Install Executable Target

Source: https://github.com/kde/akonadi/blob/master/src/rds/CMakeLists.txt

Installs the 'akonadi_rds' executable to the default system locations. ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} ensures standard installation behavior.

```cmake
install(
    TARGETS
        akonadi_rds
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Akonadi::ResourceBase Implementation Example

Source: https://context7.com/kde/akonadi/llms.txt

This example demonstrates how to implement a custom resource agent by inheriting from Akonadi::ResourceBase. It covers basic configuration, fetching collections and items, and handling item add, change, and remove operations.

```APIDOC
## Akonadi::ResourceBase

Base class for implementing Akonadi resource agents that connect external data sources to the Akonadi storage. Provides the framework for synchronizing collections and items, handling change notifications, and managing online/offline state.

### Description

This section details the implementation of a custom resource agent using the `Akonadi::ResourceBase` class. It outlines the necessary steps for configuring the resource, defining how collections and items are retrieved, and how changes to items are processed and synchronized with an external backend.

### Method

C++ (using the Akonadi framework)

### Endpoint

N/A (This is a C++ class implementation, not a network endpoint)

### Parameters

N/A for the base class itself, but derived classes implement virtual methods that take specific parameters:

#### Derived Class Constructor Parameters

- **id** (QString) - Required - A unique identifier for the resource instance.

#### Virtual Methods (Implemented by derived classes)

- **retrieveCollections()**: Called to fetch the collection structure from the external backend.
- **retrieveItems(const Collection &collection)**: Called to fetch items belonging to a specific collection.
- **retrieveItem(const Item &item, const QSet<QByteArray> &parts)**: Called to fetch the full data for a specific item on demand.
- **itemAdded(const Item &item, const Collection &collection)**: Called when a new item is added locally, to be synced to the backend.
- **itemChanged(const Item &item, const QSet<QByteArray> &parts)**: Called when an existing item is modified locally, to be synced to the backend.
- **itemRemoved(const Item &item)**: Called when an item is removed locally, to be synced to the backend.

### Request Body

N/A (This is a C++ class implementation)

### Response

N/A (This is a C++ class implementation)

### Example Usage (C++)

```cpp
#include <Akonadi/ResourceBase>

using namespace Akonadi;

class MyResource : public ResourceBase
{
    Q_OBJECT

public:
    explicit MyResource(const QString &id)
        : ResourceBase(id)
    {
        // Configure the resource
        setName(i18n("My External Data Source"));
        setAutomaticProgressReporting(true);

        // Configure change recorder
        changeRecorder()->itemFetchScope().fetchFullPayload(true);
    }

protected Q_SLOTS:
    void retrieveCollections() override
    {
        // Fetch collection structure from backend
        Collection::List collections;

        Collection root;
        root.setName(name());
        root.setRemoteId(QStringLiteral("root"));
        root.setParentCollection(Collection::root());
        root.setContentMimeTypes({Collection::mimeType(),
                                   QStringLiteral("text/calendar")});
        collections.append(root);

        // Report collections to Akonadi
        collectionsRetrieved(collections);
    }

    void retrieveItems(const Collection &collection) override
    {
        // Fetch items from backend for this collection
        Item::List items;

        // ... fetch from external source ...

        for (const auto &externalItem : externalItems) {
            Item item;
            item.setRemoteId(externalItem.id);
            item.setMimeType(QStringLiteral("text/calendar"));
            item.setPayloadFromData(externalItem.data);
            items.append(item);
        }

        itemsRetrieved(items);
    }

    bool retrieveItem(const Item &item, const QSet<QByteArray> &parts) override
    {
        // Fetch full item data on demand
        Item fetchedItem = item;
        QByteArray data = fetchFromBackend(item.remoteId());
        fetchedItem.setPayloadFromData(data);

        itemRetrieved(fetchedItem);
        return true;
    }

    void itemAdded(const Item &item, const Collection &collection) override
    {
        // Handle locally created items - sync to backend
        QString remoteId = uploadToBackend(item.payloadData());

        Item newItem = item;
        newItem.setRemoteId(remoteId);
        changeCommitted(newItem);
    }

    void itemChanged(const Item &item, const QSet<QByteArray> &parts) override
    {
        updateOnBackend(item.remoteId(), item.payloadData());
        changeCommitted(item);
    }

    void itemRemoved(const Item &item) override
    {
        deleteFromBackend(item.remoteId());
        changeProcessed();
    }
};

// In main.cpp
int main(int argc, char **argv)
{
    return ResourceBase::init<MyResource>(argc, argv);
}
```
```

--------------------------------

### Profile Build Performance

Source: https://github.com/kde/akonadi/blob/master/readme-build-ftime.txt

Commands to start, build, stop, and analyze the build trace.

```bash
cmake --preset ftime-trace

ClangBuildAnalyzer --start $PWD/build-ftime-trace
cmake --build --preset ftime-trace

ClangBuildAnalyzer --stop $PWD/build-ftime-trace build-ftime.txt

ClangBuildAnalyzer --analyze build-ftime.txt > analyze-build-ftime.txt
```

--------------------------------

### Install Akonadi Helper Applications

Source: https://github.com/kde/akonadi/blob/master/src/agentserver/CMakeLists.txt

Defines the installation rules for the agent launcher and agent server executables.

```cmake
# Install both helper apps.
install(
    TARGETS
        akonadi_agent_launcher
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)

install(
    TARGETS
        akonadi_agent_server
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Install Executable Target

Source: https://github.com/kde/akonadi/blob/master/templates/akonadiresource/src/CMakeLists.txt

Installs the Akonadi resource executable to the default location. ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} ensures standard installation practices are followed.

```cmake
install(
    TARGETS
        akonadi_%{APPNAMELC}_resource
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Install Executable Target

Source: https://github.com/kde/akonadi/blob/master/src/asapcat/CMakeLists.txt

Defines the installation rules for the 'asapcat' executable.

```cmake
install(
    TARGETS
        asapcat
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Install Desktop File

Source: https://github.com/kde/akonadi/blob/master/templates/akonadiresource/src/CMakeLists.txt

Installs the resource's desktop file to the Akonadi agents directory. This makes the resource discoverable by the Akonadi framework.

```cmake
install(FILES %{APPNAMELC}resource.desktop DESTINATION ${KDE_INSTALL_DATAROOTDIR}/akonadi/agents)
```

--------------------------------

### Install Akonadi Database Migrator

Source: https://github.com/kde/akonadi/blob/master/src/server/dbmigrator/CMakeLists.txt

Installs the Akonadi database migrator executable to the default system locations. This makes the migrator tool available after installation.

```cmake
install(
    TARGETS
        akonadi-db-migrator
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Install Pre-commit Hook

Source: https://github.com/kde/akonadi/blob/master/README-pre-commit.md

Force the installation of pre-commit hooks. This is useful for overwriting existing configurations.

```bash
pre-commit install -f
```

--------------------------------

### Install Akonadi Agent Config Dialog Executable and Desktop File

Source: https://github.com/kde/akonadi/blob/master/src/configdialog/CMakeLists.txt

Installs the 'akonadiagentconfigdialog' executable and its associated desktop file to the appropriate system directories.

```cmake
install(
    TARGETS
        akonadiagentconfigdialog
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
install(FILES org.kde.akonadi.configdialog.desktop DESTINATION ${KDE_INSTALL_APPDIR})
```

--------------------------------

### Setup QtPlugin Macro Names

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Configures Qt plugin macro names using the ecm_setup_qtplugin_macro_names function.

```cmake
ecm_setup_qtplugin_macro_names(
    MACRO_NAMES
        "AKONADI_AGENTCONFIG_FACTORY"
    CONFIG_CODE_VARIABLE
        PACKAGE_SETUP_AUTOMOC_VARIABLES
)
```

--------------------------------

### Install Akonadi Test Executable

Source: https://github.com/kde/akonadi/blob/master/autotests/libs/testrunner/CMakeLists.txt

Configures the installation of the 'akonaditest' executable. This ensures the executable is placed in the correct location during the installation phase of the build process.

```cmake
install(
    TARGETS
        akonaditest
        ${KDE_INSTALL_TARGETS_DEFAULT_ARGS}
)
```

--------------------------------

### Generate and Install Headers

Source: https://github.com/kde/akonadi/blob/master/src/shared/CMakeLists.txt

Generates headers using ecm_generate_headers and installs them to the designated include directory.

```cmake
ecm_generate_headers(shared_CC_HEADERS
    HEADER_NAMES
    VectorHelper
    REQUIRED_HEADERS shared_HEADERS
    PREFIX Akonadi
)

# shared is not generally a public library, so install only the useful
# public stuff to core
install(FILES ${shared_HEADERS} DESTINATION ${AkonadiCore_INSTALL_INCLUDEDIR}/akonadi COMPONENT Devel)
install(FILES ${shared_CC_HEADERS} DESTINATION ${AkonadiCore_INSTALL_INCLUDEDIR}/Akonadi COMPONENT Devel)
```

--------------------------------

### Configure Akonadi Serializer Plugin Build

Source: https://github.com/kde/akonadi/blob/master/templates/akonadiserializer/src/CMakeLists.txt

Defines sources, creates a library, links against AkonadiCore, and installs the plugin and its desktop file.

```cmake
set(akonadi_serializer_%{APPNAMELC}_SRCS
    akonadi_serializer_%{APPNAMELC}.cpp
    akonadi_serializer_%{APPNAMELC}.h
)

add_library(akonadi_serializer_%{APPNAMELC} MODULE ${akonadi_serializer_%{APPNAMELC}_SRCS})

target_link_libraries(akonadi_serializer_%{APPNAMELC} KF6::AkonadiCore)

install(TARGETS akonadi_serializer_%{APPNAMELC} DESTINATION ${KDE_INSTALL_PLUGINDIR})

install(FILES akonadi_serializer_%{APPNAMELC}.desktop DESTINATION ${KDE_INSTALL_DATADIR}/akonadi/plugins/serializer)
```

--------------------------------

### Install Akonadi Pre-commit Hook on openSUSE

Source: https://github.com/kde/akonadi/blob/master/README-pre-commit.md

Use this command to install the Python 3.13 pre-commit package on openSUSE systems.

```bash
zypper in python313-pre-commit
```

--------------------------------

### Run Pre-commit Hooks on All Files

Source: https://github.com/kde/akonadi/blob/master/README-pre-commit.md

Execute pre-commit hooks for all files in the repository. Ensure pre-commit is installed and configured.

```bash
pre-commit run --all
```

--------------------------------

### Install Akonadi Icons with ECM

Source: https://github.com/kde/akonadi/blob/master/icons/CMakeLists.txt

Use the ecm_install_icons macro to install application icons. Ensure the ICONS variable is populated with the desired icon files and the DESTINATION is correctly set to KDE_INSTALL_ICONDIR.

```cmake
include(ECMInstallIcons)

set(icons
    16-apps-akonadi.png
    22-apps-akonadi.png
    32-apps-akonadi.png
    48-apps-akonadi.png
    64-apps-akonadi.png
    128-apps-akonadi.png
    256-apps-akonadi.png
    sc-apps-akonadi.svgz
)

ecm_install_icons(ICONS ${icons} DESTINATION ${KDE_INSTALL_ICONDIR})
```

--------------------------------

### Determine Python Installation Directory

Source: https://github.com/kde/akonadi/blob/master/python/CMakeLists.txt

Executes a Python command to retrieve the platform-specific library path and sets it for installation.

```cmake
execute_process(
    COMMAND
        ${Python_EXECUTABLE} -Esc
        "import sysconfig; print(sysconfig.get_path('platlib', vars={'platbase': '${CMAKE_INSTALL_PREFIX}', 'base': '${CMAKE_INSTALL_PREFIX}'}))"
    OUTPUT_VARIABLE sysconfig_output
)
string(STRIP ${sysconfig_output} PYTHON_INSTALL_DIR)

install(TARGETS ${bindings_library} LIBRARY DESTINATION "${PYTHON_INSTALL_DIR}")
```

--------------------------------

### Configure Akonadi Data Directory

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Sets the installation directory for Akonadi data based on whether the provided path is absolute.

```cmake
if(IS_ABSOLUTE "${KDE_INSTALL_DATADIR_KF}")
    set(KF5Akonadi_DATA_DIR "${KDE_INSTALL_DATADIR_KF}/akonadi")
else()
    set(KF5Akonadi_DATA_DIR "${CMAKE_INSTALL_PREFIX}/${KDE_INSTALL_DATADIR_KF}/akonadi")
endif()
```

--------------------------------

### Set Multiple Content Mimetypes for a Collection

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

This example shows how to configure a collection to hold multiple types of data, such as collections themselves, contacts, and emails, by specifying their respective mimetypes.

```cpp
col.setContentMimetypes({
    Akonadi::Collection::mimeType(),
    KABC::Addressee::mimeType(),
    KMime::Message::mimeType() });
```

--------------------------------

### Find Qt6 Packages

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Finds required Qt6 core libraries. Ensure Qt6 is installed and discoverable by CMake.

```cmake
find_package(Qt6Core ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Sql ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6DBus ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Network ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Test ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Widgets ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Xml ${QT_REQUIRED_VERSION} REQUIRED)
find_package(Qt6Quick ${QT_REQUIRED_VERSION} REQUIRED)
```

--------------------------------

### Set Database Backend

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Initializes the default database backend and provides a macro to map backend names to Qt SQL drivers.

```cmake
include(CTest) # Calls enable_testing().

if(NOT DEFINED DATABASE_BACKEND)
    set(DATABASE_BACKEND
        "SQLITE"
        CACHE STRING
        "The default database backend to use for Akonadi. Can be either MYSQL, POSTGRES or SQLITE"
    )
endif()

macro(SET_DEFAULT_DB_BACKEND)
    set(_backend ${ARGV0})
    if("${_backend}" STREQUAL "SQLITE")
        set(AKONADI_DATABASE_BACKEND QSQLITE)
    elseif("${_backend}" STREQUAL "POSTGRES")
        set(AKONADI_DATABASE_BACKEND QPSQL)
    elseif("${_backend}" STREQUAL "MYSQL")
        set(AKONADI_DATABASE_BACKEND QMYSQL)
    else()
        message(
            FATAL_ERROR
            "Invalid database backend \"${_backend}\". Supported values are MYSQL, POSTGRES and SQLITE."
        )
    endif()

    message(STATUS "Using default db backend ${AKONADI_DATABASE_BACKEND}")
endmacro()
```

--------------------------------

### Set up MailModel and associated views

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

Initializes a MailModel, filters it for collections and items, and sets up corresponding views. Requires a session and monitor.

```cpp
mailModel = new MailModel(session, monitor, this);

collectionTree = new Akonadi::EntityMimeTypeFilterModel(this);
collectionTree->setSourceModel(mailModel);
// Filter out everything that is not a collection.
collectionTree->addMimeTypeInclusionFilter(Akonadi::Collection::mimeType());
collectionTree->setHeaderSet(Akonadi::EntityTreeModel::CollectionTreeHeaders);

collectionView = new Akonadi::EntityTreeView(this);
collectionView->setModel(collectionTree);

itemList = new Akonadi::EntityMimeTypeFilterModel(this);
itemList->setSourceModel(mailModel);
// Filter out collections
itemList->addMimeTypeExclusionFilter(Akonadi::Collection::mimeType());
itemList->setHeaderSet(Akonadi::EntityTreeModel::ItemListHeaders);

itemView = new Akonadi::EntityTreeView(this);
itemView->setModel(itemList);
```

--------------------------------

### Generate documentation using CMake presets

Source: https://github.com/kde/akonadi/blob/master/README-qdoc.md

Commands to configure and build the documentation target defined in CMakePreset.json.

```bash
cmake --preset generate-doc

cmake --build --preset generate-doc
```

--------------------------------

### Clone kde-qdoc-common repository

Source: https://github.com/kde/akonadi/blob/master/README-qdoc.md

Initial step to acquire the required documentation templates and tools.

```bash
cd <kde path>
git clone https://invent.kde.org/sdk/kde-qdoc-common
```

--------------------------------

### Manage Akonadi Collections

Source: https://context7.com/kde/akonadi/llms.txt

Demonstrates creating a new collection and fetching existing collections recursively using CollectionFetchJob.

```cpp
#include <Akonadi/Collection>
#include <Akonadi/CollectionFetchJob>

using namespace Akonadi;

// Create a collection for storing calendar events
Collection calendarCollection;
calendarCollection.setName("My Calendar");
calendarCollection.setParentCollection(Collection::root());
calendarCollection.setContentMimeTypes({
    Collection::mimeType(),      // Allow sub-collections
    QStringLiteral("text/calendar")  // Allow calendar items
});
calendarCollection.setRights(Collection::AllRights);

// Fetch all collections recursively from root
CollectionFetchJob *job = new CollectionFetchJob(Collection::root(),
                                                  CollectionFetchJob::Recursive);
connect(job, &KJob::result, this, [](KJob *job) {
    if (job->error()) {
        qWarning() << "Error fetching collections:" << job->errorString();
        return;
    }

    auto *fetchJob = qobject_cast<CollectionFetchJob*>(job);
    const Collection::List collections = fetchJob->collections();

    for (const Collection &col : collections) {
        qDebug() << "Collection:" << col.name()
                 << "ID:" << col.id()
                 << "MimeTypes:" << col.contentMimeTypes();
    }
});
```

--------------------------------

### Manage Akonadi Sessions

Source: https://context7.com/kde/akonadi/llms.txt

Demonstrates creating a named session, associating jobs, using the default session, and handling server reconnections.

```cpp
#include <Akonadi/Session>
#include <Akonadi/CollectionFetchJob>

using namespace Akonadi;

// Create a named session
auto *session = new Session("MyApplication-" +
                            QByteArray::number(QCoreApplication::applicationPid()),
                            this);

// Use the session for jobs
auto *job = new CollectionFetchJob(Collection::root(),
                                    CollectionFetchJob::Recursive,
                                    session);

connect(job, &KJob::result, this, &MyClass::handleResult);

// Or use the default session (thread-local)
Session *defaultSession = Session::defaultSession();
auto *job2 = new ItemFetchJob(Item(123), defaultSession);

// Clear all pending jobs on a session
session->clear();

// React to server reconnection
connect(session, &Session::reconnected, this, []() {
    qDebug() << "Session reconnected to Akonadi server";
    // Re-sync data if necessary
});
```

--------------------------------

### Locate MySQL Server and Scripts

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Finds the MySQL/MariaDB executable and its associated installation scripts.

```cmake
find_program(
    MYSQLD_EXECUTABLE
    NAMES
        mariadbd
        mysqld
    PATHS
        /usr/sbin
        /usr/local/sbin
        /usr/libexec
        /usr/local/libexec
        /opt/mysql/libexec
        /usr/mysql/bin
        /opt/mysql/sbin
    DOC "The mariadbd or mysqld executable path. ONLY needed at runtime"
)

string(
    FIND ${MYSQLD_EXECUTABLE}
    "mariadb"
    _Position
)
set(MYSQLDB_INSTALL_EXEC "mariadb-install-db")
if(${_Position} LESS 0)
    set(MYSQLDB_INSTALL_EXEC "mysql_install_db")
endif()

find_path(
    MYSQLD_SCRIPTS_PATH
    NAMES
        ${MYSQLDB_INSTALL_EXEC}
    DOC "Path to the mariadb or mysql installation scripts (mariadb-install-db, mariadb-upgrade...)"
)

if(MYSQLD_EXECUTABLE)
    message(STATUS "MySQL Server found: ${MYSQLD_EXECUTABLE}")
else()
    message(STATUS "MySQL Server wasn't found. it is required to use an MySQL backend (like mariadb or mysqld.")
endif()

if(MYSQLD_SCRIPTS_PATH)
    message(STATUS "MySQL scripts location: ${MYSQLD_SCRIPTS_PATH}")
else()
    message(STATUS "MySQL scripts location was not found. Use -DMYSQLD_SCRIPTS_PATH to point to the install location.")
endif()
```

--------------------------------

### Configure documentation environment variables

Source: https://github.com/kde/akonadi/blob/master/README-qdoc.md

Set the paths for the documentation tools and the output directory in your shell configuration.

```bash
export KDE_DOCS=<kde path>/kde-qdoc-common
```

```bash
export GENERATE_DOCDIR=<kde path>/generate-docs
```

--------------------------------

### Configure Akonadi ETM Test Application

Source: https://github.com/kde/akonadi/blob/master/tests/libs/etm_test_app/CMakeLists.txt

Sets up the executable target and links necessary Akonadi, I18n, and Qt test libraries.

```cmake
kde_enable_exceptions()

set(etmtestapp_SRCS
    main.cpp
    mainwindow.cpp
    mainwindow.h
)

add_executable(akonadi_etm_test_app ${etmtestapp_SRCS})

target_link_libraries(
    akonadi_etm_test_app
    KPim6::AkonadiWidgets
    KF6::I18n
    akonaditestfake
    Qt::Test
)
```

--------------------------------

### Add Akonadi Demo Applications

Source: https://github.com/kde/akonadi/blob/master/tests/libs/CMakeLists.txt

Adds various Akonadi demo applications using the `add_akonadi_demo` macro. This includes item dumper, subscriber, and widget tests.

```cmake
add_akonadi_demo(itemdumper.cpp itemdumper.h)
add_akonadi_demo(subscriber.cpp)
add_akonadi_demo(agentinstancewidgettest.cpp agentinstancewidgettest.h)
add_akonadi_demo(agenttypewidgettest.cpp agenttypewidgettest.h)
add_akonadi_demo(pluginloadertest.cpp)
##REACTIVATE
#add_akonadi_demo(selftester.cpp)
add_akonadi_demo(collectiondialog.cpp)
add_akonadi_demo(conflictresolvedialogtest_gui.cpp)
```

--------------------------------

### Find KF6 Packages

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Finds required KDE Frameworks 6 libraries. Ensure KF6 is installed and discoverable by CMake.

```cmake
find_package(KF6Config ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6ConfigWidgets ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6CoreAddons ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6I18n ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6IconThemes ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6ItemModels ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6WidgetsAddons ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6XmlGui ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6Crash ${KF_MIN_VERSION} CONFIG REQUIRED)
find_package(KF6ColorScheme ${KF_MIN_VERSION} CONFIG REQUIRED)
```

--------------------------------

### Configure Akonadi Server Test Environment

Source: https://github.com/kde/akonadi/blob/master/autotests/server/CMakeLists.txt

Sets up build definitions, XSLT processing for database schemas, and defines the common static library for unit tests.

```cmake
remove_definitions(-DQT_GUI_LIB)

set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})

akonadi_run_xsltproc(
    XSL ${Akonadi_SOURCE_DIR}/src/server/storage/schema.xsl
    XML ${CMAKE_CURRENT_SOURCE_DIR}/dbtest_data/unittest_schema.xml
    BASENAME unittestschema
    CLASSNAME UnitTestSchema
)
akonadi_run_xsltproc(
    XSL ${CMAKE_CURRENT_SOURCE_DIR}/dbpopulator.xsl
    XML ${CMAKE_CURRENT_SOURCE_DIR}/dbtest_data/dbdata.xml
    BASENAME dbpopulator
)

set_property(
    SOURCE
        ${CMAKE_CURRENT_BINARY_DIR}/dbpopulator.cpp
    PROPERTY
        SKIP_AUTOMOC
            TRUE
)

add_library(akonadi_unittest_common STATIC)
target_sources(
    akonadi_unittest_common
    PRIVATE
        unittestschema.cpp
        fakeconnection.cpp
        fakeintervalcheck.cpp
        fakedatastore.cpp
        fakeclient.cpp
        fakeakonadiserver.cpp
        fakesearchmanager.cpp
        fakeitemretrievalmanager.cpp
        dbinitializer.cpp
        inspectablenotificationcollector.cpp
        ${CMAKE_CURRENT_BINARY_DIR}/dbpopulator.cpp
        fakeconnection.h
        fakeintervalcheck.h
        fakedatastore.h
        fakeclient.h
        fakeakonadiserver.h
        fakesearchmanager.h
        fakeitemretrievalmanager.h
        dbinitializer.h
        inspectablenotificationcollector.h
)

target_link_libraries(
    akonadi_unittest_common
    KPim6::AkonadiPrivate
    libakonadiserver
    Qt::Core
    Qt::DBus
    Qt::Test
    Qt::Sql
    Qt::Network
)
```

--------------------------------

### Configure Monitor for EntityTreeModel

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

Configures a Monitor to fetch collections and items for a specific mimetype, then creates an EntityTreeModel. Requires a session.

```cpp
// Configure what should be shown in the model:
Monitor *monitor = new Akonadi::Monitor(this);
monitor->fetchCollection(true);
monitor->setItemFetchScope(scope);
monitor->setCollectionMonitored(Akonadi::Collection::root());
monitor->setMimeTypeMonitored(MyEntity::mimeType());

Akonadi::Session *session = new Akonadi::Session(QByteArray("MyEmailApp-") + QByteArray::number(qrand()), this);
monitor->setSession(session);

Akonadi::EntityTreeModel *entityTree = new Akonadi::EntityTreeModel(monitor, this);
```

--------------------------------

### Find Qt6 and ECM Modules

Source: https://github.com/kde/akonadi/blob/master/src/xml/autotests/CMakeLists.txt

This snippet finds the required Qt6 version and configuration, along with the ECM (Extra CMake Modules) for testing. Ensure Qt6 and ECM are installed and discoverable by CMake.

```cmake
find_package(Qt6 ${QT_REQUIRED_VERSION} CONFIG REQUIRED COMPONENTS Test)
include(ECMMarkAsTest)
```

--------------------------------

### Get Remote ID by Item ID (C++)

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

Retrieves the remote ID of an item or collection using its Akonadi ID. This function demonstrates a potential conflict if an item and collection share the same ID.

```cpp
QString getRemoteIdById(Item::Id id)
{
    // Note:
    // m_items is QHash<Item::Id, Item>
    // m_collections is QHash<Collection::Id, Collection>
    if (m_items.contains(id)) {
        // Oops, we could accidentally match a collection here.
        return m_items.value(id).remoteId();
    } else if (m_collections.contains(id)) {
        return m_collections.value(id).remoteId();
    }
    return QString();
}
```

--------------------------------

### Get Remote ID by Internal Identifier (C++)

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

Retrieves the remote ID using a signed 64-bit integer identifier. The sign bit is used to distinguish between item and collection IDs, preventing conflicts.

```cpp
qstring getremoteidbyinternalidentifier(qint64 internalidentifier)
{
    // note:
    // m_items is qhash<item::id, item>
    // m_collections is qhash<collection::id, collection>

    // if the id is negative, it refers to an item
    // otherwise it refers to a collection.

    if (internalidentifier < 0) {
        // reverse the sign of the id before using it.
        return m_items.value(-internalidentifier).remoteid();
    } else {
        return m_collections.value(internalidentifier).remoteid();
    }
}
```

--------------------------------

### CMake Project Configuration for Akonadi

Source: https://github.com/kde/akonadi/blob/master/templates/akonadiserializer/CMakeLists.txt

Sets up the CMake build environment, defines project name, minimum required versions for KDE Frameworks and Qt, and finds necessary packages. Includes standard KDE CMake modules for features and compiler settings.

```cmake
cmake_minimum_required(VERSION 3.16)

project(%{APPNAMELC})

set(KF_MIN_VERSION "6.0.0")

set(ECM_MIN_VERSION ${KF_MIN_VERSION})
find_package(ECM ${ECM_MIN_VERSION} CONFIG REQUIRED)

set(CMAKE_MODULE_PATH
    ${ECM_MODULE_PATH}
    ${CMAKE_MODULE_PATH}
)

include(FeatureSummary)
include(KDEInstallDirs)
include(KDECMakeSettings)
include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)

set(QT_MIN_VERSION "6.5.0")
find_package(
    Qt6
    ${QT_MIN_VERSION}
    REQUIRED
        Core
        Network
        Gui
)

find_package(KF6Config ${KF_MIN_VERSION} CONFIG REQUIRED)

set(AKONADI_MIN_VERSION "6.0.0")
find_package(KF6Akonadi ${AKONADI_MIN_VERSION} CONFIG REQUIRED)

add_subdirectory(src)

feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
```

--------------------------------

### Implement a Custom Akonadi Resource Agent

Source: https://context7.com/kde/akonadi/llms.txt

Inherit from ResourceBase to define how a resource fetches collections and items, and how it handles local changes. The init method is required in the main entry point to register the resource.

```cpp
#include <Akonadi/ResourceBase>

using namespace Akonadi;

class MyResource : public ResourceBase
{
    Q_OBJECT

public:
    explicit MyResource(const QString &id)
        : ResourceBase(id)
    {
        // Configure the resource
        setName(i18n("My External Data Source"));
        setAutomaticProgressReporting(true);

        // Configure change recorder
        changeRecorder()->itemFetchScope().fetchFullPayload(true);
    }

protected Q_SLOTS:
    void retrieveCollections() override
    {
        // Fetch collection structure from backend
        Collection::List collections;

        Collection root;
        root.setName(name());
        root.setRemoteId(QStringLiteral("root"));
        root.setParentCollection(Collection::root());
        root.setContentMimeTypes({Collection::mimeType(),
                                   QStringLiteral("text/calendar")});
        collections.append(root);

        // Report collections to Akonadi
        collectionsRetrieved(collections);
    }

    void retrieveItems(const Collection &collection) override
    {
        // Fetch items from backend for this collection
        Item::List items;

        // ... fetch from external source ...

        for (const auto &externalItem : externalItems) {
            Item item;
            item.setRemoteId(externalItem.id);
            item.setMimeType(QStringLiteral("text/calendar"));
            item.setPayloadFromData(externalItem.data);
            items.append(item);
        }

        itemsRetrieved(items);
    }

    bool retrieveItem(const Item &item, const QSet<QByteArray> &parts) override
    {
        // Fetch full item data on demand
        Item fetchedItem = item;
        QByteArray data = fetchFromBackend(item.remoteId());
        fetchedItem.setPayloadFromData(data);

        itemRetrieved(fetchedItem);
        return true;
    }

    void itemAdded(const Item &item, const Collection &collection) override
    {
        // Handle locally created items - sync to backend
        QString remoteId = uploadToBackend(item.payloadData());

        Item newItem = item;
        newItem.setRemoteId(remoteId);
        changeCommitted(newItem);
    }

    void itemChanged(const Item &item, const QSet<QByteArray> &parts) override
    {
        updateOnBackend(item.remoteId(), item.payloadData());
        changeCommitted(item);
    }

    void itemRemoved(const Item &item) override
    {
        deleteFromBackend(item.remoteId());
        changeProcessed();
    }
};

// In main.cpp
int main(int argc, char **argv)
{
    return ResourceBase::init<MyResource>(argc, argv);
}
```

--------------------------------

### Build Executable and Library Targets

Source: https://github.com/kde/akonadi/blob/master/src/xml/CMakeLists.txt

Configures the akonadi2xml executable and the KPim6AkonadiXml library, including target properties and link libraries.

```cmake
add_executable(akonadi2xml akonadi2xml.cpp)
if(COMPILE_WITH_UNITY_CMAKE_SUPPORT)
    set_target_properties(
        akonadi2xml
        PROPERTIES
            UNITY_BUILD
                ON
    )
endif()

set_target_properties(
    akonadi2xml
    PROPERTIES
        MACOSX_BUNDLE
            FALSE
)

target_link_libraries(
    akonadi2xml
    KPim6::AkonadiXml
    KF6::I18n
    Qt::Core
)

add_library(KPim6AkonadiXml ${akonadixml_SRCS})

generate_export_header(KPim6AkonadiXml BASE_NAME akonadi-xml)

add_library(KPim6::AkonadiXml ALIAS KPim6AkonadiXml)

target_include_directories(KPim6AkonadiXml INTERFACE "$<INSTALL_INTERFACE:${AkonadiXml_INSTALL_INCLUDEDIR}>")
target_include_directories(
    KPim6AkonadiXml
    PUBLIC
        "$<BUILD_INTERFACE:${Akonadi_SOURCE_DIR}/src/core;${Akonadi_BINARY_DIR}/src/core>"
)

target_link_libraries(
    KPim6AkonadiXml
    PUBLIC
        KPim6::AkonadiCore
        Qt::Xml
    PRIVATE
        KF6::I18n
)
if(LIBXML2_FOUND)
    target_link_libraries(KPim6AkonadiXml PRIVATE LibXml2::LibXml2)
endif()

set_target_properties(
    KPim6AkonadiXml
    PROPERTIES
        VERSION
            ${AKONADI_VERSION}
        SOVERSION
            ${AKONADI_SOVERSION}
        EXPORT_NAME
            AkonadiXml
)
```

--------------------------------

### Manage Akonadi Items

Source: https://context7.com/kde/akonadi/llms.txt

Shows how to create an item with a typed payload, set flags, and retrieve payload data from an existing item.

```cpp
#include <Akonadi/Item>
#include <KContacts/Addressee>

using namespace Akonadi;

// Create a contact item with payload
KContacts::Addressee contact;
contact.setNameFromString("John Doe");
contact.insertEmail(QStringLiteral("john@example.com"), true);
contact.insertPhoneNumber(KContacts::PhoneNumber("+1234567890",
                          KContacts::PhoneNumber::Work));

Item contactItem;
contactItem.setMimeType(KContacts::Addressee::mimeType());
contactItem.setPayload<KContacts::Addressee>(contact);

// Set flags on an item
contactItem.setFlag("\\Flagged");
contactItem.setFlag("important");

// Retrieve payload from an existing item
if (item.hasPayload<KContacts::Addressee>()) {
    KContacts::Addressee addr = item.payload<KContacts::Addressee>();
    qDebug() << "Contact name:" << addr.formattedName();
    qDebug() << "Email:" << addr.preferredEmail();
}

// Check item properties
qDebug() << "Item ID:" << item.id()
         << "Revision:" << item.revision()
         << "Size:" << item.size()
         << "Modified:" << item.modificationTime();
```

--------------------------------

### Check System Headers and Tools

Source: https://github.com/kde/akonadi/blob/master/CMakeLists.txt

Checks for unistd.h and the xmllint tool.

```cmake
find_program(XMLLINT_EXECUTABLE xmllint)
if(NOT XMLLINT_EXECUTABLE)
    message(STATUS "xmllint not found, skipping akonadidb.xml schema validation")
endif()

check_include_files(
    unistd.h
    HAVE_UNISTD_H
)
```

--------------------------------

### Define Akonadi Wrapper Source Files

Source: https://github.com/kde/akonadi/blob/master/python/CMakeLists.txt

Lists the generated wrapper source files for various Akonadi components within the build directory.

```cmake
${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_favoritecollectionsmodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_recursivecollectionfilterproxymodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_selectionproxymodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_statisticsproxymodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_tagmodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_trashfilterproxymodel_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_abstractdifferencesreporter_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_accountactivitiesabstract_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_agentconfigurationbase_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_agentinstance_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_agentmanager_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_agenttype_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_attributefactory_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_cachepolicy_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_changenotification_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_changerecorder_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_collection_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_collectionfetchscope_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_collectionpathresolver_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_collectionstatistics_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_collectionutils_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_control_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_differencesalgorithminterface_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_exception_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_gidextractorinterface_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_item_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_itemfetchscope_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_itemmonitor_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_itemsync_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_mimetypechecker_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_monitor_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_notificationsubscriber_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_partfetcher_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_searchquery_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_searchterm_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_servermanager_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_session_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_specialcollections_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_tag_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_tagcache_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_tagfetchscope_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_tagsync_wrapper.cpp
    ${CMAKE_CURRENT_BINARY_DIR}/AkonadiCore/akonadi_trashsettings_wrapper.cpp
```

--------------------------------

### Add Akonadi Demo Application Macro

Source: https://github.com/kde/akonadi/blob/master/tests/libs/CMakeLists.txt

A convenience macro to simplify adding Akonadi demo applications. It defines an executable and links it against core Akonadi and KF6 I18n libraries.

```cmake
macro(add_akonadi_demo _source)
    set(_test ${_source})
    get_filename_component(_name ${_source} NAME_WE)
    add_executable(${_name} ${_test})
    target_link_libraries(
        ${_name}
        KPim6::AkonadiCore
        KPim6::AkonadiWidgets
        KF6::I18n
    )
endmacro()
```

--------------------------------

### Implement EntityTreeModel

Source: https://context7.com/kde/akonadi/llms.txt

Configures a monitor and model to display Akonadi collections and items, including filtering and index retrieval.

```cpp
#include <Akonadi/EntityTreeModel>
#include <Akonadi/Monitor>
#include <Akonadi/EntityMimeTypeFilterModel>
#include <Akonadi/EntityTreeView>

using namespace Akonadi;

// Create and configure the monitor
auto *monitor = new Monitor(this);
monitor->setCollectionMonitored(Collection::root());
monitor->setMimeTypeMonitored(KContacts::Addressee::mimeType());
monitor->itemFetchScope().fetchFullPayload(true);

// Create the entity tree model
auto *model = new EntityTreeModel(monitor, this);

// Configure display behavior
model->setItemPopulationStrategy(EntityTreeModel::ImmediatePopulation);
model->setIncludeRootCollection(true);
model->setRootCollectionDisplayName(i18n("[All Contacts]"));

// Create a filter for collections only (tree view)
auto *collectionModel = new EntityMimeTypeFilterModel(this);
collectionModel->setSourceModel(model);
collectionModel->addMimeTypeInclusionFilter(Collection::mimeType());
collectionModel->setHeaderGroup(EntityTreeModel::CollectionTreeHeaders);

auto *treeView = new EntityTreeView(this);
treeView->setModel(collectionModel);

// Create a filter for items only (list view)
auto *itemModel = new EntityMimeTypeFilterModel(this);
itemModel->setSourceModel(model);
itemModel->addMimeTypeExclusionFilter(Collection::mimeType());
itemModel->setHeaderGroup(EntityTreeModel::ItemListHeaders);

auto *listView = new EntityTreeView(this);
listView->setModel(itemModel);

// Retrieve Collection/Item from model index
QModelIndex index = treeView->currentIndex();
Collection col = index.data(EntityTreeModel::CollectionRole).value<Collection>();
Item item = index.data(EntityTreeModel::ItemRole).value<Item>();

// Find model index for a known collection
QModelIndex colIndex = EntityTreeModel::modelIndexForCollection(model, Collection(123));
```

--------------------------------

### Specify Source Files for Executable

Source: https://github.com/kde/akonadi/blob/master/src/asapcat/CMakeLists.txt

Lists the source files required to build the 'asapcat' executable.

```cmake
target_sources(
    asapcat
    PRIVATE
        main.cpp
        session.cpp
        session.h
)
```

--------------------------------

### Fetch Collections by IDs

Source: https://github.com/kde/akonadi/blob/master/docs/client_libraries.md

Demonstrates fetching a list of collections using their IDs. The resulting collections are ordered according to the input IDs when using CollectionFetchJob.

```cpp
Collection::List getCollections(const QList<Collection::Id> &idsToGet)
{
    Collection::List getList;
    for (Collection::Id id :  idsToGet) {
        getList << Collection(id);
    }
    CollectionFetchJob *job = CollectionFetchJob(getList);
    if (job->exec()) {
        // job->collections() is in the same order as the ids in idsToGet.
    }
}
```

--------------------------------

### Define Resource Source Files

Source: https://github.com/kde/akonadi/blob/master/templates/akonadiresource/src/CMakeLists.txt

Lists the C++ source and header files for the Akonadi resource. Ensure all necessary files are included here.

```cmake
set(%{APPNAMELC}resource_SRCS
    %{APPNAMELC}resource.cpp
    %{APPNAMELC}resource.h
)
```

--------------------------------

### Configure XML Files with CMake

Source: https://github.com/kde/akonadi/blob/master/autotests/libs/testresource/tests/CMakeLists.txt

Use CMake's configure_file command to copy and process XML configuration files.

```cmake
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/knut-empty.xml ${CMAKE_CURRENT_BINARY_DIR}/knut-empty.xml COPYONLY)
```

```cmake
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/knut-step1.xml ${CMAKE_CURRENT_BINARY_DIR}/knut-step1.xml COPYONLY)
```

```cmake
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/knut-step2.xml ${CMAKE_CURRENT_BINARY_DIR}/knut-step2.xml COPYONLY)
```

```cmake
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/knutdemo.xml ${CMAKE_CURRENT_BINARY_DIR}/knutdemo.xml COPYONLY)
```

--------------------------------

### Configure Akonadi QML Module with CMake

Source: https://github.com/kde/akonadi/blob/master/src/quick/CMakeLists.txt

Defines the QML module, source files, logging categories, and library dependencies for the Akonadi Quick plugin.

```cmake
ecm_add_qml_module(akonadi_quick_plugin
    URI org.kde.akonadi
    GENERATE_PLUGIN_SOURCE
    OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/src/org/kde/akonadi
    DEPENDENCIES
        QtQuick
        QtCore
        org.kde.kirigami
        org.kde.kirigamiaddons.delegates
        org.kde.kirigamiaddons.formcard
        org.kde.kirigamiaddons.components
        org.kde.kitemmodels
)

target_sources(
    akonadi_quick_plugin
    PRIVATE
        agentconfiguration.cpp
        agentconfiguration.h
        collectioncomboboxmodel.cpp
        collectioncomboboxmodel.h
        collectionpickermodel.cpp
        collectionpickermodel.h
        collectioneditorcontroller.cpp
        collectioneditorcontroller.h
        etmtreeviewstatesaver.cpp
        etmtreeviewstatesaver.h
        mimetypes.cpp
        mimetypes.h
        tagmanager.h
        tagmanager.cpp
        types.cpp
        types.h
)

ecm_target_qml_sources(akonadi_quick_plugin SOURCES
    qml/AgentConfigurationForm.qml
    qml/CollectionComboBox.qml
    qml/CollectionChooserPage.qml
    qml/FormCollectionComboBox.qml
    qml/TagManagerPage.qml
)

ecm_qt_declare_logging_category(akonadi_quick_plugin
    HEADER akonadi_quick_debug.h
    IDENTIFIER AKONADI_QUICK_LOG
    CATEGORY_NAME org.kde.pim.akonadiquick
    DESCRIPTION "Akonadi QtQuick Plugin"
    EXPORT AKONADI
)

target_link_libraries(
    akonadi_quick_plugin
    PRIVATE
        KF6::I18n
        KPim6AkonadiCore
        KPim6AkonadiWidgets # Needed for AgentConfigurationDialog
)

ecm_finalize_qml_module(akonadi_quick_plugin
    DESTINATION ${KDE_INSTALL_QMLDIR}
    BUILD_SHARED_LIBS OFF
)
```