[Android] Sometimes no audio when device attached to Android Studio for debugging

[rh101]

I'm having a really strange and random issue when I start up the application on a real device via the debug option in Android Studio. The app starts up normally, and everything seems fine in the log regarding the audio initialisation, but no audio is played at all for any sound file. If enough sound files are played, an error appears and ends up crashing the app:

Fail to play Sounds/TestFile.mp3 cause by limited max instance of AudioEngine

If that doesn't crash it, but the app is closed via an Exit menu item, then it crashes in the following method, because result is Result::ErrorClosed, and not Result::OK as expected:

void OboePlayback::stop()
{
    oboe::Result result{mStream->stop()};
    if(result != oboe::Result::OK)
        throw al::backend_exception{al::backend_error::DeviceError, "Failed to stop stream: %s",
            oboe::convertToText(result)};
}

It seems like either the mStream failed to open, or somehow closed from the start of the app, which is why no sound can be heard. Any ideas what may be causing this issue?

I haven't yet noticed this issue when the debug version of the app is started normally without a debugger attached, so hopefully it is just limited to debugging.

[DelinWorks]

Does it occur when running the debug version of the app without debugging?

[rh101]

Oh sorry, I thought I mentioned that (post updated), but no there are no issues with the audio in the debug version when running without the debugger attached. It's really random, as sometimes with debugger attached the sound is fine, yet other times I can reproduce the issue consistently.

[halx99]

It seems like either the mStream failed to open

No, if failed to open stream, will crash at https://github.com/axmolengine/axmol/blob/dev/thirdparty/openal/alc/backends/oboe.cpp#L64

[rh101]

That makes sense. Unfortunately I haven't had time to dig into this more, but it is happening regularly when the debugger is attached, so that may have something to do with what is causing the issue.

[halx99]

The ErrorClosed returned by oboe maybe at follow locations, so you needs to toggle breakpoints to check why failed

AAudio backend

// AudioStreamAAudio.cpp
Result AudioStreamAAudio::requestStop() {
    std::lock_guard<std::mutex> lock(mLock);
    AAudioStream *stream = mAAudioStream.load();
    if (stream != nullptr) {
        return requestStop_l(stream);
    } else {
        return Result::ErrorClosed;
    }
}

// AudioStream.cpp
Result AudioStream::waitForStateTransition(StreamState startingState,
                                           StreamState endingState,
                                           int64_t timeoutNanoseconds)
{
    StreamState state;
    {
        std::lock_guard<std::mutex> lock(mLock);
        state = getState();
        if (state == StreamState::Closed) {
            return Result::ErrorClosed;
        } else if (state == StreamState::Disconnected) {
            return Result::ErrorDisconnected;
        }
    }

    StreamState nextState = state;
    // TODO Should this be a while()?!
    if (state == startingState && state != endingState) {
        Result result = waitForStateChange(state, &nextState, timeoutNanoseconds);
        if (result != Result::OK) {
            return result;
        }
    }

    if (nextState != endingState) {
        return Result::ErrorInvalidState;
    } else {
        return Result::OK;
    }
}

OpenSLES

// AudioOutputStreamOpenSLES.cpp
Result AudioOutputStreamOpenSLES::requestStop_l() {
    LOGD("AudioOutputStreamOpenSLES(): %s() called", __func__);

    StreamState initialState = getState();
    switch (initialState) {
        case StreamState::Stopping:
        case StreamState::Stopped:
            return Result::OK;
        case StreamState::Uninitialized:
        case StreamState::Closed:
            return Result::ErrorClosed;
        default:
            break;
    }

    setState(StreamState::Stopping);

    Result result = setPlayState_l(SL_PLAYSTATE_STOPPED);
    if (result == Result::OK) {

        // Also clear the buffer queue so the old data won't be played if the stream is restarted.
        // Call the _l function that expects to already be under a lock.
        if (requestFlush_l() != Result::OK) {
            LOGW("Failed to flush the stream. Error %s", convertToText(flush()));
        }

        mPositionMillis.reset32(); // OpenSL ES resets its millisecond position when stopped.
        int64_t framesWritten = getFramesWritten();
        if (framesWritten >= 0) {
            setFramesRead(framesWritten);
        }
        setState(StreamState::Stopped);
    } else {
        setState(initialState);
    }
    return result;
}

I can't reproduce on my device when debugger attached.

[rh101]

The ErrorClosed returned by oboe maybe follow locations, so you needs to toggle breakpoints to check why failed

Thanks for the code locations. I'll actually check it now while debugging the Android build of the app to see if I can catch what is causing it.

[rh101]

While debugging the app on Android (in this case Google Play Billing callbacks from Java), if any breakpoint is hit so the app is paused, then on continuing execution of the app, the following happens:

Which ends up here with an ErrorTimeout:

The audio no longer works after this happens.

If no breakpoints are used to interrupt the execution of the app, then the audio works fine, and the audio time-out never occurs.

[rh101]

For anyone reading this, the problem is resolved, with more info in #1212