1 files changed, 124 insertions, 55 deletions

diff --git a/src/components/application_manager/include/application_manager/app_service_manager.h b/src/components/application_manager/include/application_manager/app_service_manager.h
index 4c0877a456..9690d7cd46 100644
--- a/src/components/application_manager/include/application_manager/app_service_manager.h
+++ b/src/components/application_manager/include/application_manager/app_service_manager.h
@@ -34,10 +34,9 @@
 #define SRC_COMPONENTS_APPLICATION_MANAGER_INCLUDE_APPLICATION_MANAGER_APP_SERVICE_MANAGER_H_
 
 #include "application_manager/application.h"
+#include "application_manager/rpc_passing_handler.h"
 #include "interfaces/MOBILE_API.h"
 #include "smart_objects/smart_object.h"
-#include "application_manager/application.h"
-#include "application_manager/rpc_passing_handler.h"
 
 namespace resumption {
 class LastState;
@@ -52,6 +51,7 @@ struct AppService {
   smart_objects::SmartObject record;
 };
 
+class RPCPassingHandler;
 class ApplicationManager;
 /**
  * @brief The AppServiceManager is TODO.
@@ -70,95 +70,153 @@ class AppServiceManager {
   /**
    * @brief Class destructor
    */
-  ~AppServiceManager();
+  virtual ~AppServiceManager();
 
   /**
-   * @brief TODO
-   * @param manifest
+   * @brief Publish an app service. This service will be activated if it is the
+   * default service for its type, or if it is the first service to register of
+   * its type.
+   * @param manifest - The app service manifest of the service to be published
+   * @param mobile_service - True, if the service is being published by a mobile
+   * app. False, if published by the embedded system.
+   * @param connection_key - If mobile_service is true, the connection key of
+   * the app publishing this service.
+   * @return The app service record of the published app service
    */
-  smart_objects::SmartObject PublishAppService(
+  virtual smart_objects::SmartObject PublishAppService(
       const smart_objects::SmartObject& manifest,
       const bool mobile_service,
-      const uint32_t connection_key);
+      const uint32_t connection_key = 0u);
 
   /**
-   * @brief TODO
-   * @param service_id
+   * @brief Unpublish an existing app service
+   * @param service_id - The ID of the app service to be deleted.
+   * @return True on success, false otherwise
    */
-  bool UnpublishAppService(const std::string service_id);
-
-  void OnAppActivated(ApplicationConstSharedPtr app);
+  virtual bool UnpublishAppService(const std::string service_id);
 
   /**
-   * @brief TODO
-   * @param connection_key
+   * @brief Callback for when an application is activated. Will activate all
+   * services which were published by this app.
+   * @param app - The application that was activated.
    */
-  void UnpublishServices(const uint32_t connection_key);
+  virtual void OnAppActivated(ApplicationConstSharedPtr app);
 
   /**
-   * @brief TODO
-   * @param service_id
+   * @brief Unpublish any published services for a given mobile application
+   * @param connection_key - The connection key of the application from which
+   * all published services should be deleted.
    */
-  bool SetDefaultService(const std::string service_id);
+  virtual void UnpublishServices(const uint32_t connection_key);
 
   /**
-   * @brief TODO
-   * @param service_id
+   * @brief Sets a service to the default service for its type
+   * @param service_id - The ID of the service to become the default
+   * @return True on success, false otherwise
    */
-  bool RemoveDefaultService(const std::string service_id);
+  virtual bool SetDefaultService(const std::string service_id);
 
   /**
-   * @brief TODO
-   * @param service_id
+   * @brief Removes a service from the list of default services.
+   * @param service_id - The ID of the existing default service.
+   * @return True on success, false otherwise
    */
-  bool ActivateAppService(const std::string service_id);
+  virtual bool RemoveDefaultService(const std::string service_id);
 
   /**
-   * @brief TODO
-   * @param service_id
+   * @brief Activate an existing service
+   * @param service_id - The ID of the service to be activated.
+   * @return True if the service is active, false otherwise
    */
-  bool DeactivateAppService(const std::string service_id);
+  virtual bool ActivateAppService(const std::string service_id);
 
   /**
-   * @brief TODO
-   * @param manifest
+   * @brief Deactivate an existing active service
+   * @param service_id - The ID of the service to be deactivated.
+   * @return True if the service was deactivated, false otherwise
    */
-  std::vector<smart_objects::SmartObject> GetAllServices();
-  std::vector<std::pair<std::string, AppService> > GetActiveServices();
+  virtual bool DeactivateAppService(const std::string service_id);
 
-  void GetProviderByType(const std::string& service_type,
-                         bool mobile_consumer,
-                         ApplicationSharedPtr& app,
-                         bool& hmi_service);
+  /**
+   * @brief Get a list of all published service records.
+   * @return A list of all all published service records.
+   */
+  virtual std::vector<smart_objects::SmartObject> GetAllServiceRecords();
 
-  void GetProviderByID(const std::string& service_id,
-                       bool mobile_consumer,
-                       ApplicationSharedPtr& app,
-                       bool& hmi_service);
+  /**
+   * @brief Get a list of all active app services.
+   * @return A list of all all active app services.
+   */
+  virtual std::vector<AppService> GetActiveServices();
 
-  AppService* ActiveServiceByType(std::string service_type);
+  /**
+   * @brief Retrieve the active service provider for a given service type
+   * @param service_type - The service type of the provider to be retrieved
+   * @param mobile_consumer - True, if the consumer trying to communicate with
+   * the provider is a mobile application
+   * @param app - Output parameter that will be filled with the application
+   * providing the requested service on success, unchanged on failure
+   * @param hmi_service - Output parameter set to true if the service
+   * provider is the HMI, unchanged on failure
+   */
+  virtual void GetProviderByType(const std::string& service_type,
+                                 const bool mobile_consumer,
+                                 ApplicationSharedPtr& app,
+                                 bool& hmi_service);
 
-  AppService* EmbeddedServiceForType(std::string service_type);
+  /**
+   * @brief Retrieve the service provider with a given service ID
+   * @param service_type - The service type of the provider to be retrieved
+   * @param mobile_consumer - True, if the consumer trying to communicate with
+   * the provider is a mobile application
+   * @param app - Output parameter that will be filled with the application
+   * providing the requested service on success, unchanged on failure
+   * @param hmi_service - Output parameter set to true if the service
+   * provider is the HMI, unchanged on failure
+   */
+  virtual void GetProviderByID(const std::string& service_id,
+                               const bool mobile_consumer,
+                               ApplicationSharedPtr& app,
+                               bool& hmi_service);
 
-  AppService* FindServiceByID(std::string service_id);
+  /**
+   * @brief Get the active service for a given service type.
+   * @param service_type - The service type
+   * @return A pointer to the active service for the given service type on
+   * success, NULL on failure
+   */
+  virtual AppService* ActiveServiceForType(const std::string service_type);
 
-  std::string DefaultServiceByType(std::string service_type);
+  /**
+   * @brief Get the embedded service for a given service type.
+   * @param service_type - The service type
+   * @return A pointer to the embedded service for the given service type on
+   * success, NULL on failure
+   */
+  virtual AppService* EmbeddedServiceForType(const std::string service_type);
 
   /**
-   * @brief TODO
-   * @param service_id
-   * @param service_published
+   * @brief Get the service with a given service ID.
+   * @param service_type - The service ID
+   * @return A pointer to requested service on success, NULL on failure
    */
-  void SetServicePublished(const std::string service_id,
-                           bool service_published);
+  virtual AppService* FindServiceByID(const std::string service_id);
 
   /**
-   * @brief TODO
-   * @param out_params
+   * @brief Update a navigation system capability struct with the capabilities
+   * of the active navigation service.
+   * @param out_params - The struct to be modified
+   * @return True on success, false otherwise (if there was no active NAVIGATION
+   * service)
    */
-  bool UpdateNavigationCapabilities(smart_objects::SmartObject& out_params);
+  virtual bool UpdateNavigationCapabilities(
+      smart_objects::SmartObject& out_params);
 
-  RPCPassingHandler& GetRPCPassingHandler();
+  /**
+   * @brief Get the RPCPassingHandler tied to this object
+   * @return The RPCPassingHandler tied to this object
+   */
+  virtual RPCPassingHandler& GetRPCPassingHandler();
 
  private:
   ApplicationManager& app_manager_;
@@ -168,16 +226,27 @@ class AppServiceManager {
   std::map<std::string, AppService> published_services_;
   RPCPassingHandler rpc_passing_handler_;
 
+  void SetServicePublished(const std::string service_id,
+                           bool service_published);
   void AppServiceUpdated(
       const smart_objects::SmartObject& service_record,
       const mobile_apis::ServiceUpdateReason::eType update_reason,
       smart_objects::SmartObject& msg_params);
   void GetProviderFromService(const AppService& service,
-                              bool mobile_consumer,
+                              const bool mobile_consumer,
                               ApplicationSharedPtr& app,
                               bool& hmi_service);
-  AppService* FindServiceByPolicyAppID(std::string policy_app_id,
-                                       std::string type);
+
+  /**
+   * @brief Get the policy app ID of the default service provider for a given
+   * service type.
+   * @param service_type - The service type
+   * @return The policy app ID of the default service provider for the given
+   * service type on success, "" on failure
+   */
+  std::string DefaultServiceByType(const std::string service_type);
+  AppService* FindServiceByPolicyAppID(const std::string policy_app_id,
+                                       const std::string type);
   std::string GetPolicyAppID(AppService service);
 };