001
014
015 package com.liferay.portlet.asset;
016
017 import aQute.bnd.annotation.ProviderType;
018
019 import com.liferay.portal.kernel.log.Log;
020 import com.liferay.portal.kernel.log.LogFactoryUtil;
021 import com.liferay.portal.kernel.util.ListUtil;
022 import com.liferay.portal.util.PortalUtil;
023 import com.liferay.portlet.asset.model.AssetRendererFactory;
024 import com.liferay.registry.Registry;
025 import com.liferay.registry.RegistryUtil;
026 import com.liferay.registry.ServiceReference;
027 import com.liferay.registry.ServiceRegistration;
028 import com.liferay.registry.ServiceTracker;
029 import com.liferay.registry.ServiceTrackerCustomizer;
030 import com.liferay.registry.collections.ServiceRegistrationMap;
031 import com.liferay.registry.collections.ServiceRegistrationMapImpl;
032
033 import java.util.List;
034 import java.util.Map;
035 import java.util.concurrent.ConcurrentHashMap;
036
037
041 @ProviderType
042 public class AssetRendererFactoryRegistryUtil {
043
044
048 @Deprecated
049 public static List<AssetRendererFactory<?>> getAssetRendererFactories() {
050 return _instance._getAssetRendererFactories();
051 }
052
053 public static List<AssetRendererFactory<?>> getAssetRendererFactories(
054 long companyId) {
055
056 return _instance._getAssetRendererFactories(companyId);
057 }
058
059 public static <T> AssetRendererFactory<T> getAssetRendererFactoryByClass(
060 Class<T> clazz) {
061
062 return _instance._getAssetRendererFactoryByClass(clazz);
063 }
064
065 public static AssetRendererFactory<?> getAssetRendererFactoryByClassName(
066 String className) {
067
068 return _instance._getAssetRendererFactoryByClassName(className);
069 }
070
071 public static AssetRendererFactory<?> getAssetRendererFactoryByClassNameId(
072 long classNameId) {
073
074 return _instance._getAssetRendererFactoryByClassNameId(classNameId);
075 }
076
077 public static AssetRendererFactory<?> getAssetRendererFactoryByType(
078 String type) {
079
080 return _instance._getAssetRendererFactoryByType(type);
081 }
082
083
086 @Deprecated
087 public static long[] getClassNameIds() {
088 return _instance._getClassNameIds(0, false);
089 }
090
091 public static long[] getClassNameIds(long companyId) {
092 return _instance._getClassNameIds(companyId, false);
093 }
094
095 public static long[] getClassNameIds(
096 long companyId, boolean filterSelectable) {
097
098 return _instance._getClassNameIds(companyId, filterSelectable);
099 }
100
101 public static void register(AssetRendererFactory<?> assetRendererFactory) {
102 _instance._register(assetRendererFactory);
103 }
104
105 public static void register(
106 List<AssetRendererFactory<?>> assetRendererFactories) {
107
108 for (AssetRendererFactory<?> assetRendererFactory :
109 assetRendererFactories) {
110
111 register(assetRendererFactory);
112 }
113 }
114
115 public static void unregister(
116 AssetRendererFactory<?> assetRendererFactory) {
117
118 _instance._unregister(assetRendererFactory);
119 }
120
121 public static void unregister(
122 List<AssetRendererFactory<?>> assetRendererFactories) {
123
124 for (AssetRendererFactory<?> assetRendererFactory :
125 assetRendererFactories) {
126
127 unregister(assetRendererFactory);
128 }
129 }
130
131 private AssetRendererFactoryRegistryUtil() {
132 Registry registry = RegistryUtil.getRegistry();
133
134 _serviceTracker = registry.trackServices(
135 (Class<AssetRendererFactory<?>>)(Class<?>)
136 AssetRendererFactory.class,
137 new AssetRendererFactoryServiceTrackerCustomizer());
138
139 _serviceTracker.open();
140 }
141
142 private Map<String, AssetRendererFactory<?>> _filterAssetRendererFactories(
143 long companyId,
144 Map<String, AssetRendererFactory<?>> assetRendererFactories,
145 boolean filterSelectable) {
146
147 Map<String, AssetRendererFactory<?>> filteredAssetRendererFactories =
148 new ConcurrentHashMap<>();
149
150 for (String className : assetRendererFactories.keySet()) {
151 AssetRendererFactory<?> assetRendererFactory =
152 assetRendererFactories.get(className);
153
154 if (assetRendererFactory.isActive(companyId) &&
155 (!filterSelectable || assetRendererFactory.isSelectable())) {
156
157 filteredAssetRendererFactories.put(
158 className, assetRendererFactory);
159 }
160 }
161
162 return filteredAssetRendererFactories;
163 }
164
165 private List<AssetRendererFactory<?>> _getAssetRendererFactories() {
166 return ListUtil.fromMapValues(_assetRenderFactoriesMapByClassName);
167 }
168
169 private List<AssetRendererFactory<?>> _getAssetRendererFactories(
170 long companyId) {
171
172 return ListUtil.fromMapValues(
173 _filterAssetRendererFactories(
174 companyId, _assetRenderFactoriesMapByClassName, false));
175 }
176
177 private <T> AssetRendererFactory<T> _getAssetRendererFactoryByClass(
178 Class<T> clazz) {
179
180 return (AssetRendererFactory<T>)_assetRenderFactoriesMapByClassName.get(
181 clazz.getName());
182 }
183
184 private AssetRendererFactory<?> _getAssetRendererFactoryByClassName(
185 String className) {
186
187 return _assetRenderFactoriesMapByClassName.get(className);
188 }
189
190 private AssetRendererFactory<?> _getAssetRendererFactoryByClassNameId(
191 long classNameId) {
192
193 return _getAssetRendererFactoryByClassName(
194 PortalUtil.getClassName(classNameId));
195 }
196
197 private AssetRendererFactory<?> _getAssetRendererFactoryByType(
198 String type) {
199
200 return _assetRenderFactoriesMapByClassType.get(type);
201 }
202
203 private long[] _getClassNameIds(long companyId, boolean filterSelectable) {
204 Map<String, AssetRendererFactory<?>> assetRenderFactories =
205 _assetRenderFactoriesMapByClassName;
206
207 if (companyId > 0) {
208 assetRenderFactories = _filterAssetRendererFactories(
209 companyId, _assetRenderFactoriesMapByClassName,
210 filterSelectable);
211 }
212
213 long[] classNameIds = new long[assetRenderFactories.size()];
214
215 int i = 0;
216
217 for (AssetRendererFactory<?> assetRendererFactory :
218 assetRenderFactories.values()) {
219
220 classNameIds[i] = assetRendererFactory.getClassNameId();
221
222 i++;
223 }
224
225 return classNameIds;
226 }
227
228 private void _register(AssetRendererFactory<?> assetRendererFactory) {
229 Registry registry = RegistryUtil.getRegistry();
230
231 ServiceRegistration<AssetRendererFactory<?>> serviceRegistration =
232 registry.registerService(
233 (Class<AssetRendererFactory<?>>)(Class<?>)
234 AssetRendererFactory.class, assetRendererFactory);
235
236 _serviceRegistrations.put(assetRendererFactory, serviceRegistration);
237 }
238
239 private void _unregister(AssetRendererFactory<?> assetRendererFactory) {
240 ServiceRegistration<AssetRendererFactory<?>> serviceRegistration =
241 _serviceRegistrations.remove(assetRendererFactory);
242
243 if (serviceRegistration != null) {
244 serviceRegistration.unregister();
245 }
246 }
247
248 private static final Log _log = LogFactoryUtil.getLog(
249 AssetRendererFactoryRegistryUtil.class);
250
251 private static final AssetRendererFactoryRegistryUtil _instance =
252 new AssetRendererFactoryRegistryUtil();
253
254 private final Map<String, AssetRendererFactory<?>>
255 _assetRenderFactoriesMapByClassName = new ConcurrentHashMap<>();
256 private final Map<String, AssetRendererFactory<?>>
257 _assetRenderFactoriesMapByClassType = new ConcurrentHashMap<>();
258 private final ServiceRegistrationMap<AssetRendererFactory<?>>
259 _serviceRegistrations = new ServiceRegistrationMapImpl<>();
260 private final
261 ServiceTracker<AssetRendererFactory<?>, AssetRendererFactory<?>>
262 _serviceTracker;
263
264 private class AssetRendererFactoryServiceTrackerCustomizer
265 implements ServiceTrackerCustomizer
266 <AssetRendererFactory<?>, AssetRendererFactory<?>> {
267
268 @Override
269 public AssetRendererFactory<?> addingService(
270 ServiceReference<AssetRendererFactory<?>> serviceReference) {
271
272 Registry registry = RegistryUtil.getRegistry();
273
274 AssetRendererFactory<?> assetRendererFactory = registry.getService(
275 serviceReference);
276
277 String className = assetRendererFactory.getClassName();
278
279 AssetRendererFactory<?> classNameAssetRendererFactory =
280 _assetRenderFactoriesMapByClassName.put(
281 className, assetRendererFactory);
282
283 if (_log.isWarnEnabled() &&
284 (classNameAssetRendererFactory != null)) {
285
286 _log.warn(
287 "Replacing " + classNameAssetRendererFactory +
288 " for class name " + className + " with " +
289 assetRendererFactory);
290 }
291
292 String type = assetRendererFactory.getType();
293
294 AssetRendererFactory<?> typeAssetRendererFactory =
295 _assetRenderFactoriesMapByClassType.put(
296 type, assetRendererFactory);
297
298 if (_log.isWarnEnabled() && (typeAssetRendererFactory != null)) {
299 _log.warn(
300 "Replacing " + typeAssetRendererFactory + " for type " +
301 type + " with " + assetRendererFactory);
302 }
303
304 return assetRendererFactory;
305 }
306
307 @Override
308 public void modifiedService(
309 ServiceReference<AssetRendererFactory<?>> serviceReference,
310 AssetRendererFactory<?> assetRendererFactory) {
311 }
312
313 @Override
314 public void removedService(
315 ServiceReference<AssetRendererFactory<?>> serviceReference,
316 AssetRendererFactory<?> assetRendererFactory) {
317
318 Registry registry = RegistryUtil.getRegistry();
319
320 registry.ungetService(serviceReference);
321
322 _assetRenderFactoriesMapByClassName.remove(
323 assetRendererFactory.getClassName());
324 _assetRenderFactoriesMapByClassType.remove(
325 assetRendererFactory.getType());
326 }
327
328 }
329
330 }