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.mobile.device;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.security.pacl.permission.PortalRuntimePermission;
020    import com.liferay.portal.kernel.util.GetterUtil;
021    import com.liferay.portal.kernel.util.Validator;
022    import com.liferay.registry.Registry;
023    import com.liferay.registry.RegistryUtil;
024    import com.liferay.registry.ServiceReference;
025    import com.liferay.registry.ServiceTracker;
026    import com.liferay.registry.ServiceTrackerCustomizer;
027    
028    import java.util.Map;
029    import java.util.Set;
030    
031    import javax.servlet.http.HttpServletRequest;
032    
033    /**
034     * @author Milen Dyankov
035     * @author Raymond Aug??
036     */
037    @ProviderType
038    public class DeviceDetectionUtil {
039    
040            public static Device detectDevice(HttpServletRequest request) {
041                    DeviceRecognitionProvider deviceRecognitionProvider =
042                            getDeviceRecognitionProvider();
043    
044                    if (deviceRecognitionProvider == null) {
045                            return UnknownDevice.getInstance();
046                    }
047    
048                    return deviceRecognitionProvider.detectDevice(request);
049            }
050    
051            public static DeviceRecognitionProvider getDeviceRecognitionProvider() {
052                    PortalRuntimePermission.checkGetBeanProperty(DeviceDetectionUtil.class);
053    
054                    if (_instance._deviceRecognitionProvider != null) {
055                            return _instance._deviceRecognitionProvider;
056                    }
057    
058                    return _instance._defaultDeviceRecognitionProvider;
059            }
060    
061            public static Set<VersionableName> getKnownBrands() {
062                    KnownDevices knownDevices = getKnownDevices();
063    
064                    return knownDevices.getBrands();
065            }
066    
067            public static Set<VersionableName> getKnownBrowsers() {
068                    KnownDevices knownDevices = getKnownDevices();
069    
070                    return knownDevices.getBrowsers();
071            }
072    
073            /**
074             * @deprecated As of 7.0.0, with no direct replacement
075             */
076            @Deprecated
077            public static Set<String> getKnownDeviceIdsByCapability(
078                    Capability capability) {
079    
080                    KnownDevices knownDevices = getKnownDevices();
081    
082                    Map<Capability, Set<String>> deviceIds = knownDevices.getDeviceIds();
083    
084                    return deviceIds.get(capability);
085            }
086    
087            public static Set<VersionableName> getKnownOperatingSystems() {
088                    KnownDevices knownDevices = getKnownDevices();
089    
090                    return knownDevices.getOperatingSystems();
091            }
092    
093            public static Set<String> getKnownPointingMethods() {
094                    KnownDevices knownDevices = getKnownDevices();
095    
096                    return knownDevices.getPointingMethods();
097            }
098    
099            public DeviceDetectionUtil() {
100                    Registry registry = RegistryUtil.getRegistry();
101    
102                    _serviceTracker = registry.trackServices(
103                            DeviceRecognitionProvider.class,
104                            new DeviceRecognitionProviderServiceTrackerCustomizer());
105    
106                    _serviceTracker.open();
107            }
108    
109            protected static KnownDevices getKnownDevices() {
110                    DeviceRecognitionProvider deviceRecognitionProvider =
111                            getDeviceRecognitionProvider();
112    
113                    KnownDevices knownDevices = null;
114    
115                    if (deviceRecognitionProvider == null) {
116                            knownDevices = NoKnownDevices.getInstance();
117                    }
118                    else {
119                            knownDevices = deviceRecognitionProvider.getKnownDevices();
120                    }
121    
122                    return knownDevices;
123            }
124    
125            private static final DeviceDetectionUtil _instance =
126                    new DeviceDetectionUtil();
127    
128            private volatile DeviceRecognitionProvider
129                    _defaultDeviceRecognitionProvider;
130            private volatile DeviceRecognitionProvider _deviceRecognitionProvider;
131            private final ServiceTracker
132                    <DeviceRecognitionProvider, DeviceRecognitionProvider> _serviceTracker;
133    
134            private class DeviceRecognitionProviderServiceTrackerCustomizer
135                    implements ServiceTrackerCustomizer
136                            <DeviceRecognitionProvider, DeviceRecognitionProvider> {
137    
138                    @Override
139                    public DeviceRecognitionProvider addingService(
140                            ServiceReference<DeviceRecognitionProvider> serviceReference) {
141    
142                            Registry registry = RegistryUtil.getRegistry();
143    
144                            DeviceRecognitionProvider deviceRecognitionProvider =
145                                    registry.getService(serviceReference);
146    
147                            String type = GetterUtil.getString(
148                                    serviceReference.getProperty("type"));
149    
150                            if (type.equals("default")) {
151                                    _defaultDeviceRecognitionProvider = deviceRecognitionProvider;
152                            }
153                            else {
154                                    _deviceRecognitionProvider = deviceRecognitionProvider;
155                            }
156    
157                            return deviceRecognitionProvider;
158                    }
159    
160                    @Override
161                    public void modifiedService(
162                            ServiceReference<DeviceRecognitionProvider> serviceReference,
163                            DeviceRecognitionProvider deviceRecognitionProvider) {
164                    }
165    
166                    @Override
167                    public void removedService(
168                            ServiceReference<DeviceRecognitionProvider> serviceReference,
169                            DeviceRecognitionProvider deviceRecognitionProvider) {
170    
171                            Registry registry = RegistryUtil.getRegistry();
172    
173                            String type = (String)serviceReference.getProperty("type");
174    
175                            if (Validator.isNotNull(type) && type.equals("default")) {
176                                    _defaultDeviceRecognitionProvider = null;
177                            }
178                            else {
179                                    _deviceRecognitionProvider = null;
180                            }
181    
182                            registry.ungetService(serviceReference);
183                    }
184    
185            }
186    
187    }