path: root/src/plugins/common/src/com/motorola/studio/android/common/utilities/PluginUtils.java

/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.motorola.studio.android.common.utilities;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.Bundle;

import com.motorola.studio.android.common.exception.AndroidException;
import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.common.utilities.i18n.UtilitiesNLS;

/**
 * DESCRIPTION: This class serves as an utility class containing only static methods such as getters
 * for plugin attributes, plugin resources, installation path etc
 *
 * USAGE: Import this class then use the static methods.
 */
public class PluginUtils
{
    public static final int OS_WINDOWS = 0;

    public static final int OS_LINUX = 1;

    /**
     * Returns a plugin attribute using the extension as parameter.
     *
     * @param fromExtension
     *         the extension from which the attribute should be collected
     * @param element
     *         the extension element
     * @param attribute
     *         the extension attribute
     *
     * @return
     *         the value of the extension attribute
     *
     * @throws MotodevExtensionException if the executable cannot be created for any reason
     */
    public static Object getExecutable(String extensionId, String elementName, String executableName)
            throws Exception

    {
        Object executable = null;

        IExtension fromExtension = getExtension(extensionId);

        if ((fromExtension != null) && (elementName != null))
        {
            IConfigurationElement[] elements = fromExtension.getConfigurationElements();

            for (IConfigurationElement element : elements)
            {
                if (elementName.equals(element.getName()))
                {
                    try
                    {
                        executable = element.createExecutableExtension(executableName);
                    }
                    catch (Exception e)
                    {
                        String errMsg =
                                NLS.bind(
                                        UtilitiesNLS.EXC_PluginUtils_ErrorGettingTheExecutableFromExtensionPoint,
                                        new Object[]
                                        {
                                                executableName, elementName, extensionId
                                        });
                        StudioLogger.error(PluginUtils.class, errMsg, e);

                        throw new Exception(errMsg, e);
                    }
                }
            }
        }

        return executable;
    }

    /**
     * Returns a plugin attribute using the extension as parameter.
     *
     * @param fromExtension
     *         the extension from which the attribute should be collected
     * @param element
     *         the extension element
     * @param attribute
     *         the extension attribute
     *
     * @return
     *         the value of the extension attribute
     *
     * @throws MotodevExtensionException if the executable cannot be created for any reason
     */
    public static Object getExecutable(String extensionId, String elementName) throws Exception
    {
        return getExecutable(extensionId, elementName, "class");
    }

    /**
     * Returns the extension using as parameters the id of the extension
     * and the id of its extension point.
     *
     * @param extensionPointId
     *         the id of the extension point
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         the extension
     */
    public static IExtension getExtension(String extensionPointId, String extensionId)
    {
        IExtensionRegistry registry = Platform.getExtensionRegistry();
        IExtension extension = registry.getExtension(extensionPointId, extensionId);

        return extension;
    }

    /**
     * Returns the extension using as parameter only the id of the extension.
     *
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         the extension
     */
    public static IExtension getExtension(String extensionId)
    {
        IExtensionRegistry registry = Platform.getExtensionRegistry();
        IExtension extension = registry.getExtension(extensionId);

        return extension;
    }

    /**
     * Returns the label for the extension (extension name) using as parameters
     * the id of the extension and the id of its extension point.
     *
     * @param extensionPointId
     *         the id of the extension point
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         the extension label
     */
    public static String getExtensionLabel(String extensionPointId, String extensionId)
    {
        IExtension extension = getExtension(extensionPointId, extensionId);
        String extensionLabel;

        if (extension != null)
        {
            extensionLabel = extension.getLabel();
        }
        else
        {
            extensionLabel = extensionId;
        }

        return extensionLabel;
    }

    /**
     * Returns the label for the extension (extension name) using as parameter only
     * the id of the extension.
     *
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         the extension label
     */
    public static String getExtensionLabel(String extensionId)
    {
        IExtension extension = getExtension(extensionId);
        String extensionLabel;

        if (extension != null)
        {
            extensionLabel = extension.getLabel();
        }
        else
        {
            extensionLabel = extensionId;
        }

        return extensionLabel;
    }

    /**
     * Returns a collection of strings containing the ids of installed plugins.
     *
     * @param extensionPointId
     *         the id of the extension point
     *
     * @return
     *         a collection object containing the ids of the installed plugins
     */
    public static Collection<String> getInstalledPlugins(String extensionPointId)
    {
        IExtensionRegistry registry = Platform.getExtensionRegistry();
        IExtensionPoint extensionPoint = registry.getExtensionPoint(extensionPointId);
        Collection<String> pluginIds = new LinkedHashSet<String>();

        if (extensionPoint != null)
        {
            for (IExtension extension : extensionPoint.getExtensions())
            {
                pluginIds.add(extension.getUniqueIdentifier());
            }
        }

        return pluginIds;
    }

