Add error case of device policy restriction for audio_in_prepare()

[platform/core/api/audio-io.git] / src / cpp / cpp_audio_io.cpp

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index 0c5571e..936873f 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -15,10 +15,10 @@
  */
 
 
-#include "audio_io.h"
 #include "cpp_audio_io.h"
-#include "CAudioIODef.h"
 #include <sound_manager_internal.h>
+#include "audio_io.h"
+#include "CAudioIODef.h"
 
 
 using namespace std;
@@ -90,82 +90,79 @@ typedef struct audio_io_s {
 /**
  * Internal functions
  */
-static audio_io_error_e _convert_CAudioError(CAudioError& error) {
+static audio_io_error_e __convert_CAudioError(CAudioError& error) {
     audio_io_error_e    ret = AUDIO_IO_ERROR_NONE;
     CAudioError::EError err = error.getError();
 
-    switch(err)
-    {
-    case CAudioError::ERROR_NONE:
+    switch (err) {
+    case CAudioError::EError::ERROR_NONE:
         ret = AUDIO_IO_ERROR_NONE;
         break;
-
-    case CAudioError::ERROR_INVALID_ARGUMENT:
-    case CAudioError::ERROR_INVALID_HANDLE:
-    case CAudioError::ERROR_INVALID_SAMPLERATE:
-    case CAudioError::ERROR_INVALID_CHANNEL:
-    case CAudioError::ERROR_INVALID_FORMAT:
+    case CAudioError::EError::ERROR_INVALID_ARGUMENT:
+    case CAudioError::EError::ERROR_INVALID_HANDLE:
+    case CAudioError::EError::ERROR_INVALID_SAMPLERATE:
+    case CAudioError::EError::ERROR_INVALID_CHANNEL:
+    case CAudioError::EError::ERROR_INVALID_FORMAT:
         ret = AUDIO_IO_ERROR_INVALID_PARAMETER;
         break;
-
-    case CAudioError::ERROR_DEVICE_NOT_OPENED:
+    case CAudioError::EError::ERROR_DEVICE_NOT_OPENED:
         ret = AUDIO_IO_ERROR_DEVICE_NOT_OPENED;
         break;
-
-    case CAudioError::ERROR_DEVICE_NOT_CLOSED:
+    case CAudioError::EError::ERROR_DEVICE_NOT_CLOSED:
         ret = AUDIO_IO_ERROR_DEVICE_NOT_CLOSED;
         break;
-
-    case CAudioError::ERROR_PERMISSION_DENIED:
+    case CAudioError::EError::ERROR_PERMISSION_DENIED:
         ret = AUDIO_IO_ERROR_PERMISSION_DENIED;
         break;
-
-    case CAudioError::ERROR_NOT_SUPPORTED:
+    case CAudioError::EError::ERROR_DEVICE_POLICY_RESTRICTION:
+        ret = AUDIO_IO_ERROR_DEVICE_POLICY_RESTRICTION;
+        break;
+    case CAudioError::EError::ERROR_NOT_SUPPORTED:
         ret = AUDIO_IO_ERROR_NOT_SUPPORTED;
         break;
-
-    case CAudioError::ERROR_MAX:
-    case CAudioError::ERROR_INTERNAL_OPERATION:
-    case CAudioError::ERROR_NOT_INITIALIZED:
-    case CAudioError::ERROR_FAILED_OPERATION:
-    case CAudioError::ERROR_INVALID_OPERATION:
+    case CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE:
+        ret = AUDIO_IO_ERROR_NOT_SUPPORTED_TYPE;
+        break;
+    case CAudioError::EError::ERROR_MAX:
+    case CAudioError::EError::ERROR_INTERNAL_OPERATION:
+    case CAudioError::EError::ERROR_NOT_INITIALIZED:
+    case CAudioError::EError::ERROR_FAILED_OPERATION:
+    case CAudioError::EError::ERROR_INVALID_OPERATION:
         ret = AUDIO_IO_ERROR_INVALID_OPERATION;
         break;
-
-    case CAudioError::ERROR_OUT_OF_MEMORY:
-    case CAudioError::ERROR_INVALID_POINTER:
+    case CAudioError::EError::ERROR_OUT_OF_MEMORY:
+    case CAudioError::EError::ERROR_INVALID_POINTER:
         ret = AUDIO_IO_ERROR_INVALID_BUFFER;
         break;
-
-    case CAudioError::ERROR_POLICY_BLOCKED:
-    case CAudioError::ERROR_POLICY_INTERRUPTED:
-    case CAudioError::ERROR_POLICY_DUPLICATED:
+    case CAudioError::EError::ERROR_POLICY_BLOCKED:
+    case CAudioError::EError::ERROR_POLICY_INTERRUPTED:
+    case CAudioError::EError::ERROR_POLICY_DUPLICATED:
         ret = AUDIO_IO_ERROR_SOUND_POLICY;
         break;
     }
-    return ret;
 
+    return ret;
 }
 
-static void _convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) {
+static void __convert_channel_2_audio_info_channel(const audio_channel_e& src_channel, CAudioInfo::EChannel& dst_channel) {
     switch (src_channel) {
     case AUDIO_CHANNEL_MONO:
-        dst_channel = CAudioInfo::CHANNEL_MONO;
+        dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
         break;
     case AUDIO_CHANNEL_STEREO:
-        dst_channel = CAudioInfo::CHANNEL_STEREO;
+        dst_channel = CAudioInfo::EChannel::CHANNEL_STEREO;
         break;
     default:
-        dst_channel = CAudioInfo::CHANNEL_MONO;
+        dst_channel = CAudioInfo::EChannel::CHANNEL_MONO;
     }
 }
 
-static void _convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) {
+static void __convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& src_channel, audio_channel_e& dst_channel) {
     switch (src_channel) {
-    case CAudioInfo::CHANNEL_MONO:
+    case CAudioInfo::EChannel::CHANNEL_MONO:
         dst_channel = AUDIO_CHANNEL_MONO;
         break;
-    case CAudioInfo::CHANNEL_STEREO:
+    case CAudioInfo::EChannel::CHANNEL_STEREO:
         dst_channel = AUDIO_CHANNEL_STEREO;
         break;
     default:
@@ -173,25 +170,25 @@ static void _convert_audio_info_channel_2_channel(const CAudioInfo::EChannel& sr
     }
 }
 
-static void _convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) {
+static void __convert_sample_type_2_audio_info_sample_type(const audio_sample_type_e& src_type, CAudioInfo::ESampleType& dst_type) {
     switch (src_type) {
     case AUDIO_SAMPLE_TYPE_U8:
-        dst_type = CAudioInfo::SAMPLE_TYPE_U8;
+        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
         break;
     case AUDIO_SAMPLE_TYPE_S16_LE:
-        dst_type = CAudioInfo::SAMPLE_TYPE_S16_LE;
+        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE;
         break;
     default:
-        dst_type = CAudioInfo::SAMPLE_TYPE_U8;
+        dst_type = CAudioInfo::ESampleType::SAMPLE_TYPE_U8;
     }
 }
 
-static void _convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) {
+static void __convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESampleType& src_type, audio_sample_type_e& dst_type) {
     switch (src_type) {
-    case CAudioInfo::SAMPLE_TYPE_U8:
+    case CAudioInfo::ESampleType::SAMPLE_TYPE_U8:
         dst_type = AUDIO_SAMPLE_TYPE_U8;
         break;
-    case CAudioInfo::SAMPLE_TYPE_S16_LE:
+    case CAudioInfo::ESampleType::SAMPLE_TYPE_S16_LE:
         dst_type = AUDIO_SAMPLE_TYPE_S16_LE;
         break;
     default:
@@ -199,82 +196,81 @@ static void _convert_audio_info_sample_type_2_sample_type(const CAudioInfo::ESam
     }
 }
 
-static void _convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) {
+static void __convert_sound_type_2_audio_info_audio_type(const sound_type_e& src_type, CAudioInfo::EAudioType& dst_type) {
     switch (src_type) {
-        case SOUND_TYPE_SYSTEM:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
-            break;
-        case SOUND_TYPE_NOTIFICATION:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION;
-            break;
-        case SOUND_TYPE_ALARM:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_ALARM;
-            break;
-        case SOUND_TYPE_RINGTONE:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP;
-            break;
-        case SOUND_TYPE_MEDIA:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
-            break;
-        case SOUND_TYPE_CALL:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_SYSTEM;
-            break;
-        case SOUND_TYPE_VOIP:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOIP;
-            break;
-        case SOUND_TYPE_VOICE:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION;
-            break;
-        default:
-            dst_type = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
-            break;
-        }
-}
-
-static void _convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
+    case SOUND_TYPE_SYSTEM:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
+        break;
+    case SOUND_TYPE_NOTIFICATION:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION;
+        break;
+    case SOUND_TYPE_ALARM:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM;
+        break;
+    case SOUND_TYPE_RINGTONE:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP;
+        break;
+    case SOUND_TYPE_MEDIA:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
+        break;
+    case SOUND_TYPE_CALL:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM;
+        break;
+    case SOUND_TYPE_VOIP:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP;
+        break;
+    case SOUND_TYPE_VOICE:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION;
+        break;
+    default:
+        dst_type = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
+        break;
+    }
+}
+
+static void __convert_audio_info_audio_type_2_sound_type(const CAudioInfo::EAudioType& src_type, sound_type_e& dst_type) {
     switch (src_type) {
-        case CAudioInfo::AUDIO_OUT_TYPE_MEDIA:
-            dst_type = SOUND_TYPE_MEDIA;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_SYSTEM:
-            dst_type = SOUND_TYPE_SYSTEM;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_ALARM:
-            dst_type = SOUND_TYPE_ALARM;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_NOTIFICATION:
-        case CAudioInfo::AUDIO_OUT_TYPE_EMERGENCY:
-            dst_type = SOUND_TYPE_NOTIFICATION;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_VOICE_INFORMATION:
-        case CAudioInfo::AUDIO_OUT_TYPE_VOICE_RECOGNITION:
-            dst_type = SOUND_TYPE_VOICE;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_RINGTONE_VOIP:
-            dst_type = SOUND_TYPE_RINGTONE;
-            break;
-        case CAudioInfo::AUDIO_OUT_TYPE_VOIP:
-            dst_type = SOUND_TYPE_VOIP;
-            break;
-        default:
-            dst_type = SOUND_TYPE_MEDIA;
-            break;
-        }
-}
-
-static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_state) {
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA:
+        dst_type = SOUND_TYPE_MEDIA;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_SYSTEM:
+        dst_type = SOUND_TYPE_SYSTEM;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_ALARM:
+        dst_type = SOUND_TYPE_ALARM;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_NOTIFICATION:
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_EMERGENCY:
+        dst_type = SOUND_TYPE_NOTIFICATION;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOICE_INFORMATION:
+        dst_type = SOUND_TYPE_VOICE;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_RINGTONE_VOIP:
+        dst_type = SOUND_TYPE_RINGTONE;
+        break;
+    case CAudioInfo::EAudioType::AUDIO_OUT_TYPE_VOIP:
+        dst_type = SOUND_TYPE_VOIP;
+        break;
+    default:
+        dst_type = SOUND_TYPE_MEDIA;
+        break;
+    }
+}
+
+static audio_io_state_e __convert_state_type(const CAudioInfo::EAudioIOState src_state) {
     audio_io_state_e dst_state;
     switch (src_state) {
-    case CAudioInfo::AUDIO_IO_STATE_NONE:
+    case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_NONE:
         dst_state = AUDIO_IO_STATE_IDLE;
         break;
-    case CAudioInfo::AUDIO_IO_STATE_IDLE:
+    case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_IDLE:
         dst_state = AUDIO_IO_STATE_IDLE;
         break;
-    case CAudioInfo::AUDIO_IO_STATE_RUNNING:
+    case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_RUNNING:
         dst_state = AUDIO_IO_STATE_RUNNING;
         break;
-    case CAudioInfo::AUDIO_IO_STATE_PAUSED:
+    case CAudioInfo::EAudioIOState::AUDIO_IO_STATE_PAUSED:
         dst_state = AUDIO_IO_STATE_PAUSED;
         break;
     default:
@@ -283,82 +279,80 @@ static audio_io_state_e _convert_state_type(const CAudioInfo::EAudioIOState src_
     return dst_state;
 }
 
-static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type)  throw (CAudioError) {
-
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type) throw(CAudioError) {
     if (sample_rate < 0) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample rate :%d", sample_rate);
     }
 
     if (channel != AUDIO_CHANNEL_MONO && channel != AUDIO_CHANNEL_STEREO) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid channel :%d", channel);
     }
 
     if (type != AUDIO_SAMPLE_TYPE_U8 && type != AUDIO_SAMPLE_TYPE_S16_LE) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sample type :%d", type);
     }
 }
 
