1 /* 2 * Copyright (c) 2021-2022 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 RENDER_SERVICE_PIPELINE_RS_RENDER_SERVICE_CONNECTION_H 17 #define RENDER_SERVICE_PIPELINE_RS_RENDER_SERVICE_CONNECTION_H 18 19 #include <mutex> 20 #include <unordered_set> 21 22 #include "ipc_callbacks/buffer_available_callback.h" 23 #include "pipeline/rs_render_service.h" 24 #include "screen_manager/rs_screen_manager.h" 25 #include "transaction/rs_render_service_connection_stub.h" 26 #include "vsync_distributor.h" 27 28 namespace OHOS { 29 namespace Rosen { 30 class RSRenderServiceConnection : public RSRenderServiceConnectionStub { 31 public: 32 RSRenderServiceConnection( 33 pid_t remotePid, 34 wptr<RSRenderService> renderService, 35 RSMainThread* mainThread, 36 sptr<RSScreenManager> screenManager, 37 sptr<IRemoteObject> token, 38 sptr<VSyncDistributor> distributor); 39 ~RSRenderServiceConnection() noexcept; 40 RSRenderServiceConnection(const RSRenderServiceConnection&) = delete; 41 RSRenderServiceConnection& operator=(const RSRenderServiceConnection&) = delete; 42 GetToken()43 sptr<IRemoteObject> GetToken() const 44 { 45 return token_; 46 } 47 48 private: 49 void CleanVirtualScreens() noexcept; 50 void CleanRenderNodes() noexcept; 51 void CleanAll(bool toDelete = false) noexcept; 52 53 // IPC RSIRenderServiceConnection Interfaces 54 void CommitTransaction(std::unique_ptr<RSTransactionData>& transactionData) override; 55 void ExecuteSynchronousTask(const std::shared_ptr<RSSyncTask>& task) override; 56 57 int32_t SetRenderModeChangeCallback(sptr<RSIRenderModeChangeCallback> callback) override; 58 void UpdateRenderMode(bool isUniRender) override; 59 bool GetUniRenderEnabled() override; 60 bool QueryIfRTNeedRender() override; 61 62 bool CreateNode(const RSSurfaceRenderNodeConfig& config) override; 63 sptr<Surface> CreateNodeAndSurface(const RSSurfaceRenderNodeConfig& config) override; 64 65 sptr<IVSyncConnection> CreateVSyncConnection(const std::string& name) override; 66 67 int32_t SetFocusAppInfo( 68 int32_t pid, int32_t uid, const std::string &bundleName, const std::string &abilityName) override; 69 70 ScreenId GetDefaultScreenId() override; 71 72 std::vector<ScreenId> GetAllScreenIds() override; 73 74 ScreenId CreateVirtualScreen( 75 const std::string &name, 76 uint32_t width, 77 uint32_t height, 78 sptr<Surface> surface, 79 ScreenId mirrorId = 0, 80 int32_t flags = 0) override; 81 82 int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) override; 83 84 void RemoveVirtualScreen(ScreenId id) override; 85 86 int32_t SetScreenChangeCallback(sptr<RSIScreenChangeCallback> callback) override; 87 88 void SetScreenActiveMode(ScreenId id, uint32_t modeId) override; 89 90 int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) override; 91 92 void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) override; 93 94 void TakeSurfaceCapture(NodeId id, sptr<RSISurfaceCaptureCallback> callback, float scaleX, float scaleY) override; 95 96 void RegisterApplicationAgent(uint32_t pid, sptr<IApplicationAgent> app) override; 97 98 void UnRegisterApplicationAgent(sptr<IApplicationAgent> app); 99 100 RSVirtualScreenResolution GetVirtualScreenResolution(ScreenId id) override; 101 102 RSScreenModeInfo GetScreenActiveMode(ScreenId id) override; 103 104 std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) override; 105 106 RSScreenCapability GetScreenCapability(ScreenId id) override; 107 108 ScreenPowerStatus GetScreenPowerStatus(ScreenId id) override; 109 110 RSScreenData GetScreenData(ScreenId id) override; 111 112 int32_t GetScreenBacklight(ScreenId id) override; 113 114 void SetScreenBacklight(ScreenId id, uint32_t level) override; 115 116 void RegisterBufferAvailableListener( 117 NodeId id, sptr<RSIBufferAvailableCallback> callback, bool isFromRenderThread) override; 118 119 int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) override; 120 121 int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) override; 122 123 int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) override; 124 125 int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) override; 126 127 int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) override; 128 129 int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) override; 130 131 int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) override; 132 133 int32_t GetScreenType(ScreenId id, RSScreenType& screenType) override; 134 135 int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) override; 136 137 int32_t RegisterOcclusionChangeCallback(sptr<RSIOcclusionChangeCallback> callback) override; 138 139 void SetAppWindowNum(uint32_t num) override; 140 141 pid_t remotePid_; 142 wptr<RSRenderService> renderService_; 143 RSMainThread* mainThread_ = nullptr; 144 sptr<RSScreenManager> screenManager_; 145 sptr<IRemoteObject> token_; 146 147 class RSConnectionDeathRecipient : public IRemoteObject::DeathRecipient { 148 public: 149 explicit RSConnectionDeathRecipient(wptr<RSRenderServiceConnection> conn); 150 virtual ~RSConnectionDeathRecipient() = default; 151 152 void OnRemoteDied(const wptr<IRemoteObject>& token) override; 153 154 private: 155 wptr<RSRenderServiceConnection> conn_; 156 }; 157 friend class RSConnectionDeathRecipient; 158 sptr<RSConnectionDeathRecipient> connDeathRecipient_; 159 160 class RSApplicationRenderThreadDeathRecipient : public IRemoteObject::DeathRecipient { 161 public: 162 explicit RSApplicationRenderThreadDeathRecipient(wptr<RSRenderServiceConnection> conn); 163 virtual ~RSApplicationRenderThreadDeathRecipient() = default; 164 165 void OnRemoteDied(const wptr<IRemoteObject>& token) override; 166 167 private: 168 wptr<RSRenderServiceConnection> conn_; 169 }; 170 friend class RSApplicationRenderThreadDeathRecipient; 171 sptr<RSApplicationRenderThreadDeathRecipient> ApplicationDeathRecipient_; 172 173 mutable std::mutex mutex_; 174 bool cleanDone_ = false; 175 176 // save all virtual screenIds created by this connection. 177 std::unordered_set<ScreenId> virtualScreenIds_; 178 sptr<RSIScreenChangeCallback> screenChangeCallback_; 179 sptr<VSyncDistributor> appVSyncDistributor_; 180 std::vector<sptr<VSyncConnection>> vsyncConnections_; 181 }; 182 } // namespace Rosen 183 } // namespace OHOS 184 185 #endif // RENDER_SERVICE_PIPELINE_RS_RENDER_SERVICE_CONNECTION_H 186