1 /* 2 ** 3 ** Copyright 2012, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #ifndef INCLUDING_FROM_AUDIOFLINGER_H 19 #error This header file should only be included from AudioFlinger.h 20 #endif 21 22 // Checks and monitors OP_RECORD_AUDIO 23 class OpRecordAudioMonitor : public RefBase { 24 public: 25 ~OpRecordAudioMonitor() override; 26 bool hasOpRecordAudio() const; 27 28 static sp<OpRecordAudioMonitor> createIfNeeded(uid_t uid, const String16& opPackageName); 29 30 private: 31 OpRecordAudioMonitor(uid_t uid, const String16& opPackageName); 32 void onFirstRef() override; 33 34 AppOpsManager mAppOpsManager; 35 36 class RecordAudioOpCallback : public BnAppOpsCallback { 37 public: 38 explicit RecordAudioOpCallback(const wp<OpRecordAudioMonitor>& monitor); 39 void opChanged(int32_t op, const String16& packageName) override; 40 41 private: 42 const wp<OpRecordAudioMonitor> mMonitor; 43 }; 44 45 sp<RecordAudioOpCallback> mOpCallback; 46 // called by RecordAudioOpCallback when OP_RECORD_AUDIO is updated in AppOp callback 47 // and in onFirstRef() 48 void checkRecordAudio(); 49 50 std::atomic_bool mHasOpRecordAudio; 51 const uid_t mUid; 52 const String16 mPackage; 53 }; 54 55 // record track 56 class RecordTrack : public TrackBase { 57 public: 58 RecordTrack(RecordThread *thread, 59 const sp<Client>& client, 60 const audio_attributes_t& attr, 61 uint32_t sampleRate, 62 audio_format_t format, 63 audio_channel_mask_t channelMask, 64 size_t frameCount, 65 void *buffer, 66 size_t bufferSize, 67 audio_session_t sessionId, 68 uid_t uid, 69 audio_input_flags_t flags, 70 track_type type, 71 const String16& opPackageName, 72 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE); 73 virtual ~RecordTrack(); 74 virtual status_t initCheck() const; 75 76 virtual status_t start(AudioSystem::sync_event_t event, audio_session_t triggerSession); 77 virtual void stop(); 78 79 void destroy(); 80 81 virtual void invalidate(); 82 // clear the buffer overflow flag clearOverflow()83 void clearOverflow() { mOverflow = false; } 84 // set the buffer overflow flag and return previous value setOverflow()85 bool setOverflow() { bool tmp = mOverflow; mOverflow = true; 86 return tmp; } 87 88 static void appendDumpHeader(String8& result); 89 void appendDump(String8& result, bool active); 90 91 void handleSyncStartEvent(const sp<SyncEvent>& event); 92 void clearSyncStartEvent(); 93 94 void updateTrackFrameInfo(int64_t trackFramesReleased, 95 int64_t sourceFramesRead, 96 uint32_t halSampleRate, 97 const ExtendedTimestamp ×tamp); 98 isFastTrack()99 virtual bool isFastTrack() const { return (mFlags & AUDIO_INPUT_FLAG_FAST) != 0; } 100 setSilenced(bool silenced)101 void setSilenced(bool silenced) { if (!isPatchTrack()) mSilenced = silenced; } 102 bool isSilenced() const; 103 104 status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones); 105 106 private: 107 friend class AudioFlinger; // for mState 108 109 DISALLOW_COPY_AND_ASSIGN(RecordTrack); 110 111 // AudioBufferProvider interface 112 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 113 // releaseBuffer() not overridden 114 115 bool mOverflow; // overflow on most recent attempt to fill client buffer 116 117 AudioBufferProvider::Buffer mSink; // references client's buffer sink in shared memory 118 119 // sync event triggering actual audio capture. Frames read before this event will 120 // be dropped and therefore not read by the application. 121 sp<SyncEvent> mSyncStartEvent; 122 123 // number of captured frames to drop after the start sync event has been received. 124 // when < 0, maximum frames to drop before starting capture even if sync event is 125 // not received 126 ssize_t mFramesToDrop; 127 128 // used by resampler to find source frames 129 ResamplerBufferProvider *mResamplerBufferProvider; 130 131 // used by the record thread to convert frames to proper destination format 132 RecordBufferConverter *mRecordBufferConverter; 133 audio_input_flags_t mFlags; 134 135 bool mSilenced; 136 137 // used to enforce OP_RECORD_AUDIO 138 uid_t mUid; 139 String16 mOpPackageName; 140 sp<OpRecordAudioMonitor> mOpRecordAudioMonitor; 141 }; 142 143 // playback track, used by PatchPanel 144 class PatchRecord : virtual public RecordTrack, public PatchProxyBufferProvider { 145 public: 146 147 PatchRecord(RecordThread *recordThread, 148 uint32_t sampleRate, 149 audio_channel_mask_t channelMask, 150 audio_format_t format, 151 size_t frameCount, 152 void *buffer, 153 size_t bufferSize, 154 audio_input_flags_t flags); 155 virtual ~PatchRecord(); 156 157 // AudioBufferProvider interface 158 virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); 159 virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); 160 161 // PatchProxyBufferProvider interface 162 virtual status_t obtainBuffer(Proxy::Buffer *buffer, 163 const struct timespec *timeOut = NULL); 164 virtual void releaseBuffer(Proxy::Buffer *buffer); 165 setPeerProxy(PatchProxyBufferProvider * proxy)166 void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; } 167 168 private: 169 sp<ClientProxy> mProxy; 170 PatchProxyBufferProvider* mPeerProxy; 171 struct timespec mPeerTimeout; 172 }; // end of PatchRecord 173