-static void _check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw (CAudioError) {
-
-    _check_audio_param(sample_rate, channel, type);
+static void __check_audio_param(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type) throw(CAudioError) {
+    __check_audio_param(sample_rate, channel, type);
 
     if (sound_type < SOUND_TYPE_SYSTEM || sound_type > SOUND_TYPE_VOICE) {
-        THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
+        THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Invalid sound type : %d", sound_type);
     }
 }
 
-static CAudioInfo _generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_input_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
-    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
+    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo _generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_input_loopback_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type) throw(CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
-    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::AUDIO_IN_TYPE_LOOPBACK;
+    CAudioInfo::EAudioType  dstAudioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_LOOPBACK;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static CAudioInfo _generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw (CAudioError) {
+static CAudioInfo __generate_audio_output_info(int sampleRate, audio_channel_e channel, audio_sample_type_e sample_type, sound_type_e sound_type) throw(CAudioError) {
     CAudioInfo::EChannel     dstChannel;
     CAudioInfo::ESampleType dstSampleType;
     CAudioInfo::EAudioType  dstAudioType;
 
-    _convert_channel_2_audio_info_channel(channel, dstChannel);
-    _convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
-    _convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
+    __convert_channel_2_audio_info_channel(channel, dstChannel);
+    __convert_sample_type_2_audio_info_sample_type(sample_type, dstSampleType);
+    __convert_sound_type_2_audio_info_audio_type(sound_type, dstAudioType);
 
     return CAudioInfo(sampleRate, dstChannel, dstSampleType, dstAudioType, -1);
 }
 
-static audio_io_interrupted_code_e _convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
+static audio_io_interrupted_code_e __convert_interrupted_code(IAudioSessionEventListener::EInterruptCode code) {
     switch (code) {
-    case IAudioSessionEventListener::INTERRUPT_COMPLETED:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_COMPLETED:
         return AUDIO_IO_INTERRUPTED_COMPLETED;
-    case IAudioSessionEventListener::INTERRUPT_BY_CALL:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_CALL:
         return AUDIO_IO_INTERRUPTED_BY_CALL;
-    case IAudioSessionEventListener::INTERRUPT_BY_EARJACK_UNPLUG:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EARJACK_UNPLUG:
         return AUDIO_IO_INTERRUPTED_BY_EARJACK_UNPLUG;
-    case IAudioSessionEventListener::INTERRUPT_BY_RESOURCE_CONFLICT:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_RESOURCE_CONFLICT:
         return AUDIO_IO_INTERRUPTED_BY_RESOURCE_CONFLICT;
-    case IAudioSessionEventListener::INTERRUPT_BY_ALARM:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_ALARM:
         return AUDIO_IO_INTERRUPTED_BY_ALARM;
-    case IAudioSessionEventListener::INTERRUPT_BY_EMERGENCY:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_EMERGENCY:
         return AUDIO_IO_INTERRUPTED_BY_EMERGENCY;
-    case IAudioSessionEventListener::INTERRUPT_BY_NOTIFICATION:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_NOTIFICATION:
         return AUDIO_IO_INTERRUPTED_BY_NOTIFICATION;
-    case IAudioSessionEventListener::INTERRUPT_BY_MEDIA:
-    case IAudioSessionEventListener::INTERRUPT_MAX:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_BY_MEDIA:
+    case IAudioSessionEventListener::EInterruptCode::INTERRUPT_MAX:
     default:
         return AUDIO_IO_INTERRUPTED_BY_MEDIA;
     }
@@ -371,21 +365,21 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
     audio_io_s* handle = NULL;
     try {
         if (input == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
-        _check_audio_param(sample_rate, channel, type);
+        __check_audio_param(sample_rate, channel, type);
 
         handle = new audio_io_s;
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_input_info(sample_rate, channel, type);
+        CAudioInfo audioInfo = __generate_audio_input_info(sample_rate, channel, type);
 
         handle->audioIoHandle = new CAudioInput(audioInfo);
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
         }
 
         handle->audioIoHandle->initialize();
@@ -404,30 +398,31 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
             *input = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
-
 }
 
 int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio_sample_type_e type , audio_in_h* input) {
     audio_io_s* handle = NULL;
     try {
         if (input == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
+        __check_audio_param(sample_rate, channel, type);
+
         handle = new audio_io_s;
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_input_loopback_info(sample_rate, channel, type);
+        CAudioInfo audioInfo = __generate_audio_input_loopback_info(sample_rate, channel, type);
 
         handle->audioIoHandle = new CAudioInput(audioInfo);
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
         }
 
         handle->audioIoHandle->initialize();
@@ -446,7 +441,7 @@ int cpp_audio_in_create_loopback(int sample_rate, audio_channel_e channel, audio
             *input = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -457,7 +452,7 @@ int cpp_audio_in_destroy(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -467,7 +462,7 @@ int cpp_audio_in_destroy(audio_in_h input) {
         SAFE_DELETE(handle);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -478,29 +473,38 @@ int cpp_audio_in_set_stream_info(audio_in_h input, sound_stream_info_h stream_in
 
     try {
         if (handle == NULL || stream_info == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, stream_info:%p", input, stream_info);
         }
 
         assert(handle->audioIoHandle);
 
         int errorCode = SOUND_MANAGER_ERROR_NONE;
-        CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_IN_TYPE_MEDIA;
+        CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_IN_TYPE_MEDIA;
         char *type = NULL;
         int index = -1;
+        bool avail = false;
 
-        if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+        if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
         }
-        handle->audioIoHandle->getAudioInfo().convertStreamType2AudioType(type, &AudioType);
-        handle->audioIoHandle->getAudioInfo().setAudioType(AudioType);
 
-        if ((errorCode = sound_manager_get_index_from_stream_information (stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+        if (avail) {
+            if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+            }
+            handle->audioIoHandle->getAudioInfo().convertInputStreamType2AudioType(type, &audioType);
+            handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
+
+            if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+            }
+            handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
+        } else {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Input stream is not supported");
         }
-        handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -511,7 +515,7 @@ int cpp_audio_in_prepare(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -519,7 +523,7 @@ int cpp_audio_in_prepare(audio_in_h input) {
         handle->audioIoHandle->prepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -530,7 +534,7 @@ int cpp_audio_in_unprepare(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -538,7 +542,7 @@ int cpp_audio_in_unprepare(audio_in_h input) {
         handle->audioIoHandle->unprepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -549,7 +553,7 @@ int cpp_audio_in_pause(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -557,7 +561,7 @@ int cpp_audio_in_pause(audio_in_h input) {
         handle->audioIoHandle->pause();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -568,7 +572,7 @@ int cpp_audio_in_resume(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -576,7 +580,7 @@ int cpp_audio_in_resume(audio_in_h input) {
         handle->audioIoHandle->resume();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -587,7 +591,7 @@ int cpp_audio_in_drain(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -595,7 +599,7 @@ int cpp_audio_in_drain(audio_in_h input) {
         handle->audioIoHandle->drain();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -606,7 +610,7 @@ int cpp_audio_in_flush(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -614,7 +618,7 @@ int cpp_audio_in_flush(audio_in_h input) {
         handle->audioIoHandle->flush();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -625,20 +629,24 @@ int cpp_audio_in_read(audio_in_h input, void *buffer, unsigned int length) {
     int ret = 0;
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+        if (handle == NULL || buffer == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
         }
 
         assert(handle->audioIoHandle);
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
-        ret = inputHandle->read(buffer, length);
+        if (inputHandle == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+        }
+        size_t readn = inputHandle->read(buffer, static_cast<size_t>(length));
+        ret = static_cast<int>(readn);
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-        AUDIO_IO_LOGD("ret:%d", ret);
+        AUDIO_IO_LOGD("readn:%d", readn);
 #endif
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return ret;
@@ -649,16 +657,19 @@ int cpp_audio_in_get_buffer_size(audio_in_h input, int *size) {
 
     try {
         if (handle == NULL || size == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, size:%p", input, size);
         }
 
         assert(handle->audioIoHandle);
 
         CAudioIO* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
+        if (inputHandle == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+        }
         *size = inputHandle->getBufferSize();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -669,14 +680,14 @@ int cpp_audio_in_get_sample_rate(audio_in_h input, int *sample_rate) {
 
     try {
         if (handle == NULL || sample_rate == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, sample_rate:%p", input, sample_rate);
         }
 
         assert(handle->audioIoHandle);
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -687,19 +698,19 @@ int cpp_audio_in_get_channel(audio_in_h input, audio_channel_e *channel) {
 
     try {
         if (handle == NULL || channel == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, channel:%p", input, channel);
         }
 
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
         audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
-        _convert_audio_info_channel_2_channel(srcChannel, dstChannel);
+        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -710,27 +721,27 @@ int cpp_audio_in_get_sample_type(audio_in_h input, audio_sample_type_e *type) {
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, type:%p", input, type);
         }
 
         assert(handle->audioIoHandle);
 
         const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
         audio_sample_type_e     dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        _convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
+        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
 }
 
-static void _interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
+static void __interrupt_cb_internal(IAudioSessionEventListener::EInterruptCode _code, void* user_data) {
     audio_io_s* handle = static_cast<audio_io_s*>(user_data);
-    audio_io_interrupted_code_e code = _convert_interrupted_code(_code);
+    audio_io_interrupted_code_e code = __convert_interrupted_code(_code);
 
     assert(handle);
 
@@ -744,7 +755,7 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -754,12 +765,12 @@ int cpp_audio_in_set_interrupted_cb(audio_in_h input, audio_io_interrupted_cb ca
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
         cb.mUserData   = static_cast<void*>(handle);
-        cb.onInterrupt = _interrupt_cb_internal;
+        cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -770,7 +781,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -785,7 +796,7 @@ int cpp_audio_in_unset_interrupted_cb(audio_in_h input) {
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -796,11 +807,11 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         if (handle->stream_callback.onStream) {
-            THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
         }
 
         assert(handle->audioIoHandle);
@@ -808,13 +819,13 @@ int cpp_audio_in_ignore_session(audio_in_h input) {
         handle->audioIoHandle->ignoreSession();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
 }
 
-static void _stream_cb_internal(size_t nbytes, void *user_data) {
+static void __stream_cb_internal(size_t nbytes, void *user_data) {
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
@@ -823,12 +834,12 @@ static void _stream_cb_internal(size_t nbytes, void *user_data) {
     }
 }
 
-static void _state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) {
+static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state, CAudioInfo::EAudioIOState state_prev, bool by_policy, void *user_data) {
     audio_io_s* audioIo = static_cast<audio_io_s*>(user_data);
     assert(audioIo);
 
     if (audioIo->state_changed_callback.onStateChanged != NULL) {
-        audioIo->state_changed_callback.onStateChanged(audioIo, _convert_state_type(state_prev), _convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data);
+        audioIo->state_changed_callback.onStateChanged(audioIo, __convert_state_type(state_prev), __convert_state_type(state), by_policy, audioIo->state_changed_callback.user_data);
     }
 }
 
@@ -837,7 +848,7 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -847,12 +858,12 @@ int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, vo
 
         CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStream  = _stream_cb_internal;
+        cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -863,7 +874,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -878,7 +889,7 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -886,21 +897,24 @@ int cpp_audio_in_unset_stream_cb(audio_in_h input) {
 
 int cpp_audio_in_peek(audio_in_h input, const void **buffer, unsigned int *length) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
+    size_t _length = 0;
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+        if (handle == NULL || buffer == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, buffer:%p", input, buffer);
         }
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
         assert(inputHandle);
 
-        inputHandle->peek(buffer, length);
+        inputHandle->peek(buffer, &_length);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
+    *length = (unsigned int)_length;
+
     return AUDIO_IO_ERROR_NONE;
 }
 
@@ -909,7 +923,7 @@ int cpp_audio_in_drop(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p", input);
         }
 
         CAudioInput* inputHandle = dynamic_cast<CAudioInput*>(handle->audioIoHandle);
@@ -918,7 +932,7 @@ int cpp_audio_in_drop(audio_in_h input) {
         inputHandle->drop();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -928,8 +942,8 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", input, callback);
+        if (handle == NULL || callback == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL input:%p, callback:%p", input, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -939,12 +953,12 @@ int cpp_audio_in_set_state_changed_cb(audio_in_h input, audio_in_state_changed_c
 
         CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStateChanged = _state_changed_cb_internal;
+        cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -955,7 +969,7 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", input);
         }
 
         assert(handle->audioIoHandle);
@@ -970,7 +984,7 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -983,18 +997,22 @@ int cpp_audio_in_unset_state_changed_cb(audio_in_h input) {
 int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_type_e type, sound_type_e sound_type, audio_out_h *output) {
     audio_io_s* handle = NULL;
     try {
+        if (output == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+        }
+
+        __check_audio_param(sample_rate, channel, type, sound_type);
+
         handle = new audio_io_s;
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        _check_audio_param(sample_rate, channel, type, sound_type);
-
-        CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, sound_type);
+        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, sound_type);
 
         handle->audioIoHandle = new CAudioOutput(audioInfo);
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
         }
 
         handle->audioIoHandle->initialize();
@@ -1010,10 +1028,10 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
         VALID_POINTER_END
 
         VALID_POINTER_START(output)
-        *output = NULL;
+            *output = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1022,16 +1040,22 @@ int cpp_audio_out_create(int sample_rate, audio_channel_e channel, audio_sample_
 int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output) {
     audio_io_s* handle = NULL;
     try {
+        if (output == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+        }
+
+        __check_audio_param(sample_rate, channel, type, SOUND_TYPE_SYSTEM /*default check */);
+
         handle = new audio_io_s;
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation handle");
         }
 
-        CAudioInfo audioInfo = _generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_tyoe */);
+        CAudioInfo audioInfo = __generate_audio_output_info(sample_rate, channel, type, SOUND_TYPE_MEDIA /* default sound_type */);
 
         handle->audioIoHandle = new CAudioOutput(audioInfo);
         if (handle == NULL) {
-            THROW_ERROR_MSG(CAudioError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed allocation internal handle");
         }
 
         handle->audioIoHandle->initialize();
@@ -1047,10 +1071,10 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
         VALID_POINTER_END
 
         VALID_POINTER_START(output)
-        *output = NULL;
+            *output = NULL;
         VALID_POINTER_END
 
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1061,7 +1085,7 @@ int cpp_audio_out_destroy(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1071,7 +1095,7 @@ int cpp_audio_out_destroy(audio_out_h output) {
         SAFE_DELETE(handle);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1082,29 +1106,38 @@ int cpp_audio_out_set_stream_info(audio_out_h output, sound_stream_info_h stream
 
     try {
         if (handle == NULL || stream_info == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, stream_info:%p", output, stream_info);
         }
 
         assert(handle->audioIoHandle);
 
         int errorCode = SOUND_MANAGER_ERROR_NONE;
-        CAudioInfo::EAudioType AudioType = CAudioInfo::AUDIO_OUT_TYPE_MEDIA;
+        CAudioInfo::EAudioType audioType = CAudioInfo::EAudioType::AUDIO_OUT_TYPE_MEDIA;
         char *type = NULL;
         int index = -1;
+        bool avail = false;
 
-        if ((errorCode = sound_manager_get_type_from_stream_information (stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+        if ((errorCode = sound_manager_is_available_stream_information(stream_info, NATIVE_API_AUDIO_IO, &avail)) != SOUND_MANAGER_ERROR_NONE) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info is invalid [ret:%d]", errorCode);
         }
-        handle->audioIoHandle->getAudioInfo().convertStreamType2AudioType(type, &AudioType);
-        handle->audioIoHandle->getAudioInfo().setAudioType(AudioType);
 
-        if ((errorCode = sound_manager_get_index_from_stream_information (stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+        if (avail) {
+            if ((errorCode = sound_manager_get_type_from_stream_information(stream_info, &type)) != SOUND_MANAGER_ERROR_NONE) {
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->stream_type is invalid [ret:%d]", errorCode);
+            }
+            handle->audioIoHandle->getAudioInfo().convertOutputStreamType2AudioType(type, &audioType);
+            handle->audioIoHandle->getAudioInfo().setAudioType(audioType);
+
+            if ((errorCode = sound_manager_get_index_from_stream_information(stream_info, &index)) != SOUND_MANAGER_ERROR_NONE) {
+                THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter stream_info->index is invalid [ret:%d]", errorCode);
+            }
+            handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
+        } else {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_NOT_SUPPORTED_TYPE, "Output stream is not supported");
         }
-        handle->audioIoHandle->getAudioInfo().setAudioIndex(index);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1115,7 +1148,7 @@ int cpp_audio_out_prepare(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1123,7 +1156,7 @@ int cpp_audio_out_prepare(audio_out_h output) {
         handle->audioIoHandle->prepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1134,7 +1167,7 @@ int cpp_audio_out_unprepare(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1142,7 +1175,7 @@ int cpp_audio_out_unprepare(audio_out_h output) {
         handle->audioIoHandle->unprepare();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1153,7 +1186,7 @@ int cpp_audio_out_pause(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1161,7 +1194,7 @@ int cpp_audio_out_pause(audio_out_h output) {
         handle->audioIoHandle->pause();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1172,7 +1205,7 @@ int cpp_audio_out_resume(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1180,7 +1213,7 @@ int cpp_audio_out_resume(audio_out_h output) {
         handle->audioIoHandle->resume();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1191,7 +1224,7 @@ int cpp_audio_out_drain(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1199,7 +1232,7 @@ int cpp_audio_out_drain(audio_out_h output) {
         handle->audioIoHandle->drain();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1210,7 +1243,7 @@ int cpp_audio_out_flush(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1218,7 +1251,7 @@ int cpp_audio_out_flush(audio_out_h output) {
         handle->audioIoHandle->flush();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1229,20 +1262,24 @@ int cpp_audio_out_write(audio_out_h output, void *buffer, unsigned int length) {
     int ret = 0;
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p", output);
+        if (handle == NULL || buffer == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameter is NULL output:%p, buffer:%p", output, buffer);
         }
 
         assert(handle->audioIoHandle);
 
         CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
-        ret = outputHandle->write(buffer, length);
+        if (outputHandle == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+        }
+        size_t writen = outputHandle->write(buffer, static_cast<size_t>(length));
+        ret = static_cast<int>(writen);
 #ifdef _AUDIO_IO_DEBUG_TIMING_
-        AUDIO_IO_LOGD("ret:%d", ret);
+        AUDIO_IO_LOGD("writen:%d", writen);
 #endif
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return ret;
@@ -1253,16 +1290,19 @@ int cpp_audio_out_get_buffer_size(audio_out_h output, int *size) {
 
     try {
         if (handle == NULL || size == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, size:%p", output, size);
         }
 
         assert(handle->audioIoHandle);
 
         CAudioOutput* outputHandle = dynamic_cast<CAudioOutput*>(handle->audioIoHandle);
+        if (outputHandle == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_HANDLE, "Handle is NULL");
+        }
         *size = outputHandle->getBufferSize();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1273,14 +1313,14 @@ int cpp_audio_out_get_sample_rate(audio_out_h output, int *sample_rate) {
 
     try {
         if (handle == NULL || sample_rate == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, sample_rate:%p", output, sample_rate);
         }
 
         assert(handle->audioIoHandle);
         *sample_rate = handle->audioIoHandle->getAudioInfo().getSampleRate();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1291,19 +1331,19 @@ int cpp_audio_out_get_channel(audio_out_h output, audio_channel_e *channel) {
 
     try {
         if (handle == NULL || channel == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, channel:%p", output, channel);
         }
 
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EChannel srcChannel = handle->audioIoHandle->getAudioInfo().getChannel();
         audio_channel_e dstChannel = AUDIO_CHANNEL_MONO;
-        _convert_audio_info_channel_2_channel(srcChannel, dstChannel);
+        __convert_audio_info_channel_2_channel(srcChannel, dstChannel);
 
         *channel = dstChannel;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1314,19 +1354,19 @@ int cpp_audio_out_get_sample_type(audio_out_h output, audio_sample_type_e *type)
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
         }
 
         assert(handle->audioIoHandle);
 
         const CAudioInfo::ESampleType srcSampleType = handle->audioIoHandle->getAudioInfo().getSampleType();
         audio_sample_type_e     dstSampleType = AUDIO_SAMPLE_TYPE_U8;
-        _convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
+        __convert_audio_info_sample_type_2_sample_type(srcSampleType, dstSampleType);
 
         *type = dstSampleType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1337,19 +1377,19 @@ int cpp_audio_out_get_sound_type(audio_out_h output, sound_type_e *type) {
 
     try {
         if (handle == NULL || type == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, type:%p", output, type);
         }
 
         assert(handle->audioIoHandle);
 
         const CAudioInfo::EAudioType srcAudioType = handle->audioIoHandle->getAudioInfo().getAudioType();
         sound_type_e                 dstSoundType = SOUND_TYPE_MEDIA;
-        _convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
+        __convert_audio_info_audio_type_2_sound_type(srcAudioType, dstSoundType);
 
         *type = dstSoundType;
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1360,7 +1400,7 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
 
     try {
         if (handle == NULL || callback == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1370,12 +1410,12 @@ int cpp_audio_out_set_interrupted_cb(audio_out_h output, audio_io_interrupted_cb
 
         CAudioIO::SInterruptCallback cb = handle->audioIoHandle->getInterruptCallback();
         cb.mUserData   = static_cast<void*>(handle);
-        cb.onInterrupt = _interrupt_cb_internal;
+        cb.onInterrupt = __interrupt_cb_internal;
 
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1386,7 +1426,7 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1401,7 +1441,7 @@ int cpp_audio_out_unset_interrupted_cb(audio_out_h output) {
         handle->audioIoHandle->setInterruptCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1412,11 +1452,11 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
         if (handle->stream_callback.onStream) {
-            THROW_ERROR_MSG(CAudioError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
+            THROW_ERROR_MSG(CAudioError::EError::ERROR_INVALID_OPERATION, "Not support ignore session in async mode");
         }
 
         assert(handle->audioIoHandle);
@@ -1424,7 +1464,7 @@ int cpp_audio_out_ignore_session(audio_out_h output) {
         handle->audioIoHandle->ignoreSession();
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1434,8 +1474,8 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+        if (handle == NULL || callback == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1445,12 +1485,12 @@ int cpp_audio_out_set_stream_cb(audio_out_h output, audio_out_stream_cb callback
 
         CAudioIO::SStreamCallback cb = handle->audioIoHandle->getStreamCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStream  = _stream_cb_internal;
+        cb.onStream  = __stream_cb_internal;
 
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1461,7 +1501,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1476,7 +1516,7 @@ int cpp_audio_out_unset_stream_cb(audio_out_h output) {
         handle->audioIoHandle->setStreamCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1486,8 +1526,8 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
     audio_io_s* handle = static_cast<audio_io_s*>(output);
 
     try {
-        if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
+        if (handle == NULL || callback == NULL) {
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p, callback:%p", output, callback);
         }
 
         assert(handle->audioIoHandle);
@@ -1497,12 +1537,12 @@ int cpp_audio_out_set_state_changed_cb(audio_out_h output, audio_in_state_change
 
         CAudioIO::SStateChangedCallback cb = handle->audioIoHandle->getStateChangedCallback();
         cb.mUserData = static_cast<void*>(handle);
-        cb.onStateChanged = _state_changed_cb_internal;
+        cb.onStateChanged = __state_changed_cb_internal;
 
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -1513,7 +1553,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
 
     try {
         if (handle == NULL) {
-            THROW_ERROR_MSG_FORMAT(CAudioError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
+            THROW_ERROR_MSG_FORMAT(CAudioError::EError::ERROR_INVALID_ARGUMENT, "Parameters are NULL output:%p", output);
         }
 
         assert(handle->audioIoHandle);
@@ -1528,7 +1568,7 @@ int cpp_audio_out_unset_state_changed_cb(audio_out_h output) {
         handle->audioIoHandle->setStateChangedCallback(cb);
     } catch (CAudioError e) {
         AUDIO_IO_LOGE("%s", e.getErrorMsg());
-        return _convert_CAudioError(e);
+        return __convert_CAudioError(e);
     }
 
     return AUDIO_IO_ERROR_NONE;