Add punctuations in error messages

HakkyuKim · HakkyuKim · commit fc31a7cc6ddc · 2022-05-06T12:52:16.000+09:00
Remove wrapping of TizenResult in some places.
diff --git a/packages/audioplayers/tizen/src/audio_player.cc b/packages/audioplayers/tizen/src/audio_player.cc
@@ -40,12 +40,12 @@ TizenResult AudioPlayer::Play() {
         int ret = player_set_memory_buffer(player_, audio_data_.data(),
                                            audio_data_.size());
         if (ret != PLAYER_ERROR_NONE) {
-          return TizenResult(ret, "player_set_memory_buffer failed");
+          return TizenResult(ret, "player_set_memory_buffer failed.");
         }
       } else {
         int ret = player_set_uri(player_, url_.c_str());
         if (ret != PLAYER_ERROR_NONE) {
-          return TizenResult(ret, "player_set_uri failed");
+          return TizenResult(ret, "player_set_uri failed.");
         }
       }
       should_play_ = true;
@@ -59,7 +59,7 @@ TizenResult AudioPlayer::Play() {
     case PLAYER_STATE_PAUSED: {
       int ret = player_start(player_);
       if (ret != PLAYER_ERROR_NONE) {
-        return TizenResult(ret, "player_start failed");
+        return TizenResult(ret, "player_start failed.");
       }
       should_play_ = false;
       EmitPositionUpdates();
@@ -83,7 +83,7 @@ TizenResult AudioPlayer::Pause() {
   if (state == PLAYER_STATE_PLAYING) {
     int ret = player_pause(player_);
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_pause failed");
+      return TizenResult(ret, "player_pause failed.");
     }
   }
 
@@ -101,7 +101,7 @@ TizenResult AudioPlayer::Stop() {
   if (state == PLAYER_STATE_PLAYING || state == PLAYER_STATE_PAUSED) {
     int ret = player_stop(player_);
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_stop failed");
+      return TizenResult(ret, "player_stop failed.");
     }
   }
 
@@ -146,7 +146,7 @@ TizenResult AudioPlayer::Seek(int position) {
                                        this);
     if (ret != PLAYER_ERROR_NONE) {
       seeking_ = false;
-      return TizenResult(ret, "player_set_play_position failed");
+      return TizenResult(ret, "player_set_play_position failed.");
     }
   } else {
     // Player is unprepared, do seek in prepared callback.
@@ -166,7 +166,7 @@ TizenResult AudioPlayer::SetUrl(const std::string &url) {
 
     int ret = player_set_uri(player_, url.c_str());
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_set_uri failed");
+      return TizenResult(ret, "player_set_uri failed.");
     }
 
     auto prepare_result = PreparePlayer();
@@ -192,7 +192,7 @@ TizenResult AudioPlayer::SetDataSource(std::vector<uint8_t> &data) {
     int ret = player_set_memory_buffer(player_, audio_data_.data(),
                                        audio_data_.size());
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_set_memory_buffer failed");
+      return TizenResult(ret, "player_set_memory_buffer failed.");
     }
 
     auto prepare_result = PreparePlayer();
@@ -215,7 +215,7 @@ TizenResult AudioPlayer::SetVolume(double volume) {
     if (state != PLAYER_STATE_NONE) {
       int ret = player_set_volume(player_, volume_, volume_);
       if (ret != PLAYER_ERROR_NONE) {
-        return TizenResult(ret, "player_set_volume failed");
+        return TizenResult(ret, "player_set_volume failed.");
       }
     }
   }
@@ -234,7 +234,7 @@ TizenResult AudioPlayer::SetPlaybackRate(double rate) {
         state == PLAYER_STATE_PAUSED) {
       int ret = player_set_playback_rate(player_, rate);
       if (ret != PLAYER_ERROR_NONE) {
-        return TizenResult(ret, "player_set_playback_rate failed");
+        return TizenResult(ret, "player_set_playback_rate failed.");
       }
     }
   }
@@ -253,7 +253,7 @@ TizenResult AudioPlayer::SetReleaseMode(ReleaseMode mode) {
       int ret =
           player_set_looping(player_, (release_mode_ == ReleaseMode::kLoop));
       if (ret != PLAYER_ERROR_NONE) {
-        return TizenResult(ret, "player_set_looping failed");
+        return TizenResult(ret, "player_set_looping failed.");
       }
     }
   }
