AudioStreamBuilder.h

/*
 * Copyright 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef OBOE_STREAM_BUILDER_H_
#define OBOE_STREAM_BUILDER_H_
 
#include "oboe/Definitions.h"
#include "oboe/AudioStreamBase.h"
#include "oboe/Utilities.h"
#include "ResultWithValue.h"
 
namespace oboe {
 
    // This depends on AudioStream, so we use forward declaration, it will close and delete the stream
    struct StreamDeleterFunctor;
    using ManagedStream = std::unique_ptr<AudioStream, StreamDeleterFunctor>;
 
class AudioStreamBuilder : public AudioStreamBase {
public:
 
    AudioStreamBuilder() : AudioStreamBase() {}
 
    AudioStreamBuilder(const AudioStreamBase &audioStreamBase): AudioStreamBase(audioStreamBase) {}
 
    AudioStreamBuilder *setChannelCount(int channelCount) {
        mChannelCount = channelCount;
        mChannelMask = ChannelMask::Unspecified;
        return this;
    }
 
     AudioStreamBuilder *setChannelMask(ChannelMask channelMask) {
         mChannelMask = channelMask;
         mChannelCount = getChannelCountFromChannelMask(channelMask);
         return this;
     }
 
    AudioStreamBuilder *setDirection(Direction direction) {
        mDirection = direction;
        return this;
    }
 
    AudioStreamBuilder *setSampleRate(int32_t sampleRate) {
        mSampleRate = sampleRate;
        return this;
    }
 
    AudioStreamBuilder *setFramesPerCallback(int framesPerCallback) {
        return setFramesPerDataCallback(framesPerCallback);
    }
 
    AudioStreamBuilder *setFramesPerDataCallback(int framesPerCallback) {
        mFramesPerCallback = framesPerCallback;
        return this;
    }
 
    AudioStreamBuilder *setFormat(AudioFormat format) {
        mFormat = format;
        return this;
    }
 
    AudioStreamBuilder *setBufferCapacityInFrames(int32_t bufferCapacityInFrames) {
        mBufferCapacityInFrames = bufferCapacityInFrames;
        return this;
    }
 
    AudioApi getAudioApi() const { return mAudioApi; }
 
    AudioStreamBuilder *setAudioApi(AudioApi audioApi) {
        mAudioApi = audioApi;
        return this;
    }
 
    static bool isAAudioSupported();
 
    static bool isAAudioRecommended();
 
    AudioStreamBuilder *setSharingMode(SharingMode sharingMode) {
        mSharingMode = sharingMode;
        return this;
    }
 
    AudioStreamBuilder *setPerformanceMode(PerformanceMode performanceMode) {
        mPerformanceMode = performanceMode;
        return this;
    }
 
 
    AudioStreamBuilder *setUsage(Usage usage) {
        mUsage = usage;
        return this;
    }
 
    AudioStreamBuilder *setContentType(ContentType contentType) {
        mContentType = contentType;
        return this;
    }
 
    AudioStreamBuilder *setInputPreset(InputPreset inputPreset) {
        mInputPreset = inputPreset;
        return this;
    }
 
    AudioStreamBuilder *setSessionId(SessionId sessionId) {
        mSessionId = sessionId;
        return this;
    }
 
    AudioStreamBuilder *setDeviceId(int32_t deviceId) {
        mDeviceId = deviceId;
        return this;
    }
 
    AudioStreamBuilder *setAllowedCapturePolicy(AllowedCapturePolicy allowedCapturePolicy) {
        mAllowedCapturePolicy = allowedCapturePolicy;
        return this;
    }
 
    AudioStreamBuilder *setPrivacySensitiveMode(PrivacySensitiveMode privacySensitiveMode) {
        mPrivacySensitiveMode = privacySensitiveMode;
        return this;
    }
 
    AudioStreamBuilder *setIsContentSpatialized(bool isContentSpatialized) {
        mIsContentSpatialized = isContentSpatialized;
        return this;
    }
 
    AudioStreamBuilder *setSpatializationBehavior(SpatializationBehavior spatializationBehavior) {
        mSpatializationBehavior = spatializationBehavior;
        return this;
    }
 
    AudioStreamBuilder *setDataCallback(std::shared_ptr<AudioStreamDataCallback> sharedDataCallback) {
        // Use this raw pointer in the rest of the code to retain backwards compatibility.
        mDataCallback = sharedDataCallback.get();
        // Hold a shared_ptr to protect the raw pointer for the lifetime of the stream.
        mSharedDataCallback = sharedDataCallback;
        return this;
    }
 
    AudioStreamBuilder *setDataCallback(AudioStreamDataCallback *dataCallback) {
        mDataCallback = dataCallback;
        mSharedDataCallback = nullptr;
        return this;
    }
 
    AudioStreamBuilder *setErrorCallback(std::shared_ptr<AudioStreamErrorCallback> sharedErrorCallback) {
        // Use this raw pointer in the rest of the code to retain backwards compatibility.
        mErrorCallback = sharedErrorCallback.get();
        // Hold a shared_ptr to protect the raw pointer for the lifetime of the stream.
        mSharedErrorCallback = sharedErrorCallback;
        return this;
    }
 
    AudioStreamBuilder *setErrorCallback(AudioStreamErrorCallback *errorCallback) {
        mErrorCallback = errorCallback;
        mSharedErrorCallback = nullptr;
        return this;
    }
 
    AudioStreamBuilder *setCallback(AudioStreamCallback *streamCallback) {
        // Use the same callback object for both, dual inheritance.
        mDataCallback = streamCallback;
        mErrorCallback = streamCallback;
        return this;
    }
 
    AudioStreamBuilder *setChannelConversionAllowed(bool allowed) {
        mChannelConversionAllowed = allowed;
        return this;
    }
 
    AudioStreamBuilder *setFormatConversionAllowed(bool allowed) {
        mFormatConversionAllowed = allowed;
        return this;
    }
 
    AudioStreamBuilder *setSampleRateConversionQuality(SampleRateConversionQuality quality) {
        mSampleRateConversionQuality = quality;
        return this;
    }
 
    AudioStreamBuilder *setPackageName(std::string packageName) {
        mPackageName = packageName;
        return this;
    }
 
    AudioStreamBuilder *setAttributionTag(std::string attributionTag) {
        mAttributionTag = attributionTag;
        return this;
    }
 
    bool willUseAAudio() const {
        return (mAudioApi == AudioApi::AAudio && isAAudioSupported())
                || (mAudioApi == AudioApi::Unspecified && isAAudioRecommended());
    }
 
    Result openStream(AudioStream **stream);
 
    Result openStream(std::shared_ptr<oboe::AudioStream> &stream);
 
    Result openManagedStream(ManagedStream &stream);
 
private:
 
    Result openStreamInternal(AudioStream **streamPP);
 
    bool isCompatible(AudioStreamBase &other);
 
    oboe::AudioStream *build();
 
    AudioApi       mAudioApi = AudioApi::Unspecified;
};
 
} // namespace oboe
 
#endif /* OBOE_STREAM_BUILDER_H_ */