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
33namespace OHOS {
34namespace MultimediaPlugin {
35class PlatformAdp;
36class PluginFw;
37class GstPluginFw;
38
39enum class PluginFWType : int32_t {
40    PLUGIN_FW_GENERAL = 0,
41    PLUGIN_FW_GSTREAMER
42};
43
44class PluginServer final : public NoCopyable {
45public:
46    uint32_t Register(std::vector<std::string> &&pluginPaths);
47
48    template<typename T>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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
160private:
161    template<typename T>
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