I’m happy to announce first release of QCoro, a library that provides C++ coroutine support for Qt.

You can download QCoro 0.1.0 here or check the latest sources on QCoro GitHub.

I have talked about QCoro (and C++ coroutines in general) recently at KDE Akademy, you can view the recording of my talk on YouTube.

In general, QCoro provides coroutine support for various asynchronous operations provided by Qt. Since Qt doesn’t support coroutines by default, QCoro provides the necessary “glue” between native Qt types and the C++ coroutine machinery, making it possible to use Qt types with coroutines easily.

QCoro provides coroutine support for asynchronous operations of QIODevice, QNetworkReply, QProcess, QDBusPendingReply, QTimer and more. Take a look at the documentation for detailed description and list of all currently supported Qt types.

A brief example from our documentation that demonstrates how using coroutines makes handling asynchronous operations in Qt simpler:

This is a (simplified) example of how we do network requests with Qt normally, using signals and slots:

QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QNetworkReply *reply = manager->get(url);
connect(reply, &QNetworkReply::finished, this,
        [this, reply]() {
            const auto data = reply->readAll();
            doSomethingWithData(data);
            reply->deleteLater();
        });

And this is the same code, written using C++ coroutines:

QNetworkAccessManager networkAccessManager;
QNetworkReply *reply = co_await networkAccessManager.get(url);
const auto data = reply->readAll();
doSomethingWithData(data);
reply->deleteLater();

The co_await keyword here is the key here: it asynchronously waits for the reply to finish. During the wait, the execution returns to the caller, which could be the Qt event loop, which means that even if this code looks synchronous, in fact it won’t block the event loop while keeping the code simple to read and understand.

Recently my 4 year-old stepson saw a kid with an RC racing car in a park. He really wanted his own, but with Christmas and his birthday still being a long way away, I decided to solve the “problem” by combining three things I’m really passionate about: LEGO, electronics and programming.

In this short series of blogs I’ll describe how to build one such car using LEGO, Arduino and a bit of C++ (and Qt, of course!).

LEGO

Obviously, we will need some LEGO to build the car. Luckily, I bought LEGO Technic Mercedes Benz Arocs 3245 (40243) last year. It’s a big build with lots of cogs, one electric engine and bunch of pneumatics. I can absolutely recommend it - building the set was a lot of fun and thanks to the Power Functions it has a high play-value as well. There’s also fair amount of really good MOCs, especially the MOC 6060 - Mobile Crane by M_longer is really good. But I’m digressing here. :)

The problem with Arocs is that it only has a single Power Functions engine (99499 Electric Power Functions Large Motor) and we will need at least two: one for driving and one for steering. So I bought a second one. I bought the same one, but a smaller one would probably do just fine for the steering.

I started by prototyping the car and the drive train, especially how to design the gear ratios to not overload the engine when accelerating while keeping the car moving at reasonable speed.

Turns out the [76244 Technic Gear 24 Tooth Clutch][lego-part-76244] is really important as it prevents the gear teeth skipping when the engine stops suddenly, or when the car gets pushed around by hand.

Initially I thought I would base the build of the car on some existing designs but in the end I just started building and I ended up with this skeleton:

The two engines are in the middle - rear one powers the wheels, the front one handles the steering using the 61927b Technic Linear Actuator. I’m not entirely happy with the steering, so I might rework that in the future. I recently got Ford Mustang (10265) which has a really interesting steering mechanism and I think I’ll try to rebuild the steering this way.

Wires

We will control the engines from Arduino. But how to connect the LEGO Power Functions to an Arduino? Well, you just need to buy a bunch of those 58118 Electric Power Functions Extension Wires, cut them and connect them with DuPont cables that can be connected to a breadboard. Make sure to buy the "with one Light Bluish Gray End" version - I accidentally bought cables which had both ends light bluish, but those can't be connected to the 16511 Battery Box.

We will need 3 of those half-cut PF cables in total: two for the engines and one to connect to the battery box. You probably noticed that there are 4 connectors and 4 wires in each cable. Wires 1 and 4 are always GND and 9V, respectively, regardless of what position is the switch on the battery pack. Wires 2 and 3 are 0V and 9V or vice versa, depending on the position of the battery pack switch. This way we can control the engine rotation direction.

For the two cables that will control the engines we need all 4 wires connected to the DuPont cable. For the one cable that will be connected to the battery pack we only need the outter wires to be connected, since we will only use the battery pack to provide the power - we will control the engines using Arduino and an integrated circuit.

