Replace int with pid_t for representing a process ID

Change-Id: I9dc8f8fb5204b1591e67cc0fa65c27a379e2f234

diff --git a/inc/client_manager.h b/inc/client_manager.h
index b174b14..0ecad4e 100644 (file)
--- a/inc/client_manager.h
+++ b/inc/client_manager.h
@@ -28,7 +28,7 @@ extern "C" {
 #endif
 
 typedef struct {
-       int pid;
+       pid_t pid;
        std::string appid;
 } ma_client_s;
 
@@ -38,20 +38,20 @@ public:
        virtual ~CClientManager() {}
 
        int set_application_manager(IApplicationManager* manager);
-       int create_client(int pid, std::string appid);
-       int destroy_client_by_pid(int pid);
+       int create_client(pid_t pid, std::string appid);
+       int destroy_client_by_pid(pid_t pid);
        int destroy_client_by_appid(std::string appid);
 
        int get_client_num();
-       int find_client_pid_by_index(unsigned int index);
+       pid_t find_client_pid_by_index(unsigned int index);
 
-       int find_client_pid_by_appid(std::string appid);
-       std::string find_client_appid_by_pid(int pid);
+       pid_t find_client_pid_by_appid(std::string appid);
+       std::string find_client_appid_by_pid(pid_t pid);
 
        bool check_client_validity_by_appid(std::string appid);
 private:
        ma_client_s* find_client_by_appid(std::string appid);
-       ma_client_s* find_client_by_pid(int pid);
+       ma_client_s* find_client_by_pid(pid_t pid);
        ma_client_s* get_client_by_index(unsigned int index);
        int destroy_client(ma_client_s* client);
 

diff --git a/inc/service_ipc_dbus.h b/inc/service_ipc_dbus.h
index b462aec..abe1990 100644 (file)
--- a/inc/service_ipc_dbus.h
+++ b/inc/service_ipc_dbus.h
@@ -35,22 +35,22 @@ public:
 
        int open_connection();
        int close_connection();
-       int send_hello(int pid);
+       int send_hello(pid_t pid);
        int send_error_message(int reason, const char* err_msg);
-       int send_streaming_audio_data(int pid, int event, void* data, unsigned int data_size);
-       int change_active_state(int pid, int state);
-       int send_preprocessing_information(int pid, const char* app_id);
-       int send_streaming_section_changed(int pid, int section);
-       int send_preprocessing_result(int pid, bool result);
-       int send_wakeup_engine_command(int pid, const char* command);
-       int change_service_state(int pid, int state);
-       int change_voice_key_status(int pid, int status);
+       int send_streaming_audio_data(pid_t pid, int event, void* data, unsigned int data_size);
+       int change_active_state(pid_t pid, int state);
+       int send_preprocessing_information(pid_t pid, const char* app_id);
+       int send_streaming_section_changed(pid_t pid, int section);
+       int send_preprocessing_result(pid_t pid, bool result);
+       int send_wakeup_engine_command(pid_t pid, const char* command);
+       int change_service_state(pid_t pid, int state);
+       int change_voice_key_status(pid_t pid, int status);
        int masc_ui_dbus_send_hello(void);
-       int masc_ui_dbus_send_asr_result(int pid, int event, const char* asr_result);
-       int masc_ui_dbus_send_result(int pid, const char* display_text, const char* utterance_text, const char* result_json);
+       int masc_ui_dbus_send_asr_result(pid_t pid, int event, const char* asr_result);
+       int masc_ui_dbus_send_result(pid_t pid, const char* display_text, const char* utterance_text, const char* result_json);
        int masc_ui_dbus_change_assistant(const char* app_id);
        int masc_ui_dbus_send_error_message(int reason, const char* err_msg);
-       int masc_ui_dbus_send_recognition_result(int pid, int result);
+       int masc_ui_dbus_send_recognition_result(pid_t pid, int result);
        int masc_ui_dbus_enable_common_ui(int enable);
 
        DBusConnection* get_connection_listener() { return mConnectionListener; }

diff --git a/inc/service_ipc_dbus_dispatcher.h b/inc/service_ipc_dbus_dispatcher.h
index ae36c70..9a88a99 100644 (file)
--- a/inc/service_ipc_dbus_dispatcher.h
+++ b/inc/service_ipc_dbus_dispatcher.h
@@ -29,28 +29,28 @@ class CServiceMain;
 
 class IServiceIpcObserver {
 public:
-       virtual int on_initialize(int pid) = 0;
-       virtual int on_deinitialize(int pid) = 0;
-       virtual int on_get_audio_format(int pid, int& rate, int& channel, int& audio_type) = 0;
-       virtual int on_get_audio_source_type(int pid, std::string& type) = 0;
-       virtual int on_send_asr_result(int pid, int event, std::string asr_result) = 0;
-       virtual int on_send_result(int pid,
+       virtual int on_initialize(pid_t pid) = 0;
+       virtual int on_deinitialize(pid_t pid) = 0;
+       virtual int on_get_audio_format(pid_t pid, int& rate, int& channel, int& audio_type) = 0;
+       virtual int on_get_audio_source_type(pid_t pid, std::string& type) = 0;
+       virtual int on_send_asr_result(pid_t pid, int event, std::string asr_result) = 0;
+       virtual int on_send_result(pid_t pid,
                std::string display_text, std::string utterance_text, std::string result_json) = 0;
-       virtual int on_send_recognition_result(int pid, int result) = 0;
-       virtual int on_start_streaming_audio_data(int pid, int type) = 0;
-       virtual int on_stop_streaming_audio_data(int pid, int type) = 0;
-       virtual int on_update_voice_feedback_state(int pid, int state) = 0;
-       virtual int on_send_assistant_specific_command(int pid, std::string command) = 0;
-       virtual int on_set_background_volume(int pid, double ratio) = 0;
-       virtual int on_set_preprocessing_allow_mode(int pid, int mode, std::string app_id) = 0;
-       virtual int on_send_preprocessing_result(int pid, int result) = 0;
-       virtual int on_set_wake_word_audio_require_flag(int pid, int require) = 0;
-       virtual int on_set_assistant_language(int pid, std::string language) = 0;
-       virtual int on_add_wake_word(int pid, std::string wake_word, std::string language) = 0;
-       virtual int on_remove_wake_word(int pid, std::string wake_word, std::string language) = 0;
+       virtual int on_send_recognition_result(pid_t pid, int result) = 0;
+       virtual int on_start_streaming_audio_data(pid_t pid, int type) = 0;
+       virtual int on_stop_streaming_audio_data(pid_t pid, int type) = 0;
+       virtual int on_update_voice_feedback_state(pid_t pid, int state) = 0;
+       virtual int on_send_assistant_specific_command(pid_t pid, std::string command) = 0;
+       virtual int on_set_background_volume(pid_t pid, double ratio) = 0;
+       virtual int on_set_preprocessing_allow_mode(pid_t pid, int mode, std::string app_id) = 0;
+       virtual int on_send_preprocessing_result(pid_t pid, int result) = 0;
+       virtual int on_set_wake_word_audio_require_flag(pid_t pid, int require) = 0;
+       virtual int on_set_assistant_language(pid_t pid, std::string language) = 0;
+       virtual int on_add_wake_word(pid_t pid, std::string wake_word, std::string language) = 0;
+       virtual int on_remove_wake_word(pid_t pid, std::string wake_word, std::string language) = 0;
 
-       virtual int on_ui_initialize(int pid) = 0;
-       virtual int on_ui_deinitialize(int pid) = 0;
+       virtual int on_ui_initialize(pid_t pid) = 0;
+       virtual int on_ui_deinitialize(pid_t pid) = 0;
        virtual int on_ui_change_assistant(std::string app_id) = 0;
 };
 

diff --git a/inc/service_main.h b/inc/service_main.h
index 6aed620..c33b6c1 100644 (file)
--- a/inc/service_main.h
+++ b/inc/service_main.h
@@ -76,35 +76,35 @@ public:
                {}
        virtual ~CServiceMain() {}
 
-       int mas_client_get_audio_format(int pid, int* rate, int* channel, int* audio_type);
-       int mas_client_get_audio_source_type(int pid, char** type);
-       int mas_client_send_preprocessing_information(int pid);
-       int mas_client_send_voice_key_status_change(int pid, ma_voice_key_status_e status);
-       int mas_client_request_speech_data(int pid);
-       int mas_client_send_asr_result(int pid, int event, const char* asr_result);
-       int mas_client_send_result(int pid, const char* display_text,
+       int mas_client_get_audio_format(pid_t pid, int* rate, int* channel, int* audio_type);
+       int mas_client_get_audio_source_type(pid_t pid, char** type);
+       int mas_client_send_preprocessing_information(pid_t pid);
+       int mas_client_send_voice_key_status_change(pid_t pid, ma_voice_key_status_e status);
+       int mas_client_request_speech_data(pid_t pid);
+       int mas_client_send_asr_result(pid_t pid, int event, const char* asr_result);
+       int mas_client_send_result(pid_t pid, const char* display_text,
                const char* utterance_text, const char* result_json);
-       int mas_client_send_recognition_result(int pid, int result);
-       int mas_client_start_streaming_audio_data(int pid, int type);
-       int mas_client_stop_streaming_audio_data(int pid, int type);
-       int mas_client_update_voice_feedback_state(int pid, int state);
-       int mas_client_set_assistant_specific_command(int pid, const char *command);
-       int mas_client_set_background_volume(int pid, double ratio);
-       int mas_client_set_preprocessing_allow_mode(int pid, ma_preprocessing_allow_mode_e mode, const char* appid);
-       int mas_client_send_preprocessing_result(int pid, bool result);
-       int mas_client_set_wake_word_audio_require_flag(int pid, bool require);
-       int mas_client_set_assistant_language(int pid, const char* language);
-       int mas_client_add_wake_word(int pid, const char* wake_word, const char* language);
-       int mas_client_remove_wake_word(int pid, const char* wake_word, const char* language);
-       int mas_ui_client_initialize(int pid);
-       int mas_ui_client_deinitialize(int pid);
+       int mas_client_send_recognition_result(pid_t pid, int result);
+       int mas_client_start_streaming_audio_data(pid_t pid, int type);
+       int mas_client_stop_streaming_audio_data(pid_t pid, int type);
+       int mas_client_update_voice_feedback_state(pid_t pid, int state);
+       int mas_client_set_assistant_specific_command(pid_t pid, const char *command);
+       int mas_client_set_background_volume(pid_t pid, double ratio);
+       int mas_client_set_preprocessing_allow_mode(pid_t pid, ma_preprocessing_allow_mode_e mode, const char* appid);
+       int mas_client_send_preprocessing_result(pid_t pid, bool result);
+       int mas_client_set_wake_word_audio_require_flag(pid_t pid, bool require);
+       int mas_client_set_assistant_language(pid_t pid, const char* language);
+       int mas_client_add_wake_word(pid_t pid, const char* wake_word, const char* language);
+       int mas_client_remove_wake_word(pid_t pid, const char* wake_word, const char* language);
+       int mas_ui_client_initialize(pid_t pid);
+       int mas_ui_client_deinitialize(pid_t pid);
        int mas_ui_client_change_assistant(const char* appid);
-       int mas_get_current_client_pid();
-       int mas_get_current_preprocessing_client_pid();
+       pid_t mas_get_current_client_pid();
+       pid_t mas_get_current_preprocessing_client_pid();
        pid_t mas_get_current_audio_processing_pid();
        int mas_get_client_pid_by_wakeup_word(const char *wakeup_word);
        int mas_get_client_pid_by_appid(const char *appid);
-       std::string mas_get_client_appid_by_pid(int pid);
+       std::string mas_get_client_appid_by_pid(pid_t pid);
        bool mas_get_client_custom_ui_option_by_appid(const char *appid);
        const char* mas_get_client_appid_by_wakeup_word(const char *wakeup_word);
        int mas_set_current_client_by_wakeup_word(const char *wakeup_word);
@@ -118,28 +118,28 @@ public:
        int mas_process_preprocessing_state_event(PREPROCESSING_STATE_EVENT event);
        int mas_update_voice_key_support_mode();
 
-       virtual int on_initialize(int pid) override;
-       virtual int on_deinitialize(int pid) override;
-       virtual int on_get_audio_format(int pid, int& rate, int& channel, int& audio_type) override;
-       virtual int on_get_audio_source_type(int pid, std::string& type) override;
-       virtual int on_send_asr_result(int pid, int event, std::string asr_result) override;
-       virtual int on_send_result(int pid, std::string display_text,
+       virtual int on_initialize(pid_t pid) override;
+       virtual int on_deinitialize(pid_t pid) override;
+       virtual int on_get_audio_format(pid_t pid, int& rate, int& channel, int& audio_type) override;
+       virtual int on_get_audio_source_type(pid_t pid, std::string& type) override;
+       virtual int on_send_asr_result(pid_t pid, int event, std::string asr_result) override;
+       virtual int on_send_result(pid_t pid, std::string display_text,
                std::string utterance_text, std::string result_json) override;
-       virtual int on_send_recognition_result(int pid, int result) override;
-       virtual int on_start_streaming_audio_data(int pid, int type) override;
-       virtual int on_stop_streaming_audio_data(int pid, int type) override;
-       virtual int on_update_voice_feedback_state(int pid, int state) override;
-       virtual int on_send_assistant_specific_command(int pid, std::string command) override;
-       virtual int on_set_background_volume(int pid, double ratio) override;
-       virtual int on_set_preprocessing_allow_mode(int pid, int mode, std::string app_id) override;
-       virtual int on_send_preprocessing_result(int pid, int result) override;
-       virtual int on_set_wake_word_audio_require_flag(int pid, int require) override;
-       virtual int on_set_assistant_language(int pid, std::string language) override;
-       virtual int on_add_wake_word(int pid, std::string wake_word, std::string language) override;
-       virtual int on_remove_wake_word(int pid, std::string wake_word, std::string language) override;
-
-       virtual int on_ui_initialize(int pid) override;
-       virtual int on_ui_deinitialize(int pid) override;
+       virtual int on_send_recognition_result(pid_t pid, int result) override;
+       virtual int on_start_streaming_audio_data(pid_t pid, int type) override;
+       virtual int on_stop_streaming_audio_data(pid_t pid, int type) override;
+       virtual int on_update_voice_feedback_state(pid_t pid, int state) override;
+       virtual int on_send_assistant_specific_command(pid_t pid, std::string command) override;
+       virtual int on_set_background_volume(pid_t pid, double ratio) override;
+       virtual int on_set_preprocessing_allow_mode(pid_t pid, int mode, std::string app_id) override;
+       virtual int on_send_preprocessing_result(pid_t pid, int result) override;
+       virtual int on_set_wake_word_audio_require_flag(pid_t pid, int require) override;
+       virtual int on_set_assistant_language(pid_t pid, std::string language) override;
+       virtual int on_add_wake_word(pid_t pid, std::string wake_word, std::string language) override;
+       virtual int on_remove_wake_word(pid_t pid, std::string wake_word, std::string language) override;
+
+       virtual int on_ui_initialize(pid_t pid) override;
+       virtual int on_ui_deinitialize(pid_t pid) override;
        virtual int on_ui_change_assistant(std::string app_id) override;
 
        bool app_create(void *data);

diff --git a/src/application_manager_aul.cpp b/src/application_manager_aul.cpp
index 6b2ca7a..00b6ecb 100644 (file)
--- a/src/application_manager_aul.cpp
+++ b/src/application_manager_aul.cpp
@@ -115,7 +115,7 @@ boost::optional<pid_t> CApplicationManagerAul::get_pid_by_appid(const std::strin
 {
        boost::optional<pid_t> ret;
 
-       int pid = aul_app_get_pid(appid.c_str());
+       pid_t pid = aul_app_get_pid(appid.c_str());
        if (pid >= 0) {
                ret = pid;
        }

diff --git a/src/client_manager.cpp b/src/client_manager.cpp
index f9cf2f9..01cd9d5 100644 (file)
--- a/src/client_manager.cpp
+++ b/src/client_manager.cpp
@@ -23,7 +23,7 @@ int CClientManager::set_application_manager(IApplicationManager* manager)
        return 0;
 }
 
-int CClientManager::create_client(int pid, std::string appid)
+int CClientManager::create_client(pid_t pid, std::string appid)
 {
        ma_client_s* data = NULL;
 
@@ -60,7 +60,7 @@ int CClientManager::destroy_client(ma_client_s* client)
        return 0;
 }
 
-int CClientManager::destroy_client_by_pid(int pid)
+int CClientManager::destroy_client_by_pid(pid_t pid)
 {
        ma_client_s* client = find_client_by_pid(pid);
        return destroy_client(client);
@@ -94,7 +94,7 @@ ma_client_s* CClientManager::find_client_by_appid(std::string appid)
        return NULL;
 }
 
-ma_client_s* CClientManager::find_client_by_pid(int pid)
+ma_client_s* CClientManager::find_client_by_pid(pid_t pid)
 {
        ma_client_s *data = NULL;
 
@@ -126,9 +126,9 @@ ma_client_s* CClientManager::get_client_by_index(unsigned int index)
        return static_cast<ma_client_s*>(g_slist_nth_data(mClientList, index));
 }
 
-int CClientManager::find_client_pid_by_index(unsigned int index)
+pid_t CClientManager::find_client_pid_by_index(unsigned int index)
 {
-       int pid = -1;
+       pid_t pid = -1;
        ma_client_s* client = get_client_by_index(index);
        if (client) {
                pid = client->pid;
@@ -136,9 +136,9 @@ int CClientManager::find_client_pid_by_index(unsigned int index)
        return pid;
 }
 
-int CClientManager::find_client_pid_by_appid(std::string appid)
+pid_t CClientManager::find_client_pid_by_appid(std::string appid)
 {
-       int pid = -1;
+       pid_t pid = -1;
 
        if (nullptr == mApplicationManager) {
                MAS_LOGE("ApplicationManager is NULL, can't check if app is running or not");
@@ -158,7 +158,7 @@ int CClientManager::find_client_pid_by_appid(std::string appid)
        return pid;
 }
 
-std::string CClientManager::find_client_appid_by_pid(int pid)
+std::string CClientManager::find_client_appid_by_pid(pid_t pid)
 {
        std::string appid;
 
@@ -182,7 +182,7 @@ std::string CClientManager::find_client_appid_by_pid(int pid)
 
 bool CClientManager::check_client_validity_by_appid(std::string appid)
 {
-       int pid = find_client_pid_by_appid(appid);
+       pid_t pid = find_client_pid_by_appid(appid);
        if (0 < pid) return true;
        return false;
 }

diff --git a/src/service_ipc_dbus.cpp b/src/service_ipc_dbus.cpp
index 1d176c6..bb1c3fa 100644 (file)
--- a/src/service_ipc_dbus.cpp
+++ b/src/service_ipc_dbus.cpp
@@ -74,7 +74,7 @@ int CServiceIpcDbus::mas_check_dbus_connection()
        return 0;
 }
 
-int CServiceIpcDbus::send_hello(int pid)
+int CServiceIpcDbus::send_hello(pid_t pid)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -206,7 +206,7 @@ static void masc_message_port_error(int error)
                "MESSAGE_PORT_ERROR_UNKNOWN");
 }
 
-int CServiceIpcDbus::send_streaming_audio_data(int pid, int event, void* data, unsigned int data_size)
+int CServiceIpcDbus::send_streaming_audio_data(pid_t pid, int event, void* data, unsigned int data_size)
 {
        if (nullptr == mClientManager) {
                MAS_LOGE("mClientManager variable is NULL");
@@ -289,7 +289,7 @@ int CServiceIpcDbus::send_streaming_audio_data(int pid, int event, void* data, u
        return 0;
 }
 
-int CServiceIpcDbus::change_active_state(int pid, int state)
+int CServiceIpcDbus::change_active_state(pid_t pid, int state)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -339,7 +339,7 @@ int CServiceIpcDbus::change_active_state(int pid, int state)
        return 0;
 }
 
-int CServiceIpcDbus::send_preprocessing_information(int pid, const char* app_id)
+int CServiceIpcDbus::send_preprocessing_information(pid_t pid, const char* app_id)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -403,7 +403,7 @@ int CServiceIpcDbus::send_preprocessing_information(int pid, const char* app_id)
        return 0;
 }
 
-int CServiceIpcDbus::send_streaming_section_changed(int pid, int section)
+int CServiceIpcDbus::send_streaming_section_changed(pid_t pid, int section)
 {
        if (nullptr == mClientManager) {
                MAS_LOGE("mClientManager variable is NULL");
@@ -438,7 +438,7 @@ int CServiceIpcDbus::send_streaming_section_changed(int pid, int section)
        return 0;
 }
 
-int CServiceIpcDbus::send_preprocessing_result(int pid, bool result)
+int CServiceIpcDbus::send_preprocessing_result(pid_t pid, bool result)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -491,7 +491,7 @@ int CServiceIpcDbus::send_preprocessing_result(int pid, bool result)
        return 0;
 }
 
-int CServiceIpcDbus::send_wakeup_engine_command(int pid, const char* command)
+int CServiceIpcDbus::send_wakeup_engine_command(pid_t pid, const char* command)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -555,7 +555,7 @@ int CServiceIpcDbus::send_wakeup_engine_command(int pid, const char* command)
        return 0;
 }
 
-int CServiceIpcDbus::change_service_state(int pid, int state)
+int CServiceIpcDbus::change_service_state(pid_t pid, int state)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -605,7 +605,7 @@ int CServiceIpcDbus::change_service_state(int pid, int state)
        return 0;
 }
 
-int CServiceIpcDbus::change_voice_key_status(int pid, int status)
+int CServiceIpcDbus::change_voice_key_status(pid_t pid, int status)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -699,7 +699,7 @@ int CServiceIpcDbus::masc_ui_dbus_send_hello(void)
        return result;
 }
 
-int CServiceIpcDbus::masc_ui_dbus_send_asr_result(int pid, int event, const char* asr_result)
+int CServiceIpcDbus::masc_ui_dbus_send_asr_result(pid_t pid, int event, const char* asr_result)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;
@@ -753,7 +753,7 @@ int CServiceIpcDbus::masc_ui_dbus_send_asr_result(int pid, int event, const char
        return 0;
 }
 
-int CServiceIpcDbus::masc_ui_dbus_send_result(int pid, const char* display_text, const char* utterance_text, const char* result_json)
+int CServiceIpcDbus::masc_ui_dbus_send_result(pid_t pid, const char* display_text, const char* utterance_text, const char* result_json)
 {
        if (0 != __dbus_check()) {
                return -1; //MA_ERROR_OPERATION_FAILED;
@@ -933,7 +933,7 @@ int CServiceIpcDbus::masc_ui_dbus_send_error_message(int reason, const char* err
        return 0;
 }
 
-int CServiceIpcDbus::masc_ui_dbus_send_recognition_result(int pid, int result)
+int CServiceIpcDbus::masc_ui_dbus_send_recognition_result(pid_t pid, int result)
 {
        if (0 != __dbus_check()) {
                return -1; //MAS_ERROR_OPERATION_FAILED;

diff --git a/src/service_ipc_dbus_dispatcher.cpp b/src/service_ipc_dbus_dispatcher.cpp
index 26e7ac1..2e9a044 100644 (file)
--- a/src/service_ipc_dbus_dispatcher.cpp
+++ b/src/service_ipc_dbus_dispatcher.cpp
@@ -54,7 +54,7 @@ int CServiceIpcDbusDispatcher::on_initialize(DBusConnection* conn, DBusMessage*
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        int ret = 0;
 
        dbus_message_get_args(msg, &err,
@@ -110,7 +110,7 @@ int CServiceIpcDbusDispatcher::on_deinitialize(DBusConnection* conn, DBusMessage
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        int ret = 0;
 
        dbus_message_get_args(msg, &err,
@@ -166,7 +166,7 @@ int CServiceIpcDbusDispatcher::on_get_audio_format(DBusConnection* conn, DBusMes
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        int rate, channel, audio_type;
        int ret;
 
@@ -225,7 +225,7 @@ int CServiceIpcDbusDispatcher::on_get_audio_source_type(DBusConnection* conn, DB
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        std::string type;
        int ret;
 
@@ -292,7 +292,7 @@ int CServiceIpcDbusDispatcher::on_send_asr_result(DBusConnection* conn, DBusMess
        DBusError err;
        dbus_error_init(&err);
 
-       int pid, event;
+       pid_t pid, event;
        char *asr_result;
        int ret = 0;
 
@@ -354,7 +354,7 @@ int CServiceIpcDbusDispatcher::on_send_result(DBusConnection* conn, DBusMessage*
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        char* display_text;
        char* utterance_text;
        char* result_json;
@@ -421,7 +421,7 @@ int CServiceIpcDbusDispatcher::on_send_recognition_result(DBusConnection* conn,
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int result;
        int ret = 0;
 
@@ -457,7 +457,7 @@ int CServiceIpcDbusDispatcher::on_start_streaming_audio_data(DBusConnection* con
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int type;
        int ret = 0;
 
@@ -493,7 +493,7 @@ int CServiceIpcDbusDispatcher::on_stop_streaming_audio_data(DBusConnection* conn
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int type;
        int ret = 0;
 
@@ -529,7 +529,7 @@ int CServiceIpcDbusDispatcher::on_update_voice_feedback_state(DBusConnection* co
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int state;
        int ret = 0;
 
@@ -565,7 +565,7 @@ int CServiceIpcDbusDispatcher::on_send_assistant_specific_command(DBusConnection
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        char* command;
 
@@ -602,7 +602,7 @@ int CServiceIpcDbusDispatcher::on_set_background_volume(DBusConnection* conn, DB
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        double ratio;
 
@@ -638,7 +638,7 @@ int CServiceIpcDbusDispatcher::on_set_preprocessing_allow_mode(DBusConnection* c
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        int mode;
        char* app_id;
@@ -678,7 +678,7 @@ int CServiceIpcDbusDispatcher::on_send_preprocessing_result(DBusConnection* conn
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        int result;
 
@@ -714,7 +714,7 @@ int CServiceIpcDbusDispatcher::on_set_wake_word_audio_require_flag(DBusConnectio
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        int require;
 
@@ -750,7 +750,7 @@ int CServiceIpcDbusDispatcher::on_set_assistant_language(DBusConnection* conn, D
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        char* language;
 
@@ -787,7 +787,7 @@ int CServiceIpcDbusDispatcher::on_add_wake_word(DBusConnection* conn, DBusMessag
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        char* wake_word;
        char* language;
@@ -826,7 +826,7 @@ int CServiceIpcDbusDispatcher::on_remove_wake_word(DBusConnection* conn, DBusMes
        DBusError err;
        dbus_error_init(&err);
 
-       int pid;
+       pid_t pid;
        int ret = 0;
        char* wake_word;
        char* language;
@@ -866,7 +866,7 @@ int CServiceIpcDbusDispatcher::on_ui_initialize(DBusConnection* conn, DBusMessag
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        int ret = 0;
 
        dbus_message_get_args(msg, &err,
@@ -922,7 +922,7 @@ int CServiceIpcDbusDispatcher::on_ui_deinitialize(DBusConnection* conn, DBusMess
        DBusError err;
        dbus_error_init(&err);
 
-       int pid = -1;
+       pid_t pid = -1;
        int ret = 0;
 
        dbus_message_get_args(msg, &err,

diff --git a/src/service_main.cpp b/src/service_main.cpp
index ac58436..424b653 100644 (file)
--- a/src/service_main.cpp
+++ b/src/service_main.cpp
@@ -74,7 +74,7 @@ bool CServiceMain::is_current_preprocessing_assistant(const char* appid)
        return ret;
 }
 
-int CServiceMain::mas_client_get_audio_format(int pid, int* rate, int* channel, int* audio_type)
+int CServiceMain::mas_client_get_audio_format(pid_t pid, int* rate, int* channel, int* audio_type)
 {
        MAS_LOGD("[Enter] pid(%d)", pid);
 
@@ -87,7 +87,7 @@ int CServiceMain::mas_client_get_audio_format(int pid, int* rate, int* channel,
 }
 
 #define MAX_LOCAL_VARIABLE_STRING_LEN 256
-int CServiceMain::mas_client_get_audio_source_type(int pid, char** type)
+int CServiceMain::mas_client_get_audio_source_type(pid_t pid, char** type)
 {
        MAS_LOGD("[Enter] pid(%d)", pid);
 
@@ -106,7 +106,7 @@ int CServiceMain::mas_client_get_audio_source_type(int pid, char** type)
        return ret;
 }
 
-int CServiceMain::mas_client_send_preprocessing_information(int pid)
+int CServiceMain::mas_client_send_preprocessing_information(pid_t pid)
 {
        int ret = -1;
        MAS_LOGD("[Enter] pid(%d)", pid);
@@ -121,7 +121,7 @@ int CServiceMain::mas_client_send_preprocessing_information(int pid)
        return ret;
 }
 
-int CServiceMain::mas_client_send_voice_key_status_change(int pid, ma_voice_key_status_e status)
+int CServiceMain::mas_client_send_voice_key_status_change(pid_t pid, ma_voice_key_status_e status)
 {
        int ret = -1;
        MAS_LOGD("[Enter] pid(%d)", pid);
@@ -135,7 +135,7 @@ int CServiceMain::mas_client_send_voice_key_status_change(int pid, ma_voice_key_
        return ret;
 }
 
-int CServiceMain::mas_client_send_asr_result(int pid, int event, const char* asr_result)
+int CServiceMain::mas_client_send_asr_result(pid_t pid, int event, const char* asr_result)
 {
        MAS_LOGD("[Enter] pid(%d), event(%d), asr_result(%s)", pid, event, asr_result);
        int ret = mServiceIpc.masc_ui_dbus_send_asr_result(pid, event, asr_result);
@@ -148,7 +148,7 @@ int CServiceMain::mas_client_send_asr_result(int pid, int event, const char* asr
        return ret;
 }
 
-int CServiceMain::mas_client_send_result(int pid, const char* display_text,
+int CServiceMain::mas_client_send_result(pid_t pid, const char* display_text,
        const char* utterance_text, const char* result_json)
 {
        MAS_LOGD("[Enter] pid(%d), display_text(%s), utterance_text(%s), result_json(%s)", pid, display_text, utterance_text, result_json);
@@ -167,7 +167,7 @@ int CServiceMain::mas_client_send_result(int pid, const char* display_text,
        return ret;
 }
 
-int CServiceMain::mas_client_send_recognition_result(int pid, int result)
+int CServiceMain::mas_client_send_recognition_result(pid_t pid, int result)
 {
        MAS_LOGD("[Enter] pid(%d), result(%d)", pid, result);
        int ret = mServiceIpc.masc_ui_dbus_send_recognition_result(pid, result);
@@ -185,7 +185,7 @@ int CServiceMain::mas_client_send_recognition_result(int pid, int result)
        return ret;
 }
 
-int CServiceMain::mas_client_start_streaming_audio_data(int pid, int type)
+int CServiceMain::mas_client_start_streaming_audio_data(pid_t pid, int type)
 {
        int ret = -1;
        switch(type) {
@@ -205,7 +205,7 @@ int CServiceMain::mas_client_start_streaming_audio_data(int pid, int type)
        return ret;
 }
 
-int CServiceMain::mas_client_stop_streaming_audio_data(int pid, int type)
+int CServiceMain::mas_client_stop_streaming_audio_data(pid_t pid, int type)
 {
        int ret = -1;
        switch(type) {
@@ -222,7 +222,7 @@ int CServiceMain::mas_client_stop_streaming_audio_data(int pid, int type)
        return ret;
 }
 
-int CServiceMain::mas_client_update_voice_feedback_state(int pid, int state)
+int CServiceMain::mas_client_update_voice_feedback_state(pid_t pid, int state)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -233,7 +233,7 @@ int CServiceMain::mas_client_update_voice_feedback_state(int pid, int state)
        return 0;
 }
 
-int CServiceMain::mas_client_set_assistant_specific_command(int pid, const char *command)
+int CServiceMain::mas_client_set_assistant_specific_command(pid_t pid, const char *command)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -244,7 +244,7 @@ int CServiceMain::mas_client_set_assistant_specific_command(int pid, const char
        return 0;
 }
 
-int CServiceMain::mas_client_set_background_volume(int pid, double ratio)
+int CServiceMain::mas_client_set_background_volume(pid_t pid, double ratio)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -255,7 +255,7 @@ int CServiceMain::mas_client_set_background_volume(int pid, double ratio)
        return 0;
 }
 
-int CServiceMain::mas_client_set_preprocessing_allow_mode(int pid, ma_preprocessing_allow_mode_e mode, const char* appid)
+int CServiceMain::mas_client_set_preprocessing_allow_mode(pid_t pid, ma_preprocessing_allow_mode_e mode, const char* appid)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -282,7 +282,7 @@ int CServiceMain::mas_client_set_preprocessing_allow_mode(int pid, ma_preprocess
        return 0;
 }
 
-int CServiceMain::mas_client_send_preprocessing_result(int pid, bool result)
+int CServiceMain::mas_client_send_preprocessing_result(pid_t pid, bool result)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -305,7 +305,7 @@ int CServiceMain::mas_client_send_preprocessing_result(int pid, bool result)
        }
 
        if (current_maclient_appid) {
-               int pid_by_appid = mClientManager.find_client_pid_by_appid(
+               pid_t pid_by_appid = mClientManager.find_client_pid_by_appid(
                        std::string{current_maclient_appid});
                mServiceIpc.send_preprocessing_result(pid_by_appid, result);
        }
@@ -313,7 +313,7 @@ int CServiceMain::mas_client_send_preprocessing_result(int pid, bool result)
        return 0;
 }
 
-int CServiceMain::mas_client_set_wake_word_audio_require_flag(int pid, bool require)
+int CServiceMain::mas_client_set_wake_word_audio_require_flag(pid_t pid, bool require)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -325,7 +325,7 @@ int CServiceMain::mas_client_set_wake_word_audio_require_flag(int pid, bool requ
        return 0;
 }
 
-int CServiceMain::mas_client_set_assistant_language(int pid, const char* language)
+int CServiceMain::mas_client_set_assistant_language(pid_t pid, const char* language)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -337,7 +337,7 @@ int CServiceMain::mas_client_set_assistant_language(int pid, const char* languag
        return 0;
 }
 
-int CServiceMain::mas_client_add_wake_word(int pid, const char* wake_word, const char* language)
+int CServiceMain::mas_client_add_wake_word(pid_t pid, const char* wake_word, const char* language)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -366,7 +366,7 @@ int CServiceMain::mas_client_add_wake_word(int pid, const char* wake_word, const
        return 0;
 }
 
-int CServiceMain::mas_client_remove_wake_word(int pid, const char* wake_word, const char* language)
+int CServiceMain::mas_client_remove_wake_word(pid_t pid, const char* wake_word, const char* language)
 {
        std::string pid_appid;
        boost::optional<std::string> appid_by_pid = mApplicationManager.get_appid_by_pid(pid);
@@ -392,14 +392,14 @@ int CServiceMain::mas_client_remove_wake_word(int pid, const char* wake_word, co
        return 0;
 }
 
-int CServiceMain::mas_ui_client_initialize(int pid)
+int CServiceMain::mas_ui_client_initialize(pid_t pid)
 {
        MAS_LOGD("[Enter] pid(%d)", pid);
 
        return 0;
 }
 
-int CServiceMain::mas_ui_client_deinitialize(int pid)
+int CServiceMain::mas_ui_client_deinitialize(pid_t pid)
 {
        MAS_LOGD("[Enter] pid(%d)", pid);
 
@@ -419,7 +419,7 @@ int CServiceMain::mas_ui_client_change_assistant(const char* appid)
        mServiceIpc.masc_ui_dbus_enable_common_ui(!use_custom_ui);
 
        mas_set_current_client_by_appid(appid);
-       int pid = mas_get_client_pid_by_appid(appid);
+       pid_t pid = mas_get_client_pid_by_appid(appid);
        if (pid != -1) {
                mas_bring_client_to_foreground(appid);
                mas_client_send_preprocessing_information(pid);
@@ -688,9 +688,9 @@ int CServiceMain::mas_get_current_client_pid()
        return ret;
 }
 
-int CServiceMain::mas_get_current_preprocessing_client_pid()
+pid_t CServiceMain::mas_get_current_preprocessing_client_pid()
 {
-       int ret = -1;
+       pid_t ret = -1;
        if (mCurrentPreprocessingClientInfo >= 0 && mCurrentPreprocessingClientInfo < MAX_MACLIENT_INFO_NUM) {
                const char *appid = mClientInfo[mCurrentPreprocessingClientInfo].appid;
                if (appid) {
@@ -717,9 +717,9 @@ pid_t CServiceMain::mas_get_current_audio_processing_pid()
        return ret;
 }
 
-int CServiceMain::mas_get_client_pid_by_appid(const char *appid)
+pid_t CServiceMain::mas_get_client_pid_by_appid(const char *appid)
 {
-       int ret = -1;
+       pid_t ret = -1;
 
        if (appid) {
                ret = mClientManager.find_client_pid_by_appid(std::string{appid});
@@ -846,7 +846,7 @@ int CServiceMain::mas_set_current_client_by_wakeup_word(const char *wakeup_word)
 
        if (mCurrentClientInfo != prev_selection) {
                if (prev_selection >= 0 && prev_selection < MAX_MACLIENT_INFO_NUM) {
-                       int pid = mas_get_client_pid_by_appid(mClientInfo[prev_selection].appid);
+                       pid_t pid = mas_get_client_pid_by_appid(mClientInfo[prev_selection].appid);
                        mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE);
                }
        }
@@ -872,7 +872,7 @@ int CServiceMain::mas_set_current_client_by_appid(const char *appid)
 
        if (mCurrentClientInfo != prev_selection) {
                if (prev_selection >= 0 && prev_selection < MAX_MACLIENT_INFO_NUM) {
-                       int pid = mas_get_client_pid_by_appid(mClientInfo[prev_selection].appid);
+                       pid_t pid = mas_get_client_pid_by_appid(mClientInfo[prev_selection].appid);
                        mServiceIpc.change_active_state(pid, MA_ACTIVE_STATE_INACTIVE);
                }
        }
@@ -1117,7 +1117,7 @@ int CServiceMain::mas_set_current_service_state(ma_service_state_e state)
        int i;
 
        for (i = 0; i < count; i++) {
-               int pid = mClientManager.find_client_pid_by_index(i);
+               pid_t pid = mClientManager.find_client_pid_by_index(i);
 
                if (-1 != pid) {
                        int ret = mServiceIpc.change_service_state(pid, state);
@@ -1384,7 +1384,7 @@ void CServiceMain::app_terminate(void *data)
        return;
 }
 
-int CServiceMain::on_initialize(int pid) {
+int CServiceMain::on_initialize(pid_t pid) {
        MAS_LOGD("[Enter] pid(%d)", pid);
 
        std::string pid_appid;
@@ -1433,13 +1433,13 @@ int CServiceMain::on_initialize(int pid) {
        return 0;
 }
 
-int CServiceMain::on_deinitialize(int pid) {
+int CServiceMain::on_deinitialize(pid_t pid) {
        MAS_LOGD("[Enter] pid(%d)", pid);
        mClientManager.destroy_client_by_pid(pid);
        return 0;
 }
 
-int CServiceMain::on_get_audio_format(int pid, int& rate, int& channel, int& audio_type) {
+int CServiceMain::on_get_audio_format(pid_t pid, int& rate, int& channel, int& audio_type) {
        int main_rate, main_channel, main_audio_type;
        int ret = mas_client_get_audio_format(pid,
                &main_rate, &main_channel, &main_audio_type);
@@ -1449,7 +1449,7 @@ int CServiceMain::on_get_audio_format(int pid, int& rate, int& channel, int& aud
        return ret;
 }
 
-int CServiceMain::on_get_audio_source_type(int pid, std::string& type) {
+int CServiceMain::on_get_audio_source_type(pid_t pid, std::string& type) {
        char *main_type = nullptr;
        int ret = mas_client_get_audio_source_type(pid, &main_type);
        if (0 == ret && main_type) {
@@ -1458,71 +1458,71 @@ int CServiceMain::on_get_audio_source_type(int pid, std::string& type) {
        return ret;
 }
 
-int CServiceMain::on_send_asr_result(int pid, int event, std::string asr_result) {
+int CServiceMain::on_send_asr_result(pid_t pid, int event, std::string asr_result) {
        return mas_client_send_asr_result(pid, event, asr_result.c_str());
 }
 
-int CServiceMain::on_send_result(int pid, std::string display_text,
+int CServiceMain::on_send_result(pid_t pid, std::string display_text,
        std::string utterance_text, std::string result_json) {
        return mas_client_send_result(pid,
                display_text.c_str(), utterance_text.c_str(), result_json.c_str());
 }
 
-int CServiceMain::on_send_recognition_result(int pid, int result) {
+int CServiceMain::on_send_recognition_result(pid_t pid, int result) {
        return mas_client_send_recognition_result(pid, result);
 }
 
-int CServiceMain::on_start_streaming_audio_data(int pid, int type) {
+int CServiceMain::on_start_streaming_audio_data(pid_t pid, int type) {
        return mas_client_start_streaming_audio_data(pid, type);
 }
 
-int CServiceMain::on_stop_streaming_audio_data(int pid, int type) {
+int CServiceMain::on_stop_streaming_audio_data(pid_t pid, int type) {
        return mas_client_stop_streaming_audio_data(pid, type);
 }
 
-int CServiceMain::on_update_voice_feedback_state(int pid, int state) {
+int CServiceMain::on_update_voice_feedback_state(pid_t pid, int state) {
        return mas_client_update_voice_feedback_state(pid, state);
 }
 
-int CServiceMain::on_send_assistant_specific_command(int pid, std::string command) {
+int CServiceMain::on_send_assistant_specific_command(pid_t pid, std::string command) {
        return mas_client_set_assistant_specific_command(pid, command.c_str());
 }
 
-int CServiceMain::on_set_background_volume(int pid, double ratio) {
+int CServiceMain::on_set_background_volume(pid_t pid, double ratio) {
        return mas_client_set_background_volume(pid, ratio);
 }
 
-int CServiceMain::on_set_preprocessing_allow_mode(int pid, int mode, std::string app_id) {
+int CServiceMain::on_set_preprocessing_allow_mode(pid_t pid, int mode, std::string app_id) {
        return mas_client_set_preprocessing_allow_mode(pid,
                static_cast<ma_preprocessing_allow_mode_e>(mode), app_id.c_str());
 }
 
-int CServiceMain::on_send_preprocessing_result(int pid, int result) {
+int CServiceMain::on_send_preprocessing_result(pid_t pid, int result) {
        return mas_client_send_preprocessing_result(pid, result);
 }
 
-int CServiceMain::on_set_wake_word_audio_require_flag(int pid, int require) {
+int CServiceMain::on_set_wake_word_audio_require_flag(pid_t pid, int require) {
        return mas_client_set_wake_word_audio_require_flag(pid, require);
 }
 
-int CServiceMain::on_set_assistant_language(int pid, std::string language) {
+int CServiceMain::on_set_assistant_language(pid_t pid, std::string language) {
        return mas_client_set_assistant_language(pid, language.c_str());
 }
 
-int CServiceMain::on_add_wake_word(int pid, std::string wake_word, std::string language) {
+int CServiceMain::on_add_wake_word(pid_t pid, std::string wake_word, std::string language) {
        return mas_client_add_wake_word(pid, wake_word.c_str(), language.c_str());
 }
 
-int CServiceMain::on_remove_wake_word(int pid, std::string wake_word, std::string language) {
+int CServiceMain::on_remove_wake_word(pid_t pid, std::string wake_word, std::string language) {
        return mas_client_remove_wake_word(pid, wake_word.c_str(), language.c_str());
 }
 
-int CServiceMain::on_ui_initialize(int pid)
+int CServiceMain::on_ui_initialize(pid_t pid)
 {
        return mas_ui_client_initialize(pid);
 }
 
-int CServiceMain::on_ui_deinitialize(int pid)
+int CServiceMain::on_ui_deinitialize(pid_t pid)
 {
        return mas_ui_client_deinitialize(pid);
 }

diff --git a/src/service_plugin.cpp b/src/service_plugin.cpp
index 64dd796..339cf79 100644 (file)
--- a/src/service_plugin.cpp
+++ b/src/service_plugin.cpp
@@ -92,7 +92,7 @@ static Eina_Bool process_wakeup_event_by_appid_timer(void* data)
        char* appid = static_cast<char*>(param->data);
        MAS_LOGD("[ENTER] appid(%s)", appid);
 
-       int pid = -1;
+       pid_t pid = -1;
        if (!appid) return ECORE_CALLBACK_CANCEL;
 
        CServicePlugin* plugin = param->plugin;
@@ -262,7 +262,7 @@ static void __wakeup_event_cb(mas_wakeup_event_info wakeup_info, void* user_data
        }
 }
 
-static bool __validate_streaming_event_order(int pid, mas_speech_streaming_event_e *event)
+static bool __validate_streaming_event_order(pid_t pid, mas_speech_streaming_event_e *event)
 {
        bool ret = false;
 
@@ -437,7 +437,7 @@ static void __streaming_section_changed_cb(ma_audio_streaming_data_section_e sec
        CServiceIpcDbus *service_ipc = plugin->get_service_ipc();
        CServiceMain* service_main = plugin->get_service_main();
        if (service_ipc && service_main) {
-               int pid = service_main->mas_get_current_client_pid();
+               pid_t pid = service_main->mas_get_current_client_pid();
                int ret = service_ipc->send_streaming_section_changed(pid, (int)section);
                if (0 != ret) {
                        MAS_LOGE("[ERROR] Fail to send streaming section changed information, ret(%d)", ret);
@@ -455,7 +455,7 @@ static void __wakeup_engine_command_cb(mas_wakeup_engine_command_target_e target
        CServiceIpcDbus *service_ipc = plugin->get_service_ipc();
        CServiceMain* service_main = plugin->get_service_main();
        if (service_ipc && service_main) {
-               int pid = service_main->mas_get_client_pid_by_appid(assistant_name);
+               pid_t pid = service_main->mas_get_client_pid_by_appid(assistant_name);
                if (-1 != pid) {
                        int ret = service_ipc->send_wakeup_engine_command(pid, command);
                        if (0 != ret) {
@@ -488,7 +488,7 @@ static void __wakeup_service_voice_key_status_changed_cb(ma_voice_key_status_e s
        CServiceIpcDbus *service_ipc = plugin->get_service_ipc();
        CServiceMain* service_main = plugin->get_service_main();
        if (service_ipc && service_main) {
-               int pid = service_main->mas_get_current_client_pid();
+               pid_t pid = service_main->mas_get_current_client_pid();
                int ret = service_ipc->change_voice_key_status(pid, status);
                if (0 != ret) {
                        MAS_LOGE("[ERROR] Fail to send voice key status changed information, ret(%d)", ret);

diff --git a/tests/utc/client-manager/test_client_manager.cpp b/tests/utc/client-manager/test_client_manager.cpp
index 73f9cbe..1900dcc 100644 (file)
--- a/tests/utc/client-manager/test_client_manager.cpp
+++ b/tests/utc/client-manager/test_client_manager.cpp
@@ -52,7 +52,7 @@ public:
 
 TEST_F(StorageWithNoClient, HasOneClientAfterCreate) {
        const std::string arbitrary_client_appid{"Client1"};
-       const int arbitrary_client_pid{1};
+       const pid_t arbitrary_client_pid{1};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
@@ -63,7 +63,7 @@ TEST_F(StorageWithNoClient, HasOneClientAfterCreate) {
 
 TEST_F(StorageWithNoClient, ValidityReturnsTrueForCreatedClient) {
        const std::string arbitrary_client_appid{"Client1"};
-       const int arbitrary_client_pid{1};
+       const pid_t arbitrary_client_pid{1};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
@@ -74,7 +74,7 @@ TEST_F(StorageWithNoClient, ValidityReturnsTrueForCreatedClient) {
 
 TEST_F(StorageWithNoClient, ValidityReturnsFalseForNotCreatedClient) {
        const std::string arbitrary_client_appid{"Client1"};
-       const int arbitrary_client_pid{1};
+       const pid_t arbitrary_client_pid{1};
 
        const std::string noexist_client_appid{"Client987654321"};
 
@@ -98,82 +98,82 @@ public:
        void TearDown() override {
        }
        const std::string preloaded_client_appid_1{"Client1"};
-       const int preloaded_client_pid_1{1};
+       const pid_t preloaded_client_pid_1{1};
        CClientManager client_manager;
        CDummyApplicationManager application_manager;
 };
 
 TEST_F(StorageWithOneClient, ReturnsExistingPIDByIndex) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
-       int pid = client_manager.find_client_pid_by_index(0);
+       pid_t pid = client_manager.find_client_pid_by_index(0);
 
        ASSERT_EQ(pid, preloaded_client_pid_1);
 }
 
 TEST_F(StorageWithOneClient, ReturnsCreatedPIDByIndex) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
-       int pid = client_manager.find_client_pid_by_index(1);
+       pid_t pid = client_manager.find_client_pid_by_index(1);
 
        ASSERT_EQ(pid, arbitrary_client_pid);
 }
 
 TEST_F(StorageWithOneClient, PreservesExistingItemNotRequestedForRemoval) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
        client_manager.destroy_client_by_pid(arbitrary_client_pid);
 
-       int pid = client_manager.find_client_pid_by_index(0);
+       pid_t pid = client_manager.find_client_pid_by_index(0);
 
        ASSERT_EQ(pid, preloaded_client_pid_1);
 }
 
 TEST_F(StorageWithOneClient, PreservesCreatedItemNotRequestedForRemoval) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
        client_manager.destroy_client_by_pid(preloaded_client_pid_1);
 
-       int pid = client_manager.find_client_pid_by_index(0);
+       pid_t pid = client_manager.find_client_pid_by_index(0);
 
        ASSERT_EQ(pid, arbitrary_client_pid);
 }
 
 TEST_F(StorageWithOneClient, ReturnsCorrectExistingPIDByAppID) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
-       int pid = client_manager.find_client_pid_by_appid(preloaded_client_appid_1);
+       pid_t pid = client_manager.find_client_pid_by_appid(preloaded_client_appid_1);
 
        ASSERT_EQ(pid, preloaded_client_pid_1);
 }
 
 TEST_F(StorageWithOneClient, ReturnsCorrectCreatedPIDByAppID) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);
 
-       int pid = client_manager.find_client_pid_by_appid(arbitrary_client_appid);
+       pid_t pid = client_manager.find_client_pid_by_appid(arbitrary_client_appid);
 
        ASSERT_EQ(pid, arbitrary_client_pid);
 }
 
 TEST_F(StorageWithOneClient, ReturnsCorrectExistingAppIDByPID) {
        const std::string arbitrary_client_appid{"Client2"};
-       const int arbitrary_client_pid{2};
+       const pid_t arbitrary_client_pid{2};
 
        client_manager.create_client(arbitrary_client_pid, arbitrary_client_appid);