diff --git a/image/assets/lang/lang_en.json b/image/assets/lang/lang_en.json
index 26399faf2..bb919a22f 100644
--- a/image/assets/lang/lang_en.json
+++ b/image/assets/lang/lang_en.json
@@ -75,8 +75,8 @@
     "app_desktop_pin_info1": "Wrong passcode",
     "app_desktop_pin_info2": "Allowed unlock attempts",
     "app_desktop_pin_blocked1": "Sorry, phone blocked",
-    "app_desktop_unread_messages": "unread messages",
-    "app_desktop_missed_calls": "missed calls",
+    "app_desktop_unread_messages": "Unread messages",
+    "app_desktop_missed_calls": "Missed calls",
     "app_desktop_menu_phone": "PHONE",
     "app_desktop_menu_contacts": "CONTACTS",
     "app_desktop_menu_messages": "MESSAGES",
diff --git a/image/calllog.db b/image/calllog.db
index 22b5df3e0..f4b8f1e2e 100644
Binary files a/image/calllog.db and b/image/calllog.db differ
diff --git a/image/sms.db b/image/sms.db
index a9c7e108f..cab87e8c3 100644
Binary files a/image/sms.db and b/image/sms.db differ
diff --git a/module-apps/application-desktop/windows/DesktopMainWindow.cpp b/module-apps/application-desktop/windows/DesktopMainWindow.cpp
index f41bf31ac..84004ea5d 100644
--- a/module-apps/application-desktop/windows/DesktopMainWindow.cpp
+++ b/module-apps/application-desktop/windows/DesktopMainWindow.cpp
@@ -26,6 +26,8 @@
 #include <Style.hpp>
 #include <time/time_conversion.hpp>
 
+#include "service-db/api/DBServiceAPI.hpp"
+
 namespace style
 {
     const auto design_time_offset = 106;
@@ -365,8 +367,16 @@ auto DesktopMainWindow::fillNotifications() -> bool
     }
 
     // 2. actually fill it in
-    add_notification(notifications, "phone", "texttemplate", "2", [](Item &) { return true; });
-    add_notification(notifications, "mail", "texttemplate", "13", [](Item &) { return true; });
+    auto unhandled_calls = DBServiceAPI::CalllogGetCount(application, CallState::MISSED);
+    if (unhandled_calls)
+    {
+        add_notification(notifications, "phone", utils::localize.get("app_desktop_missed_calls"), std::to_string(unhandled_calls), [](Item &) { return true; });
+    }
+    auto unread_sms = DBServiceAPI::SMSGetCount(this->application, SMSState::UNREAD);
+    if (unread_sms)
+    {
+        add_notification(notifications, "mail", utils::localize.get("app_desktop_unread_messages"), std::to_string(unread_sms), [](Item &) { return true; });
+    }
     setFocusItem(notifications);
     return true;
 }
diff --git a/module-db/Common/Common.hpp b/module-db/Common/Common.hpp
index 99bd886fe..e5f6458b9 100644
--- a/module-db/Common/Common.hpp
+++ b/module-db/Common/Common.hpp
@@ -21,6 +21,20 @@ enum class SMSType {
     ALL = 0xFF
 };
 
+enum class SMSState
+{
+    ALL,   /// read and unread messages
+    READ,  /// only read messages
+    UNREAD /// only unread messages
+};
+
+enum class CallState
+{
+    ALL,      // all calls in record cunt (missed & not)
+    MISSED,   // only missed calls
+    ANSWERED, // only answered calls
+};
+
 /**
  * Types of contacts
  */
diff --git a/module-db/Interface/CalllogRecord.cpp b/module-db/Interface/CalllogRecord.cpp
index f3597262d..749f84b8a 100644
--- a/module-db/Interface/CalllogRecord.cpp
+++ b/module-db/Interface/CalllogRecord.cpp
@@ -128,9 +128,12 @@ CalllogRecord CalllogRecordInterface::GetByID(uint32_t id) {
     };
 }
 