I used the glue gun to connect the PF wires and the DuPont cables, which works fairly well. You could use a solder if you have one, but the glue also works as an isolator to prevent the wires from short-circuiting.

This completes the LEGO part of this guide. Next comes the electronics :)

Arduino

To remotely control the car we need some electronics on board. I used the following components:

• Arduino UNO - to run the software, obviously
• HC-06 Bluetooth module - for remote control
• 400 pin bread board - to connect the wiring
• L293D integrated circuit - to control the engines
• 1 kΩ and 2 kΩ resistors - to reduce voltage between Arduino and BT module
• 9V battery box - to power the Arduino board once on board the car
• M-M DuPont cables - to wire everything together

The total price of those components is about €30, which is still less than what I paid for the LEGO engine and PF wires.

Let’s start with the Bluetooth module. There are some really nice guides online how to use them, I’ll try to describe it quickly here. The module has 4 pins: RX, TX, GND and VCC. GND can be connected directly to Arduino’s GND pin. VCC is power supply for the bluetooth module. You can connect it to the 5V pin on Arduino. Now for TX and RX pins. You could connect them to the RX and TX pins on the Arduino board, but that makes it hard to debug the program later, since all output from the program will go to the bluetooth module rather than our computer. Instead connect it to pins 2 and 3. Warning: you need to use a voltage divider for the RX pin, because Arduino operates on 5V, but the HC-06 module operates on 3.3V. You can do it by putting a 1kΩ resistor between Arduino pin 3 and HC-06 RX and 2kΩ resistor between Arduino GND and HC-06 RX pins.

Next comes up the L293D integrated circuit. This circuit will allow us to control the engines. While in theory we could hook up the engines directly to the Arduino board (there’s enough free pins), in practice it’s a bad idea. The engines need 9V to operate, which is a lot of power drain for the Arduino circuitry. Additionally, it would mean that the Arduino board and the engines would both be drawing power from the single 9V battery used to power the Arduino.

Instead, we use the L293D IC, where you connect external power source (the LEGO Battery pack in our case) to it as well as the engines and use only a low voltage signal from the Arduino to control the current from the external power source to the engines (very much like a transistor). The advantage of the L293D is that it can control up to 2 separate engines and it can also reverse the polarity, allowing to control direction of each engine.

Here’s schematics of the L293D:

To sum it up, pin 1 (Enable 1,2) turns on the left half of the IC, pin 9 (Enable 3,4) turns on the right half of the IC. Hook it up to Arduino's 5V pin. Do the same with pin 16 (VCC1), which powers the overall integrated circuit. The external power source (the 9V from the LEGO Battery pack) is connected to pin 8 (VCC2). Pin 2 (Input 1) and pin 7 (Input 2) are connected to Arduino and are used to control the engines. Pin 3 (Output 1) and pin 6 (Output 2) are output pins that are connected to one of the LEGO engines. On the other side of the circuit, pin 10 (Input 3) and pin 15 (Input 4) are used to control the other LEGO engine, which is connected to pin 11 (Output 3) and pin 14 (Output 4). The remaining four pins in the middle (4, 5, 12 and 13 double as ground and heat sink, so connect them to GND (ideally both Arduino and the LEGO battery GND).

Since we have 9V LEGO Battery pack connected to VCC2, sending 5V from Arduino to Input 1 and 0V to Input 2 will cause 9V on Output 1 and 0V on Output 2 (the engine will spin clockwise). Sending 5V from Arduino to Input 2 and 0V to Input 1 will cause 9V to be on Output 2 and 0V on Output 1, making the engine rotate counterclockwise. Same goes for the other side of the IC. Simple!

Conclusion

I also built a LEGO casing for the Arduino board and the breadboard to attach them to the car. With some effort I could probably rebuild the chassis to allow the casing to “sink” lower into the construction.

The batterry packs (the LEGO Battery box and the 9V battery case for Arduino) are nicely hidden in the middle of the car on the sides next to the engines.

Now we are done with the hardware side - we have a LEGO car with two engines and all the electronics wired together and hooked up to the engines and battery. In the next part we will start writing software for the Arduino board so that we can control the LEGO engines programmatically. Stay tuned!

I’ve seen lots of posts like this in the past, never thought I’d be writing one myself.

