path: root/src/plugins/videos/src/com/motorola/studio/android/videos/ui/views/MOTODEVVideosView.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.videos.ui.views;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.action.ControlContribution;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.BrowserFunction;
import org.eclipse.swt.browser.ProgressAdapter;
import org.eclipse.swt.browser.ProgressEvent;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Device;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.layout.RowData;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.browser.IWebBrowser;
import org.eclipse.ui.browser.IWorkbenchBrowserSupport;
import org.eclipse.ui.part.ViewPart;
import org.osgi.framework.Bundle;

import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.common.log.UsageDataConstants;
import com.motorola.studio.android.common.utilities.EclipseUtils;
import com.motorola.studio.android.videos.Activator;
import com.motorola.studio.android.videos.i18n.VideosNLS;
import com.motorola.studio.android.videos.model.Video;
import com.motorola.studio.android.videos.model.VideoManager;
import com.motorola.studio.android.videos.ui.utils.UiUtilities;

/**
 * The view that contains all MOTODEV Video Tutorials
 */
public class MOTODEVVideosView extends ViewPart
{

    /*
     * The ID of the view as specified by the extension.
     */
    public static final String ID = "com.motorola.studio.android.videos.views.MOTODEVVideosView";

    /*
     * View state
     */
    private final String OPEN_EXTERNAL_BROWSER_PREFERENCE = "open.external.browser";

    /*
     * Video Manager
     */
    private VideoManager videoManager;

    /*
     * Resource constants
     */
    private final String VIDEO_WATCH_EMBED_HTML = "resources/watch_video.html";

    private final String VIDEO_WATCH_EMBED_HTML_JS_LIBRARY = "resources/swfobject.js";

    private final String VIEW_LOADING_ICON = "icons/loading_icon.gif";

    private final String VIEW_ERROR_ICON = "icons/error_icon.png";

    /*
     * Containers
     */
    private Composite parentComposite = null;

    private Composite container = null;

    private VideosListComposite videosListComposite;

    private SashForm sash;

    private VideoPlayerComposite videoPlayerArea;

    private String videoWatchURL;

    private String videoWatchJSLibraryURL;

    private Boolean flashPlayerSupport = null;

    private Boolean isBrowserLoaded = null;

    private static Boolean openExternalBrowser = null;

    public static int PLAY_LISTENER = 43214321;

    private Color backgroundColor = null;

    private Image viewErrorImg = null;

