diff --git a/android/src/main/cpp/AudioConstants.h b/android/src/main/cpp/AudioConstants.h
index d05d43c..4919684 100644
--- a/android/src/main/cpp/AudioConstants.h
+++ b/android/src/main/cpp/AudioConstants.h
@@ -6,11 +6,33 @@
 #define AUDIOPLAYBACK_AUDIOCONSTANTS_H
 
 #include <cstdint>
+#include <optional>
+#include <string>
 
 struct AudioProperties {
     int32_t channelCount;
     int32_t sampleRate;
 };
 
+struct SetupAudioStreamResult {
+    std::optional<std::string> error;
+};
+
+struct OpenAudioStreamResult {
+    std::optional<std::string> error;
+};
+
+struct CloseAudioStreamResult {
+    std::optional<std::string> error;
+};
+
+struct LoadSoundResult {
+    std::optional<std::string> id;
+    std::optional<std::string> error;
+};
+
+struct UnloadSoundResult {
+    std::optional<std::string> error;
+};
 
 #endif //AUDIOPLAYBACK_AUDIOCONSTANTS_H
diff --git a/android/src/main/cpp/AudioEngine.cpp b/android/src/main/cpp/AudioEngine.cpp
index c980784..a0b258a 100644
--- a/android/src/main/cpp/AudioEngine.cpp
+++ b/android/src/main/cpp/AudioEngine.cpp
@@ -8,10 +8,9 @@
 
 #include "audio/AAssetDataSource.h"
 
