/*
* 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);
}
}
}