I haven’t been very actively contributing to KDE for the past months. It’s been rather frustrating, because I felt like I have to contribute something, fix some bugs, finish some feature…but whenever I had the time to work on PIM, I just couldn’t bring myself to do anything. Instead I found myself running away to other projects or just playing games.

It took me a while to realize that the problem was that I was putting pressure on myself to contribute even though I did not feel like it. It turned from hobby and passion into a duty, and that’s wrong.

I think the main frustration comes from the feeling that I cannot innovate - I’m bound by various restrictions - libraries and languages I can use, APIs I must preserve/conform to, legacy behavior to not break anything for existing users… This has been taking away the fun. I have enough of this in my dayjob, thank you. So….

I decided to take a break from KDE PIM for a while. I’m sure I’ll be back at some point. But right now I feel like I gave it all I could and it’s still not where I’d like it to be and it’s no longer fun for me. What makes me very happy is the number of new contributors that have appeared over the past year or so.

Instead of hacking on KDE PIM I went back to some of my older projects - I improved Passilic, the Pass password manager frontend for Sailfish OS and revived my old Android app to sync Facebook events with Android calenar.

I also started playing with C++20 coroutines and how they could be used with Qt. The result is the QCoro library. I’ll blog about that soon and, hopefully, will talk about it in more depth in two months on Akademy (see, I’m not leaving completely 😉).

Finally, I spent the past week building a remote-controlled car using Lego, Arduino and a mobile app I wrote (with Qt, of course 😉). I’ll blog about that as well (spoiler alert: it’s fun!).

See y’all around!

/Dan

Plasma Pass, a Plasma applet for the Pass password manager version 1.2.0 is out.

The applet now supports OTP codes (in the format supported by the pass OTP plugin). The ‘clock’ icon appears next to all passwords, even those that do not have OTP code. This is a limitation caused by the passwords being stored in files encrypted and being decrypted only when the user requests it - so the applet cannot know whether there’s an OTP code available in the password file until you click on it. There were also some small fixups and UI improvements.

Tarball:

https://download.kde.org/stable/plasma-pass/plasma-pass-1.2.0.tar.xz

Checksum:

SHA-256: 01f0b03b99e41c067295e7708d41bbe581c0d73e78d43b50bf86b4699969f780
SHA-1:   07a32d21b0c4dd38cad9c800d7b8f463f42c39c6

Signature:

0ABDFA55A4E6BEA99A83EA974D69557AECB13683 Daniel Vrátil <dvratil@kde.org>

Feel free to report any issues or feature requests to KDE Bugzilla.

Following the post about what happened in KDE PIM in January and February let’s look into what the KDE PIM community has been up to in March and April. In total 38 contributors have made almost 1700 changes. Big thanks to everyone who helped us make Kontact better!

April 2020 Release

A new bundle of KDE applications has been released in April, including Kontact with its many bugfixes and improvements.

KDE PIM Sprint

Every year in April the PIM team meets in Toulouse in France for a weekend of discussions and hacking. This year due to the coronavirus it wasn’t possible for us to meet so instead we held a virtual KDE PIM Sprint. You can read the sprint agenda as well as Volker’s report from the sprint.

To highlight some of the topics discussed

• Moving KDAV into KDE Frameworks
• KParts usage in Kontact
• Remove the Kolab Resource, encourage users to use IMAP+DAV instead
• Data provider plugins for the KCalendarCore library
• Porting Account Wizard away from Kross (port to QML, eventually replace it completely by KAccounts)

KMail

Bugfixes

KMail has received its usual dose of bugfixes, mostly those:

• Fixed a crash when sending an email (Laurent Montel, bug 419473)
• Fixed a crash when adding too many recipients (Jonathan Marten, D28876)
• Fixed a bug when KMail showed only a part of an HTML email (Laurent Montel, bug 419949)
• Fixed a bug when KMail did not correctly display email answer in HTML mode (Laurent Montel, bug 418482)
• Fixed broken message status filter (Laurent Montel, bug 419720)
• Fixed the maildir backend creating junk folders around and not storing the path configuration properly (Igor Poboiko, D27722, D27906 and D28634)
• Fixed a crash when configuring the POP3 resource (Daniel Vrátil, bug 419726)
• Fixed name of the top-level folder created by the EWS resource (Igor Poboiko, bug 416663)
• Fixed the EWS resource not storing user password properly (Igor Poboiko, bug 414789)

Improvements