-uint32_t CalllogRecordInterface::GetCount() {
-    return calllogDB->calls.GetCount();
+uint32_t CalllogRecordInterface::GetCount(CallState state)
+{
+    return calllogDB->calls.GetCount(state);
 }
 
-
-
+uint32_t CalllogRecordInterface::GetCount()
+{
+    return GetCount(CallState::ALL);
+}
diff --git a/module-db/Interface/CalllogRecord.hpp b/module-db/Interface/CalllogRecord.hpp
index 6b5ba2e40..c6da03e65 100644
--- a/module-db/Interface/CalllogRecord.hpp
+++ b/module-db/Interface/CalllogRecord.hpp
@@ -49,6 +49,7 @@ public:
     CalllogRecord GetByID(uint32_t id) override final;
 
     uint32_t GetCount() override final;
+    uint32_t GetCount(CallState state);
 
     std::unique_ptr<std::vector<CalllogRecord>> GetLimitOffset(uint32_t offset,uint32_t limit) override final;
 
diff --git a/module-db/Interface/SMSRecord.cpp b/module-db/Interface/SMSRecord.cpp
index 10ee800dc..b9ef68be3 100644
--- a/module-db/Interface/SMSRecord.cpp
+++ b/module-db/Interface/SMSRecord.cpp
@@ -109,9 +109,13 @@ bool SMSRecordInterface::Add(const SMSRecord &rec) {
 
     return true;
 }
+uint32_t SMSRecordInterface::GetCount(SMSState state)
+{
+    return smsDB->sms.GetCount(state);
+}
 
 uint32_t SMSRecordInterface::GetCount() {
-    return smsDB->sms.GetCount();
+    return GetCount(SMSState::ALL);
 }
 
 uint32_t SMSRecordInterface::GetLastID(void)
diff --git a/module-db/Interface/SMSRecord.hpp b/module-db/Interface/SMSRecord.hpp
index e2275b6b0..008dbf1a0 100644
--- a/module-db/Interface/SMSRecord.hpp
+++ b/module-db/Interface/SMSRecord.hpp
@@ -54,6 +54,7 @@ public:
     SMSRecord GetByID(uint32_t id) override final;
 
     uint32_t GetCount() override final;
+    uint32_t GetCount(SMSState state);
     uint32_t GetLastID(void);
     std::unique_ptr<std::vector<SMSRecord>> GetLimitOffset(uint32_t offset,uint32_t limit) override final;
 
diff --git a/module-db/Tables/CalllogTable.cpp b/module-db/Tables/CalllogTable.cpp
index 088538f50..b2e72e9f7 100644
--- a/module-db/Tables/CalllogTable.cpp
+++ b/module-db/Tables/CalllogTable.cpp
@@ -24,9 +24,10 @@ bool CalllogTable::Create() {
 bool CalllogTable::Add(CalllogTableRow entry)
 {
 
-    return db->Execute("INSERT or ignore INTO calls (number, presentation, date, duration, type, name, contactId) VALUES ('%s', %lu, %s, %s, %lu, '%s', '%s');",
-                       entry.number.c_str(), static_cast<uint32_t>(entry.presentation), utils::to_string(entry.date).c_str(),
-                       utils::to_string(entry.duration).c_str(), static_cast<uint32_t>(entry.type), entry.name.c_str(), entry.contactId.c_str());
+    return db->Execute(
+        "INSERT or ignore INTO calls (number, presentation, date, duration, type, name, contactId, answered) VALUES ('%s', %lu, %s, %s, %lu, '%s', '%s', %d);",
+        entry.number.c_str(), static_cast<uint32_t>(entry.presentation), utils::to_string(entry.date).c_str(), utils::to_string(entry.duration).c_str(),
+        static_cast<uint32_t>(entry.type), entry.name.c_str(), entry.contactId.c_str(), entry.answered);
 }
 
 bool CalllogTable::RemoveByID(uint32_t id) {
@@ -39,10 +40,11 @@ bool CalllogTable::RemoveByField(CalllogTableFields field, const char *str) {
 
 bool CalllogTable::Update(CalllogTableRow entry)
 {
-    return db->Execute(
-        "UPDATE calls SET number = '%s', presentation = %lu, date = %lu, duration = %lu, type = %lu, name = '%s', contactId = '%s' WHERE _id = %lu;",
-        entry.number.c_str(), static_cast<uint32_t>(entry.presentation), static_cast<uint32_t>(entry.date), static_cast<uint32_t>(entry.duration),
-        static_cast<uint32_t>(entry.type), entry.name.c_str(), entry.contactId.c_str(), entry.id);
+    return db->Execute("UPDATE calls SET number = '%s', presentation = %lu, date = %lu, duration = %lu, type = %lu, name = '%s', contactId = '%s', answered = "
+                       "%d WHERE _id = %lu;",
+                       entry.number.c_str(), static_cast<uint32_t>(entry.presentation), static_cast<uint32_t>(entry.date),
+                       static_cast<uint32_t>(entry.duration), static_cast<uint32_t>(entry.type), entry.name.c_str(), entry.contactId.c_str(), entry.answered,
+                       entry.id);
 }
 
 CalllogTableRow CalllogTable::GetByID(uint32_t id) {
@@ -61,6 +63,7 @@ CalllogTableRow CalllogTable::GetByID(uint32_t id) {
         static_cast<CallType>((*retQuery)[5].GetUInt32()),         // type
         (*retQuery)[6].GetString(),                                // name
         (*retQuery)[7].GetString(),                                // contactID
+        static_cast<CallState>((*retQuery)[8].GetUInt64()),        // answered
     };
 }
 
@@ -85,6 +88,7 @@ std::vector<CalllogTableRow> CalllogTable::GetLimitOffset(uint32_t offset, uint3
             static_cast<CallType>((*retQuery)[5].GetUInt32()),         // type
             (*retQuery)[6].GetString(),                                // name
             (*retQuery)[7].GetString(),                                // contactID
+            static_cast<CallState>((*retQuery)[8].GetUInt64()),        // answered
         });
     } while (retQuery->NextRow());
 
@@ -128,22 +132,44 @@ CalllogTable::GetLimitOffsetByField(uint32_t offset, uint32_t limit, CalllogTabl
             static_cast<CallType>((*retQuery)[5].GetUInt32()),         // type
             (*retQuery)[6].GetString(),                                // name
             (*retQuery)[7].GetString(),                                // contactID
+            static_cast<CallState>((*retQuery)[8].GetUInt64()),        // answered
         });
     } while (retQuery->NextRow());
 
     return ret;
 }
 
