1/*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef AAUDIO_SERVICE_ENDPOINT_H
18#define AAUDIO_SERVICE_ENDPOINT_H
19
20#include <atomic>
21#include <functional>
22#include <mutex>
23#include <vector>
24
25#include "client/AudioStreamInternal.h"
26#include "client/AudioStreamInternalPlay.h"
27#include "core/AAudioStreamParameters.h"
28#include "binding/AAudioServiceMessage.h"
29#include "binding/AAudioStreamConfiguration.h"
30
31#include "AAudioServiceStreamBase.h"
32
33namespace aaudio {
34
35/**
36 * AAudioServiceEndpoint is used by a subclass of AAudioServiceStreamBase
37 * to communicate with the underlying audio device or port.
38 */
39class AAudioServiceEndpoint
40        : public virtual android::RefBase
41        , public AAudioStreamParameters {
42public:
43
44    virtual ~AAudioServiceEndpoint();
45
46    virtual std::string dump() const;
47
48    virtual aaudio_result_t open(const aaudio::AAudioStreamRequest &request) = 0;
49
50    virtual aaudio_result_t close() = 0;
51
52    aaudio_result_t registerStream(android::sp<AAudioServiceStreamBase> stream);
53
54    aaudio_result_t unregisterStream(android::sp<AAudioServiceStreamBase> stream);
55
56    virtual aaudio_result_t startStream(android::sp<AAudioServiceStreamBase> stream,
57                                        audio_port_handle_t *clientHandle) = 0;
58
59    virtual aaudio_result_t stopStream(android::sp<AAudioServiceStreamBase> stream,
60                                       audio_port_handle_t clientHandle) = 0;
61
62    virtual aaudio_result_t startClient(const android::AudioClient& client,
63                                        audio_port_handle_t *clientHandle) {
64        ALOGD("AAudioServiceEndpoint::startClient(%p, ...) AAUDIO_ERROR_UNAVAILABLE", &client);
65        return AAUDIO_ERROR_UNAVAILABLE;
66    }
67
68    virtual aaudio_result_t stopClient(audio_port_handle_t clientHandle) {
69        ALOGD("AAudioServiceEndpoint::stopClient(...) AAUDIO_ERROR_UNAVAILABLE");
70        return AAUDIO_ERROR_UNAVAILABLE;
71    }
72
73    /**
74     * @param positionFrames
75     * @param timeNanos
76     * @return AAUDIO_OK or AAUDIO_ERROR_UNAVAILABLE or other negative error
77     */
78    virtual aaudio_result_t getFreeRunningPosition(int64_t *positionFrames, int64_t *timeNanos) = 0;
79
80    virtual aaudio_result_t getTimestamp(int64_t *positionFrames, int64_t *timeNanos) = 0;
81
82    int32_t getFramesPerBurst() const {
83        return mFramesPerBurst;
84    }
85
86    int32_t getRequestedDeviceId() const { return mRequestedDeviceId; }
87
88    bool matches(const AAudioStreamConfiguration& configuration);
89
90    // This should only be called from the AAudioEndpointManager under a mutex.
91    int32_t getOpenCount() const {
92        return mOpenCount;
93    }
94
95    // This should only be called from the AAudioEndpointManager under a mutex.
96    void setOpenCount(int32_t count) {
97        mOpenCount = count;
98    }
99
100    bool isConnected() const {
101        return mConnected;
102    }
103
104protected:
105
106    /**
107     * @param portHandle
108     * @return return true if a stream with the given portHandle is registered
109     */
110    bool                     isStreamRegistered(audio_port_handle_t portHandle);
111
112    void                     disconnectRegisteredStreams();
113
114    mutable std::mutex       mLockStreams;
115    std::vector<android::sp<AAudioServiceStreamBase>> mRegisteredStreams;
116
117    SimpleDoubleBuffer<Timestamp>  mAtomicTimestamp;
118
119    android::AudioClient     mMmapClient;   // set in open, used in open and startStream
120
121    int32_t                  mFramesPerBurst = 0;
122    int32_t                  mOpenCount = 0;
123    int32_t                  mRequestedDeviceId = 0;
124
125    std::atomic<bool>        mConnected{true};
126};
127
128} /* namespace aaudio */
129
130
131#endif //AAUDIO_SERVICE_ENDPOINT_H
132