@@ -263,15 +263,15 @@ TizenResult AudioPlayer::SetReleaseMode(ReleaseMode mode) {
 TizenResult AudioPlayer::GetDuration(int &out) {
   int ret = player_get_duration(player_, &out);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_get_duration failed");
+    return TizenResult(ret, "player_get_duration failed.");
   }
   return TizenResult();
 }
 
 TizenResult AudioPlayer::GetCurrentPosition(int &out) {
   int ret = player_get_play_position(player_, &out);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_get_play_position failed");
+    return TizenResult(ret, "player_get_play_position failed.");
   }
   return TizenResult();
 }
@@ -292,29 +292,29 @@ TizenResult AudioPlayer::CreatePlayer() {
 
   int ret = player_create(&player_);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_create failed");
+    return TizenResult(ret, "player_create failed.");
   }
 
   if (low_latency_) {
     ret = player_set_audio_latency_mode(player_, AUDIO_LATENCY_MODE_LOW);
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_set_audio_latency_mode failed");
+      return TizenResult(ret, "player_set_audio_latency_mode failed.");
     }
   }
 
   ret = player_set_completed_cb(player_, OnPlayCompleted, this);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_set_completed_cb failed");
+    return TizenResult(ret, "player_set_completed_cb failed.");
   }
 
   ret = player_set_interrupted_cb(player_, OnInterrupted, this);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_set_interrupted_cb failed");
+    return TizenResult(ret, "player_set_interrupted_cb failed.");
   }
 
   ret = player_set_error_cb(player_, OnError, this);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_set_error_cb failed");
+    return TizenResult(ret, "player_set_error_cb failed.");
   }
 
   return TizenResult();
@@ -323,17 +323,17 @@ TizenResult AudioPlayer::CreatePlayer() {
 TizenResult AudioPlayer::PreparePlayer() {
   int ret = player_set_volume(player_, volume_, volume_);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_set_volume failed");
+    return TizenResult(ret, "player_set_volume failed.");
   }
 
   ret = player_set_looping(player_, (release_mode_ == ReleaseMode::kLoop));
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_set_looping failed");
+    return TizenResult(ret, "player_set_looping failed.");
   }
 
   ret = player_prepare_async(player_, OnPrepared, this);
   if (ret != PLAYER_ERROR_NONE) {
-    return TizenResult(ret, "player_prepare_async failed");
+    return TizenResult(ret, "player_prepare_async failed.");
   }
 
   preparing_ = true;
@@ -366,7 +366,7 @@ TizenResult AudioPlayer::ResetPlayer() {
         // Cancel preparing if it's already preparing.
         int ret = player_unprepare(player_);
         if (ret != PLAYER_ERROR_NONE) {
-          return TizenResult(ret, "player_unprepare failed");
+          return TizenResult(ret, "player_unprepare failed.");
         }
         preparing_ = false;
       }
@@ -376,7 +376,7 @@ TizenResult AudioPlayer::ResetPlayer() {
     case PLAYER_STATE_PAUSED:
       int ret = player_unprepare(player_);
       if (ret != PLAYER_ERROR_NONE) {
-        return TizenResult(ret, "player_unprepare failed");
+        return TizenResult(ret, "player_unprepare failed.");
       }
       break;
   }
