1 /*
2  * Copyright (C) 2021 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 PLUGIN_SERVER_H
17 #define PLUGIN_SERVER_H
18 
19 #include <cstdint>
20 #include <map>
21 #include <string>
22 #include <vector>
23 #include <functional>
24 #include "attr_data.h"
25 #include "iosfwd"
26 #include "nocopyable.h"
27 #include "plugin_class_base.h"
28 #include "plugin_common_type.h"
29 #include "plugin_service.h"
30 #include "priority_scheme.h"
31 #include "singleton.h"
32 
33 namespace OHOS {
34 namespace MultimediaPlugin {
35 class PlatformAdp;
36 class PluginFw;
37 class GstPluginFw;
38 
39 enum class PluginFWType : int32_t {
40     PLUGIN_FW_GENERAL = 0,
41     PLUGIN_FW_GSTREAMER
42 };
43 
44 class PluginServer final : public NoCopyable {
45 public:
46     uint32_t Register(std::vector<std::string> &&pluginPaths);
47 
48     template<typename T>
CreateObject(const std::string & className,uint32_t & errorCode)49     inline T *CreateObject(const std::string &className, uint32_t &errorCode)
50     {
51         uint16_t interfaceID = GetInterfaceId<T>();
52         return ConvertToServiceInterface<T>(CreateObject(interfaceID, className, errorCode));
53     }
54 
55     template<typename T>
CreateObject(const std::string & className)56     inline T *CreateObject(const std::string &className)
57     {
58         uint16_t interfaceID = GetInterfaceId<T>();
59         uint32_t errorCode = 0;
60         return ConvertToServiceInterface<T>(CreateObject(interfaceID, className, errorCode));
61     }
62 
63     template<typename T>
CreateObject(uint16_t serviceType,uint32_t & errorCode)64     inline T *CreateObject(uint16_t serviceType, uint32_t &errorCode)
65     {
66         uint16_t interfaceID = GetInterfaceId<T>();
67         std::map<std::string, AttrData> emptyCapabilities;
68         PriorityScheme emptyPriScheme;
69         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, emptyCapabilities,
70                                                          emptyPriScheme, errorCode));
71     }
72 
73     template<typename T>
CreateObject(uint16_t serviceType)74     inline T *CreateObject(uint16_t serviceType)
75     {
76         uint16_t interfaceID = GetInterfaceId<T>();
77         std::map<std::string, AttrData> emptyCapabilities;
78         PriorityScheme emptyPriScheme;
79         uint32_t errorCode = 0;
80         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, emptyCapabilities,
81                                                          emptyPriScheme, errorCode));
82     }
83 
84     template<typename T>
CreateObject(uint16_t serviceType,const PriorityScheme & priorityScheme,uint32_t & errorCode)85     inline T *CreateObject(uint16_t serviceType, const PriorityScheme &priorityScheme, uint32_t &errorCode)
86     {
87         uint16_t interfaceID = GetInterfaceId<T>();
88         std::map<std::string, AttrData> emptyCapabilities;
89         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, emptyCapabilities,
90                                                          priorityScheme, errorCode));
91     }
92 
93     template<typename T>
CreateObject(uint16_t serviceType,const PriorityScheme & priorityScheme)94     inline T *CreateObject(uint16_t serviceType, const PriorityScheme &priorityScheme)
95     {
96         uint16_t interfaceID = GetInterfaceId<T>();
97         std::map<std::string, AttrData> emptyCapabilities;
98         uint32_t errorCode = 0;
99         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, emptyCapabilities,
100                                                          priorityScheme, errorCode));
101     }
102 
103     template<typename T>
CreateObject(uint16_t serviceType,const std::map<std::string,AttrData> & capabilities,uint32_t & errorCode)104     inline T *CreateObject(uint16_t serviceType, const std::map<std::string, AttrData> &capabilities,
105                            uint32_t &errorCode)
106     {
107         uint16_t interfaceID = GetInterfaceId<T>();
108         PriorityScheme emptyPriScheme;
109         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, capabilities,
110                                                          emptyPriScheme, errorCode));
111     }
112 
113     template<typename T>
CreateObject(uint16_t serviceType,const std::map<std::string,AttrData> & capabilities)114     inline T *CreateObject(uint16_t serviceType, const std::map<std::string, AttrData> &capabilities)
115     {
116         uint16_t interfaceID = GetInterfaceId<T>();
117         PriorityScheme emptyPriScheme;
118         uint32_t errorCode = 0;
119         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, capabilities,
120                                                          emptyPriScheme, errorCode));
121     }
122 
123     template<typename T>
CreateObject(uint16_t serviceType,const std::map<std::string,AttrData> & capabilities,const PriorityScheme & priorityScheme,uint32_t & errorCode)124     inline T *CreateObject(uint16_t serviceType, const std::map<std::string, AttrData> &capabilities,
125                            const PriorityScheme &priorityScheme, uint32_t &errorCode)
126     {
127         uint16_t interfaceID = GetInterfaceId<T>();
128         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, capabilities,
129                                                          priorityScheme, errorCode));
130     }
131 
132     template<typename T>
CreateObject(uint16_t serviceType,const std::map<std::string,AttrData> & capabilities,const PriorityScheme & priorityScheme)133     inline T *CreateObject(uint16_t serviceType, const std::map<std::string, AttrData> &capabilities,
134                            const PriorityScheme &priorityScheme)
135     {
136         uint16_t interfaceID = GetInterfaceId<T>();
137         uint32_t errorCode = 0;
138         return ConvertToServiceInterface<T>(CreateObject(interfaceID, serviceType, capabilities,
139                                                          priorityScheme, errorCode));
140     }
141 
142     template<typename T>
PluginServerGetClassInfo(uint16_t serviceType,std::vector<ClassInfo> & classesInfo)143     inline uint32_t PluginServerGetClassInfo(uint16_t serviceType, std::vector<ClassInfo> &classesInfo)
144     {
145         uint16_t interfaceID = GetInterfaceId<T>();
146         std::map<std::string, AttrData> emptyCapabilities;
147         return PluginServerGetClassInfo(interfaceID, serviceType, emptyCapabilities, classesInfo);
148     }
149 
150     template<typename T>
PluginServerGetClassInfo(uint16_t serviceType,const std::map<std::string,AttrData> & capabilities,std::vector<ClassInfo> & classesInfo)151     inline uint32_t PluginServerGetClassInfo(uint16_t serviceType, const std::map<std::string, AttrData> &capabilities,
152                                  std::vector<ClassInfo> &classesInfo)
153     {
154         uint16_t interfaceID = GetInterfaceId<T>();
155         return PluginServerGetClassInfo(interfaceID, serviceType, capabilities, classesInfo);
156     }
157 
158     DECLARE_DELAYED_REF_SINGLETON(PluginServer);
159 
160 private:
161     template<typename T>
ConvertToServiceInterface(PluginClassBase * pluginBase)162     inline T *ConvertToServiceInterface(PluginClassBase *pluginBase)
163     {
164 #ifdef PLUGIN_FLAG_RTTI_ENABLE
165         // when -frtti is enabled, we use dynamic cast directly
166         // to achieve the correct base class side-to-side conversion.
167         T *serviceObj = dynamic_cast<T *>(pluginBase);
168         if (serviceObj == nullptr && pluginBase != nullptr) {
169             // type mismatch.
170             delete pluginBase;
171         }
172 #else
173         // adjust pointer position when multiple inheritance.
174         void *obj = dynamic_cast<void *>(pluginBase);
175         // when -frtti is not enable, we use static cast.
176         // static cast is not safe enough, but we have checked before we get here.
177         T *serviceObj = static_cast<T *>(obj);
178 #endif
179         return serviceObj;
180     }
181 
182     PluginClassBase *CreateObject(uint16_t interfaceID, const std::string &className, uint32_t &errorCode);
183     PluginClassBase *CreateObject(uint16_t interfaceID, uint16_t serviceType,
184                                   const std::map<std::string, AttrData> &capabilities,
185                                   const PriorityScheme &priorityScheme, uint32_t &errorCode);
186     uint32_t PluginServerGetClassInfo(uint16_t interfaceID, uint16_t serviceType,
187                           const std::map<std::string, AttrData> &capabilities,
188                           std::vector<ClassInfo> &classesInfo);
189     PluginFWType AnalyzeFWType(const std::string &canonicalPath);
190 
191     PlatformAdp &platformAdp_;
192     PluginFw &pluginFw_;
193     GstPluginFw &gstPluginFw_;
194 };
195 } // namespace MultimediaPlugin
196 } // namespace OHOS
197 
198 #endif // PLUGIN_SERVER_H
199