    /**
     * Fills an array object with the ids contained in the collection object returned by
     * {@link #getInstalledPlugins(String)}.
     *
     * @param extensionPointId
     *         the id of the extension point
     *
     * @return
     *         an array object containing the ids of the installed plugins
     */
    public static String[] getInstalledPluginsAsArray(String extensionPointId)
    {
        Collection<String> sampleAppPluginIds = getInstalledPlugins(extensionPointId);
        String[] sampleAppPluginIdsArray = new String[sampleAppPluginIds.size()];

        return sampleAppPluginIds.toArray(sampleAppPluginIdsArray);
    }

    /**
     * Retrieves the namespaces used by the platform.
     *
     *
     * @return a collection with the namespaces used by the platform
     */
    public static Collection<String> getPlatformNamespaces()
    {
        IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
        String[] namespaces = extensionRegistry.getNamespaces();

        return Arrays.asList(namespaces);
    }

    /**
     * Returns a plugin attribute using the extension id and the extension point id as parameters.
     *
     * @param extensionPointId
     *         the id of the extension point of the exten sion
     * @param extensionId
     *         the id of the extension
     * @param element
     *         the extension element
     * @param attribute
     *         the extension attribute
     *
     * @return
     *         the value of the extension attribute
     */
    public static String getPluginAttribute(String extensionPointId, String extensionId,
            String element, String attribute)
    {
        IExtension fromPlugin = getExtension(extensionPointId, extensionId);

        return getPluginAttribute(fromPlugin, element, attribute);
    }

    /**
     * Returns a plugin attribute using the extension id and the extension point id as parameters.
     *
     * @param extensionId
     *         the id of the extension
     * @param element
     *         the extension element
     * @param attribute
     *         the extension attribute
     *
     * @return
     *         the value of the extension attribute
     */
    public static String getPluginAttribute(String extensionId, String element, String attribute)
    {
        IExtension fromPlugin = getExtension(extensionId);

        return getPluginAttribute(fromPlugin, element, attribute);
    }

    /**
     * Returns a plugin attribute using the extension as parameter.
     *
     * @param fromExtension
     *         the extension from which the attribute should be collected
     * @param element
     *         the extension element
     * @param attribute
     *         the extension attribute
     *
     * @return
     *         the value of the extension attribute
     */
    public static String getPluginAttribute(IExtension fromExtension, String element,
            String attribute)
    {
        String attributeValue = null;

        if (fromExtension != null)
        {
            IConfigurationElement[] ceArray = fromExtension.getConfigurationElements();

            for (IConfigurationElement ce : ceArray)
            {
                if ((ce != null) && ce.getName().equals(element))
                {
                    attributeValue = ce.getAttribute(attribute);
                }
            }
        }

        return attributeValue;
    }

    /**
     * DOCUMENT ME
     *
     * @param extensionId DOCUMENT ME!
     * @param element DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public static Collection<Map<String, String>> getPluginAttributes(String extensionId,
            String element)
    {
        IExtension fromExtension = getExtension(extensionId);

        return getPluginAttributes(fromExtension, element);
    }

    /**
     * DOCUMENT ME
     *
     * @param fromExtension DOCUMENT ME!
     * @param element DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    public static Collection<Map<String, String>> getPluginAttributes(IExtension fromExtension,
            String element)
    {
        Collection<Map<String, String>> elementValues = new LinkedHashSet<Map<String, String>>();

        if (fromExtension != null)
        {
            IConfigurationElement[] ceArray = fromExtension.getConfigurationElements();

            for (IConfigurationElement ce : ceArray)
            {
                if ((ce != null) && ce.getName().equals(element))
                {
                    String[] attributes = ce.getAttributeNames();

                    if ((attributes != null) && (attributes.length > 0))
                    {
                        int attributesLenght = attributes.length;
                        Map<String, String> attributesMap =
                                new LinkedHashMap<String, String>(attributesLenght,
                                        attributesLenght);

                        for (String attribute : attributes)
                        {
                            String attributeValue = ce.getAttribute(attribute);

                            if ((attributeValue != null) && (!attributeValue.equals("")))
                            {
                                attributesMap.put(attribute, attributeValue);
                            }
                        }

                        // only add to elementValues if all values were read correctly
                        if (attributesMap.size() == attributesLenght)
                        {
                            elementValues.add(attributesMap);
                        }
                    }
                }
            }
        }

        return elementValues;
    }

    /**
     * Returns the absolute path of installation as a file object using the plugin as parameter.
     *
     * @param plugin
     *         the plugin installed
     *
     * @return
     *         a file object pointing to the installation path of the plugin
     */
    public static File getPluginInstallationPath(Plugin plugin)
    {
        Bundle pluginBundle = plugin.getBundle();

        return getPluginInstallationPath(pluginBundle);
    }

