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