1 /* 2 * Copyright (C) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef SCREEN_CAPTURE_SERVICE_SERVER_H 17 #define SCREEN_CAPTURE_SERVICE_SERVER_H 18 19 #include <mutex> 20 #include <cstdlib> 21 #include <thread> 22 #include <string> 23 #include <memory> 24 #include <atomic> 25 #include <queue> 26 #include <vector> 27 #include "securec.h" 28 #include "i_screen_capture_service.h" 29 #include "nocopyable.h" 30 #include "uri_helper.h" 31 #include "task_queue.h" 32 #include "accesstoken_kit.h" 33 #include "privacy_kit.h" 34 #include "ipc_skeleton.h" 35 #include "screen_capture.h" 36 #include "audio_capturer.h" 37 #include "nativetoken_kit.h" 38 #include "token_setproc.h" 39 #include "audio_info.h" 40 #include "surface.h" 41 #include "display_manager.h" 42 #include "screen_manager.h" 43 44 namespace OHOS { 45 namespace Media { 46 using namespace Rosen; 47 using namespace AudioStandard; 48 using OHOS::Security::AccessToken::PrivacyKit; 49 50 struct SurfaceBufferEntry { SurfaceBufferEntrySurfaceBufferEntry51 SurfaceBufferEntry(sptr<OHOS::SurfaceBuffer> buf, int32_t fence, int64_t timeStamp, OHOS::Rect& damage) 52 : buffer(std::move(buf)), flushFence(fence), timeStamp(timeStamp), damageRect(damage) 53 { 54 } 55 ~SurfaceBufferEntry() noexcept = default; 56 57 sptr<OHOS::SurfaceBuffer> buffer; 58 int32_t flushFence; 59 int64_t timeStamp = 0; 60 OHOS::Rect damageRect = {0, 0, 0, 0}; 61 }; 62 63 enum VideoPermissionState : int32_t { 64 START_VIDEO = 0, 65 STOP_VIDEO = 1 66 }; 67 68 class ScreenCapBufferConsumerListener : public IBufferConsumerListener { 69 public: ScreenCapBufferConsumerListener(sptr<Surface> consumer,const std::shared_ptr<ScreenCaptureCallBack> & screenCaptureCb)70 ScreenCapBufferConsumerListener(sptr<Surface> consumer, 71 const std::shared_ptr<ScreenCaptureCallBack> &screenCaptureCb) : consumer_(consumer), 72 screenCaptureCb_(screenCaptureCb) 73 { 74 } ~ScreenCapBufferConsumerListener()75 ~ScreenCapBufferConsumerListener() 76 { 77 std::unique_lock<std::mutex> vlock(vmutex_); 78 while (!availableVideoBuffers_.empty()) { 79 if (consumer_ != nullptr) { 80 consumer_->ReleaseBuffer(availableVideoBuffers_.front()->buffer, 81 availableVideoBuffers_.front()->flushFence); 82 } 83 availableVideoBuffers_.pop(); 84 } 85 } 86 87 void OnBufferAvailable() override; 88 int32_t AcquireVideoBuffer(sptr<OHOS::SurfaceBuffer> &surfacebuffer, int32_t &fence, 89 int64_t ×tamp, OHOS::Rect &damage); 90 int32_t ReleaseVideoBuffer(); 91 int32_t Release(); 92 static constexpr uint32_t MAX_BUFFER_SIZE = 3; 93 94 private: 95 sptr<OHOS::Surface> consumer_ = nullptr; 96 std::mutex cbMutex_; 97 std::mutex vmutex_; 98 std::condition_variable bufferCond_; 99 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb_ = nullptr; 100 std::queue<std::unique_ptr<SurfaceBufferEntry>> availableVideoBuffers_; 101 }; 102 103 class AudioCapturerCallbackImpl : public AudioCapturerCallback { 104 public: 105 void OnInterrupt(const InterruptEvent &interruptEvent) override; 106 void OnStateChange(const CapturerState state) override; 107 }; 108 109 class ScreenCaptureServer : public IScreenCaptureService, public NoCopyable { 110 public: 111 static std::shared_ptr<IScreenCaptureService> Create(); 112 ScreenCaptureServer(); 113 ~ScreenCaptureServer(); 114 115 int32_t SetCaptureMode(CaptureMode captureMode) override; 116 int32_t InitAudioCap(AudioCaptureInfo audioInfo) override; 117 int32_t InitVideoCap(VideoCaptureInfo videoInfo) override; 118 int32_t StartScreenCapture() override; 119 int32_t StopScreenCapture() override; 120 int32_t SetScreenCaptureCallback(const std::shared_ptr<ScreenCaptureCallBack> &callback) override; 121 int32_t AcquireAudioBuffer(std::shared_ptr<AudioBuffer> &audioBuffer, AudioCaptureSourceType type) override; 122 int32_t AcquireVideoBuffer(sptr<OHOS::SurfaceBuffer> &surfacebuffer, int32_t &fence, 123 int64_t ×tamp, OHOS::Rect &damage) override; 124 int32_t ReleaseAudioBuffer(AudioCaptureSourceType type) override; 125 int32_t ReleaseVideoBuffer() override; 126 int32_t SetMicrophoneEnabled(bool isMicrophone) override; 127 void Release() override; 128 129 private: 130 bool CheckAudioCaptureMicPermission(); 131 bool CheckScreenCapturePermission(); 132 bool GetUsingPermissionFromPrivacy(VideoPermissionState state); 133 int32_t CheckVideoParam(VideoCaptureInfo videoInfo); 134 int32_t CheckAudioParam(AudioCaptureInfo audioInfo); 135 std::shared_ptr<AudioCapturer> CreateAudioCapture(AudioCaptureInfo audioInfo); 136 int32_t StartAudioCapture(); 137 int32_t StartAudioInnerCapture(); 138 int32_t StartVideoCapture(); 139 int32_t StartHomeVideoCapture(); 140 int32_t StopAudioCapture(); 141 int32_t StopVideoCapture(); 142 void ReleaseAudioCapture(); 143 void ReleaseVideoCapture(); 144 145 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb_ = nullptr; 146 std::mutex mutex_; 147 std::mutex audioMutex_; 148 std::mutex audioInnerMutex_; 149 std::mutex cbMutex_; 150 std::condition_variable bufferCond_; 151 std::condition_variable bufferInnerCond_; 152 /* use Mic AudioCaptureHandler */ 153 std::shared_ptr<AudioCapturer> audioMicCapturer_ = nullptr; 154 std::shared_ptr<AudioCapturerCallbackImpl> cb1_ = nullptr; 155 std::atomic<bool> isRunning_ = false; 156 std::unique_ptr<std::thread> readAudioLoop_ = nullptr; 157 std::queue<std::shared_ptr<AudioBuffer>> availableAudioBuffers_; 158 bool isMicrophoneOn = true; 159 /* use Inner AudioCaptureHandler */ 160 std::shared_ptr<AudioCapturer> audioInnerCapturer_ = nullptr; 161 std::atomic<bool> isInnerRunning_ = false; 162 std::unique_ptr<std::thread> readInnerAudioLoop_ = nullptr; 163 std::queue<std::shared_ptr<AudioBuffer>> availableInnerAudioBuffers_; 164 /* use VideoCapture */ 165 sptr<OHOS::Surface> consumer_ = nullptr; 166 ScreenCapBufferConsumerListener* surfaceCb_ = nullptr; 167 ScreenId screenId_ = SCREEN_ID_INVALID; 168 bool isConsumerStart_ = false; 169 bool isAudioStart_ = false; 170 bool isAudioInnerStart_ = false; 171 AudioCaptureSourceType audioCurrentInnerType_; 172 VideoCaptureInfo videoInfo_; 173 Security::AccessToken::AccessTokenID clientTokenId = 0; 174 CaptureMode captureMode_ = CAPTURE_HOME_SCREEN; 175 176 static constexpr uint32_t MAX_AUDIO_BUFFER_SIZE = 128; 177 static constexpr uint64_t SEC_TO_NANOSECOND = 1000000000; 178 }; 179 } // namespace Media 180 } // namespace OHOS 181 #endif // SCREEN_CAPTURE_SERVICE_SERVER_H 182