There were some exciting improvements to KMail as well: Sandro Knauß has implemented support for Protected Headers for Cryptographic E-Mails. This means that we also send a signed/encrypted copy of headers and display the signed/encrypted headers if available and ignores the unsecure headers. Currently we don’t obfuscate the subject to not break current workflows. Those things will be improved later on. Sandro together with Thomas Pfeiffer get a funding from nlnet to improve mail encryption. That means there will be more improvement happen the next months. The next topic they will look at is to add Autocrypt support for KMail.

Volker has improved the look and feel of the “HTML Content” and “External References” warnings in emails.

As the Libre Avatar service has come back from the dead a while ago, so did now the support for it in KMail. The ‘Export to PDF’ feature which we introduced in the previous report has been polished (Daniel Vrátil, D27793).

The ‘Move To Trash’ code has been optimized so that deleting large amounts of emails should now be faster.

For developers it is now possible to open Chromium DevTools inside the message viewer pane to make it easier to debug message templates.

KOrganizer

Bugfixes

• Fixed crashes in category and filter managers (Allen Winter)
• Fixed bug when single instance of a recurring event couldn’t be changed (Shashwat Jolly, bug 410758)
• Fixed crash when creating a new Todo from Kontact (David Faure, bug 420192)
• Fixed ‘Only resources can modify remote identifiers’ error when re-editing event (Igor Poboiko, bug 407965)
• Fixed the DAV resource getting stuck when parse error occurs (David Faure, D27858)

Improvements

The Google Calendar and Google Contacts backends have been merged into a single Google Groupware resource (Igor Poboiko, D28560). The change should be mostly transparent to users, the old backends will be migrated to the new unified backend automatically after update. During this Igor also fixed various bugs and issues in the backends and the LibKGAPI library, big kudos to him!

The DAV resource is now able to synchronize the calendar color from KOrganizer to the DAV server (David Faure, D28938). Related to that, the menu to configure calendar color in KOrganizer has been simplified by removing the “Disable Color” action.

It is now easier to recognize and set the default calendar and the event editor now respects the settings correctly.

KJots

KJots, the note taking application, which has been on life support for 5 years, has received some love recently thanks to Igor Poboiko. Most of the things were happening under the hood: some ancient dusty code has been dropped, some refactoring happening, etc. However, if you still use KJots, you might also notice quite a number of changes too. And if you don’t, it’s a good time to consider using it :)

Bugfixes

• Fixed a data loss issue due to bugs in the Akonadi Maildir resource, which is used as a KJots backend
• Fixed a crash on startup (bug 420228)
• Fixed multiple actions for the same shortcut (bug 384000)
• Fixed bookmarks support (D29073)
• Fixed export to plain text and to HTML
• Fixed random scrollback jumps (bug 195828)
• Fixed nested bullet lists breaking the undo stack (bug 256001)

Improvements

• Link destination is displayed in tooltip (D29289)
• Ctrl+click follows the link (bug 244846)
• Priting support has been revived (D29045)
• The text editing widget now supports different headings (bug 230317)
• Improved support for nested bullet lists

Future

Igor has quite huge plans for the future of KJots. First of all, more bug squashing. Secondly: ability to store notes in Markdown format, synchronization with online services (thoughts are on OwnCloud/NextCloud, or proprietary Evernote). On a lesser scale, the port to the same text editing component as used by KMail email composer is being considered, which will give KJots more text-editing features. There are also plans to add a support for inline checkboxes introduced in Qt 5.14, which would allow making checklists and TODO-lists in KJots, and ability to sort books and pages by their modification date (so more relevant would pop up first).

Other components

Other parts of PIM has also received bugfixes and improvements. Kleopatra, the certificate management software, now displays GPG configuration tabs and option groups always in the same order (Andrey Legayev, T6446). A bug in Akregator has been fixed that could have caused some feeds to have an icon missing (David Faure, D28581). KAlarm has received a bunch of UI improvements as well as some smaller features - for instance it is now possible to import alarms from multiple calendars at once and the calendar list is now sorted by name (all by David Jarvie).

Common Infrastructure

Lots of work went into modernizing Akonadi, the “backend” service for Kontact. One major change was switch to C++17 and some initial usage of C++17 features internally (public API is still C++11-compatible). Widgets for managing Tags have been improved and polished and the deprecated ItemModel and CollectionModel have been removed.