    /**
     * Returns the absolute path of installation as a file object using the ids of the extension
     * and extension point as parameters.
     *
     * @param extensionPointId
     *         the id of the extension point
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         a file object pointing to the installation path of the plugin
     */
    public static File getPluginInstallationPath(String extensionPointId, String extensionId)
    {
        IExtension extension = getExtension(extensionPointId, extensionId);

        return getPluginInstallationPath(extension);
    }

    /**
     * Returns the absolute path of installation as a file object using the extension as parameter.
     *
     * @param extension
     *         the extension object
     *
     * @return
     *         a file object pointing to the installation path of the plugin
     */
    public static File getPluginInstallationPath(IExtension extension)
    {
        String pluginId = extension.getNamespaceIdentifier();
        Bundle pluginBundle = Platform.getBundle(pluginId);

        return getPluginInstallationPath(pluginBundle);
    }

    /**
     * Returns the absolute path of installation as a file object using the plugin bundle as parameter.
     *
     * @param pluginBundle
     *         the plugin bundle
     *
     * @return
     *         a file object pointing to the installation path of the plugin
     */
    public static File getPluginInstallationPath(Bundle pluginBundle)
    {
        //get file using FileLocator
        File relativeInstalationPath = null;
        try
        {
            relativeInstalationPath =
                    new File(FileLocator.toFileURL(pluginBundle.getEntry("")).getFile());
        }
        catch (IOException e)
        {
            StudioLogger.warn("Illegal state while getting plugin installation path ("
                    + e.getMessage() + ").");
        }

        //if failed to get the file using FileLocator        
        if (relativeInstalationPath == null)
        {
            String platformPath = Platform.getInstallLocation().getURL().getPath();
            String pluginPath = pluginBundle.getLocation();
            int removeIndex = pluginPath.indexOf("@");
            pluginPath = pluginPath.substring(removeIndex + 1);

            relativeInstalationPath = new File(platformPath, pluginPath);
        }

        return FileUtil.getCanonicalFile(relativeInstalationPath);
    }

    /**
     * Returns a file object from the path: $installationPath\resource
     *
     * @param plugin
     *         the plugin object
     *
     * @param resource
     *         the plugin resource
     *
     * @return
     *         a file object pointing to the path of the resource
     *
     * @throws MotodevResourceNotAvailable
     *         throws an exception if it occurs an I/O exception with the path $installationPath\resource
     */
    public static File getPluginResource(Plugin plugin, String resource) throws Exception
    {
        File pluginPath = getPluginInstallationPath(plugin);
        File resourceFile = new File(pluginPath, resource);
        File canonicalFile = null;

        canonicalFile = FileUtil.getCanonicalFile(resourceFile);

        return canonicalFile;
    }

    /**
     * Checks if an extension is installed using the extension point id and extension id as parameters.
     *
     * @param extensionPointId
     *         the id of the extension point
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         true if the extension is installed or false otherwise
     */
    public static boolean isInstalled(String extensionPointId, String extensionId)
    {
        return getExtension(extensionPointId, extensionId) != null;
    }

    /**
     * Checks if an extension is installed using the extension id as parameter.
     *
     * @param extensionId
     *         the id of the extension
     *
     * @return
     *         true if the extension is installed or false otherwise
     */
    public static boolean isInstalled(String extensionId)
    {
        return getExtension(extensionId) != null;
    }

    /**
     * Returns which is the OS.
     * @return
     *      a code corresponding to the proper OS
     */
    public static int getOS()
    {
        int result = -1;

        String osName = System.getProperty("os.name").toLowerCase();

        if (osName.indexOf("linux") > -1)
        {
            result = OS_LINUX;
        }

        else if (osName.indexOf("windows") > -1)
        {
            result = OS_WINDOWS;
        }

        return result;
    }

    /**
     * Retrieves the File object representing a file stored into the
     * preferences area of the given plugin
     *
     * @return the File inside the given plugin preferences area.
     * @throws MotodevException if it fails to determine the preferences directory of the given plugin
     */
    public final static File getFileOnPreferenceDirectory(Plugin plugin, String filename)
            throws Exception
    {
        File targetXmlFile = null;

        try
        {
            IPath path = plugin.getStateLocation();

            if (path != null)
            {
                path = path.append(filename);
                targetXmlFile = path.toFile().getAbsoluteFile();
            }
        }
        catch (IllegalStateException e)
        {
            StudioLogger.warn("Illegal state while getting file on preferences directory ("
                    + e.getMessage() + ").");
        }

        if (targetXmlFile == null)
        {
            throw new AndroidException("Could use file " + filename + " on preferences plug-in "
                    + plugin.getBundle().getBundleId());
        }

        return targetXmlFile;
    }
}