@@ -389,7 +389,7 @@ TizenResult AudioPlayer::GetPlayerState(player_state_e &out) {
   if (player_) {
     int ret = player_get_state(player_, &out);
     if (ret != PLAYER_ERROR_NONE) {
-      return TizenResult(ret, "player_get_state failed");
+      return TizenResult(ret, "player_get_state failed.");
     }
   }
   return TizenResult();
@@ -412,9 +412,7 @@ void AudioPlayer::OnPrepared(void *data) {
   if (player->should_play_) {
     int ret = player_start(player->player_);
     if (ret != PLAYER_ERROR_NONE) {
-      player->error_listener_(
-          player->GetPlayerId(),
-          TizenResult(ret, "player_start failed").Message());
+      player->error_listener_(player->GetPlayerId(), "player_start failed.");
       return;
     }
     player->EmitPositionUpdates();
@@ -427,9 +425,8 @@ void AudioPlayer::OnPrepared(void *data) {
                                        true, OnSeekCompleted, data);
     if (ret != PLAYER_ERROR_NONE) {
       player->seeking_ = false;
-      player->error_listener_(
-          player->GetPlayerId(),
-          TizenResult(ret, "player_set_play_position failed").Message());
+      player->error_listener_(player->GetPlayerId(),
+                              "player_set_play_position failed.");
       return;
     }
     player->should_seek_to_ = -1;
@@ -457,8 +454,7 @@ void AudioPlayer::OnInterrupted(player_interrupted_code_e code, void *data) {
 
 void AudioPlayer::OnError(int code, void *data) {
   auto *player = reinterpret_cast<AudioPlayer *>(data);
-  std::string error(get_error_message(code));
-  player->error_listener_(player->player_id_, "Player error: " + error);
+  player->error_listener_(player->player_id_, get_error_message(code));
 }
 
 void AudioPlayer::StartPositionUpdates(void *data) {

Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,12 @@ TizenResult AudioPlayer::Play() {`
`40`	`40`	`int ret = player_set_memory_buffer(player_, audio_data_.data(),`
`41`	`41`	`audio_data_.size());`
`42`	`42`	`if (ret != PLAYER_ERROR_NONE) {`
`43`		`- return TizenResult(ret, "player_set_memory_buffer failed");`
	`43`	`+ return TizenResult(ret, "player_set_memory_buffer failed.");`
`44`	`44`	`}`
`45`	`45`	`} else {`
`46`	`46`	`int ret = player_set_uri(player_, url_.c_str());`
`47`	`47`	`if (ret != PLAYER_ERROR_NONE) {`
`48`		`- return TizenResult(ret, "player_set_uri failed");`
	`48`	`+ return TizenResult(ret, "player_set_uri failed.");`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`should_play_ = true;`
`@@ -59,7 +59,7 @@ TizenResult AudioPlayer::Play() {`
`59`	`59`	`case PLAYER_STATE_PAUSED: {`
`60`	`60`	`int ret = player_start(player_);`
`61`	`61`	`if (ret != PLAYER_ERROR_NONE) {`
`62`		`- return TizenResult(ret, "player_start failed");`
	`62`	`+ return TizenResult(ret, "player_start failed.");`
`63`	`63`	`}`
`64`	`64`	`should_play_ = false;`
`65`	`65`	`EmitPositionUpdates();`
`@@ -83,7 +83,7 @@ TizenResult AudioPlayer::Pause() {`
`83`	`83`	`if (state == PLAYER_STATE_PLAYING) {`
`84`	`84`	`int ret = player_pause(player_);`
`85`	`85`	`if (ret != PLAYER_ERROR_NONE) {`
`86`		`- return TizenResult(ret, "player_pause failed");`
	`86`	`+ return TizenResult(ret, "player_pause failed.");`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`@@ -101,7 +101,7 @@ TizenResult AudioPlayer::Stop() {`
`101`	`101`	`if (state == PLAYER_STATE_PLAYING \|\| state == PLAYER_STATE_PAUSED) {`
`102`	`102`	`int ret = player_stop(player_);`
`103`	`103`	`if (ret != PLAYER_ERROR_NONE) {`
`104`		`- return TizenResult(ret, "player_stop failed");`
	`104`	`+ return TizenResult(ret, "player_stop failed.");`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`@@ -146,7 +146,7 @@ TizenResult AudioPlayer::Seek(int position) {`
`146`	`146`	`this);`
`147`	`147`	`if (ret != PLAYER_ERROR_NONE) {`
`148`	`148`	`seeking_ = false;`
`149`		`- return TizenResult(ret, "player_set_play_position failed");`
	`149`	`+ return TizenResult(ret, "player_set_play_position failed.");`
`150`	`150`	`}`
`151`	`151`	`} else {`
`152`	`152`	`// Player is unprepared, do seek in prepared callback.`
`@@ -166,7 +166,7 @@ TizenResult AudioPlayer::SetUrl(const std::string &url) {`
`166`	`166`
`167`	`167`	`int ret = player_set_uri(player_, url.c_str());`
`168`	`168`	`if (ret != PLAYER_ERROR_NONE) {`
`169`		`- return TizenResult(ret, "player_set_uri failed");`
	`169`	`+ return TizenResult(ret, "player_set_uri failed.");`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`auto prepare_result = PreparePlayer();`
`@@ -192,7 +192,7 @@ TizenResult AudioPlayer::SetDataSource(std::vector<uint8_t> &data) {`
`192`	`192`	`int ret = player_set_memory_buffer(player_, audio_data_.data(),`
`193`	`193`	`audio_data_.size());`
`194`	`194`	`if (ret != PLAYER_ERROR_NONE) {`
`195`		`- return TizenResult(ret, "player_set_memory_buffer failed");`
	`195`	`+ return TizenResult(ret, "player_set_memory_buffer failed.");`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`auto prepare_result = PreparePlayer();`
`@@ -215,7 +215,7 @@ TizenResult AudioPlayer::SetVolume(double volume) {`
`215`	`215`	`if (state != PLAYER_STATE_NONE) {`
`216`	`216`	`int ret = player_set_volume(player_, volume_, volume_);`
`217`	`217`	`if (ret != PLAYER_ERROR_NONE) {`
`218`		`- return TizenResult(ret, "player_set_volume failed");`
	`218`	`+ return TizenResult(ret, "player_set_volume failed.");`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`	`}`
`@@ -234,7 +234,7 @@ TizenResult AudioPlayer::SetPlaybackRate(double rate) {`
`234`	`234`	`state == PLAYER_STATE_PAUSED) {`
`235`	`235`	`int ret = player_set_playback_rate(player_, rate);`
`236`	`236`	`if (ret != PLAYER_ERROR_NONE) {`
`237`		`- return TizenResult(ret, "player_set_playback_rate failed");`
	`237`	`+ return TizenResult(ret, "player_set_playback_rate failed.");`
`238`	`238`	`}`
`239`	`239`	`}`
`240`	`240`	`}`
`@@ -253,7 +253,7 @@ TizenResult AudioPlayer::SetReleaseMode(ReleaseMode mode) {`
`253`	`253`	`int ret =`
`254`	`254`	`player_set_looping(player_, (release_mode_ == ReleaseMode::kLoop));`
`255`	`255`	`if (ret != PLAYER_ERROR_NONE) {`
`256`		`- return TizenResult(ret, "player_set_looping failed");`
	`256`	`+ return TizenResult(ret, "player_set_looping failed.");`
`257`	`257`	`}`
`258`	`258`	`}`
`259`	`259`	`}`
`@@ -263,15 +263,15 @@ TizenResult AudioPlayer::SetReleaseMode(ReleaseMode mode) {`
`263`	`263`	`TizenResult AudioPlayer::GetDuration(int &out) {`
`264`	`264`	`int ret = player_get_duration(player_, &out);`
`265`	`265`	`if (ret != PLAYER_ERROR_NONE) {`
`266`		`- return TizenResult(ret, "player_get_duration failed");`
	`266`	`+ return TizenResult(ret, "player_get_duration failed.");`
`267`	`267`	`}`
`268`	`268`	`return TizenResult();`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`TizenResult AudioPlayer::GetCurrentPosition(int &out) {`
`272`	`272`	`int ret = player_get_play_position(player_, &out);`
`273`	`273`	`if (ret != PLAYER_ERROR_NONE) {`
`274`		`- return TizenResult(ret, "player_get_play_position failed");`
	`274`	`+ return TizenResult(ret, "player_get_play_position failed.");`
`275`	`275`	`}`
`276`	`276`	`return TizenResult();`
`277`	`277`	`}`
`@@ -292,29 +292,29 @@ TizenResult AudioPlayer::CreatePlayer() {`
`292`	`292`
`293`	`293`	`int ret = player_create(&player_);`
`294`	`294`	`if (ret != PLAYER_ERROR_NONE) {`
`295`		`- return TizenResult(ret, "player_create failed");`
	`295`	`+ return TizenResult(ret, "player_create failed.");`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`if (low_latency_) {`
`299`	`299`	`ret = player_set_audio_latency_mode(player_, AUDIO_LATENCY_MODE_LOW);`
`300`	`300`	`if (ret != PLAYER_ERROR_NONE) {`
`301`		`- return TizenResult(ret, "player_set_audio_latency_mode failed");`
	`301`	`+ return TizenResult(ret, "player_set_audio_latency_mode failed.");`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`ret = player_set_completed_cb(player_, OnPlayCompleted, this);`
`306`	`306`	`if (ret != PLAYER_ERROR_NONE) {`
`307`		`- return TizenResult(ret, "player_set_completed_cb failed");`
	`307`	`+ return TizenResult(ret, "player_set_completed_cb failed.");`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`ret = player_set_interrupted_cb(player_, OnInterrupted, this);`
`311`	`311`	`if (ret != PLAYER_ERROR_NONE) {`
`312`		`- return TizenResult(ret, "player_set_interrupted_cb failed");`
	`312`	`+ return TizenResult(ret, "player_set_interrupted_cb failed.");`
`313`	`313`	`}`
`314`	`314`
`315`	`315`	`ret = player_set_error_cb(player_, OnError, this);`
`316`	`316`	`if (ret != PLAYER_ERROR_NONE) {`
`317`		`- return TizenResult(ret, "player_set_error_cb failed");`
	`317`	`+ return TizenResult(ret, "player_set_error_cb failed.");`
`318`	`318`	`}`
`319`	`319`
`320`	`320`	`return TizenResult();`
`@@ -323,17 +323,17 @@ TizenResult AudioPlayer::CreatePlayer() {`
`323`	`323`	`TizenResult AudioPlayer::PreparePlayer() {`
`324`	`324`	`int ret = player_set_volume(player_, volume_, volume_);`
`325`	`325`	`if (ret != PLAYER_ERROR_NONE) {`
`326`		`- return TizenResult(ret, "player_set_volume failed");`
	`326`	`+ return TizenResult(ret, "player_set_volume failed.");`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`ret = player_set_looping(player_, (release_mode_ == ReleaseMode::kLoop));`
`330`	`330`	`if (ret != PLAYER_ERROR_NONE) {`
`331`		`- return TizenResult(ret, "player_set_looping failed");`
	`331`	`+ return TizenResult(ret, "player_set_looping failed.");`
`332`	`332`	`}`
`333`	`333`
`334`	`334`	`ret = player_prepare_async(player_, OnPrepared, this);`
`335`	`335`	`if (ret != PLAYER_ERROR_NONE) {`
`336`		`- return TizenResult(ret, "player_prepare_async failed");`
	`336`	`+ return TizenResult(ret, "player_prepare_async failed.");`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`preparing_ = true;`
`@@ -366,7 +366,7 @@ TizenResult AudioPlayer::ResetPlayer() {`
`366`	`366`	`// Cancel preparing if it's already preparing.`
`367`	`367`	`int ret = player_unprepare(player_);`
`368`	`368`	`if (ret != PLAYER_ERROR_NONE) {`
`369`		`- return TizenResult(ret, "player_unprepare failed");`
	`369`	`+ return TizenResult(ret, "player_unprepare failed.");`
`370`	`370`	`}`
`371`	`371`	`preparing_ = false;`
`372`	`372`	`}`
`@@ -376,7 +376,7 @@ TizenResult AudioPlayer::ResetPlayer() {`
`376`	`376`	`case PLAYER_STATE_PAUSED:`
`377`	`377`	`int ret = player_unprepare(player_);`
`378`	`378`	`if (ret != PLAYER_ERROR_NONE) {`
`379`		`- return TizenResult(ret, "player_unprepare failed");`
	`379`	`+ return TizenResult(ret, "player_unprepare failed.");`
`380`	`380`	`}`
`381`	`381`	`break;`
`382`	`382`	`}`
`@@ -389,7 +389,7 @@ TizenResult AudioPlayer::GetPlayerState(player_state_e &out) {`
`389`	`389`	`if (player_) {`
`390`	`390`	`int ret = player_get_state(player_, &out);`
`391`	`391`	`if (ret != PLAYER_ERROR_NONE) {`
`392`		`- return TizenResult(ret, "player_get_state failed");`
	`392`	`+ return TizenResult(ret, "player_get_state failed.");`
`393`	`393`	`}`
`394`	`394`	`}`
`395`	`395`	`return TizenResult();`
`@@ -412,9 +412,7 @@ void AudioPlayer::OnPrepared(void *data) {`
`412`	`412`	`if (player->should_play_) {`
`413`	`413`	`int ret = player_start(player->player_);`
`414`	`414`	`if (ret != PLAYER_ERROR_NONE) {`
`415`		`- player->error_listener_(`
`416`		`- player->GetPlayerId(),`
`417`		`- TizenResult(ret, "player_start failed").Message());`
	`415`	`+ player->error_listener_(player->GetPlayerId(), "player_start failed.");`
`418`	`416`	`return;`
`419`	`417`	`}`
`420`	`418`	`player->EmitPositionUpdates();`
`@@ -427,9 +425,8 @@ void AudioPlayer::OnPrepared(void *data) {`
`427`	`425`	`true, OnSeekCompleted, data);`
`428`	`426`	`if (ret != PLAYER_ERROR_NONE) {`
`429`	`427`	`player->seeking_ = false;`
`430`		`- player->error_listener_(`
`431`		`- player->GetPlayerId(),`
`432`		`- TizenResult(ret, "player_set_play_position failed").Message());`
	`428`	`+ player->error_listener_(player->GetPlayerId(),`
	`429`	`+ "player_set_play_position failed.");`
`433`	`430`	`return;`
`434`	`431`	`}`
`435`	`432`	`player->should_seek_to_ = -1;`
`@@ -457,8 +454,7 @@ void AudioPlayer::OnInterrupted(player_interrupted_code_e code, void *data) {`
`457`	`454`
`458`	`455`	`void AudioPlayer::OnError(int code, void *data) {`
`459`	`456`	`auto player = reinterpret_cast<AudioPlayer >(data);`
`460`		`- std::string error(get_error_message(code));`
`461`		`- player->error_listener_(player->player_id_, "Player error: " + error);`
	`457`	`+ player->error_listener_(player->player_id_, get_error_message(code));`
`462`	`458`	`}`
`463`	`459`
`464`	`460`	`void AudioPlayer::StartPositionUpdates(void *data) {`