-uint32_t CalllogTable::GetCount() {
-    auto queryRet = db->Query("SELECT COUNT(*) FROM calls;");
+uint32_t CalllogTable::GetCount(CallState state)
+{
+    std::string query = "SELECT COUNT(*) FROM calls ";
+    switch (state)
+    {
+    case CallState::ALL:
+        break;
+    case CallState::MISSED:
+        query += "WHERE calls.answered = 0";
+        break;
+    case CallState::ANSWERED:
+        query += "WHERE calls.answered = 1";
+        break;
+    }
+    query += ";";
+    LOG_DEBUG("> %s", query.c_str());
+    auto queryRet = db->Query(query.c_str());
 
-    if (queryRet->GetRowCount() == 0) {
+    if (queryRet == nullptr || queryRet->GetRowCount() == 0)
+    {
         return 0;
     }
 
     return uint32_t{(*queryRet)[0].GetUInt32()};
 }
 
+uint32_t CalllogTable::GetCount()
+{
+    return GetCount(CallState::ALL);
+}
+
 uint32_t CalllogTable::GetCountByFieldID(const char *field, uint32_t id) {
     auto queryRet = db->Query("SELECT COUNT(*) FROM calls WHERE %s=%lu;", field, id);
 
diff --git a/module-db/Tables/CalllogTable.hpp b/module-db/Tables/CalllogTable.hpp
index 37907cb71..929c7d3d3 100644
--- a/module-db/Tables/CalllogTable.hpp
+++ b/module-db/Tables/CalllogTable.hpp
@@ -43,6 +43,7 @@ struct CalllogTableRow{
     CallType    type;
     UTF8        name;
 	UTF8        contactId;
+    CallState answered = CallState::MISSED;
 };
 
  enum class CalllogTableFields{
@@ -68,7 +69,8 @@ public:
 	std::vector<CalllogTableRow> GetLimitOffsetByField(uint32_t offset,uint32_t limit,CalllogTableFields field,const char* str) override final;
 
 	uint32_t GetCount() override final;
-	uint32_t GetCountByFieldID(const char* field,uint32_t id) override final;
+    uint32_t GetCount(CallState state);
+    uint32_t GetCountByFieldID(const char* field,uint32_t id) override final;
 
 private:
 
diff --git a/module-db/Tables/SMSTable.cpp b/module-db/Tables/SMSTable.cpp
index d3c74e911..03eb7eea4 100644
--- a/module-db/Tables/SMSTable.cpp
+++ b/module-db/Tables/SMSTable.cpp
@@ -10,7 +10,7 @@
 
 
 #include "SMSTable.hpp"
-
+#include <log/log.hpp>
 
 SMSTable::SMSTable(Database *db) : Table(db) {
 }
@@ -163,17 +163,36 @@ SMSTable::GetLimitOffsetByField(uint32_t offset, uint32_t limit, SMSTableFields
 
     return ret;
 }
+uint32_t SMSTable::GetCount(SMSState state)
+{
+    std::string query = "SELECT COUNT(*) FROM sms ";
+    switch (state)
+    {
+    case SMSState::ALL:
+        break;
+    case SMSState::READ:
+        query += "WHERE sms.read=1";
+        break;
+    case SMSState::UNREAD:
+        query += "WHERE sms.read=0";
+        break;
+    };
+    query += ";";
 
-uint32_t SMSTable::GetCount() {
-    auto queryRet = db->Query("SELECT COUNT(*) FROM SMS;");
-
-    if (queryRet->GetRowCount() == 0) {
+    auto queryRet = db->Query(query.c_str());
+    if (queryRet == nullptr || queryRet->GetRowCount() == 0)
+    {
         return 0;
     }
 
     return uint32_t{(*queryRet)[0].GetUInt32()};
 }
 
+uint32_t SMSTable::GetCount()
+{
+    return GetCount(SMSState::ALL);
+}
+
 uint32_t SMSTable::GetCountByFieldID(const char *field, uint32_t id) {
     auto queryRet = db->Query("SELECT COUNT(*) FROM sms WHERE %s=%lu;", field, id);
 
diff --git a/module-db/Tables/SMSTable.hpp b/module-db/Tables/SMSTable.hpp
index aeeafe722..2e512cb7a 100644
--- a/module-db/Tables/SMSTable.hpp
+++ b/module-db/Tables/SMSTable.hpp
@@ -52,6 +52,7 @@ public:
     std::vector<SMSTableRow> GetLimitOffsetByField(uint32_t offset,uint32_t limit,SMSTableFields field,const char* str) override final;
 
     uint32_t GetCount() override final;
+    uint32_t GetCount(SMSState state);
     uint32_t GetCountByFieldID(const char* field,uint32_t id) override final;
 
 private:
diff --git a/module-services/service-db/ServiceDB.cpp b/module-services/service-db/ServiceDB.cpp
index 8974937b1..4bd554fc9 100644
--- a/module-services/service-db/ServiceDB.cpp
+++ b/module-services/service-db/ServiceDB.cpp
@@ -20,6 +20,7 @@
 
 #include "log/log.hpp"
 
+#include <cassert>
 #include <time/ScopedTime.hpp>
 
 const char *ServiceDB::serviceName = "ServiceDB";
@@ -137,8 +138,10 @@ sys::Message_t ServiceDB::DataReceivedHandler(sys::DataMessage *msgl, sys::Respo
     	break;
     }
     case MessageType::DBSMSGetCount: {
+        auto msg = dynamic_cast<DBSMSGetCount *>(msgl);
+        assert(msg);
         auto time = utils::time::Scoped("DBSMSGetCount");
-        auto ret = smsRecordInterface->GetCount();
+        auto ret = smsRecordInterface->GetCount(msg->state);
         responseMsg = std::make_shared<DBSMSResponseMessage>(nullptr, true, ret);
         break;
     }
@@ -428,8 +431,10 @@ sys::Message_t ServiceDB::DataReceivedHandler(sys::DataMessage *msgl, sys::Respo
     break;
 
     case MessageType::DBCalllogGetCount: {
+        auto *msg = reinterpret_cast<DBCalllogGetCount *>(msgl);
+        assert(msg);
         auto time = utils::time::Scoped("DBCalllogGetCount");
-        auto ret = calllogRecordInterface->GetCount();
+        auto ret = calllogRecordInterface->GetCount(msg->state);
         responseMsg = std::make_shared<DBCalllogResponseMessage>(nullptr, true, 0, 0, ret);
     }
     break;
diff --git a/module-services/service-db/api/DBServiceAPI.cpp b/module-services/service-db/api/DBServiceAPI.cpp
index 9c50c71e9..f5399d77e 100644
--- a/module-services/service-db/api/DBServiceAPI.cpp
+++ b/module-services/service-db/api/DBServiceAPI.cpp
@@ -161,9 +161,9 @@ std::unique_ptr<std::vector<SMSRecord>> DBServiceAPI::SMSGetLimitOffsetByThreadI
     }
 }
 
-uint32_t DBServiceAPI::SMSGetCount(sys::Service *serv)
+uint32_t DBServiceAPI::SMSGetCount(sys::Service *serv, SMSState state)
 {
-    std::shared_ptr<DBSMSMessage> msg = std::make_shared<DBSMSMessage>(MessageType::DBSMSGetCount);
+    std::shared_ptr<DBSMSMessage> msg = std::make_shared<DBSMSGetCount>(state);
 
     auto ret = sys::Bus::SendUnicast(msg, ServiceDB::serviceName, serv, 5000);
     auto *sms = reinterpret_cast<DBSMSResponseMessage *>(ret.second.get());
@@ -746,9 +746,9 @@ bool DBServiceAPI::CalllogUpdate(sys::Service *serv, const CalllogRecord &rec)
     }
 }
 
-uint32_t DBServiceAPI::CalllogGetCount(sys::Service *serv)
+uint32_t DBServiceAPI::CalllogGetCount(sys::Service *serv, CallState state)
 {
-    std::shared_ptr<DBCalllogMessage> msg = std::make_shared<DBCalllogMessage>(MessageType::DBCalllogGetCount);
+    std::shared_ptr<DBCalllogMessage> msg = std::make_shared<DBCalllogGetCount>(state);
 
     auto ret = sys::Bus::SendUnicast(msg, ServiceDB::serviceName, serv, 5000);
     DBCalllogResponseMessage *calllogResponse = reinterpret_cast<DBCalllogResponseMessage *>(ret.second.get());
diff --git a/module-services/service-db/api/DBServiceAPI.hpp b/module-services/service-db/api/DBServiceAPI.hpp
index a7525328c..3af15a939 100644
--- a/module-services/service-db/api/DBServiceAPI.hpp
+++ b/module-services/service-db/api/DBServiceAPI.hpp
@@ -45,7 +45,7 @@ class DBServiceAPI
     static bool SMSUpdate(sys::Service *serv, const SMSRecord &rec);
     static std::unique_ptr<std::vector<SMSRecord>> SMSGetLimitOffset(sys::Service *serv, uint32_t offset, uint32_t limit);
     static std::unique_ptr<std::vector<SMSRecord>> SMSGetLimitOffsetByThreadID(sys::Service *serv, uint32_t offset, uint32_t limit, uint32_t id);
-    static uint32_t SMSGetCount(sys::Service *serv);
+    static uint32_t SMSGetCount(sys::Service *serv, SMSState state = SMSState::ALL);
     /**
      * @brief Function is getting last modified SMS record.
      * @param serv Pointer to Service based object that is sending request.
@@ -100,7 +100,7 @@ class DBServiceAPI
     static uint32_t CalllogAdd(sys::Service *serv, const CalllogRecord &rec);
     static bool CalllogRemove(sys::Service *serv, uint32_t id);
     static bool CalllogUpdate(sys::Service *serv, const CalllogRecord &rec);
-    static uint32_t CalllogGetCount(sys::Service *serv);
+    static uint32_t CalllogGetCount(sys::Service *serv, CallState state = CallState::ALL);
     static bool CalllogGetLimitOffset(sys::Service *serv, uint32_t offset, uint32_t limit);
 
     /* country codes */
diff --git a/module-services/service-db/messages/DBMessage.hpp b/module-services/service-db/messages/DBMessage.hpp
index d6da99229..760b178c5 100644
--- a/module-services/service-db/messages/DBMessage.hpp
+++ b/module-services/service-db/messages/DBMessage.hpp
@@ -11,6 +11,7 @@
 #ifndef PUREPHONE_DBMESSAGE_HPP
 #define PUREPHONE_DBMESSAGE_HPP
 
+#include "Common/Common.hpp"
 #include "Interface/AlarmsRecord.hpp"
 #include "Interface/CalllogRecord.hpp"
 #include "Interface/ContactRecord.hpp"
@@ -81,6 +82,15 @@ class DBSMSMessage : public DBMessage
     SMSRecord record;
 };
 
+class DBSMSGetCount : public DBSMSMessage
+{
+  public:
+    SMSState state;
+    DBSMSGetCount(SMSState state = SMSState::ALL) : DBSMSMessage(MessageType::DBSMSGetCount), state(state)
+    {
+    }
+};
+
 class DBSMSResponseMessage : public DBResponseMessage
 {
   public:
@@ -259,6 +269,15 @@ class DBCalllogMessage : public DBMessage
     CalllogRecord record;
 };
 
+class DBCalllogGetCount : public DBCalllogMessage
+{
+  public:
+    CallState state;
+    DBCalllogGetCount(CallState state) : DBCalllogMessage(MessageType::DBCalllogGetCount), state(state)
+    {
+    }
+};
+
 class DBCalllogResponseMessage : public DBResponseMessage
 {
   public: