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