001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.template;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.util.PortalUtil;
020    import com.liferay.registry.Registry;
021    import com.liferay.registry.RegistryUtil;
022    import com.liferay.registry.ServiceReference;
023    import com.liferay.registry.ServiceRegistration;
024    import com.liferay.registry.ServiceTracker;
025    import com.liferay.registry.ServiceTrackerCustomizer;
026    import com.liferay.registry.collections.StringServiceRegistrationMap;
027    
028    import java.util.ArrayList;
029    import java.util.Collections;
030    import java.util.List;
031    import java.util.Map;
032    import java.util.concurrent.ConcurrentHashMap;
033    
034    /**
035     * @author Juan Fern??ndez
036     */
037    @ProviderType
038    public class TemplateHandlerRegistryUtil {
039    
040            public static long[] getClassNameIds() {
041                    long[] classNameIds = new long[_instance._templateHandlers.size()];
042    
043                    int i = 0;
044    
045                    for (Map.Entry<String, TemplateHandler> entry :
046                                    _instance._templateHandlers.entrySet()) {
047    
048                            TemplateHandler templateHandler = entry.getValue();
049    
050                            classNameIds[i++] = PortalUtil.getClassNameId(
051                                    templateHandler.getClassName());
052                    }
053    
054                    return classNameIds;
055            }
056    
057            public static TemplateHandler getTemplateHandler(long classNameId) {
058                    String className = PortalUtil.getClassName(classNameId);
059    
060                    return _instance._templateHandlers.get(className);
061            }
062    
063            public static TemplateHandler getTemplateHandler(String className) {
064                    return _instance._templateHandlers.get(className);
065            }
066    
067            public static List<TemplateHandler> getTemplateHandlers() {
068                    List<TemplateHandler> templateHandlers = new ArrayList<TemplateHandler>(
069                            _instance._templateHandlers.values());
070    
071                    return Collections.unmodifiableList(templateHandlers);
072            }
073    
074            public static void register(TemplateHandler templateHandler) {
075                    _instance._register(templateHandler);
076            }
077    
078            public static void unregister(TemplateHandler templateHandler) {
079                    _instance._unregister(templateHandler);
080            }
081    
082            private TemplateHandlerRegistryUtil() {
083                    Registry registry = RegistryUtil.getRegistry();
084    
085                    _serviceTracker = registry.trackServices(
086                            TemplateHandler.class,
087                            new TemplateHandlerServiceTrackerCustomizer());
088    
089                    _serviceTracker.open();
090            }
091    
092            private void _register(TemplateHandler templateHandler) {
093                    Registry registry = RegistryUtil.getRegistry();
094    
095                    ServiceRegistration<TemplateHandler> serviceRegistration =
096                            registry.registerService(TemplateHandler.class, templateHandler);
097    
098                    _serviceRegistrations.put(
099                            templateHandler.getClassName(), serviceRegistration);
100            }
101    
102            private void _unregister(TemplateHandler templateHandler) {
103                    ServiceRegistration<TemplateHandler> serviceRegistration =
104                            _serviceRegistrations.remove(templateHandler.getClassName());
105    
106                    if (serviceRegistration != null) {
107                            serviceRegistration.unregister();
108                    }
109            }
110    
111            private static TemplateHandlerRegistryUtil _instance =
112                    new TemplateHandlerRegistryUtil();
113    
114            private StringServiceRegistrationMap<TemplateHandler>
115                    _serviceRegistrations =
116                            new StringServiceRegistrationMap<TemplateHandler>();
117            private ServiceTracker<TemplateHandler, TemplateHandler> _serviceTracker;
118            private Map<String, TemplateHandler> _templateHandlers =
119                    new ConcurrentHashMap<String, TemplateHandler>();
120    
121            private class TemplateHandlerServiceTrackerCustomizer
122                    implements ServiceTrackerCustomizer<TemplateHandler, TemplateHandler> {
123    
124                    @Override
125                    public TemplateHandler addingService(
126                            ServiceReference<TemplateHandler> serviceReference) {
127    
128                            Registry registry = RegistryUtil.getRegistry();
129    
130                            TemplateHandler templateHandler = registry.getService(
131                                    serviceReference);
132    
133                            _templateHandlers.put(
134                                    templateHandler.getClassName(), templateHandler);
135    
136                            return templateHandler;
137                    }
138    
139                    @Override
140                    public void modifiedService(
141                            ServiceReference<TemplateHandler> serviceReference,
142                            TemplateHandler templateHandler) {
143                    }
144    
145                    @Override
146                    public void removedService(
147                            ServiceReference<TemplateHandler> serviceReference,
148                            TemplateHandler templateHandler) {
149    
150                            Registry registry = RegistryUtil.getRegistry();
151    
152                            registry.ungetService(serviceReference);
153    
154                            _templateHandlers.remove(templateHandler.getClassName());
155                    }
156    
157            }
158    
159    }