1 /* 2 * Copyright (C) 2016 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_AAUDIO_SERVICE_H 18 #define AAUDIO_AAUDIO_SERVICE_H 19 20 #include <time.h> 21 #include <pthread.h> 22 23 #include <binder/BinderService.h> 24 #include <media/AudioClient.h> 25 26 #include <aaudio/AAudio.h> 27 #include <aaudio/BnAAudioService.h> 28 29 #include "binding/AAudioCommon.h" 30 #include "binding/AAudioBinderAdapter.h" 31 #include "binding/AAudioServiceInterface.h" 32 33 #include "AAudioServiceStreamBase.h" 34 #include "AAudioStreamTracker.h" 35 36 namespace android { 37 38 #define AAUDIO_SERVICE_NAME "media.aaudio" 39 40 class AAudioService : 41 public BinderService<AAudioService>, 42 public aaudio::BnAAudioService 43 { 44 friend class BinderService<AAudioService>; 45 46 public: 47 AAudioService(); 48 virtual ~AAudioService() = default; 49 asAAudioServiceInterface()50 aaudio::AAudioServiceInterface& asAAudioServiceInterface() { 51 return mAdapter; 52 } 53 getServiceName()54 static const char* getServiceName() { return AAUDIO_SERVICE_NAME; } 55 56 virtual status_t dump(int fd, const Vector<String16>& args) override; 57 58 binder::Status registerClient(const ::android::sp<::aaudio::IAAudioClient>& client) override; 59 60 binder::Status openStream(const ::aaudio::StreamRequest& request, 61 ::aaudio::StreamParameters* paramsOut, 62 int32_t* _aidl_return) override; 63 64 binder::Status closeStream(int32_t streamHandle, int32_t* _aidl_return) override; 65 66 binder::Status 67 getStreamDescription(int32_t streamHandle, ::aaudio::Endpoint* endpoint, 68 int32_t* _aidl_return) override; 69 70 binder::Status startStream(int32_t streamHandle, int32_t* _aidl_return) override; 71 72 binder::Status pauseStream(int32_t streamHandle, int32_t* _aidl_return) override; 73 74 binder::Status stopStream(int32_t streamHandle, int32_t* _aidl_return) override; 75 76 binder::Status flushStream(int32_t streamHandle, int32_t* _aidl_return) override; 77 78 binder::Status 79 registerAudioThread(int32_t streamHandle, int32_t clientThreadId, int64_t periodNanoseconds, 80 int32_t* _aidl_return) override; 81 82 binder::Status unregisterAudioThread(int32_t streamHandle, int32_t clientThreadId, 83 int32_t* _aidl_return) override; 84 85 aaudio_result_t startClient(aaudio::aaudio_handle_t streamHandle, 86 const android::AudioClient& client, 87 const audio_attributes_t *attr, 88 audio_port_handle_t *clientHandle); 89 90 aaudio_result_t stopClient(aaudio::aaudio_handle_t streamHandle, 91 audio_port_handle_t clientHandle); 92 93 // =============================================================================== 94 // The following public methods are only called from the service and NOT by Binder. 95 // =============================================================================== 96 97 aaudio_result_t disconnectStreamByPortHandle(audio_port_handle_t portHandle); 98 99 /* 100 * This is only called from within the Service. 101 * It bypasses the permission checks in closeStream(handle). 102 */ 103 aaudio_result_t closeStream(sp<aaudio::AAudioServiceStreamBase> serviceStream); 104 105 private: 106 class Adapter : public aaudio::AAudioBinderAdapter { 107 public: Adapter(AAudioService * service)108 explicit Adapter(AAudioService *service) 109 : aaudio::AAudioBinderAdapter(service), 110 mService(service) {} 111 startClient(aaudio::aaudio_handle_t streamHandle,const android::AudioClient & client,const audio_attributes_t * attr,audio_port_handle_t * clientHandle)112 aaudio_result_t startClient(aaudio::aaudio_handle_t streamHandle, 113 const android::AudioClient &client, 114 const audio_attributes_t *attr, 115 audio_port_handle_t *clientHandle) override { 116 return mService->startClient(streamHandle, client, attr, clientHandle); 117 } 118 stopClient(aaudio::aaudio_handle_t streamHandle,audio_port_handle_t clientHandle)119 aaudio_result_t stopClient(aaudio::aaudio_handle_t streamHandle, 120 audio_port_handle_t clientHandle) override { 121 return mService->stopClient(streamHandle, clientHandle); 122 } 123 124 private: 125 AAudioService* const mService; 126 }; 127 128 Adapter mAdapter; 129 130 /** @return true if the client is the audioserver 131 */ 132 bool isCallerInService(); 133 134 /** 135 * Lookup stream and then validate access to the stream. 136 * @param streamHandle 137 * @return 138 */ 139 sp<aaudio::AAudioServiceStreamBase> convertHandleToServiceStream( 140 aaudio::aaudio_handle_t streamHandle); 141 142 android::AudioClient mAudioClient; 143 144 aaudio::AAudioStreamTracker mStreamTracker; 145 146 // We use a lock to prevent thread A from reopening an exclusive stream 147 // after thread B steals thread A's exclusive MMAP resource stream. 148 std::recursive_mutex mOpenLock; 149 150 // TODO Extract the priority constants from services/audioflinger/Threads.cpp 151 // and share them with this code. Look for "kPriorityFastMixer". 152 static constexpr int32_t kRealTimeAudioPriorityClient = 2; 153 static constexpr int32_t kRealTimeAudioPriorityService = 3; 154 155 }; 156 157 } /* namespace android */ 158 159 #endif //AAUDIO_AAUDIO_SERVICE_H 160