The KIMAP library has been optimized to better handle large message sets (Daniel Vrátil, D28944). The KLDAP library can now connect to LDAP server using SSL encryption (Tobias Junghans, D28915), alongside the existing TLS support.

Volker Krause has been working on preparing the KDAV library (which implements the DAV protocol) into KDE Frameworks.

Laurent Montel has been working throughout the entire PIM codebase, preparing it to port to Qt6, once it’s available.

Help us make Kontact even better!

Take a look at some of the junior jobs that we have! They are simple, mostly programming tasks that don’t require any deep knowledge or understanding of Kontact, so anyone can work on them. Feel free to pick any task from the list and reach out to us! We’ll be happy to guide you and answer all your questions. Read more here…

Following the post about what happened in KDE PIM in November and December by Volker, let’s look into what the KDE PIM community has been up to in the first two months of the new year. In total 23 contributors have made 740 changes.

KMail

• A warning is shown when message composer is opened by clicking on a URL that asks for a file to be attached

• DKIM validation support is enabled by default now

• The email can now be easily exported to PDF
• Improved support for rendering markdown in emails
• “Important email” icon is now used consistently in KMail
• Fixed “Move Message to Folder” dialog not accepting certain characters (#415850)
• Fixed large emails not being displayed (#387061)
• Fixed attachments being lost when message is saved as draft (#416369)

KOrganizer

• Fixed restoring last used calendar in incidence editor (#411191)
• Fixed fallback to the default calendar in incidence editor
• Fixed a crash in release builds (#417794)

Akregator

• Fixed filename extensions being translated (#416983)

KAlarm

• Fixed message captions
• Added warning when no default alarm calendar is set during archiving
• Fixed crashes
• Better handling when calendars are added or removed

Common Infrastructure

Laurent has been working on porting our code away from API that has been deprecated in Qt 5.15. Volker has been working on removing KDBusConnectionPool from all of KDE PIM.

For network communication we now use some safer defaults - for example we enabled HSTS by default and we don’t allow redirects to less-safe protocols (i.e. from https:// to http://).

KMail and some other components have begun integrating KUserFeedback to provide some basic telemetry information about usage.

Help us make Kontact even better!

Take a look at some of the junior jobs that we have! They are simple, mostly programming tasks that don’t require any deep knowledge or understanding of Kontact, so anyone can work on them. Feel free to pick any task from the list and reach out to us! We’ll be happy to guide you and answer all your questions. Read more here…

Plasma Pass, a Plasma applet for the Pass password manager version 1.1.0 is out.

There’s only one bugfix, but an important one - the applet now no longer freezes during filtering, so searching for your passwords is faster and more comfortable. The new release also contains new and updated translations.

Tarball:

https://download.kde.org/stable/plasma-pass/plasma-pass-1.1.0.tar.xz

Checksum:

SHA-256: a9789142c1b487f41e245bde9179d7857972c521df906e58176e0b0c0c3cdc39
SHA-1:   427e6bae205c29bd26db6e3590c3e9d75accc537

Signature:

0ABDFA55A4E6BEA99A83EA974D69557AECB13683 Daniel Vrátil <dvratil@kde.org>

Feel free to report any issues or feature requests to KDE Bugzilla.

When using PIMPL, we sometimes want to move implementation of slots into the private class as well. In order for Qt to be able to invoke those slots that formally exist only in the private class (which usually is not a QObject), we use the Q_PRIVATE_SLOT macro in the main class. It allows Qt to invoke the slot method, even though it exists in the private class.

Let’s have a short example:

/// mybutton.h

class MyButtonPrivate;
class MyButton : public QPushButton {
    Q_OBJECT
public:
    explicit MyButton(QWidget *parent);
    ~MyButton() noexcept override;

private:
    std::unique_ptr<MyButtonPrivate> const d_ptr;
    Q_DECLARE_PRIVATE(MyButton);

    Q_PRIVATE_SLOT(d_func(), void onClicked(bool));
};

/// mybutton.cpp

class MyButtonPrivate
{
public:
    void onClicked(bool clicked) {
        qDebug() << "Clicked!";
    }
};

MyButton::MyButton(QWidget *parent)
    : QPushButton(parent)
    , d_ptr(std::make_unique<MyButtonPrivate>())
{
    // Connecting to slot on "this" (MyButton*), although "onClicked" is defined in MyButtonPrivate
    connect(this, SIGNAL(clicked(bool)),
            this, SLOT(onClicked(bool)));
}

MyButton::~MyButton() noexcept = default;

Q_PRIVATE_SLOT does not create any new method in the MyButton class. The way Q_PRIVATE_SLOT works is that it just instructs moc to generate a metacall that looks like obj->d_func()->onClicked(val) instead of obj->onClicked(val), like it does for normal slots or invokables.

This approach has one big disadvantage: it means that Q_PRIVATE_SLOTs can only be invoked through the old QObject::connect() syntax.

So far I’ve been using a simple workaround to get all the compile-time checks that I would get with the new connect syntax normally:

connect(this, &MyButton::clicked,
        this, [this](bool clicked) { d_func()->onClicked(clicked); });

Here we use a lambda to forward the call to the actual PIMPL’ed slot. This is somewhat better than the old connect syntax but IMO it has two major drawbacks:

It’s hard to read - it’s difficult to immediatelly decipher what method the call is actually being forwarded to.

It’s tedious to write - it’s a lot of boilerplate code to be written and if there are too many arguments it becomes quite ugly. C++14 generic lambdas improve the situation a bit since we can use auto instead of spelling out the argument types, but I don’t think it makes the code necessarily better to read:

connect(this, &MyObject::mySignal,
        this, [this](const auto &foo, auto bar, auto *baz) {
            d_func()->mySlot(foo, bar, baz);
        });

It got me thinking if there might be some way to auto-generate the forwarding lambda and be able to just use the pointer-to-function here somehow.

In the end I came up with this tiny template function, which takes the d-pointer and the pointer to the PIMPL’ed slot and returns a generic lambda which gets passed into QObject::connect and which forwards arguments to the real slot method.

template<typename DPtr, typename Slot>
auto priv_slot(DPtr &&dptr, Slot &&slot)
{
    return [&dptr, &slot](auto && ... args)
    {
        (dptr->*slot)(std::forward<decltype(args)>(args) ...);
    }
}

The result has all the benefits of the new QObject::connect() syntax without the ugliness of the “forwarding lambda”:

connect(this, &MyObject::mySignal,
        this, priv_slot(d_func(), &MyObjectPrivate::onSignal));

In just five days I’ll be on my way to Akademy! I’m so excited to meet with all my friends from KDE! After missing the conference weekends in Almería and Vienna, I’ll be able to get the full Akademy experience again - including delivering a talk!

Build Expressive APIs with Modern C++

I’ll be giving a talk about how to use some cool features from C++17 (even if you cannot use C++17!) in your code to make it easier for others (and yourself) to understand the intentions of the code, which helps improve productivity and reduce bugs and errors. The talk will be on Sunday at 14:35 in room U4-08.

KDE PIM BoF

The KDE PIM team will have a BoF session on Monday morning (10:30 - 12:30) in room U1-04. If you want to talk to us about anything KDE PIM related, feel free to stop by!

–

Other than that my main intention is to make use of the whole week to do some intensive hacking on Akonadi, in-person debugging and fixing bugs :)

See you all in Milan!

Lately there were some issues with the Google integration in Kontact which caused that it is no longer possible to add new Google Calendar or Gmail account in Kontact because the log in process will fail. This is due to an oversight on our side which lead to Google blocking Kontact as it did not comply with Google’s policies. We are working on resolving the situation, but it will take a little bit.

Existing users should not be affected by this - if you already had Google Calendar or Gmail set up in Kontact, the sync should continue to work. It is only new accounts that cannot be created.

In case of Gmail the problem can mostly be worked around when setting up the IMAP account in KMail by selecting PLAIN authentication¹ method in the Advanced tab and using your email and password. You may need to enable Less Secure Applications in your Google account settings in order to be able to log in with regular email address and password.

If you are interested in the technical background of this issue, the problem comes from Google’s OAuth App Verification process. When a developer wants to connect their app to a Google service they have to select which particular services their app needs access to, and sometimes even which data within each service they want to access. Google will then verify that the app is not trying to access any other data or that it is not misusing the data it has access to - this serves to protect Google users as they might sometimes approve apps that will access their calendars or emails with malicious intent without them realizing that.

When I registered Kontact I forgot to list some of the data points that Kontact needs access to. Google has noticed this after a while and asked us to clarify the missing bits. Unfortunately I wasn’t able to react within the given time limit and so Google has preemptively blocked login for all new users.

I’m working on clarifying the missing bits and having Google review the new information, so hopefuly the Google login should start working again soon.