Implement fully functional GetSystemTime feature

Implemented fully working GetSystemTime feature
Fixed UT in the security manager due to code changes
Disable randomly failed test

18 files changed, 802 insertions, 12 deletions

diff --git a/src/components/application_manager/CMakeLists.txt b/src/components/application_manager/CMakeLists.txt
index e9f2f8ec7b..966dbee353 100644
--- a/src/components/application_manager/CMakeLists.txt
+++ b/src/components/application_manager/CMakeLists.txt
@@ -52,6 +52,7 @@ include_directories (
   ${COMPONENTS_DIR}/config_profile/include
   ${COMPONENTS_DIR}/request_watchdog/include
   ${COMPONENTS_DIR}/resumption/include
+  ${COMPONENTS_DIR}/system_time/
   ${COMPONENTS_DIR}/rpc_base/include
   ${COMPONENTS_DIR}/interfaces
   ${POLICY_PATH}/include/
@@ -85,6 +86,9 @@ set (MESSAGE_HELPER_PATHS
 )
 collect_sources(MESSAGE_HELPER_SOURCES "${MESSAGE_HELPER_PATHS}")
 
+set (SYSTEM_TIME_SOURCES
+  ${AM_SOURCE_DIR}/src/system_time/system_time_handler_impl.cc
+)
 
 set (POLICIES_SOURCE_DIR
   ${AM_SOURCE_DIR}/src/policies
@@ -146,6 +150,9 @@ set (HMI_COMMANDS_SOURCES
   ${COMMANDS_SOURCE_DIR}/hmi/activate_app_response.cc
   ${COMMANDS_SOURCE_DIR}/hmi/get_system_info_request.cc
   ${COMMANDS_SOURCE_DIR}/hmi/get_system_info_response.cc
+  ${COMMANDS_SOURCE_DIR}/hmi/basic_communication_get_system_time_request.cc
+  ${COMMANDS_SOURCE_DIR}/hmi/basic_communication_get_system_time_response.cc
+  ${COMMANDS_SOURCE_DIR}/hmi/on_system_time_ready_notification.cc
   ${COMMANDS_SOURCE_DIR}/hmi/sdl_get_list_of_permissions_request.cc
   ${COMMANDS_SOURCE_DIR}/hmi/sdl_get_list_of_permissions_response.cc
   ${COMMANDS_SOURCE_DIR}/hmi/sdl_get_user_friendly_message_request.cc
@@ -447,6 +454,10 @@ target_link_libraries("AMHMICommandsLibrary" ${LIBRARIES} AMEventEngine)
 add_library("MessageHelper" ${MESSAGE_HELPER_SOURCES})
 target_link_libraries("MessageHelper" ${LIBRARIES})
 
+add_library("SystemTimeLibrary" ${SYSTEM_TIME_SOURCES})
+target_link_libraries("SystemTimeLibrary" ${LIBRARIES} AMEventEngine)
+add_dependencies("MessageHelper" HMI_API MOBILE_API)
+
 add_library("AMMobileCommandsLibrary" ${MOBILE_COMMANDS_SOURCES} )
 target_link_libraries("AMMobileCommandsLibrary" ${LIBRARIES} AMEventEngine)
 
diff --git a/src/components/application_manager/include/application_manager/application_manager_impl.h b/src/components/application_manager/include/application_manager/application_manager_impl.h
index 286ad87018..d3fe69efcb 100644
--- a/src/components/application_manager/include/application_manager/application_manager_impl.h
+++ b/src/components/application_manager/include/application_manager/application_manager_impl.h
@@ -958,6 +958,13 @@ class ApplicationManagerImpl
       security_manager::SSLContext::HandshakeResult result) OVERRIDE;
 
   /**
+   * @brief OnHandshakeFailed currently does nothing.
+   * This method is declared as pure virtual in common base class
+   * therefore it has to be present and should be implemented
+   * to allow creation of current class instances
+   */
+  void OnHandshakeFailed() OVERRIDE;
+  /**
    * @brief Notification that certificate update is required.
    */
   void OnCertificateUpdateRequired() OVERRIDE;
diff --git a/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_request.h b/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_request.h
new file mode 100644
index 0000000000..1638b2f51b
--- /dev/null
+++ b/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_request.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_REQUEST_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_REQUEST_H_
+
+#include "application_manager/commands/hmi/request_to_hmi.h"
+#include "utils/macro.h"
+
+namespace application_manager {
+namespace commands {
+
+/**
+ * @brief The BasicCommunicationGetSystemTimeRequest class sends the request
+ * to the HMI in order to receive current system time.
+ */
+class BasicCommunicationGetSystemTimeRequest : public RequestToHMI {
+ public:
+  /**
+   * @brief BasicCommunicationGetSystemTimeRequest does nothing except of
+   * initializing base class with the passed parameters.
+   * @param message the message to send to HMI
+   * @param application_manager application manager. Location service which
+   * is provides neccessary api to send the request.
+   */
+  BasicCommunicationGetSystemTimeRequest(
+      const MessageSharedPtr& message, ApplicationManager& application_manager);
+
+ private:
+  /**
+   * @brief onTimeOut allows to handle case when
+   * system does not respond for certain request in
+   * appropriate time window.
+   */
+  void onTimeOut() FINAL;
+};
+
+}  // namespace commands
+}  // namespace application_manager
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_REQUEST_H_
diff --git a/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_response.h b/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_response.h
new file mode 100644
index 0000000000..1bf7447c7d
--- /dev/null
+++ b/src/components/application_manager/include/application_manager/commands/hmi/basic_communication_get_system_time_response.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_RESPONSE_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_RESPONSE_H_
+
+#include "application_manager/commands/hmi/response_from_hmi.h"
+
+#include "utils/macro.h"
+#include "application_manager/application_manager_impl.h"
+
+namespace application_manager {
+
+namespace commands {
+
+/**
+ * @brief The BasicCommunicationGetSystemTimeResponse class represents the
+ * HMI response which is contains data obtained from HMI.
+ */
+class BasicCommunicationGetSystemTimeResponse : public ResponseFromHMI {
+ public:
+  /**
+   * @brief BasicCommunicationGetSystemTimeResponse does nothing except of
+   * initializing base class with the passed parameters.
+   * @param message the message to send to HMI
+   * @param application_manager Location service which which is provides
+   * neccessary api to send the request.
+   */
+  BasicCommunicationGetSystemTimeResponse(
+      const MessageSharedPtr& message, ApplicationManager& application_manager);
+
+ private:
+  /**
+   * @brief Run takes the message obtained from the HMI and
+   * sends this data to the subscribed on certain event class
+   */
+  void Run() FINAL;
+};
+
+}  // namespace commands
+}  // namespace application_manager
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_BASIC_COMMUNICATION_GET_SYSTEM_TIME_RESPONSE_H_
diff --git a/src/components/application_manager/include/application_manager/commands/hmi/on_system_time_ready_notification.h b/src/components/application_manager/include/application_manager/commands/hmi/on_system_time_ready_notification.h
new file mode 100644
index 0000000000..9b8763da42
--- /dev/null
+++ b/src/components/application_manager/include/application_manager/commands/hmi/on_system_time_ready_notification.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_ON_SYSTEM_TIME_READY_NOTIFICATION_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_ON_SYSTEM_TIME_READY_NOTIFICATION_H_
+
+#include "application_manager/commands/hmi/notification_from_hmi.h"
+#include "application_manager/application_manager_impl.h"
+
+namespace application_manager {
+
+namespace commands {
+
+/**
+ * @brief OnSystemTimeReadyNotification command class.
+ * Notifies SDL whenever system time module is ready.
+ * It could be GPS or any other module which is allows
+ * to obtain system time. Once SDL receive this notification
+ * it is allowed to use GetSystemTimeRequest to rerieve system time.
+ */
+class OnSystemTimeReadyNotification : public NotificationFromHMI {
+ public:
+  /**
+   * @brief OnSystemTimeReadyNotification create the command.
+   * @param message content of the command. Passed directy to base class.
+   */
+  OnSystemTimeReadyNotification(const MessageSharedPtr& message,
+                                ApplicationManager& application_manager);
+
+  /**
+   * @brief ~OnSystemTimeReadyNotification destroys the command object.
+   */
+  ~OnSystemTimeReadyNotification();
+
+ private:
+  /**
+   * @brief Run creates SystemTimeReady event
+   * and notifies all the subscribers.
+   */
+  void Run() FINAL;
+};
+
+}  // namespace commands
+}  // namespace application_manager
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_COMMANDS_HMI_ON_SYSTEM_TIME_READY_NOTIFICATION_H_
diff --git a/src/components/application_manager/include/application_manager/message_helper.h b/src/components/application_manager/include/application_manager/message_helper.h
index b94609c01b..0a476712d6 100644
--- a/src/components/application_manager/include/application_manager/message_helper.h
+++ b/src/components/application_manager/include/application_manager/message_helper.h
@@ -107,6 +107,15 @@ class MessageHelper {
   static void SendDecryptCertificateToHMI(const std::string& file_name,
                                           ApplicationManager& app_mngr);
 
+  /**
+    * @brief SendGetSystemTimeRequest sends mentioned request to HMI.
+    * @param correlation_id the message correlation id, required for proper
+    * response processing.
+    * @param app_mngr
+    */
+  static void SendGetSystemTimeRequest(const uint32_t correlation_id,
+                                       ApplicationManager& app_mngr);
+
   /*
    * @brief Retrieve vehicle data map for param name in mobile request
    * to VehicleDataType
diff --git a/src/components/application_manager/include/application_manager/smart_object_keys.h b/src/components/application_manager/include/application_manager/smart_object_keys.h
index 32a2315f23..e79b34c55f 100644
--- a/src/components/application_manager/include/application_manager/smart_object_keys.h
+++ b/src/components/application_manager/include/application_manager/smart_object_keys.h
@@ -406,7 +406,19 @@ extern const char* kFull;
 extern const char* kLimited;
 extern const char* kBackground;
 extern const char* kNone;
-}
+}  // namespace hmi_levels
+
+namespace time_keys {
+extern const char* millisecond;
+extern const char* second;
+extern const char* minute;
+extern const char* hour;
+extern const char* day;
+extern const char* month;
+extern const char* year;
+extern const char* tz_hour;
+extern const char* tz_minute;
+}  // namespace time_keys
 
 namespace hmi_request {
 extern const char* parent_id;
@@ -478,7 +490,7 @@ extern const char* num_custom_presets_available;
 extern const char* urls;
 extern const char* policy_app_id;
 extern const char* enabled;
-
+extern const char* system_time;
 }  // namespace hmi_response
 
 namespace hmi_notification {
diff --git a/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h b/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h
new file mode 100644
index 0000000000..28ba629e19
--- /dev/null
+++ b/src/components/application_manager/include/application_manager/system_time/system_time_handler_impl.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_SYSTEM_TIME_SYSTEM_TIME_HANDLER_IMPL_H_
+#define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_SYSTEM_TIME_SYSTEM_TIME_HANDLER_IMPL_H_
+
+#include <time.h>
+#include <vector>
+
+#include "utils/lock.h"
+#include "utils/macro.h"
+#include "utils/system_time_handler.h"
+#include "application_manager/application_manager_impl.h"
+#include "application_manager/event_engine/event_observer.h"
+
+namespace application_manager {
+
+/**
+ * @brief The SystemTimeHandlerImpl class.
+ * Responsible for the system time notification. It keeps the list
+ * of system time listeners, sends appropriate request to the system
+ * and notifies the listeners with new time right after response has appeared.
+ */
+class SystemTimeHandlerImpl : public utils::SystemTimeHandler,
+                              public event_engine::EventObserver {
+ public:
+  /**
+   * @brief SystemTimeHandlerImpl creates the instance of the class.
+   */
+  explicit SystemTimeHandlerImpl(ApplicationManager& application_manager);
+
+  /**
+   * @brief ~SystemTimeHandlerImpl
+   */
+  ~SystemTimeHandlerImpl();
+
+ private:
+  /**
+   * @brief on_event allows to process certain events from the system.
+   * Event which are handles within this methods  are: OnSystemTimeReady
+   * in order to send system time query and GetSystemTimeResponse in order
+   * to retrieve utc time and notify all the listeners with new time value.
+   */
+  void on_event(const application_manager::event_engine::Event& event) FINAL;
+
+  /**
+   * @brief DoSystemTimeQuery sends the appropriate request to the system
+   * and subscribes the class to the response. This is asynchronous request
+   * thus it won't block until the system respond and returns immediately.
+   */
+  void DoSystemTimeQuery() FINAL;
+
+  /**
+   * @brief DoSubscribe allows to subscribe certain listener for
+   * SystemTime. This certain implementation does not maintain
+   * listeners collection instead it save the pointer to listener.
+   * @note the class is not reponsible for the pointer's lifecycle.
+   * So consider to explicitly unsibsscribe from event when listener
+   * is going to be destroyed.
+   * @param listener the listener which will be notified
+   * in case of SystemTime appeared.
+   */
+  void DoSubscribe(utils::SystemTimeListener* listener) FINAL;
+
+  /**
+   * @brief DoUnsubscribe assigns the pointer to listener to NULL.
+   * This certain implementation ignores passed parameter.
+   * @param listener pointer to the object which should be
+   * unsubscribed from events.
+   */
+  void DoUnsubscribe(utils::SystemTimeListener* listener) FINAL;
+
+  /**
+   * @brief FetchSystemTime this method allows to obtain
+   * recently received utc time.
+   * @note it is up to user to check whether the returned
+   * argument is valid
+   * @return the time value returned by system.
+   */
+  time_t FetchSystemTime() FINAL;
+
+  /**
+   * @brief SendTimeRequest sends the request to the system
+   * and subscribes for response.
+   */
+  void SendTimeRequest();
+
+  /**
+   * @brief ProcessSystemTimeResponse allows to process GetSystemTimeResponse
+   * @param event contains response parameters aka "systemTime".
+   */
+  void ProcessSystemTimeResponse(
+      const application_manager::event_engine::Event& event);
+
+  /**
+   * @brief ProcessSystemTimeReadyNotification allows to process
+   * OnSystemTimeready notification
+   * from HMI. It unsubscribes from the mentioned notification and sends
+   * GetSystemTimeRequest to HMI in order to obtain system time
+   */
+  void ProcessSystemTimeReadyNotification();
+
+  /**
+   * @brief Checks if UTC time is ready to provided by HMI
+   * and can be requested by GetSystemTime request
+   * @return True if HMI is ready to provide UTC time
+   * otherwise False
+   */
+  bool utc_time_can_be_received() const FINAL;
+
+  mutable sync_primitives::Lock state_lock_;
+  // Variable means HMI readiness to provide system time by request
+  volatile bool utc_time_can_be_received_;
+  // Varible used to schedule next GetSystemTime request
+  // if at the moment of sending first GetSystemTime request
+  // HMI is not ready to provide system time
+  volatile bool schedule_request_;
+  // Varible used to store result for GetSystemTime request
+  time_t last_time_;
+
+  sync_primitives::Lock system_time_listener_lock_;
+  utils::SystemTimeListener* system_time_listener_;
+  ApplicationManager& app_manager_;
+};
+
+}  // namespace application_manager
+
+#endif  // SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_SYSTEM_TIME_SYSTEM_TIME_HANDLER_IMPL_H_
diff --git a/src/components/application_manager/src/application_manager_impl.cc b/src/components/application_manager/src/application_manager_impl.cc
index 248b54fee5..5aa72d77e5 100644
--- a/src/components/application_manager/src/application_manager_impl.cc
+++ b/src/components/application_manager/src/application_manager_impl.cc
@@ -1691,6 +1691,10 @@ bool ApplicationManagerImpl::OnHandshakeDone(
   return false;
 }
 
+void ApplicationManagerImpl::OnHandshakeFailed() {
+  LOG4CXX_AUTO_TRACE(logger_);
+}
+
 void ApplicationManagerImpl::OnCertificateUpdateRequired() {
   LOG4CXX_AUTO_TRACE(logger_);
   GetPolicyHandler().OnPTExchangeNeeded();
diff --git a/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_request.cc b/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_request.cc
new file mode 100644
index 0000000000..215b0404a7
--- /dev/null
+++ b/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_request.cc
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribut wiion.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/commands/hmi/basic_communication_get_system_time_request.h"
+
+namespace application_manager {
+
+namespace commands {
+
+BasicCommunicationGetSystemTimeRequest::BasicCommunicationGetSystemTimeRequest(
+    const MessageSharedPtr& message, ApplicationManager& application_manager)
+    : RequestToHMI(message, application_manager) {}
+
+void BasicCommunicationGetSystemTimeRequest::onTimeOut() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  application_manager_.protocol_handler().NotifyOnFailedHandshake();
+}
+
+}  // namespace commands
+}  // namespace application_manager
diff --git a/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_response.cc b/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_response.cc
new file mode 100644
index 0000000000..26dd115d1a
--- /dev/null
+++ b/src/components/application_manager/src/commands/hmi/basic_communication_get_system_time_response.cc
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/commands/hmi/basic_communication_get_system_time_response.h"
+#include "utils/logger.h"
+
+CREATE_LOGGERPTR_GLOBAL(logger_, "Commands")
+
+namespace application_manager {
+namespace commands {
+
+BasicCommunicationGetSystemTimeResponse::
+    BasicCommunicationGetSystemTimeResponse(
+        const MessageSharedPtr& message,
+        ApplicationManager& application_manager)
+    : ResponseFromHMI(message, application_manager) {}
+
+void BasicCommunicationGetSystemTimeResponse::Run() {
+  LOG4CXX_AUTO_TRACE(logger_);
+
+  event_engine::Event event(
+      hmi_apis::FunctionID::BasicCommunication_GetSystemTime);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+}  // namespace commands
+}  // namespace application_manager
diff --git a/src/components/application_manager/src/commands/hmi/on_system_time_ready_notification.cc b/src/components/application_manager/src/commands/hmi/on_system_time_ready_notification.cc
new file mode 100644
index 0000000000..d2376e6dfe
--- /dev/null
+++ b/src/components/application_manager/src/commands/hmi/on_system_time_ready_notification.cc
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/commands/hmi/on_system_time_ready_notification.h"
+
+#include "application_manager/event_engine/event.h"
+#include "interfaces/HMI_API.h"
+
+namespace application_manager {
+
+namespace commands {
+
+OnSystemTimeReadyNotification::OnSystemTimeReadyNotification(
+    const MessageSharedPtr& message, ApplicationManager& application_manager)
+    : NotificationFromHMI(message, application_manager) {}
+
+OnSystemTimeReadyNotification::~OnSystemTimeReadyNotification() {}
+
+void OnSystemTimeReadyNotification::Run() {
+  event_engine::Event event(
+      hmi_apis::FunctionID::BasicCommunication_OnSystemTimeReady);
+  event.set_smart_object(*message_);
+  event.raise(application_manager_.event_dispatcher());
+}
+
+}  // namespace commands
+}  // namespace application_manager
diff --git a/src/components/application_manager/src/commands/hmi/request_to_hmi.cc b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
index 6905e7cdef..23c020bca2 100644
--- a/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
+++ b/src/components/application_manager/src/commands/hmi/request_to_hmi.cc
@@ -74,7 +74,9 @@ bool RequestToHMI::CleanUp() {
   return true;
 }
 
-void RequestToHMI::Run() {}
+void RequestToHMI::Run() {
+  SendRequest();
+}
 
 void RequestToHMI::SendRequest() {
   (*message_)[strings::params][strings::protocol_type] = hmi_protocol_type_;
diff --git a/src/components/application_manager/src/hmi_command_factory.cc b/src/components/application_manager/src/hmi_command_factory.cc
index a7f3ce7e6b..5ef8605999 100644
--- a/src/components/application_manager/src/hmi_command_factory.cc
+++ b/src/components/application_manager/src/hmi_command_factory.cc
@@ -224,6 +224,7 @@
 #include "application_manager/commands/hmi/navi_get_way_points_request.h"
 #include "application_manager/commands/hmi/navi_get_way_points_response.h"
 #include "application_manager/commands/hmi/on_ready_notification.h"
+#include "application_manager/commands/hmi/on_system_time_ready_notification.h"
 #include "application_manager/commands/hmi/on_device_chosen_notification.h"
 #include "application_manager/commands/hmi/on_file_removed_notification.h"
 #include "application_manager/commands/hmi/on_system_context_notification.h"
@@ -269,6 +270,8 @@
 #include "application_manager/commands/hmi/on_system_error_notification.h"
 #include "application_manager/commands/hmi/basic_communication_system_request.h"
 #include "application_manager/commands/hmi/basic_communication_system_response.h"
+#include "application_manager/commands/hmi/basic_communication_get_system_time_request.h"
+#include "application_manager/commands/hmi/basic_communication_get_system_time_response.h"
 #include "application_manager/commands/hmi/basic_communication_on_awake_sdl.h"
 #include "application_manager/commands/hmi/sdl_policy_update.h"
 #include "application_manager/commands/hmi/sdl_policy_update_response.h"
@@ -1285,6 +1288,11 @@ CommandSharedPtr HMICommandFactory::CreateCommand(
           new commands::OnReadyNotification(message, application_manager));
       break;
     }
+    case hmi_apis::FunctionID::BasicCommunication_OnSystemTimeReady: {
+      command.reset(new commands::OnSystemTimeReadyNotification(
+          message, application_manager));
+      break;
+    }
     case hmi_apis::FunctionID::BasicCommunication_OnDeviceChosen: {
       command.reset(new commands::OnDeviceChosenNotification(
           message, application_manager));
@@ -2221,6 +2229,16 @@ CommandSharedPtr HMICommandFactory::CreateCommand(
       }
       break;
     }
+    case hmi_apis::FunctionID::BasicCommunication_GetSystemTime: {
+      if (is_response) {
+        command.reset(new commands::BasicCommunicationGetSystemTimeResponse(
+            message, application_manager));
+      } else {
+        command.reset(new commands::BasicCommunicationGetSystemTimeRequest(
+            message, application_manager));
+      }
+      break;
+    }
     case hmi_apis::FunctionID::Navigation_SendLocation: {
       if (is_response) {
         command.reset(new commands::NaviSendLocationResponse(
diff --git a/src/components/application_manager/src/message_helper/message_helper.cc b/src/components/application_manager/src/message_helper/message_helper.cc
index 6a908c4ebc..9a10c908f1 100644
--- a/src/components/application_manager/src/message_helper/message_helper.cc
+++ b/src/components/application_manager/src/message_helper/message_helper.cc
@@ -365,6 +365,20 @@ void MessageHelper::SendDecryptCertificateToHMI(const std::string& file_name,
   app_mngr.ManageHMICommand(message);
 }
 
+void MessageHelper::SendGetSystemTimeRequest(const uint32_t correlation_id,
+                                             ApplicationManager& app_mngr) {
+  using namespace smart_objects;
+  SmartObjectSPtr message =
+      CreateMessageForHMI(hmi_apis::messageType::request, correlation_id);
+
+  DCHECK(message);
+
+  (*message)[strings::params][strings::function_id] =
+      hmi_apis::FunctionID::BasicCommunication_GetSystemTime;
+
+  app_mngr.ManageHMICommand(message);
+}
+
 void MessageHelper::SendHashUpdateNotification(const uint32_t app_id,
                                                ApplicationManager& app_mngr) {
   LOG4CXX_AUTO_TRACE(logger_);
diff --git a/src/components/application_manager/src/policies/policy_handler.cc b/src/components/application_manager/src/policies/policy_handler.cc
index bbf391a9f1..98fb6bae65 100644
--- a/src/components/application_manager/src/policies/policy_handler.cc
+++ b/src/components/application_manager/src/policies/policy_handler.cc
@@ -1765,11 +1765,11 @@ void PolicyHandler::OnCertificateDecrypted(bool is_succeeded) {
 void PolicyHandler::OnCertificateUpdated(const std::string& certificate_data) {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock lock(listeners_lock_);
-  HandlersCollection::const_iterator it = listeners_.begin();
-  for (; it != listeners_.end(); ++it) {
-    PolicyHandlerObserver* observer = *it;
-    observer->OnCertificateUpdated(certificate_data);
-  }
+  std::for_each(
+      listeners_.begin(),
+      listeners_.end(),
+      std::bind2nd(std::mem_fun(&PolicyHandlerObserver::OnCertificateUpdated),
+                   certificate_data));
 }
 #endif  // EXTERNAL_PROPRIETARY_MODE
 
diff --git a/src/components/application_manager/src/smart_object_keys.cc b/src/components/application_manager/src/smart_object_keys.cc
index c3aba90dd5..888943d4d6 100644
--- a/src/components/application_manager/src/smart_object_keys.cc
+++ b/src/components/application_manager/src/smart_object_keys.cc
@@ -351,7 +351,7 @@ const char* instance_follow_redirect = "InstanceFollowRedirect";
 const char* charset = "charset";
 const char* content_lenght = "Content_Lenght";
 const char* GET = "GET";
-}  // http_request
+}  // namespace http_request
 
 namespace mobile_notification {
 const char* state = "state";
@@ -364,7 +364,17 @@ const char* kFull = "FULL";
 const char* kLimited = "LIMITED";
 const char* kBackground = "BACKGROUND";
 const char* kNone = "NONE";
-}
+}  // namespace hmi_levels
+
+namespace time_keys {
+const char* millisecond = "millisecond";
+const char* second = "second";
+const char* minute = "minute";
+const char* hour = "hour";
+const char* day = "day";
+const char* month = "month";
+const char* year = "year";
+}  // namespace time_keys
 
 namespace hmi_request {
 const char* parent_id = "parentID";
@@ -436,7 +446,7 @@ const char* num_custom_presets_available = "numCustomPresetsAvailable";
 const char* urls = "urls";
 const char* policy_app_id = "policyAppID";
 const char* enabled = "enabled";
-
+const char* system_time = "systemTime";
 }  // namespace hmi_response
 
 namespace hmi_notification {
@@ -451,7 +461,6 @@ const char* policyfile = "policyfile";
 const char* is_active = "isActive";
 const char* is_deactivated = "isDeactivated";
 const char* event_name = "eventName";
-
 }  // namespace hmi_notification
 
 }  // namespace application_manager
diff --git a/src/components/application_manager/src/system_time/system_time_handler_impl.cc b/src/components/application_manager/src/system_time/system_time_handler_impl.cc
new file mode 100644
index 0000000000..a91fb16197
--- /dev/null
+++ b/src/components/application_manager/src/system_time/system_time_handler_impl.cc
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "application_manager/system_time/system_time_handler_impl.h"
+
+#include <algorithm>
+
+#include "application_manager/message_helper.h"
+#include "application_manager/smart_object_keys.h"
+#include "interfaces/HMI_API.h"
+#include "utils/logger.h"
+
+namespace application_manager {
+
+SystemTimeHandlerImpl::SystemTimeHandlerImpl(
+    ApplicationManager& application_manager)
+    : event_engine::EventObserver(application_manager.event_dispatcher())
+    , utc_time_can_be_received_(false)
+    , schedule_request_(false)
+    , system_time_listener_(NULL)
+    , app_manager_(application_manager) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  subscribe_on_event(
+      hmi_apis::FunctionID::BasicCommunication_OnSystemTimeReady);
+}
+
+SystemTimeHandlerImpl::~SystemTimeHandlerImpl() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  unsubscribe_from_all_events();
+}
+
+void SystemTimeHandlerImpl::DoSystemTimeQuery() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  using namespace application_manager;
+
+  sync_primitives::AutoLock lock(state_lock_);
+  if (!utc_time_can_be_received_) {
+    LOG4CXX_INFO(logger_,
+                 "Navi module is not yet ready."
+                     << "Will process request once it became ready.");
+    schedule_request_ = true;
+    return;
+  }
+  SendTimeRequest();
+}
+
+void SystemTimeHandlerImpl::DoSubscribe(utils::SystemTimeListener* listener) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  DCHECK(listener);
+  sync_primitives::AutoLock lock(system_time_listener_lock_);
+  system_time_listener_ = listener;
+}
+
+void SystemTimeHandlerImpl::DoUnsubscribe(utils::SystemTimeListener* listener) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(system_time_listener_lock_);
+  system_time_listener_ = NULL;
+}
+
+time_t SystemTimeHandlerImpl::FetchSystemTime() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return last_time_;
+}
+
+bool SystemTimeHandlerImpl::utc_time_can_be_received() const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(state_lock_);
+  return utc_time_can_be_received_;
+}
+
+void SystemTimeHandlerImpl::SendTimeRequest() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  using namespace application_manager;
+  uint32_t correlation_id = app_manager_.GetNextHMICorrelationID();
+  subscribe_on_event(hmi_apis::FunctionID::BasicCommunication_GetSystemTime,
+                     correlation_id);
+  MessageHelper::SendGetSystemTimeRequest(correlation_id, app_manager_);
+}
+
+void SystemTimeHandlerImpl::on_event(
+    const application_manager::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  using namespace application_manager;
+  using namespace hmi_apis::FunctionID;
+  switch (event.id()) {
+    case BasicCommunication_OnSystemTimeReady:
+      ProcessSystemTimeReadyNotification();
+      break;
+    case BasicCommunication_GetSystemTime:
+      ProcessSystemTimeResponse(event);
+      break;
+    default:
+      LOG4CXX_ERROR(logger_, "Unknown Event received");
+      break;
+  }
+}
+
+void SystemTimeHandlerImpl::ProcessSystemTimeReadyNotification() {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock lock(state_lock_);
+  utc_time_can_be_received_ = true;
+  if (schedule_request_) {
+    SendTimeRequest();
+    schedule_request_ = false;
+  }
+  unsubscribe_from_event(
+      hmi_apis::FunctionID::BasicCommunication_OnSystemTimeReady);
+}
+
+void SystemTimeHandlerImpl::ProcessSystemTimeResponse(
+    const application_manager::event_engine::Event& event) {
+  LOG4CXX_AUTO_TRACE(logger_);
+  const smart_objects::SmartObject& message = event.smart_object();
+  const smart_objects::SmartObject& system_time_so =
+      message[strings::msg_params][hmi_response::system_time];
+
+  struct tm system_time;
+  memset(&system_time, 0, sizeof(struct tm));
+
+  system_time.tm_sec = system_time_so[time_keys::second].asInt();
+  system_time.tm_min = system_time_so[time_keys::minute].asInt();
+  // According to tm specification of tm type hour should be decreased by 1
+  system_time.tm_hour = system_time_so[time_keys::hour].asInt() - 1;
+  system_time.tm_mday = system_time_so[time_keys::day].asInt();
+  // According to tm specification of tm type mon should be decreased by 1
+  system_time.tm_mon = system_time_so[time_keys::month].asInt() - 1;
+  // According to tm specification of tm type
+  // tm_year - number of years since 1900
+  system_time.tm_year = system_time_so[time_keys::year].asInt() - 1900;
+
+  // Normalize and convert time from 'tm' format to 'time_t'
+  last_time_ = mktime(&system_time);
+
+  sync_primitives::AutoLock lock(system_time_listener_lock_);
+  if (system_time_listener_) {
+    system_time_listener_->OnSystemTimeArrived(last_time_);
+  }
+}
+
+}  // namespace application_manager