-void AudioEngine::setupAudioStream(double sampleRate, double channelCount) {
+SetupAudioStreamResult AudioEngine::setupAudioStream(double sampleRate, double channelCount) {
     if(mAudioStream) {
-        LOGD("Setting up an audio stream while one is already available");
-        return;
+        return { .error =  "Setting up an audio stream while one is already available"};
     }
 
     mDesiredSampleRate = static_cast<int32_t>(sampleRate);
@@ -32,49 +31,50 @@ void AudioEngine::setupAudioStream(double sampleRate, double channelCount) {
     oboe::Result result = builder.openStream(mAudioStream);
 
     if( result != oboe::Result::OK) {
-        LOGE("Failed to open stream. Error: %s", convertToText(result));
+        auto error = "Failed to open stream:" + std::string (convertToText(result));
+        return { .error = error};
     } else {
-        LOGE("Opened stream successfully");
+        return {.error = std::nullopt};
     }
-
 }
 
 
-void AudioEngine::openAudioStream() {
+OpenAudioStreamResult AudioEngine::openAudioStream() {
     if(!mAudioStream) {
-        LOGD("There is no audio stream to start");
-        return;
+        return {.error = "There is no audio stream to start" };
     }
     auto streamState = mAudioStream->getState();
 
     if(streamState == oboe::StreamState::Starting || streamState == oboe::StreamState::Started) {
-        LOGD("Audio stream was requested to start but it is already started");
-        return;
+        return {.error = "Audio stream was requested to start but it is already started"};
     }
 
     oboe::Result result = mAudioStream->requestStart();
     if(result != oboe::Result::OK) {
-        LOGE("Failed to start stream, Error: %s", oboe::convertToText(result));
+       auto error = "Failed to start stream, Error: %s" + std::string(oboe::convertToText(result));
+       return {.error = error};
+    } else {
+        return {.error = std::nullopt};
     }
 }
 
-void AudioEngine::closeAudioStream() {
+CloseAudioStreamResult AudioEngine::closeAudioStream() {
     if(!mAudioStream) {
-        LOGD("There is no audio stream to close");
-        return;
+        return { .error = "There is no audio stream to close" };
     }
     auto streamState = mAudioStream->getState();
 
     if(streamState == oboe::StreamState::Closing || streamState == oboe::StreamState::Closed) {
-        LOGD("Audio stream was requested to close but it is already closed");
-        return;
+        return { .error = "Audio stream was requested to close but it is already closed" };
     }
 
     oboe::Result result = mAudioStream->close();
     if(result != oboe::Result::OK) {
-        LOGE("Failed to start stream, Error: %s", oboe::convertToText(result));
+        auto error ="Failed to close stream: %s" + std::string(oboe::convertToText(result));
+        return {.error = error};
     }
     mAudioStream = nullptr;
+    return {.error = std::nullopt};
 }
 
 oboe::DataCallbackResult
@@ -115,7 +115,7 @@ void AudioEngine::seekSoundsTo(const std::vector<std::pair<std::string, double>>
     }
 }
 
-std::optional<std::string> AudioEngine::loadSound(int fd, int offset, int length) {
+LoadSoundResult AudioEngine::loadSound(int fd, int offset, int length) {
     auto playersSize = mPlayers.size();
 
     LOGD("Loading audio with already %d sounds loaded", playersSize);
@@ -125,30 +125,28 @@ std::optional<std::string> AudioEngine::loadSound(int fd, int offset, int length
             .sampleRate = mDesiredSampleRate
     };
 
-    std::shared_ptr<AAssetDataSource> mClapSource {
-            AAssetDataSource::newFromCompressedAsset(fd, offset, length, targetProperties)
-    };
 
-    if(mClapSource == nullptr) {
-        LOGE("Could not load source data for clap sound");
-        return std::nullopt;
+    auto compressedAssetResult = AAssetDataSource::newFromCompressedAsset(fd, offset, length, targetProperties);
+
+    if(compressedAssetResult.error) {
+        return {.id = std::nullopt, .error = compressedAssetResult.error};
+    } else if(compressedAssetResult.dataSource == nullptr) {
+        return {.id = std::nullopt, .error = "An unknown error occurred while loading the audio file. Please create an issue with a reproducible"};
     }
 
     std::string id = uuid::generate_uuid_v4();
-    mPlayers[id] = std::make_unique<Player>(std::move(mClapSource));
-    return id;
+    mPlayers[id] = std::make_unique<Player>(compressedAssetResult.dataSource);
+    return {.id = id, .error = std::nullopt};
 }
 
-void AudioEngine::unloadSound(const std::string &playerId) {
-    auto playersSize = mPlayers.size();
-
-    LOGD("Unloading audio with already %d sounds loaded", playersSize);
-
+UnloadSoundResult AudioEngine::unloadSound(const std::string &playerId) {
     auto it = mPlayers.find(playerId);
     if(it != mPlayers.end()) {
         mPlayers.erase(it);
     } else {
-        LOGE("Player with identifier: %s not found", playerId.c_str());
+        return {.error = "Audio file could not be unloaded because it is not found"};
     }
+
+    return {.error = std::nullopt};
 }
 
diff --git a/android/src/main/cpp/AudioEngine.h b/android/src/main/cpp/AudioEngine.h
index 7ed8307..0c07b37 100644
--- a/android/src/main/cpp/AudioEngine.h
+++ b/android/src/main/cpp/AudioEngine.h
@@ -11,18 +11,19 @@
 
 #include <oboe/Oboe.h>
 #include "audio/Player.h"
+#include "AudioConstants.h"
 #include <android/asset_manager.h>
 
 class AudioEngine : public oboe::AudioStreamDataCallback{
 public:
-    void setupAudioStream(double sampleRate, double channelCount);
-    void openAudioStream();
-    void closeAudioStream();
-    std::optional<std::string> loadSound(int fd, int offset, int length);
-    void unloadSound(const std::string &playerId);
+    SetupAudioStreamResult setupAudioStream(double sampleRate, double channelCount);
+    OpenAudioStreamResult openAudioStream();
+    CloseAudioStreamResult closeAudioStream();
     void playSounds(const std::vector<std::pair<std::string, bool>>&);
     void loopSounds(const std::vector<std::pair<std::string, bool>>&);
     void seekSoundsTo(const std::vector<std::pair<std::string, double>>&);
+    LoadSoundResult loadSound(int fd, int offset, int length);
+    UnloadSoundResult unloadSound(const std::string &playerId);
 
     oboe::DataCallbackResult onAudioReady(oboe::AudioStream *oboeStream, void *audioData, int32_t numFrames) override;
 
diff --git a/android/src/main/cpp/audio/AAssetDataSource.cpp b/android/src/main/cpp/audio/AAssetDataSource.cpp
index cfecdf7..2ea0daf 100644
--- a/android/src/main/cpp/audio/AAssetDataSource.cpp
+++ b/android/src/main/cpp/audio/AAssetDataSource.cpp
@@ -24,7 +24,7 @@
 
 constexpr int kMaxCompressionRatio { 12 };
 
-AAssetDataSource *
+NewFromCompressedAssetResult
 AAssetDataSource::newFromCompressedAsset(int fd, int offset,
                                          int length, AudioProperties targetProperties) {
 
@@ -35,9 +35,12 @@ AAssetDataSource::newFromCompressedAsset(int fd, int offset,
     const long maximumDataSizeInBytes = kMaxCompressionRatio * length * sizeof(int16_t);
     auto decodedData = new uint8_t[maximumDataSizeInBytes];
 
-    int64_t bytesDecoded = NDKExtractor::decodeFileDescriptor(fd, offset, length, decodedData, targetProperties);
-    auto numSamples = bytesDecoded / sizeof(int16_t);
-    LOGE("Number of samples: %lld", numSamples);
+    auto decodeResult = NDKExtractor::decodeFileDescriptor(fd, offset, length, decodedData, targetProperties);
+    if(decodeResult.error) {
+        return {.dataSource = nullptr, .error = decodeResult.error };
+    }
+
+    auto numSamples = decodeResult.bytesRead / sizeof(int16_t);
 
     // Now we know the exact number of samples we can create a float array to hold the audio data
     auto outputBuffer = std::make_unique<float[]>(numSamples);
@@ -46,13 +49,14 @@ AAssetDataSource::newFromCompressedAsset(int fd, int offset,
     oboe::convertPcm16ToFloat(
             reinterpret_cast<int16_t*>(decodedData),
             outputBuffer.get(),
-            bytesDecoded / sizeof(int16_t));
+            decodeResult.bytesRead / sizeof(int16_t));
 
     delete[] decodedData;
-    // TODO: handle closing asset
-//    AAsset_close(asset);
 
-    return new AAssetDataSource(std::move(outputBuffer),
-                                numSamples,
-                                targetProperties);
+    return {
+            .dataSource = new AAssetDataSource(std::move(outputBuffer),
+                                               numSamples,
+                                               targetProperties),
+            .error = std::nullopt
+    };
 }
diff --git a/android/src/main/cpp/audio/AAssetDataSource.h b/android/src/main/cpp/audio/AAssetDataSource.h
index e08e861..547c0a7 100644
--- a/android/src/main/cpp/audio/AAssetDataSource.h
+++ b/android/src/main/cpp/audio/AAssetDataSource.h
@@ -17,18 +17,26 @@
 #ifndef AUDIOPLAYBACK_AASSETDATASOURCE_H
 #define AUDIOPLAYBACK_AASSETDATASOURCE_H
 
+#include <optional>
 #include <android/asset_manager.h>
 #include <AudioConstants.h>
 #include "DataSource.h"
 
+class AAssetDataSource;
+
+struct NewFromCompressedAssetResult {
+    AAssetDataSource *dataSource;
+    std::optional<std::string> error;
+};
+
 class AAssetDataSource : public DataSource {
 
 public:
-    int64_t getSize() const override { return mBufferSize; }
-    AudioProperties getProperties() const override { return mProperties; }
-    const float* getData() const override { return mBuffer.get(); }
+    [[nodiscard]] int64_t getSize() const override { return mBufferSize; }
+    [[nodiscard]] AudioProperties getProperties() const override { return mProperties; }
+    [[nodiscard]] const float* getData() const override { return mBuffer.get(); }
 
-    static AAssetDataSource* newFromCompressedAsset(
+    static NewFromCompressedAssetResult newFromCompressedAsset(
             int fd, int offset, int length,
             AudioProperties targetProperties);
 
diff --git a/android/src/main/cpp/audio/NDKExtractor.cpp b/android/src/main/cpp/audio/NDKExtractor.cpp
index d7d3c17..2f55668 100644
--- a/android/src/main/cpp/audio/NDKExtractor.cpp
+++ b/android/src/main/cpp/audio/NDKExtractor.cpp
@@ -17,6 +17,8 @@
 #include <sys/types.h>
 
 #include <cstring>
+#include <sstream>
+#include <format>
 
 #include <media/NdkMediaExtractor.h>
 #include <utils/logging.h>
@@ -24,182 +26,7 @@
 
 #include "NDKExtractor.h"
 
-int32_t NDKExtractor::decode(AAsset *asset, uint8_t *targetData, AudioProperties targetProperties) {
-
-    LOGD("Using NDK decoder");
-
-    // open asset as file descriptor
-    off_t start, length;
-    int fd = AAsset_openFileDescriptor(asset, &start, &length);
-
-    // Extract the audio frames
-    AMediaExtractor *extractor = AMediaExtractor_new();
-    media_status_t amresult = AMediaExtractor_setDataSourceFd(extractor, fd,
-                                                              static_cast<off64_t>(start),
-                                                              static_cast<off64_t>(length));
-    if (amresult != AMEDIA_OK){
-        LOGE("Error setting extractor data source, err %d", amresult);
-        return 0;
-    }
-
-    // Specify our desired output format by creating it from our source
-    AMediaFormat *format = AMediaExtractor_getTrackFormat(extractor, 0);
-
-    int32_t sampleRate;
-    if (AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &sampleRate)){
-        LOGD("Source sample rate %d", sampleRate);
-        if (sampleRate != targetProperties.sampleRate){
-            LOGE("Input (%d) and output (%d) sample rates do not match. "
-                 "NDK decoder does not support resampling.",
-                 sampleRate,
-                 targetProperties.sampleRate);
-            return 0;
-        }
-    } else {
-        LOGE("Failed to get sample rate");
-        return 0;
-    };
-
-    int32_t channelCount;
-    if (AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &channelCount)){
-        LOGD("Got channel count %d", channelCount);
-        if (channelCount != targetProperties.channelCount){
-            LOGE("NDK decoder does not support different "
-                 "input (%d) and output (%d) channel counts",
-                 channelCount,
-                 targetProperties.channelCount);
-        }
-    } else {
-        LOGE("Failed to get channel count");
-        return 0;
-    }
-
-    const char *formatStr = AMediaFormat_toString(format);
-    LOGD("Output format %s", formatStr);
-
-    const char *mimeType;
-    if (AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mimeType)) {
-        LOGD("Got mime type %s", mimeType);
-    } else {
-        LOGE("Failed to get mime type");
-        return 0;
-    }
-
-    // Obtain the correct decoder
-    AMediaCodec *codec = nullptr;
-    AMediaExtractor_selectTrack(extractor, 0);
-    codec = AMediaCodec_createDecoderByType(mimeType);
-    AMediaCodec_configure(codec, format, nullptr, nullptr, 0);
-    AMediaCodec_start(codec);
-
-    // DECODE
-
-    bool isExtracting = true;
-    bool isDecoding = true;
-    int32_t bytesWritten = 0;
-
-    while(isExtracting || isDecoding){
-
-        if (isExtracting){
-
-            // Obtain the index of the next available input buffer
-            ssize_t inputIndex = AMediaCodec_dequeueInputBuffer(codec, 2000);
-            //LOGV("Got input buffer %d", inputIndex);
-
-            // The input index acts as a status if its negative
-            if (inputIndex < 0){
-                if (inputIndex == AMEDIACODEC_INFO_TRY_AGAIN_LATER){
-                    // LOGV("Codec.dequeueInputBuffer try again later");
-                } else {
-                    LOGE("Codec.dequeueInputBuffer unknown error status");
-                }
-            } else {
-
-                // Obtain the actual buffer and read the encoded data into it
-                size_t inputSize;
-                uint8_t *inputBuffer = AMediaCodec_getInputBuffer(codec, inputIndex, &inputSize);
-                //LOGV("Sample size is: %d", inputSize);
-
-                ssize_t sampleSize = AMediaExtractor_readSampleData(extractor, inputBuffer, inputSize);
-                auto presentationTimeUs = AMediaExtractor_getSampleTime(extractor);
-
-                if (sampleSize > 0){
-
-                    // Enqueue the encoded data
-                    AMediaCodec_queueInputBuffer(codec, inputIndex, 0, sampleSize,
-                                                 presentationTimeUs,
-                                                 0);
-                    AMediaExtractor_advance(extractor);
-
-                } else {
-                    LOGD("End of extractor data stream");
-                    isExtracting = false;
-
-                    // We need to tell the codec that we've reached the end of the stream
-                    AMediaCodec_queueInputBuffer(codec, inputIndex, 0, 0,
-                                                 presentationTimeUs,
-                                                 AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM);
-                }
-            }
-        }
-
-        if (isDecoding){
-            // Dequeue the decoded data
-            AMediaCodecBufferInfo info;
-            ssize_t outputIndex = AMediaCodec_dequeueOutputBuffer(codec, &info, 0);
-
-            if (outputIndex >= 0){
-
-                // Check whether this is set earlier
-                if (info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM){
-                    LOGD("Reached end of decoding stream");
-                    isDecoding = false;
-                }
-
-                // Valid index, acquire buffer
-                size_t outputSize;
-                uint8_t *outputBuffer = AMediaCodec_getOutputBuffer(codec, outputIndex, &outputSize);
-
-                /*LOGV("Got output buffer index %d, buffer size: %d, info size: %d writing to pcm index %d",
-                     outputIndex,
-                     outputSize,
-                     info.size,
-                     m_writeIndex);*/
-
-                // copy the data out of the buffer
-                memcpy(targetData + bytesWritten, outputBuffer, info.size);
-                bytesWritten+=info.size;
-                AMediaCodec_releaseOutputBuffer(codec, outputIndex, false);
-            } else {
-
-                // The outputIndex doubles as a status return if its value is < 0
-                switch(outputIndex){
-                    case AMEDIACODEC_INFO_TRY_AGAIN_LATER:
-                        LOGD("dequeueOutputBuffer: try again later");
-                        break;
-                    case AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED:
-                        LOGD("dequeueOutputBuffer: output buffers changed");
-                        break;
-                    case AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED:
-                        LOGD("dequeueOutputBuffer: output outputFormat changed");
-                        format = AMediaCodec_getOutputFormat(codec);
-                        LOGD("outputFormat changed to: %s", AMediaFormat_toString(format));
-                        break;
-                }
-            }
-        }
-    }
-
-    // Clean up
-    AMediaFormat_delete(format);
-    AMediaCodec_delete(codec);
-    AMediaExtractor_delete(extractor);
-
-    return bytesWritten;
-}
-
-int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8_t* targetData, AudioProperties targetProperties) {
-
+DecodeFileDescriptorResult NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8_t* targetData, AudioProperties targetProperties) {
     LOGD("Using NDK decoder");
 
     // Extract the audio frames
@@ -209,7 +36,7 @@ int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8
                                                               static_cast<off64_t>(length));
     if (amresult != AMEDIA_OK){
         LOGE("Error setting extractor data source, err %d", amresult);
-        return 0;
+        return {.bytesRead = 0, .error = "Decoding sound file failed"};
     }
 
     // Specify our desired output format by creating it from our source
@@ -217,42 +44,44 @@ int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8
 
     int32_t sampleRate;
     if (AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &sampleRate)){
-        LOGD("Source sample rate %d", sampleRate);
+        LOGD("File sample rate: %d", sampleRate);
         if (sampleRate != targetProperties.sampleRate){
-            LOGE("Input (%d) and output (%d) sample rates do not match. "
-                 "NDK decoder does not support resampling.",
-                 sampleRate,
-                 targetProperties.sampleRate);
-            return 0;
+            std::stringstream error;
+            error
+                << "Resampling audio files is not supported."
+                << "The sample rate of the audio file, "
+                << sampleRate
+                << ", doesn't match the sample rate of the stream, "
+                << targetProperties.sampleRate << ".";
+
+            return {.bytesRead = 0, .error = error.str()};
         }
     } else {
-        LOGE("Failed to get sample rate");
-        return 0;
+        return {.bytesRead = 0, .error = "Failed to load sound file: could not determine sample rate"};
     };
 
     int32_t channelCount;
     if (AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &channelCount)){
-        LOGD("Got channel count %d", channelCount);
+        LOGD("File channel count: %d", channelCount);
         if (channelCount != targetProperties.channelCount){
-            LOGE("NDK decoder does not support different "
-                 "input (%d) and output (%d) channel counts",
-                 channelCount,
-                 targetProperties.channelCount);
+            std::stringstream error;
+            error
+                    << "The channel count of the audio file, "
+                    << channelCount
+                    << ", doesn't match the channel count of the stream, "
+                    << targetProperties.channelCount << ".";
+
+            return {.bytesRead = 0, .error = error.str()};
         }
     } else {
-        LOGE("Failed to get channel count");
-        return 0;
+        return {.bytesRead = 0, .error = "Failed to load sound file: could not determine channel count"};
     }
 
-    const char *formatStr = AMediaFormat_toString(format);
-    LOGD("Output format %s", formatStr);
-
     const char *mimeType;
     if (AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mimeType)) {
-        LOGD("Got mime type %s", mimeType);
+        LOGD("File mime type: %s", mimeType);
     } else {
-        LOGE("Failed to get mime type");
-        return 0;
+        return {.bytesRead = 0, .error = "Failed to load sound file: could not determine mimeType"};
     }
 
     // Obtain the correct decoder
@@ -288,7 +117,6 @@ int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8
                 // Obtain the actual buffer and read the encoded data into it
                 size_t inputSize;
                 uint8_t *inputBuffer = AMediaCodec_getInputBuffer(codec, inputIndex, &inputSize);
-                //LOGV("Sample size is: %d", inputSize);
 
                 ssize_t sampleSize = AMediaExtractor_readSampleData(extractor, inputBuffer, inputSize);
                 auto presentationTimeUs = AMediaExtractor_getSampleTime(extractor);
@@ -330,12 +158,6 @@ int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8
                 size_t outputSize;
                 uint8_t *outputBuffer = AMediaCodec_getOutputBuffer(codec, outputIndex, &outputSize);
 
-                /*LOGV("Got output buffer index %d, buffer size: %d, info size: %d writing to pcm index %d",
-                     outputIndex,
-                     outputSize,
-                     info.size,
-                     m_writeIndex);*/
-
                 // copy the data out of the buffer
                 memcpy(targetData + bytesWritten, outputBuffer, info.size);
                 bytesWritten+=info.size;
@@ -365,6 +187,6 @@ int32_t NDKExtractor::decodeFileDescriptor(int fd, int offset, int length, uint8
     AMediaCodec_delete(codec);
     AMediaExtractor_delete(extractor);
 
-    return bytesWritten;
+    return {.bytesRead = bytesWritten, .error = std::nullopt};
 }
 
diff --git a/android/src/main/cpp/audio/NDKExtractor.h b/android/src/main/cpp/audio/NDKExtractor.h
index 3cbe495..c634177 100644
--- a/android/src/main/cpp/audio/NDKExtractor.h
+++ b/android/src/main/cpp/audio/NDKExtractor.h
@@ -23,14 +23,15 @@
 #include <AudioConstants.h>
 #include "utils/logging.h"
 
+struct DecodeFileDescriptorResult {
+    int32_t bytesRead;
+    std::optional<std::string> error;
+};
 
-class NDKExtractor {
 
+class NDKExtractor {
 public:
-    static int32_t decode(AAsset *asset, uint8_t *targetData, AudioProperties targetProperties);
-
-    static int32_t decodeFileDescriptor(int fd, int offset, int length, uint8_t *targetData,
-                                        AudioProperties targetProperties);
+    static DecodeFileDescriptorResult decodeFileDescriptor(int fd, int offset, int length, uint8_t *targetData, AudioProperties targetProperties);
 };
 
 #endif //AUDIOPLAYBACK_NDKMEDIAEXTRACTOR_H
diff --git a/android/src/main/cpp/audio/Player.h b/android/src/main/cpp/audio/Player.h
index f0965a9..82b15ed 100644
--- a/android/src/main/cpp/audio/Player.h
+++ b/android/src/main/cpp/audio/Player.h
@@ -41,8 +41,8 @@ class Player : public IRenderableAudio{
      *
      * @param source
      */
-    explicit Player(std::shared_ptr<DataSource> source)
-        : mSource(std::move(source))
+    explicit Player(DataSource *source)
+        : mSource(source)
     {};
 
     void renderAudio(float *targetData, int32_t numFrames) override;
@@ -54,7 +54,7 @@ class Player : public IRenderableAudio{
     int32_t mReadFrameIndex = 0;
     std::atomic<bool> mIsPlaying { false };
     std::atomic<bool> mIsLooping { false };
-    std::shared_ptr<DataSource> mSource;
+    std::unique_ptr<DataSource> mSource;
 };
 
 #endif //AUDIOPLAYBACK_PLAYER_H
diff --git a/android/src/main/cpp/native-lib.cpp b/android/src/main/cpp/native-lib.cpp
index f237813..a67af54 100644
--- a/android/src/main/cpp/native-lib.cpp
+++ b/android/src/main/cpp/native-lib.cpp
@@ -67,30 +67,79 @@ std::string jstringToStdString(JNIEnv* env, jstring jStr) {
 }
 
 extern "C" {
-JNIEXPORT void JNICALL
+JNIEXPORT jobject JNICALL
 Java_com_audioplayback_AudioPlaybackModule_setupAudioStreamNative(JNIEnv *env, jobject thiz, jdouble sample_rate, jdouble channel_count) {
-    audioEngine->setupAudioStream(sample_rate, channel_count);
+    auto result = audioEngine->setupAudioStream(sample_rate, channel_count);
+
+    jclass structClass = env->FindClass("com/audioplayback/models/SetupAudioStreamResult");
+    jmethodID constructor = env->GetMethodID(structClass, "<init>", "(Ljava/lang/String;)V");
+
+    jstring jError = result.error.has_value() ? env->NewStringUTF(result.error->c_str()): nullptr;
+    jobject returnValue = env->NewObject(structClass, constructor, jError);
+
+    if(jError) {
+        env->DeleteLocalRef(jError);
+    }
+
+    return returnValue;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT jobject JNICALL
 Java_com_audioplayback_AudioPlaybackModule_openAudioStreamNative(JNIEnv *env, jobject thiz) {
-    audioEngine->openAudioStream();
+    auto result = audioEngine->openAudioStream();
+
+    jclass structClass = env->FindClass("com/audioplayback/models/OpenAudioStreamResult");
+    jmethodID constructor = env->GetMethodID(structClass, "<init>", "(Ljava/lang/String;)V");
+
+    jstring jError = result.error.has_value() ? env->NewStringUTF(result.error->c_str()): nullptr;
+    jobject returnValue = env->NewObject(structClass, constructor, jError);
+
+    if(jError) {
+        env->DeleteLocalRef(jError);
+    }
+
+    return returnValue;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT jobject JNICALL
 Java_com_audioplayback_AudioPlaybackModule_closeAudioStreamNative(JNIEnv *env, jobject thiz) {
-    audioEngine->closeAudioStream();
+    auto result = audioEngine->closeAudioStream();
+
+    jclass structClass = env->FindClass("com/audioplayback/models/CloseAudioStreamResult");
+    jmethodID constructor = env->GetMethodID(structClass, "<init>", "(Ljava/lang/String;)V");
+
+    jstring jError = result.error.has_value() ? env->NewStringUTF(result.error->c_str()): nullptr;
+    jobject returnValue = env->NewObject(structClass, constructor, jError);
+
+    if(jError) {
+        env->DeleteLocalRef(jError);
+    }
+
+    return returnValue;
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT jobject JNICALL
 Java_com_audioplayback_AudioPlaybackModule_unloadSoundNative(JNIEnv *env, jobject instance, jstring playerId) {
-    audioEngine->unloadSound(jstringToStdString(env, playerId));
+    auto result = audioEngine->unloadSound(jstringToStdString(env, playerId));
+
+    jclass structClass = env->FindClass("com/audioplayback/models/UnloadSoundResult");
+    jmethodID constructor = env->GetMethodID(structClass, "<init>", "(Ljava/lang/String;)V");
+
+    jstring jError = result.error.has_value() ? env->NewStringUTF(result.error->c_str()): nullptr;
+    jobject returnValue = env->NewObject(structClass, constructor, jError);
+
+    if(jError) {
+        env->DeleteLocalRef(jError);
+    }
+
+    return returnValue;
 }
 
 
-JNIEXPORT jstring JNICALL
+JNIEXPORT jobject JNICALL
 Java_com_audioplayback_AudioPlaybackModule_loadSoundNative(JNIEnv *env, jobject instance, jint fd, jint fileLength, jint fileOffset) {
-   auto id = audioEngine->loadSound(fd, fileOffset, fileLength);
+   auto result = audioEngine->loadSound(fd, fileOffset, fileLength);
+
    // Once done, close the file descriptor
    if (close(fd) == -1) {
        LOGE("Error closing file descriptor: %s", strerror(errno));
@@ -98,11 +147,19 @@ Java_com_audioplayback_AudioPlaybackModule_loadSoundNative(JNIEnv *env, jobject
        LOGD("File descriptor closed");
    }
 
-   if(id) {
-       return env->NewStringUTF(id->c_str());
-   } else {
-       return nullptr;
-   }
+    jclass structClass = env->FindClass("com/audioplayback/models/LoadSoundResult");
+    jmethodID constructor = env->GetMethodID(structClass, "<init>", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+    jstring jError = result.error.has_value() ? env->NewStringUTF(result.error->c_str()): nullptr;
+    jstring jId = result.id.has_value() ? env->NewStringUTF(result.id->c_str()): nullptr;
+    jobject returnValue = env->NewObject(structClass, constructor, jError, jId);
+
+    if(jError) {
+        env->DeleteLocalRef(jError);
+        env->DeleteLocalRef(jId);
+    }
+
+    return returnValue;
 }
 
 
diff --git a/android/src/main/java/com/audioplayback/AudioPlaybackModule.kt b/android/src/main/java/com/audioplayback/AudioPlaybackModule.kt
index bcdd1a2..c93d318 100644
--- a/android/src/main/java/com/audioplayback/AudioPlaybackModule.kt
+++ b/android/src/main/java/com/audioplayback/AudioPlaybackModule.kt
@@ -1,13 +1,19 @@
 package com.audioplayback
 
 import android.net.Uri
-import android.util.Log
+import com.audioplayback.models.CloseAudioStreamResult
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableType
 import com.audioplayback.models.FileDescriptorProps
+import com.audioplayback.models.LoadSoundResult
+import com.audioplayback.models.OpenAudioStreamResult
+import com.audioplayback.models.SetupAudioStreamResult
+import com.audioplayback.models.UnloadSoundResult
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -22,21 +28,31 @@ class AudioPlaybackModule internal constructor(context: ReactApplicationContext)
     return NAME
   }
 
-  @ReactMethod
-  override fun setupAudioStream(sampleRate: Double, channelCount: Double) {
-    setupAudioStreamNative(sampleRate, channelCount)
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun setupAudioStream(sampleRate: Double, channelCount: Double): WritableMap {
+    val result = setupAudioStreamNative(sampleRate, channelCount)
+    val map = Arguments.createMap()
+    result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+    return map
   }
 
-  @ReactMethod
-  override fun closeAudioStream() {
-    closeAudioStreamNative()
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun openAudioStream(): WritableMap {
+    val result = openAudioStreamNative()
+    val map = Arguments.createMap()
+    result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+    return map
   }
 
-  @ReactMethod
-  override fun openAudioStream() {
-    openAudioStreamNative()
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun closeAudioStream(): WritableMap {
+    val result = closeAudioStreamNative()
+    val map = Arguments.createMap()
+    result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+    return map
   }
 
+
   @ReactMethod
   override fun loopSounds(arg: ReadableArray) {
     val (ids, values) = readableArrayToStringBooleanArray(arg)
@@ -56,17 +72,25 @@ class AudioPlaybackModule internal constructor(context: ReactApplicationContext)
   }
 
 
-  @ReactMethod
-  override fun unloadSound(id: String) {
-    unloadSoundNative(id)
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun unloadSound(id: String): WritableMap {
+    val result = unloadSoundNative(id)
+    val map = Arguments.createMap()
+    result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+    return map
   }
 
   @ReactMethod
   override fun loadSound(uri: String, promise: Promise) {
+    val map = Arguments.createMap()
+
     val scheme = Uri.parse(uri).scheme
     if( scheme == null) {
       val fileDescriptorProps = FileDescriptorProps.fromLocalResource(reactApplicationContext, uri)
-      return promise.resolve(loadSoundNative(fileDescriptorProps.id, fileDescriptorProps.length, fileDescriptorProps.offset))
+      val result = loadSoundNative(fileDescriptorProps.id, fileDescriptorProps.length, fileDescriptorProps.offset);
+      result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+      result.id?.let { map.putString("id", it) } ?: map.putNull("id")
+      promise.resolve(map)
     } else {
       CoroutineScope(Dispatchers.Main).launch {
         withContext(Dispatchers.IO) {
@@ -74,9 +98,13 @@ class AudioPlaybackModule internal constructor(context: ReactApplicationContext)
           val fileDescriptorProps = FileDescriptorProps.getFileDescriptorPropsFromUrl(reactApplicationContext, url)
           if(fileDescriptorProps == null) {
             promise.resolve(null)
-            Log.d("Could not get file descriptor info from uri", LOG)
+            map.putString("error", "Failed to load sound file")
+            map.putNull("id")
           } else {
-            promise.resolve(loadSoundNative(fileDescriptorProps.id, fileDescriptorProps.length, fileDescriptorProps.offset))
+            val result = loadSoundNative(fileDescriptorProps.id, fileDescriptorProps.length, fileDescriptorProps.offset);
+            result.error?.let { map.putString("error", it) } ?: map.putNull("error")
+            result.id?.let { map.putString("id", it) } ?: map.putNull("id")
+            promise.resolve(map)
           }
         }
       }
@@ -144,14 +172,14 @@ class AudioPlaybackModule internal constructor(context: ReactApplicationContext)
     closeAudioStreamNative()
   }
 
-  private external fun setupAudioStreamNative(sampleRate: Double, channelCount: Double)
-  private external fun openAudioStreamNative()
-  private external fun closeAudioStreamNative()
+  private external fun setupAudioStreamNative(sampleRate: Double, channelCount: Double): SetupAudioStreamResult
+  private external fun openAudioStreamNative(): OpenAudioStreamResult
+  private external fun closeAudioStreamNative(): CloseAudioStreamResult
   private external fun playSoundsNative(ids: Array<String>, values: BooleanArray)
   private external fun loopSoundsNative(ids: Array<String>, values: BooleanArray)
   private external fun seekSoundsToNative(ids: Array<String>, values: DoubleArray)
-  private external fun loadSoundNative(fd: Int, fileLength: Int, fileOffset: Int): String?
-  private external fun unloadSoundNative(playerId: String): Unit
+  private external fun loadSoundNative(fd: Int, fileLength: Int, fileOffset: Int): LoadSoundResult
+  private external fun unloadSoundNative(playerId: String): UnloadSoundResult
 
   // Example method
   // See https://reactnative.dev/docs/native-modules-android
diff --git a/android/src/main/java/com/audioplayback/models/AudioPlaybackMethodsResults.kt b/android/src/main/java/com/audioplayback/models/AudioPlaybackMethodsResults.kt
new file mode 100644
index 0000000..9b87d6e
--- /dev/null
+++ b/android/src/main/java/com/audioplayback/models/AudioPlaybackMethodsResults.kt
@@ -0,0 +1,7 @@
+package com.audioplayback.models
+
+data class SetupAudioStreamResult(val error: String?)
+data class OpenAudioStreamResult(val error: String?)
+data class CloseAudioStreamResult(val error: String?)
+data class LoadSoundResult(val error: String?, val id: String?)
+data class UnloadSoundResult(val error: String?)
diff --git a/android/src/oldarch/AudioPlaybackSpec.kt b/android/src/oldarch/AudioPlaybackSpec.kt
index d0b63dc..ac93961 100644
--- a/android/src/oldarch/AudioPlaybackSpec.kt
+++ b/android/src/oldarch/AudioPlaybackSpec.kt
@@ -1,21 +1,20 @@
 package com.audioplayback
 
-import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
 
 
 abstract class AudioPlaybackSpec internal constructor(context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
 
-  abstract fun setupAudioStream(sampleRate: Double, channelCount: Double)
+  abstract fun setupAudioStream(sampleRate: Double, channelCount: Double): WritableMap
 
-  abstract fun openAudioStream()
+  abstract fun openAudioStream(): WritableMap
 
-  abstract fun closeAudioStream()
+  abstract fun closeAudioStream(): WritableMap
 
   abstract fun loopSounds(arg: ReadableArray)
 
@@ -23,7 +22,7 @@ abstract class AudioPlaybackSpec internal constructor(context: ReactApplicationC
 
   abstract fun seekSoundsTo(arg: ReadableArray)
 
-  abstract fun unloadSound(id: String)
+  abstract fun unloadSound(id: String): WritableMap
 
   abstract fun loadSound(uri: String, promise: Promise)
 }
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index 07af4e9..4282245 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -1242,7 +1242,7 @@ PODS:
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
     - Yoga
-  - react-native-audio-playback (0.1.0):
+  - react-native-audio-playback (0.2.0-alpha.3):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -1772,7 +1772,7 @@ SPEC CHECKSUMS:
   React-logger: 81d58ca6f1d93fca9a770bda6cc1c4fbfcc99c9c
   React-Mapbuffer: 726951e68f4bb1c2513d322f2548798b2a3d628d
   React-microtasksnativemodule: 7a69a9b8fded72ea3cf81923ecf75cad5558ed26
-  react-native-audio-playback: eaff56b0cd9f5d4ca98d2a3809f1493cdddd8244
+  react-native-audio-playback: 90ecd527297c496404fbad379c672d59a53bb6cc
   React-nativeconfig: 470fce6d871c02dc5eff250a362d56391b7f52d6
   React-NativeModulesApple: 6297fc3136c1fd42884795c51d7207de6312b606
   React-perflogger: f2c94413cfad44817c96cab33753831e73f0d0dd
diff --git a/example/src/App.tsx b/example/src/App.tsx
index 02d3e5d..994999b 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -11,9 +11,6 @@ import {
 } from 'react-native';
 import { Player, AudioManager } from 'react-native-audio-playback';
 
-AudioManager.shared.setupAudioStream(44100, 2);
-AudioManager.shared.openAudioStream();
-
 export default function App() {
   const [players, setPlayers] = useState<
     Array<{ player: Player; title: string }>
@@ -21,26 +18,26 @@ export default function App() {
 
   useEffect(() => {
     // loads the sounds
-    const players = Array<{ player: Player; title: string }>();
+    const effectPlayers = Array<{ player: Player; title: string }>();
 
     (async () => {
       const player1 = await AudioManager.shared.loadSound(
         require('./assets/bamboo.mp3')
       );
       if (player1) {
-        players.push({ player: player1, title: 'Bamboo' });
+        effectPlayers.push({ player: player1, title: 'Bamboo' });
       }
       const player2 = await AudioManager.shared.loadSound(
         require('./assets/swords.mp3')
       );
       if (player2) {
-        players.push({ player: player2, title: 'Swords' });
+        effectPlayers.push({ player: player2, title: 'Swords' });
       }
       const player3 = await AudioManager.shared.loadSound(
         require('./assets/coins.mp3')
       );
       if (player3) {
-        players.push({ player: player3, title: 'Coins' });
+        effectPlayers.push({ player: player3, title: 'Coins' });
       }
 
       const player4 = await AudioManager.shared.loadSound(
@@ -48,99 +45,105 @@ export default function App() {
       );
 
       if (player4) {
-        players.push({ player: player4, title: 'Axe' });
+        effectPlayers.push({ player: player4, title: 'Axe' });
       }
 
-      setPlayers(players);
+      setPlayers(effectPlayers);
     })();
 
     return () => {
-      players.forEach((player) => player.player.unloadSound());
+      effectPlayers.forEach((player) => player.player.unloadSound());
     };
   }, []);
 
+  const playersExceptAxe = players
+    .filter((p) => p.title !== 'Axe')
+    .map((player) => player.player);
+
   return (
     <SafeAreaView style={styles.screen}>
       <ScrollView contentContainerStyle={styles.contentContainer}>
-        {players.map((player) => (
-          <PlayerControls
-            key={player.player.id}
-            title={player.title}
-            player={player.player}
+        <ButtonsGroup title="Audio Manager">
+          <Button
+            title="Setup Stream"
+            onPress={() => {
+              AudioManager.shared.setupAudioStream(44100, 2);
+            }}
+          />
+          <Button
+            title="Open Stream"
+            onPress={() => {
+              AudioManager.shared.openAudioStream();
+            }}
+          />
+          <Button
+            title="Close Stream"
+            onPress={() => {
+              AudioManager.shared.closeAudioStream();
+            }}
           />
+        </ButtonsGroup>
+        {players.map(({ title, player }) => (
+          <ButtonsGroup title={title} key={player.id}>
+            <Button title="Play" onPress={() => player.playSound()} />
+            <Button title="Pause" onPress={() => player.pauseSound()} />
+            <Button
+              title="Seek To 5 secs"
+              onPress={() => player.seekTo(5000)}
+            />
+            <Button title="loop" onPress={() => player.loopSound(true)} />
+            <Button title="unloop" onPress={() => player.loopSound(false)} />
+          </ButtonsGroup>
         ))}
-        <PlayersControls
-          players={players
-            .filter((p) => p.title !== 'Axe')
-            .map((player) => player.player)}
-        />
+        <ButtonsGroup title="All players">
+          <Button
+            title="Play all"
+            onPress={() =>
+              AudioManager.shared.playSounds(
+                playersExceptAxe.map((player) => [player, true])
+              )
+            }
+          />
+          <Button
+            title="Pause all"
+            onPress={() =>
+              AudioManager.shared.playSounds(
+                playersExceptAxe.map((player) => [player, false] as const)
+              )
+            }
+          />
+          <Button
+            title="Loop all"
+            onPress={() =>
+              AudioManager.shared.loopSounds(
+                playersExceptAxe.map((player) => [player, true] as const)
+              )
+            }
+          />
+          <Button
+            title="Unloop all"
+            onPress={() =>
+              AudioManager.shared.loopSounds(
+                playersExceptAxe.map((player) => [player, false] as const)
+              )
+            }
+          />
+        </ButtonsGroup>
       </ScrollView>
     </SafeAreaView>
   );
 }
 
-interface PlayersControlsProps {
-  players: Array<Player>;
-}
-
-function PlayersControls({ players }: PlayersControlsProps) {
-  return (
-    <View style={styles.controlsContainer}>
-      <Text style={styles.controlsTitle}>All players</Text>
-      <View style={styles.controlsInnerContainer}>
-        <Button
-          title="Play all"
-          onPress={() =>
-            AudioManager.shared.playSounds(
-              players.map((player) => [player, true])
-            )
-          }
-        />
-        <Button
-          title="Pause all"
-          onPress={() =>
-            AudioManager.shared.playSounds(
-              players.map((player) => [player, false] as const)
-            )
-          }
-        />
-        <Button
-          title="Loop all"
-          onPress={() =>
-            AudioManager.shared.loopSounds(
-              players.map((player) => [player, true] as const)
-            )
-          }
-        />
-        <Button
-          title="Unloop all"
-          onPress={() =>
-            AudioManager.shared.loopSounds(
-              players.map((player) => [player, false] as const)
-            )
-          }
-        />
-      </View>
-    </View>
-  );
-}
-
-interface PlayerControlsProps {
+interface ButtonsGroupProps {
   title: string;
-  player: Player;
+  children: React.ReactNode;
 }
 
-function PlayerControls({ title, player }: PlayerControlsProps) {
+function ButtonsGroup({ title, children }: ButtonsGroupProps) {
   return (
-    <View style={styles.controlsContainer}>
-      <Text style={styles.controlsTitle}>{title}</Text>
-      <View style={styles.controlsInnerContainer}>
-        <Button title="Play" onPress={() => player.playSound()} />
-        <Button title="Pause" onPress={() => player.pauseSound()} />
-        <Button title="Seek To 5 secs" onPress={() => player.seekTo(5000)} />
-        <Button title="loop" onPress={() => player.loopSound(true)} />
-        <Button title="unloop" onPress={() => player.loopSound(false)} />
-      </View>
+    <View style={styles.buttonsGroupContainer}>
+      <Text style={styles.buttonGroupTitle}>{title}</Text>
+      <View style={styles.buttonsContainer}>{children}</View>
     </View>
   );
 }
@@ -173,18 +176,18 @@ const styles = StyleSheet.create({
     padding: 16,
     gap: 32,
   },
-  controlsContainer: {
+  buttonsGroupContainer: {
     gap: 8,
     borderRadius: 4,
     borderWidth: 2,
     borderColor: 'black',
     padding: 8,
   },
-  controlsTitle: {
+  buttonGroupTitle: {
     fontSize: 16,
     fontWeight: 'bold',
   },
-  controlsInnerContainer: {
+  buttonsContainer: {
     flexDirection: 'row',
     flexWrap: 'wrap',
     gap: 8,
diff --git a/ios/AudioEngine.swift b/ios/AudioEngine.swift
index 7e5c3ef..6313b50 100644
--- a/ios/AudioEngine.swift
+++ b/ios/AudioEngine.swift
@@ -14,6 +14,32 @@ enum AudioStreamState {
   case initialized, opened, closed
 }
 
+enum AudioEngineError: LocalizedError {
+  case audioStreamAlreadyInitialized
+  case failedToSetupAudioStream(reason: String)
+  case failedToOpenAudioStream(reason: String)
+  case failedToCloseAudioStream(reason: String)
+  case failedToUnloadSound
+  case failedToLoadAudioFile(reason: String)
+
+  var errorDescription: String? {
+    switch self {
+    case .audioStreamAlreadyInitialized:
+      return "Audio stream is already initialized"
+    case .failedToSetupAudioStream(reason: let reason):
+      return "Failed to setup audio stream: \(reason)"
+    case .failedToOpenAudioStream(reason: let reason):
+      return "Failed to open audio stream: \(reason)"
+    case .failedToCloseAudioStream(reason: let reason):
+      return "Failed to close audio stream: \(reason)"
+    case .failedToUnloadSound:
+      return "Failed to unload sound. No Audio file is loaded"
+    case .failedToLoadAudioFile(reason: let reason):
+      return "Failed to load audio file: \(reason)"
+    }
+  }
+}
+
 class AudioEngine {
   private var desiredSampleRate: Double = 44100
   private var desiredChannelCount: Int = 2
@@ -31,19 +57,18 @@ class AudioEngine {
     try? audioSession.setActive(true)
   }
 
-  public func setupAudioStream(sampleRate: Double, channelCount: Int) {
+  public func setupAudioStream(sampleRate: Double, channelCount: Int) throws {
     guard audioStreamState != .initialized else {
-      print("Trying to initialize audio stream while it is already initialized.")
-      return
+      throw AudioEngineError.audioStreamAlreadyInitialized
     }
 
     self.desiredSampleRate = sampleRate
     self.desiredChannelCount = channelCount
 
-    setupAudioUnit()
+    try setupAudioUnit()
   }
 
-  private func setupAudioUnit() {
+  private func setupAudioUnit() throws {
     var audioDescription = AudioStreamBasicDescription(
       mSampleRate: Float64(desiredSampleRate),
       mFormatID: kAudioFormatLinearPCM,
@@ -65,14 +90,13 @@ class AudioEngine {
     )
 
     guard let audioComponent = AudioComponentFindNext(nil, &audioComponentDescription) else {
-      return
+      throw AudioEngineError.failedToSetupAudioStream(reason: "audio component not found")
     }
 
     AudioComponentInstanceNew(audioComponent, &audioUnit)
 
     guard let audioUnit else {
-      print("Failed to create Audio Unit")
-      return;
+      throw AudioEngineError.failedToSetupAudioStream(reason: "could not create audio unit")
     }
 
     AudioUnitSetProperty(
@@ -103,7 +127,7 @@ class AudioEngine {
     if(status == noErr) {
       audioStreamState = .initialized
     } else {
-      print("Failed to initialize Audio Unit")
+      throw AudioEngineError.failedToSetupAudioStream(reason: "initializing the stream failed")
     }
   }
 
@@ -132,93 +156,98 @@ class AudioEngine {
     return noErr
   }
 
-  @objc public func openAudioStream() {
+  @objc public func openAudioStream() throws {
     guard audioStreamState == .initialized else {
-      print("Audio stream has to be in an initialized state before opening it")
-      return
+      throw AudioEngineError.failedToOpenAudioStream(reason: "Stream is not initialized")
     }
 
     guard let audioUnit else { return }
-    AudioOutputUnitStart(audioUnit)
+    let status = AudioOutputUnitStart(audioUnit)
+
+    if(status == noErr) {
+      audioStreamState = .opened
+    } else {
+      throw AudioEngineError.failedToOpenAudioStream(reason: "Stream could not be open")
+    }
   }
 
-  @objc public func loadAudioWith(localFileUrl: URL) -> String?  {
+  @objc public func loadAudioWith(localFileUrl: URL) throws -> String  {
+    let audioFile: AVAudioFile
     do {
-      // Initialize AVAudioFile
-      let audioFile = try AVAudioFile(forReading: localFileUrl)
-
-      // Get the file's processing format
-      let fileFormat = audioFile.processingFormat
-      let fileSampleRate = fileFormat.sampleRate
-      let fileChannels = fileFormat.channelCount
-      let fileCommonFormat = fileFormat.commonFormat
-      let fileInterleaved = fileFormat.isInterleaved
-
-      // Check if sample rate, channel count, and format match the desired format
-      let needsSampleRateConversion = fileSampleRate != desiredSampleRate
-      let needsChannelConversion = fileChannels != desiredChannelCount
-      let needsFormatConversion = fileCommonFormat != desiredCommonFormat
-
-      // Handle only interleaving changes; other conversions are not supported in this simplified approach
-      guard !needsSampleRateConversion,
-            !needsChannelConversion,
-            !needsFormatConversion else {
-        print("Unsupported conversion requirements. Only interleaving change is handled.")
-        return nil
-      }
+      audioFile = try AVAudioFile(forReading: localFileUrl)
+    } catch {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Could not create AVAudioFile")
+    }
 
-      // Prepare to read the audio data
-      let frameCount = AVAudioFrameCount(audioFile.length)
-      guard let pcmBuffer = AVAudioPCMBuffer(pcmFormat: fileFormat, frameCapacity: frameCount) else {
-        print("Failed to create PCM Buffer with file's format")
-        return nil
-      }
+    let fileFormat = audioFile.processingFormat
+    let fileSampleRate = fileFormat.sampleRate
+    let fileChannels = fileFormat.channelCount
+    let fileCommonFormat = fileFormat.commonFormat
+    let fileInterleaved = fileFormat.isInterleaved
+
+    guard fileSampleRate == desiredSampleRate else {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Sample rate mismatch. Resampling is not supported. File sample rate: \(fileSampleRate), stream sample rate: \(desiredSampleRate).")
+    }
+
+    guard fileChannels == desiredChannelCount else {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Channel count mismatch. File channel count: \(fileChannels), stream channel count: \(desiredChannelCount).")
+    }
+
+    guard fileCommonFormat == desiredCommonFormat else {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Format mismatch. File format: \(fileCommonFormat), stream format: \(desiredCommonFormat).")
+    }
+
+    // Prepare to read the audio data
+    let frameCount = AVAudioFrameCount(audioFile.length)
+    guard let pcmBuffer = AVAudioPCMBuffer(pcmFormat: fileFormat, frameCapacity: frameCount) else {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Could not create AVAudioPCMBuffer.")
+    }
 
+    do {
       // Read the entire audio file into the buffer
       try audioFile.read(into: pcmBuffer)
-      print("Read \(pcmBuffer.frameLength) frames in file's native format")
+    } catch {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Could not read audio file into buffer: \(error.localizedDescription).")
+    }
 
-      // Access the float32 audio data
-      guard let channelData = pcmBuffer.floatChannelData else {
-        print("Failed to access channel data")
-        return nil
-      }
+    // Access the float32 audio data
+    guard let channelData = pcmBuffer.floatChannelData else {
+      throw AudioEngineError.failedToLoadAudioFile(reason: "Could not access audio data.")
+    }
 
-      let channels = Int(fileChannels)
-      let frames = Int(pcmBuffer.frameLength)
-      let totalSamples = frames * channels
-
-      // Allocate the Float32 buffer
-      var audioBuffer: [Float32]
-
-      if fileInterleaved {
-        // If the file is already interleaved, copy the data directly
-        let data = channelData[0]
-        audioBuffer = Array(UnsafeBufferPointer(start: data, count: totalSamples))
-      } else {
-        audioBuffer = Array(repeating: 0, count: totalSamples)
-        // Manual interleaving: Iterate through each frame and channel to interleave samples
-        for frame in 0..<frames {
-          for channel in 0..<channels {
-            audioBuffer[frame * channels + channel] = channelData[channel][frame]
-          }
+    let channels = Int(fileChannels)
+    let frames = Int(pcmBuffer.frameLength)
+    let totalSamples = frames * channels
+
+    // Allocate the Float32 buffer
+    var audioBuffer: [Float32]
+
+    if fileInterleaved {
+      // If the file is already interleaved, copy the data directly
+      let data = channelData[0]
+      audioBuffer = Array(UnsafeBufferPointer(start: data, count: totalSamples))
+    } else {
+      audioBuffer = Array(repeating: 0, count: totalSamples)
+      // Manual interleaving: Iterate through each frame and channel to interleave samples
+      for frame in 0..<frames {
+        for channel in 0..<channels {
+          audioBuffer[frame * channels + channel] = channelData[channel][frame]
         }
       }
+    }
 
-      let uuid = UUID()
+    let uuid = UUID()
 
 
-      let player = Player(source: DataSource(sampleCount: Int(audioFile.length * 2), data: audioBuffer, sampleRate: desiredSampleRate, channelCount: desiredChannelCount))
-      self.players[uuid.uuidString] = player
-      return uuid.uuidString
-    } catch {
-      print("Error loading audio file: \(error.localizedDescription)")
-      return nil
-    }
+    let player = Player(source: DataSource(sampleCount: Int(audioFile.length * 2), data: audioBuffer, sampleRate: desiredSampleRate, channelCount: desiredChannelCount))
+    self.players[uuid.uuidString] = player
+    return uuid.uuidString
   }
 
-  @objc public func unloadSound(id: String) {
-    players.removeValue(forKey: id)
+  @objc public func unloadSound(id: String) throws {
+    guard players.removeValue(forKey: id) != nil else {
+      throw AudioEngineError.failedToUnloadSound
+    }
   }
 
   public func playSounds(_ args: [(String, Bool)]) {
@@ -242,16 +271,31 @@ class AudioEngine {
     }
   }
 
-  public func closeAudioStream() {
-    if let audioUnit {
-      AudioOutputUnitStop(audioUnit)
-      AudioUnitUninitialize(audioUnit)
-      self.audioUnit = nil
+  public func closeAudioStream() throws {
+    guard let audioUnit else {
+      throw AudioEngineError.failedToCloseAudioStream(reason: "No stream to close found.")
+    }
+
+    guard audioStreamState != .closed else {
+      throw AudioEngineError.failedToCloseAudioStream(reason: "Stream is already closed.")
     }
+
+    var status = AudioOutputUnitStop(audioUnit)
+    if(status != noErr) {
+      throw AudioEngineError.failedToCloseAudioStream(reason: "Failed to stop audio stream.")
+    }
+
+    status = AudioUnitUninitialize(audioUnit)
+    if(status != noErr) {
+      throw AudioEngineError.failedToCloseAudioStream(reason: "Failed to uninitialize audio stream.")
+    }
+
+    self.audioStreamState = .closed
+    self.audioUnit = nil
   }
 
   deinit {
-    closeAudioStream()
+    try? closeAudioStream()
   }
 }
 
diff --git a/ios/AudioPlayback.mm b/ios/AudioPlayback.mm
index df7d244..7d42448 100644
--- a/ios/AudioPlayback.mm
+++ b/ios/AudioPlayback.mm
@@ -16,26 +16,34 @@ - (instancetype) init {
 
 RCT_EXPORT_MODULE()
 
-RCT_EXPORT_METHOD(setupAudioStream:(double)sampleRate channelCount:(double)channelCount) {
-  [moduleImpl setupAudioStreamWithSampleRate:sampleRate channelCount:channelCount];
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, setupAudioStream:(double)sampleRate channelCount:(double)channelCount) {
+  NSString *error = [moduleImpl setupAudioStreamWithSampleRate:sampleRate channelCount:channelCount];
+
+  return @{@"error":error?: [NSNull null]};
 }
 
-RCT_EXPORT_METHOD(openAudioStream) {
-  [moduleImpl openAudioStream];
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, openAudioStream) {
+  NSString *error = [moduleImpl openAudioStream];
+
+  return @{@"error":error?: [NSNull null]};
 }
 
-RCT_EXPORT_METHOD(closeAudioStream) {
-  [moduleImpl openAudioStream];
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, closeAudioStream) {
+  NSString *error = [moduleImpl closeAudioStream];
+
+  return @{@"error":error?: [NSNull null]};
 }
 
 RCT_EXPORT_METHOD(loadSound:(NSString *)uri resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
-  [moduleImpl loadSoundWithUri:uri completion:^(NSString * _Nullable soundId) {
-    resolve(soundId);
+  [moduleImpl loadSoundWithUri:uri completion:^(NSString * _Nullable soundId, NSString * _Nullable error) {
+    resolve(@{@"error": error?: [NSNull null], @"id": soundId?: [NSNull null]});
   }];
 }
 
-RCT_EXPORT_METHOD(unloadSound:(NSString *)id) {
-  [moduleImpl unloadSoundWithId:id];
+RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, unloadSound:(NSString *)id) {
+  NSString *error = [moduleImpl unloadSoundWithId:id];
+
+  return @{@"error":error?: [NSNull null]};
 }
 
 RCT_EXPORT_METHOD(loopSounds:(NSArray *)arg) {
diff --git a/ios/AudioPlaybackImpl.swift b/ios/AudioPlaybackImpl.swift
index e5c4a1c..3ef7187 100644
--- a/ios/AudioPlaybackImpl.swift
+++ b/ios/AudioPlaybackImpl.swift
@@ -1,15 +1,31 @@
 import AVFoundation
 import AudioToolbox
 
+
 @objc public class AudioPlaybackImpl: NSObject {
+  private static let unknownError: String = "An unknown error occurred while loading the audio file. Please create an issue with a reproducible"
   let audioEngine = AudioEngine()
 
-  @objc public func setupAudioStream(sampleRate: Double, channelCount: Double) {
-    audioEngine.setupAudioStream(sampleRate: sampleRate, channelCount: Int(channelCount))
+  @objc public func setupAudioStream(sampleRate: Double, channelCount: Double) -> String? {
+    do {
+      try audioEngine.setupAudioStream(sampleRate: sampleRate, channelCount: Int(channelCount))
+      return nil
+    } catch let error as AudioEngineError {
+      return error.localizedDescription
+    } catch {
+      return Self.unknownError
+    }
   }
 
-  @objc public func openAudioStream() {
-    audioEngine.openAudioStream()
+  @objc public func openAudioStream() -> String? {
+    do {
+      try audioEngine.openAudioStream()
+      return nil
+    } catch let error as AudioEngineError {
+      return error.localizedDescription
+    } catch {
+      return Self.unknownError
+    }
   }
 
   @objc public func loopSounds(arg: NSArray) {
@@ -24,50 +40,73 @@ import AudioToolbox
     audioEngine.seekSoundsTo(convertNSArrayToArrayOfStringDoubleTuples(arg))
   }
 
-  @objc public func loadSound(uri: String, completion: @escaping (String?) -> Void) {
+  @objc public func loadSound(uri: String, completion: @escaping (_ id:String?, _ error: String?) -> Void) {
     let isLocalFile = uri.hasPrefix("file://")
     let url = URL(string: uri)
 
     guard let url else {
-      completion(nil)
+      completion(nil, "Invalid Uri: \(uri)")
       return
     }
 
+    let cb = {(_ localFileUrl: URL) in
+      do {
+        let id = try self.audioEngine.loadAudioWith(localFileUrl: localFileUrl)
+        completion(id, nil)
+      } catch let error as AudioEngineError {
+        completion(nil, error.localizedDescription)
+      } catch {
+        completion(nil, Self.unknownError)
+      }
+    }
+
     if isLocalFile {
-      completion(self.audioEngine.loadAudioWith(localFileUrl: url))
+      cb(url)
     } else {
-      loadRemoteSound(url: url) { [weak self] localUrl in
-        guard let self, let localUrl else {
-          completion(nil)
+      loadRemoteSound(url: url) {  localUrl, error in
+        guard  let localUrl else {
+          completion(nil, error)
           return
         }
 
-        completion(self.audioEngine.loadAudioWith(localFileUrl: localUrl))
+        cb(localUrl)
       }
     }
   }
 
-  @objc public func unloadSound(id: String) {
-    audioEngine.unloadSound(id: id)
+  @objc public func unloadSound(id: String) -> String? {
+    do {
+      try audioEngine.unloadSound(id: id)
+      return nil
+    } catch let error as AudioEngineError {
+      return error.localizedDescription
+    } catch {
+      return Self.unknownError
+    }
   }
 
-  @objc public func closeAudioStream() {
-    audioEngine.closeAudioStream()
+  @objc public func closeAudioStream() -> String? {
+    do {
+      try audioEngine.closeAudioStream()
+      return nil
+    } catch let error as AudioEngineError {
+      return error.localizedDescription
+    } catch {
+      return Self.unknownError
+    }
   }
 
-  private func loadRemoteSound(url: URL, _ completion: @escaping (URL?) -> Void) {
+  private func loadRemoteSound(url: URL, _ completion: @escaping (_ url: URL?,_ error: String?) -> Void) {
     URLSession.shared.downloadTask(with: url) { localUrl, response, error in
       if let error {
-        print("Downloading local file failed: \(error)")
-        completion(nil)
+        completion(nil, "Downloading local file failed: \(error.localizedDescription)")
         return
       }
 
       if let localUrl {
-        completion(localUrl)
+        completion(localUrl, nil)
       } else {
-        print("Downloaded file is nil with no error")
-        completion(nil)
+        completion(nil, Self.unknownError)
       }
     }.resume()
   }
diff --git a/src/NativeAudioPlayback.ts b/src/NativeAudioPlayback.ts
index 11e1b22..579cc7a 100644
--- a/src/NativeAudioPlayback.ts
+++ b/src/NativeAudioPlayback.ts
@@ -2,14 +2,19 @@ import type { TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
 
 export interface Spec extends TurboModule {
-  setupAudioStream: (sampleRate: number, channelCount: number) => void;
-  openAudioStream: () => void;
-  closeAudioStream: () => void;
+  setupAudioStream: (
+    sampleRate: number,
+    channelCount: number
+  ) => { error: string | null };
+  openAudioStream: () => { error: string | null };
+  closeAudioStream: () => { error: string | null };
   loopSounds: (arg: Array<[string, boolean]>) => void;
   playSounds: (arg: Array<[string, boolean]>) => void;
   seekSoundsTo: (arg: Array<[string, number]>) => void;
-  unloadSound: (id: string) => void;
-  loadSound: (uri: string) => Promise<string | null>;
+  unloadSound: (id: string) => { error: string | null };
+  loadSound: (
+    uri: string
+  ) => Promise<{ id: string | null; error: string | null }>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('AudioPlayback');
diff --git a/src/module.ts b/src/module.ts
index 72a663f..b6c84fe 100644
--- a/src/module.ts
+++ b/src/module.ts
@@ -29,33 +29,55 @@ export function setupAudioStream(
   sampleRate: number,
   channelCount: number
 ): void {
-  return AudioPlayback.setupAudioStream(sampleRate, channelCount);
+  const res = AudioPlayback.setupAudioStream(sampleRate, channelCount);
+  if (res.error) {
+    throw new Error(res.error);
+  }
 }
 
 export function openAudioStream(): void {
-  return AudioPlayback.openAudioStream();
+  const res = AudioPlayback.openAudioStream();
+  if (res.error) {
+    throw new Error(res.error);
+  }
 }
 
 export function closeAudioStream(): void {
-  return AudioPlayback.closeAudioStream();
+  const res = AudioPlayback.closeAudioStream();
+  if (res.error) {
+    throw new Error(res.error);
+  }
 }
 
 export function playSounds(arg: Array<[string, boolean]>): void {
-  return AudioPlayback.playSounds(arg);
+  AudioPlayback.playSounds(arg);
 }
 
 export function seekSoundsTo(arg: Array<[string, number]>): void {
-  return AudioPlayback.seekSoundsTo(arg);
+  AudioPlayback.seekSoundsTo(arg);
 }
 
 export function loopSounds(arg: Array<[string, boolean]>): void {
-  return AudioPlayback.loopSounds(arg);
+  AudioPlayback.loopSounds(arg);
 }
 
-export function loadSound(requiredAsset: number): Promise<string | null> {
-  return AudioPlayback.loadSound(Image.resolveAssetSource(requiredAsset).uri);
+export async function loadSound(requiredAsset: number): Promise<string> {
+  const res = await AudioPlayback.loadSound(
+    Image.resolveAssetSource(requiredAsset).uri
+  );
+  if (res.error) {
+    throw new Error(res.error);
+  } else if (typeof res.id !== 'string') {
+    throw new Error(
+      'An unknown error occurred while loading the audio file. Please create an issue with a reproducible'
+    );
+  }
+  return res.id;
 }
 
 export function unloadSound(playerId: string) {
-  AudioPlayback.unloadSound(playerId);
+  const res = AudioPlayback.unloadSound(playerId);
+  if (res.error) {
+    throw new Error(res.error);
+  }
 }