    private String loadingImgFullPath = null;

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite, org.eclipse.ui.IMemento)
     */
    @Override
    public void init(IViewSite site, IMemento memento) throws PartInitException
    {

        super.init(site, memento);

        try
        {

            Device device = getDefaultImage().getDevice();
            Bundle bundle = Activator.getDefault().getBundle();
            Display display = getSite().getShell().getDisplay();

            /*
             * Retrieve view state
             */
            if (openExternalBrowser == null && memento != null)
            {
                openExternalBrowser = memento.getBoolean(OPEN_EXTERNAL_BROWSER_PREFERENCE);
            }

            /*
             * Colors
             */
            backgroundColor = display.getSystemColor(SWT.COLOR_LIST_BACKGROUND);

            /*
             * HTML to be embedded in the browser
             */
            videoWatchURL =
                    FileLocator.toFileURL(bundle.getEntry(VIDEO_WATCH_EMBED_HTML)).getFile();

            // using the method getAbsolutePath is necessary for this to work on all systems
            videoWatchJSLibraryURL =
                    new Path(FileLocator.toFileURL(
                            bundle.getEntry(VIDEO_WATCH_EMBED_HTML_JS_LIBRARY)).getFile())
                            .toPortableString();

            /*
             * Images to be used
             */
            viewErrorImg =
                    new Image(device, FileLocator.toFileURL(bundle.getEntry(VIEW_ERROR_ICON))
                            .getPath());

            loadingImgFullPath =
                    FileLocator.toFileURL(
                            Activator.getDefault().getBundle().getEntry(VIEW_LOADING_ICON))
                            .getPath();

        }
        catch (IOException e)
        {
            StudioLogger.error(this.getClass(), "Error while initializing Videos View", e);
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
     */
    @Override
    public void createPartControl(Composite parent)
    {

        // just point to the parent so that it can be accessed by the Job that will be created
        parentComposite = parent;

        clearContent();

        /*
         * Display a loading screen while the content is not loaded
         */
        displayLoadingScreen(parent);

        /*
         * Create a Job to load the view content
         */
        Job refreshViews = new Job(VideosNLS.UI_Job_Refresh_View)
        {
            @Override
            protected IStatus run(IProgressMonitor monitor)
            {

                final Boolean[] showErrorComposite = new Boolean[1];
                showErrorComposite[0] = false;

                final String[] errorMessage = new String[1];
                errorMessage[0] = null;

                /*
                 * Try to load the videos information.
                 * If an exception is thrown, log the error and prepare to show 
                 * the error screen
                 */
                try
                {
                    videoManager = VideoManager.getInstance();
                    videoManager.load();
                    videoManager.sort(VideoManager.SORT_MOST_RECENT);
                }
                catch (Exception e)
                {
                    showErrorComposite[0] = true;
                    errorMessage[0] = VideosNLS.UI_ErrorMsg + " " + e.getLocalizedMessage();
                    StudioLogger.error(this.getClass(), "Error while initializing Videos View", e);
                }

                if (!monitor.isCanceled())
                {

                    /*
                     * Run the following code in the UI thread, whether it's the
                     * error screen or the videos screen itself. Also, disable the 
                     * loading composite that is being displayed
                     */
                    Display.getDefault().asyncExec(new Runnable()
                    {
                        public void run()
                        {

                            // dispose the loading composite
                            clearContent();

                            if (showErrorComposite[0])
                            {
                                // if an error occurred, display the error screen
                                displayErrorScreen(parentComposite, errorMessage[0]);
                            }
                            else
                            {
                                // ... otherwise, continue with the normal workflow
                                displayVideosScreen(parentComposite);
                            }

                        }
                    });

                }

                return Status.OK_STATUS;
            }

            @Override
            public boolean belongsTo(Object family)
            {
                // relate the Job to this view
                return getTitle().equals(family);
            }

        };

        // Schedule the job to run
        refreshViews.schedule();

    }

    /**
     * Display the videos screen
     * 
     * @param parent the parent composite
     */
    private void displayVideosScreen(Composite parent)
    {

        // Create the main composite container
        container = new Composite(parent, SWT.NONE);
        container.setLayoutData(new GridData(GridData.FILL_BOTH));
        container.setLayout(new GridLayout(1, false));

        sash = new SashForm(container, SWT.VERTICAL | SWT.SMOOTH | SWT.BORDER);

        sash.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        // Create a global media player area, with the media player and info related to the video
        createMediaPlayerAndToolbarArea(sash);

        // Create videos list area
        createVideosListArea(sash);

        // Adjust the media player size then the view changes its size
        sash.getChildren()[0].addControlListener(new ControlListener()
        {
            public void controlResized(ControlEvent e)
            {
                videoPlayerArea.adjustMediaPlayerSize(sash);
            }

            public void controlMoved(ControlEvent e)
            {
                //do nothing   
            }
        });

        sash.setWeights(new int[]
        {
                1, 2
        });
        parentComposite.layout();

    }

    /**
     * Display the loading screen
     * 
     * @param parent the parent composite
     * @return the loading composite
     */
    private void displayLoadingScreen(Composite parent)
    {
        container =
                displayInfoScreen(parent, loadingImgFullPath, null, VideosNLS.UI_Loading, null,
                        false);

        parentComposite.layout();
    }

    /**
     * Display the error screen
     * 
     * @param parent the parent composite
     */
    private void displayErrorScreen(Composite parent, String error)
    {

        container = displayInfoScreen(parent, null, viewErrorImg, error, new SelectionAdapter()
        {
            @Override
            public void widgetSelected(SelectionEvent e)
            {
                EclipseUtils.openNetworkPreferences(getSite().getShell());
            }
        }, true);

        parentComposite.layout();

    }

    /**
     * Generic method that display a information message (loading, error, warning, etc) in 
     * the screen, being composed of an image, a text and possibly a reload button
     * 
     * @param parent the parent composite
     * @param imagePath path to the image that must be displayed
     * @param image alternatively, if no path is provided (null), an Image object can be used
     * @param message the message to be displayed (a Link will be used to display the message)
     * @param selectionListener handler to be called when the user clicks on the message
     * @param reloadButton whether a "reload" button should be displayed or not
     * @return the composite created to construct the view
     */
    private Composite displayInfoScreen(Composite parent, String imagePath, Image image,
            String message, SelectionListener selectionListener, boolean reloadButton)
    {

        Composite mainComposite = new Composite(parent, SWT.NONE);
        mainComposite.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, true, true));
        mainComposite.setLayout(new GridLayout(1, false));
        mainComposite.setBackground(backgroundColor);

        Composite centeredComposite = new Composite(mainComposite, SWT.NONE);
        centeredComposite.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, true, true));
        centeredComposite.setLayout(new GridLayout(1, false));
        centeredComposite.setBackground(backgroundColor);

        /*
         * Status image
         */
        final Label infoImg = new Label(centeredComposite, SWT.NONE);
        infoImg.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, true, false));
        infoImg.setBackground(backgroundColor);

        // Checking the mime type doesn't work on Linux
        // MimetypesFileTypeMap.getDefaultFileTypeMap().getContentType(new File(imagePath)).equals("image/gif"))
        // Instead of "image/gif", it returns "application/octet-stream"
        if (imagePath != null && imagePath.endsWith(".gif"))
        {
            UiUtilities.displayAnimatedGIF(getDefaultImage().getDevice(), imagePath, infoImg);
        }
        else if (image != null)
        {
            infoImg.setImage(image);
        }

        /*
         * Status text
         */
        Link infoText = new Link(centeredComposite, SWT.NONE);
        GridData loadingTextGridData = new GridData(SWT.CENTER, SWT.NONE, true, false);
        loadingTextGridData.verticalIndent = 10;
        infoText.setLayoutData(loadingTextGridData);
        infoText.setBackground(backgroundColor);
        infoText.setText(message);
        if (selectionListener != null)
        {
            infoText.addSelectionListener(selectionListener);
        }

        /*
         * Reload button, if requested
         */
        if (reloadButton)
        {
            Button button = new Button(centeredComposite, SWT.NONE);
            GridData buttonGridData = new GridData(SWT.CENTER, SWT.NONE, false, false);
            buttonGridData.verticalIndent = 10;
            button.setLayoutData(buttonGridData);
            button.setText(VideosNLS.UI_Reload);
            button.addSelectionListener(new SelectionAdapter()
            {
                @Override
                public void widgetSelected(SelectionEvent e)
                {
                    reloadView();
                }
            });
        }

        return mainComposite;
    }

    /**
     * Select the initial video to be displayed
     * It's the first video of the first channel
     */
    private void selectInitialVideo()
    {

        if (openExternalBrowser != null && !openExternalBrowser)
        {
            Video firstVideo = null;
            try
            {
                firstVideo = videoManager.getActiveChannels().get(0).getVideos().get(0);
            }
            catch (Exception e)
            {
                StudioLogger.error(this.getClass(), "No initial video to set", e);
            }

            if (firstVideo != null)
            {
                playVideo(firstVideo);
            }

            videoPlayerArea.adjustVideoPlayerInitialSize();
        }
    }

    /**
     * Clear view content, i.e. remove everything being displayed
     */
    private void clearContent()
    {
        if (container != null && !container.isDisposed())
        {
            container.dispose();
        }

    }

    /**
     * Try to reload the view
     */
    private void reloadView()
    {
        createPartControl(parentComposite);
    }

    /**
     * Create the view toolbar, with search field and a checkbox to
     * define if the video must be displayed inside the view or in 
     * the external browser
     */
    private void createToolBar()
    {
        ToolBarManager tbManager =
                (ToolBarManager) getViewSite().getActionBars().getToolBarManager();
        tbManager.add(new ToolbarContribution("MOTODEV Video Tutorials Toolbar"));
        tbManager.update(true);
        getViewSite().getActionBars().updateActionBars();
    }

    /**
     * Create the area that contains the media player (browser embedded) as well as
     * the information about the video being watched.
     * 
     * Additionally, the toolbar are is also created after the browser is loaded, since 
     * it depends on information acquired during browser loading (such as browser compatibility
     * and Flash Player availability)
     * 
     * @param parent the parent SashForm composite
     */
    private void createMediaPlayerAndToolbarArea(SashForm parent)
    {
        Composite newPage = new Composite(parent, SWT.BORDER);
        GridLayout layout = new GridLayout(1, false);
        layout.marginWidth = 1;
        layout.marginHeight = 1;
        newPage.setLayout(layout);
        newPage.setVisible(false);

        videoPlayerArea = new VideoPlayerComposite(newPage);
        videoPlayerArea.createVideoPlayerArea(new Font(getDefaultImage().getDevice(), getSite()
                .getShell().getDisplay().getSystemFont().getFontData()[0].getName(), 12, SWT.BOLD));
        Browser browser = videoPlayerArea.getBrowser();
        new FlashPlayerDetection(browser, "hasFlashPlayer");
        // identify when the page is loaded
        browser.addProgressListener(new ProgressAdapter()
        {

            @Override
            public void completed(ProgressEvent event)
            {
                // only the first loading matters, so that we remove the listener, 
                // otherwise it would be called each time a new video is selected to
                // be played
                isBrowserLoaded = true;
                videoPlayerArea.getBrowser().removeProgressListener(this);

                /*
                 * The toolbar is only created when the embedded page is loaded
                 */
                createToolBar();
                selectInitialVideo();
            }
        });

        // Set the JavaScript library source (with the real path) and open the URL
        File file = getVideoWatchHTML(videoWatchURL, videoWatchJSLibraryURL);
        browser.setUrl(file.toString());
    }

    /**
     * Get the HTML to be used in runtime, with the JavasScript library real path
     * set. This is necessary because relative paths do not work, and loading
     * the lib programmatically using JavaScript doesn't work on Linux and MacOS 
     * since this is a async process and the objects defined in the lib might not
     * be loaded when you try to use them. 
     * 
     * @param fileURL the original HTML file
     * @param javascriptSrc the JavaScript full path
     * @return a file with the original HTML file, but with the JavasScript full path set
     */
    private File getVideoWatchHTML(String fileURL, String javascriptSrc)
    {

        File tempFile = null;

        BufferedReader bReader = null;
        BufferedWriter bWriter = null;
        FileReader fReader = null;
        FileWriter fWriter = null;
        try
        {
            // the original file
            File originalFile = new File(fileURL);

            // the temp file, with the same name as the original
            String[] tempFileName = originalFile.getName().split("\\.");
            tempFile = File.createTempFile(tempFileName[0], "." + tempFileName[1]);
            tempFile.deleteOnExit();

            /*
             * Read the original file and copy it's content to the temp file, 
             * at the same time that the placeholders for the javascript library
             * path is replaced by the real path(s)
             */
            fReader = new FileReader(originalFile);
            fWriter = new FileWriter(tempFile);
            bReader = new BufferedReader(fReader);
            bWriter = new BufferedWriter(fWriter);
            String line;
            StringBuffer stringBuffer = new StringBuffer();
            while ((line = bReader.readLine()) != null)
            {
                stringBuffer.append(line);
            }
            bWriter.write(stringBuffer.toString().replace("@@JAVASCRIPT_SRC@@", javascriptSrc));

        }
        catch (IOException e)
        {
            StudioLogger.error(this.getClass(),
                    "Could not create the HTML to be diplayed in the Browser widget", e);
        }
        finally
        {
            // close both reader/writer
            try
            {
                bWriter.close();
                bReader.close();
                fWriter.close();
                fReader.close();
            }
            catch (IOException e)
            {
                StudioLogger.error(e.getMessage());
            }

        }

        return tempFile;
    }

    /**
     * Crate the tabs, which represent the playlists
     * 
     * @param parent the parent composite
     */
    private void createVideosListArea(Composite parent)
    {
        Composite newPage = new Composite(parent, SWT.NONE);
        newPage.setLayout(new GridLayout(1, false));

        videosListComposite =
                new VideosListComposite(newPage, SWT.NONE, videoManager.getActiveChannels(),
                        videoManager.getDefaultChannel().getName());
        videosListComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        videosListComposite.addListener(MOTODEVVideosView.PLAY_LISTENER, new Listener()
        {
            public void handleEvent(Event event)
            {
                playVideo((Video) event.data);
            }
        });
    }

    /**
     * Play the video, whether using the internal or external browser
     * 
     * @param video     the video to be played
     */
    private void playVideo(Video video)
    {

        if (openExternalBrowser == null || openExternalBrowser)
        {
            openVideoInExternalBrowser(video);
        }
        else
        {
            openVideoInEmbeddedBrowser(video);
        }

        // Log video playback
        try
        {

            StudioLogger.collectUsageData(UsageDataConstants.WHAT_VIDEOS_PLAY,
                    UsageDataConstants.KIND_VIDEOS,
                    "Video Played: "
                            + video.getId()
                            + "|"
                            + video.getTitle()
                            + "|"
                            + (openExternalBrowser != null ? openExternalBrowser.toString()
                                    : "null"), Activator.PLUGIN_ID, Activator.getDefault()
                            .getBundle().getVersion().toString());
        }
        catch (Exception e)
        {
            // do nothing, just do that to be safe and to not break the functionality
            // due to errors when logging usage information
        }

    }

    /**
     * Play the video using the embedded browser
     * 
     * @param video the video to be played
     */
    private void openVideoInEmbeddedBrowser(Video video)
    {
        videoPlayerArea.openVideo(video);
        /*
         * Select video in the list
         */
        videosListComposite.setSelectedVideo(video);

        parentComposite.layout();

        /*
         * Adjust size
         */
        videoPlayerArea.adjustMediaPlayerSize(sash);
    }

    /**
     * Open the external browser
     * 
     * @param video the video to be opened
     */
    private void openVideoInExternalBrowser(Video video)
    {

        IWorkbenchBrowserSupport browserSupport = PlatformUI.getWorkbench().getBrowserSupport();
        IWebBrowser browser;
        try
        {

            browser =
                    browserSupport.createBrowser(IWorkbenchBrowserSupport.LOCATION_BAR
                            | IWorkbenchBrowserSupport.NAVIGATION_BAR
                            | IWorkbenchBrowserSupport.AS_EXTERNAL, VideosNLS.UI_MOTODEV_Video
                            + video.getTitle(), null, null);
            browser.openURL(new URL(video.getExternalLink()));

        }
        catch (Exception e)
        {
            StudioLogger.error(this.getClass(), "Error opening video on external browser", e);
        }
    }

    /**
     * Filter videos in the UI based on the search results
     * 
     * @param keyword search keyword
     */
    private void searchAndFilter(String keyword)
    {
        // execute trim and remove duplicated blank spaces
        keyword = removeDuplicatedBlankSpaces(keyword.trim());

        // search and filter
        videosListComposite.filter(videoManager.search(keyword), keyword.equals(""));
        // highlight keywords
        videosListComposite.highlightKeywords(keyword);

    }

    /**
     * Remove all duplicated spaces in a given string
     * 
     * @param text the string to have duplicated spaces removed
     * @return the string passed as parameter with no duplicated spaces
     */
    private String removeDuplicatedBlankSpaces(String text)
    {
        Pattern pattern = Pattern.compile("\\s+");
        Matcher matcher = pattern.matcher(text);
        matcher.find();
        return matcher.replaceAll(" ");
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#dispose()
     */
    @Override
    public void dispose()
    {
        super.dispose();
        if (container != null && !container.isDisposed())
        {
            container.dispose();
        }
        // cancel all jobs related to this view
        Job.getJobManager().cancel(getTitle());
    }

    /* 
     * Save the view state when the workbench is closed
     * 
     * @see org.eclipse.ui.part.ViewPart#saveState(org.eclipse.ui.IMemento)
     */
    @Override
    public void saveState(IMemento memento)
    {
        if (canPlayEmbeddedVideo() && openExternalBrowser != null)
        {
            memento.putBoolean(OPEN_EXTERNAL_BROWSER_PREFERENCE, openExternalBrowser);
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
     */
    @Override
    public void setFocus()
    {
        // nothing
    }

    /**
     * Check if the browser can load web pages. Due to several problems of the 
     * Browser widget on Linux, we are disabling this feature on this OS for now. 
     * 
     * Some of the problems on Linux are:
     *      - Browser doesn't work with some proxies
     *      - Intermitent crashes of SWT
     *      - The Browser widget blinks on the screen
     *      
     * For MacOS X, it's enabled only from Snow Leopard on (> 10.6), since the Browser 
     * widget might not work correctly in Leopard with Flash Player 64 bits, since the 
     * kernel modules themselves run in 32 bits, what causes a crash (Studio closes).
     * 
     * @return "true" if the browser can load pages, "false" otherwise
     */
    private boolean canPlayEmbeddedVideo()
    {

        Boolean result = false;

        // for now, the correct version will only be analyzed on MacOSX
        boolean correctVersion = true;

        if (Platform.getOS().equals(Platform.OS_MACOSX))
        {
            String versionText = System.getProperty("os.version");

            // Get the version as a number
            float versionNumber = 0;
            try
            {

                if (!versionText.contains("."))
                {
                    versionNumber = Integer.parseInt(versionText);
                }
                else
                {
                    String[] versionPieces = versionText.split("\\.");
                    versionNumber =
                            Float.parseFloat(versionPieces[0] + "."
                                    + (!versionPieces[1].equals("") ? versionPieces[1] : "0"));

                }
            }
            catch (NumberFormatException e)
            {
                StudioLogger.error(this.getClass(), "Cannot get the OS version", e);
            }

            // Leopard = 10.5 = not supported
            if (versionNumber <= 10.5)
            {
                correctVersion = false;
            }

        }

        // If we are not on Linux and the MacOS X has the correct version, 
        // check if the browser could load the web page and, consequently,
        // if the flash player is supported or not
        if (!Platform.getOS().equals(Platform.OS_LINUX) && correctVersion)
        {
            if (isBrowserLoaded != null && isBrowserLoaded && flashPlayerSupport != null)
            {
                result = true;
            }
        }

        // Log player support
        try
        {

            StudioLogger.collectUsageData(UsageDataConstants.WHAT_VIDEOS_PLAYER_SUPPORT,
                    UsageDataConstants.KIND_VIDEOS, result.toString() + "|" + Platform.getOS()
                            + "|" + correctVersion, Activator.PLUGIN_ID, Activator.getDefault()
                            .getBundle().getVersion().toString());
        }
        catch (Exception e)
        {
            // do nothing, just do that to be safe and to not break the functionality
            // due to errors when logging usage information
        }

        return result;
    }

    /**
     * Check if an appropriate version of Flash Player was found, which
     * means that the videos can be displayed in the embedded browser
     * 
     * @return "true" if an appropriate version of Flash Player was found, "false" otherwise
     */
    private boolean hasFlashPlayer()
    {
        Boolean result = false;

        if (isBrowserLoaded != null && isBrowserLoaded && flashPlayerSupport != null)
        {
            result = flashPlayerSupport;
        }

        // Log flash player support
        try
        {

            StudioLogger.collectUsageData(UsageDataConstants.WHAT_VIDEOS_PLAYER_SUPPORT,
                    UsageDataConstants.KIND_VIDEOS, result.toString(), Activator.PLUGIN_ID,
                    Activator.getDefault().getBundle().getVersion().toString());
        }
        catch (Exception e)
        {
            // do nothing, just do that to be safe and to not break the functionality
            // due to errors when logging usage information
        }

        return result;
    }

    /**
     * Get the message that will be displayed to the user to inform that 
     * the appropriate version of Flash Player was not found 
     * 
     * @return the "no Flash Player" message
     */
    private String getNoFlashMessage()
    {
        String message = VideosNLS.UI_No_Flash_Player + " ";

        if (Platform.getOSArch().equals(Platform.ARCH_X86))
        {
            // 32 bits
            message +=
                    NLS.bind(VideosNLS.UI_No_Flash_Player_32bits_Extension,
                            VideosNLS.UI_Flash_Player_Link_32bits);
        }
        else
        {
            // 64 bits
            message +=
                    NLS.bind(VideosNLS.UI_No_Flash_Player_64bits_Extension,
                            VideosNLS.UI_Flash_Player_Link_64bits);
        }

        return message;
    }

    /**
     * Create the toolbar, with a search field and a checkbox to
     * define if the video must be displayed inside the view or in
     * the external browser
     */
    private class ToolbarContribution extends ControlContribution
    {

        protected ToolbarContribution(String id)
        {
            super(id);
        }

        @Override
        protected Control createControl(Composite parent)
        {

            Composite toolbarComposite = new Composite(parent, SWT.NONE);
            toolbarComposite.setLayout(new RowLayout(SWT.HORIZONTAL));

            final Text searchText = new Text(toolbarComposite, SWT.SEARCH);
            searchText.setLayoutData(new RowData(150, SWT.DEFAULT));
            searchText.setMessage(VideosNLS.UI_Search);

            searchText.addModifyListener(new ModifyListener()
            {
                public void modifyText(ModifyEvent e)
                {
                    searchAndFilter(searchText.getText());
                }
            });

            if (canPlayEmbeddedVideo())
            {

                // recover the state, if there is flash player
                // if there is NO flash player, the checkbox is always selected
                boolean enablement = hasFlashPlayer();
                boolean selection =
                        !enablement ? true : openExternalBrowser != null ? openExternalBrowser
                                : false;
                final Button openExternal = new Button(toolbarComposite, SWT.CHECK);
                openExternal.setText(VideosNLS.UI_Open_External_Browser);
                openExternal.setToolTipText(VideosNLS.UI_Open_External_Browser);
                openExternal.setEnabled(enablement);
                openExternal.setSelection(selection);
                openExternalBrowser = selection;

                if (!enablement)
                {
                    Label warningImg = new Label(toolbarComposite, SWT.NONE);
                    warningImg.setImage(PlatformUI.getWorkbench().getSharedImages()
                            .getImage(ISharedImages.IMG_OBJS_WARN_TSK));
                    warningImg.setToolTipText(getNoFlashMessage());
                }

                openExternal.addSelectionListener(new SelectionAdapter()
                {
                    @Override
                    public void widgetSelected(SelectionEvent e)
                    {
                        openExternalBrowser = openExternal.getSelection();
                    }
                });

            }

            return toolbarComposite;

        }
    }

    /**
     * Function called from JavaScript to inform if the browser
     * could find Adobe Flash Player or not
     */
    private class FlashPlayerDetection extends BrowserFunction
    {

        @Override
        public Object function(Object[] arguments)
        {
            flashPlayerSupport = new Boolean(arguments[0].toString());
            return null;
        }

        public FlashPlayerDetection(Browser browser, String name)
        {
            super(browser, name);
        }

    }

}