diff -r 000000000000 -r a02c979e8dfd srcanaapps/apiquerytool/com.nokia.s60tools.apiquery.cache/src/com/nokia/s60tools/apiquery/cache/searchmethod/LocalCacheSearchMethodExtension.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/srcanaapps/apiquerytool/com.nokia.s60tools.apiquery.cache/src/com/nokia/s60tools/apiquery/cache/searchmethod/LocalCacheSearchMethodExtension.java Sat Jan 09 10:04:11 2010 +0530
@@ -0,0 +1,859 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+package com.nokia.s60tools.apiquery.cache.searchmethod;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Hashtable;
+import java.util.Set;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExecutableExtension;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.jobs.IJobChangeEvent;
+import org.eclipse.core.runtime.jobs.IJobChangeListener;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.browser.IWebBrowser;
+
+
+
+import com.nokia.s60tools.apiquery.cache.configuration.CacheEntry;
+import com.nokia.s60tools.apiquery.cache.configuration.CacheEntryStorage;
+import com.nokia.s60tools.apiquery.cache.core.job.UpdateSDKSelectionJob;
+import com.nokia.s60tools.apiquery.cache.resources.Messages;
+import com.nokia.s60tools.apiquery.cache.searchmethod.ui.LocalCacheUIComposite;
+import com.nokia.s60tools.apiquery.cache.util.SDKFinder;
+import com.nokia.s60tools.apiquery.cache.util.SDKUtil;
+import com.nokia.s60tools.apiquery.cache.xml.MetadataXMLToUIMappingRules;
+import com.nokia.s60tools.apiquery.popup.actions.OpenFileAction;
+import com.nokia.s60tools.apiquery.shared.datatypes.APIDetailField;
+import com.nokia.s60tools.apiquery.shared.datatypes.APIDetails;
+import com.nokia.s60tools.apiquery.shared.datatypes.APIQueryParameters;
+import com.nokia.s60tools.apiquery.shared.datatypes.APIShortDescription;
+import com.nokia.s60tools.apiquery.shared.datatypes.APIShortDescriptionSearchResults;
+import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry;
+import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage;
+import com.nokia.s60tools.apiquery.shared.exceptions.QueryOperationFailedException;
+import com.nokia.s60tools.apiquery.shared.exceptions.XMLNotValidException;
+import com.nokia.s60tools.apiquery.shared.searchmethod.AbstractSearchMethodExtension;
+import com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension;
+import com.nokia.s60tools.apiquery.shared.searchmethod.SearchMethodExtensionInfo;
+import com.nokia.s60tools.apiquery.shared.searchmethod.ui.AbstractUiFractionComposite;
+import com.nokia.s60tools.apiquery.shared.services.QueryServices;
+import com.nokia.s60tools.apiquery.shared.util.console.APIQueryConsole;
+import com.nokia.s60tools.apiquery.shared.util.xml.XMLUtils;
+import com.nokia.s60tools.sdk.SdkInformation;
+import com.nokia.s60tools.util.debug.DbgUtility;
+
+/**
+ * Search Method extension allowing to create local caches from the web server
+ * entries, and used the cached information instead of the online information.
+ */
+public class LocalCacheSearchMethodExtension implements ISearchMethodExtension, IExecutableExtension, IJobChangeListener
+{
+
+ /**
+ * This class is created by using createExecutableExtension
+ * method from IConfigurationElement
class, and therefore the
+ * constructor cannot have any parameters.
+ *
+ * @see org.eclipse.core.runtime.IConfigurationElement#createExecutableExtension
+ */
+ public LocalCacheSearchMethodExtension(){
+ extensionInfo = new SearchMethodExtensionInfo();
+ }
+
+ private SearchMethodExtensionInfo extensionInfo;
+ private APIQueryParameters apiQueryParameters = null;
+
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.IExecutableExtension#setInitializationData(org.eclipse.core.runtime.IConfigurationElement,
+ * java.lang.String, java.lang.Object)
+ */
+ public void setInitializationData(IConfigurationElement configElem, String classPropertyName, Object data) throws CoreException {
+ extensionInfo.setId(configElem.getAttribute(AbstractSearchMethodExtension.ID_ATTRIBUTE));
+ extensionInfo.setDescription(configElem.getAttribute(AbstractSearchMethodExtension.DESCRIPTION_ATTRIBUTE));
+ extensionInfo.setDefault(Boolean.parseBoolean(configElem.getAttribute(AbstractSearchMethodExtension.IS_DEFAULT_ATTRIBUTE)));
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getExtensionInfo()
+ */
+ public SearchMethodExtensionInfo getExtensionInfo() {
+ return extensionInfo;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.searchmethodregistry.ISearchMethodExtension#notifyExtensionShutdown()
+ */
+ public void notifyExtensionShutdown() {
+ // Currently nothing to do
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.searchmethodregistry.ISearchMethodExtension#createExtensionConfigurationUi(org.eclipse.swt.widgets.Composite)
+ */
+ public AbstractUiFractionComposite createExtensionConfigurationUi(Composite parent) {
+ return new LocalCacheUIComposite(parent);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#isSupportedQueryType(int)
+ */
+ public boolean isSupportedQueryType(int queryType) {
+ // By default the query type is not supported.
+ boolean isSupported = false;
+
+ switch (queryType) {
+
+ // Flow through (supported types)
+ case APIQueryParameters.QUERY_BY_API_NAME:
+ case APIQueryParameters.QUERY_BY_SUBSYSTEM_NAME:
+ case APIQueryParameters.QUERY_BY_LIB_NAME:
+ case APIQueryParameters.QUERY_BY_HEADER_NAME:
+ isSupported = true;
+ break;
+
+ default:
+ break;
+ }
+
+ return isSupported;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getAPIDetails(com.nokia.s60tools.apiquery.shared.datatypes.APIShortDescription)
+ */
+ public APIDetails getAPIDetails(APIShortDescription summary) throws QueryOperationFailedException {
+
+ CacheEntryStorage storage = CacheEntryStorage.getInstance();
+ if(!storage.isLoaded()){
+ startUpdateJobAndWaitUntilFinished(storage);
+ }
+
+ APIDetails details = null;
+
+ CacheEntry entry = (CacheEntry) storage.getByEntryId(summary.getSource());
+ details = entry.getAPIDetails();
+ return details;
+ }
+
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getEntryStorageInstance()
+ */
+ public AbstractEntryStorage getEntryStorageInstance() {
+ return CacheEntryStorage.getInstance();
+ }
+
+
+
+ /**
+ * Handles (run) query for one entry
+ *
+ * @param parameters
+ * @param runSynchronous
+ * @return APIs matching search criteria
+ * @throws QueryOperationFailedException
+ */
+ private Collection handleSingleEntryQuery(APIQueryParameters parameters, boolean runSynchronous) throws QueryOperationFailedException {
+
+ ArrayList summary = null;
+ // Create a job to convert needed Excel If sheets to XML format
+ try {
+ summary = getSummarys(parameters, runSynchronous);
+ } catch (Exception e1) {
+ examineAndHandleQueryFailureException(e1);
+ }
+
+ return summary;
+
+ }
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#runAPIQuery(com.nokia.s60tools.apiquery.shared.datatypes.APIQueryParameters)
+ */
+ public APIShortDescriptionSearchResults runAPIQuery(APIQueryParameters parameters) {
+
+ this.apiQueryParameters = parameters;
+ // Owerwriting query for if sheets, because of usually there is multiple
+ // (>100) data sources
+ APIShortDescriptionSearchResults results = new APIShortDescriptionSearchResults();
+
+ try {
+ // Making query for each configured and selected server entry.
+ AbstractEntry[] selEntryArr = getEntryStorageInstance().getSelectedEntries();
+
+ // Were any entries configured or selected?
+ if(selEntryArr.length == 0){
+ throw new QueryOperationFailedException(Messages.getString("LocalCacheSearchMethodExtension.No_Server_Entries_ErrMsg")); //$NON-NLS-1$
+ }
+
+ boolean runSynchronous = !parameters.isQueryFromUI();// If query
+ // comes
+ // from UI,
+ // running
+ // async, if
+ // not,
+ // running
+ // sync
+
+ // If there was semi-comma separated search items or not
+ if (parameters.getSearchString().contains(
+ APIQueryParameters.SEARCH_ITEM_SEPARATOR_CHAR)) {
+ results.addSearchResults(handleMultiEntryQuery(parameters, runSynchronous));
+ } else {
+ results.addSearchResults(handleSingleEntryQuery(parameters, runSynchronous));
+ }
+ }catch(QueryOperationFailedException e){
+ results.addSearchError(e);
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ results.addSearchError( new QueryOperationFailedException(e.getMessage()));
+ }
+
+ return results;
+ }
+
+ /**
+ * Get APIShortDescriptions from XML Excel If Sheet XML files.
+ *
+ * @return
+ * @throws QueryOperationFailedException
+ */
+ private ArrayList getSummarys( APIQueryParameters parameters, boolean runSynchronous) throws QueryOperationFailedException {
+ ArrayList summary = new ArrayList();
+ String curId = "";//$NON-NLS-1$
+ try {
+ CacheEntryStorage storage = CacheEntryStorage.getInstance();
+ Collection selectedAPIs = storage.getSelectedEntriesCollection();
+
+ // if storage is not loaded, e.g. this is first time of searching
+ // after Carbide is started up, must load data first
+ if(!storage.isLoaded() && !runSynchronous){
+ startUpdateJobAndRunQueryWhenFinished(storage);
+ }
+ else{
+ if(!storage.isLoaded()){
+ startUpdateJobAndWaitUntilFinished(storage);
+ }
+
+ String [] searchStrings = new String []{parameters.getSearchString()};
+
+
+ // Try to found search string from selected search method
+ // (selected field from XML data)
+ for (AbstractEntry abstractEntry : selectedAPIs) {
+
+ CacheEntry entry = (CacheEntry)abstractEntry;
+
+ APIDetails det = entry.getAPIDetails();
+ if(det == null){
+ APIQueryConsole.getInstance().println(Messages.getString("LocalCacheSearchMethodExtension.UnexpectedEntryErrMsg") +entry.getId()); //$NON-NLS-1$
+ continue;// Should not be able to occur, because load
+ // deselects source if load fails
+ }
+ curId = entry.getId();
+ String curSourceDesc = entry.getName() ;
+ // Select Field from APIDetail, by selected search type, to
+ // found if that field contais the search string
+ APIDetailField fieldToSearchFor = getSelectedSearchField(det, parameters.getQueryType());
+ String fieldValueToSearch = fieldToSearchFor.getValue();
+ String apiName = det.getDetail(MetadataXMLToUIMappingRules.NAME).getValue();
+
+ DbgUtility.println(DbgUtility.PRIORITY_LOOP, "From API: " +//$NON-NLS-1$
+ apiName
+ +", file: " + curId //$NON-NLS-1$
+ +", querytype: " +parameters.getQueryType()//$NON-NLS-1$
+ + ", foundig values to search for: " +fieldValueToSearch);//$NON-NLS-1$
+
+ // Looking for all search strings if there was semi-comma
+ // separated strings to search for
+ for (int i = 0; i < searchStrings.length; i++) {
+ boolean matchs;
+ if(apiQueryParameters.isExactMatchInUse()){
+ // If exact match is in use, using equals as match
+ matchs = fieldValueToSearch.equalsIgnoreCase(searchStrings[i]);
+ }
+ else{
+ // If exact match is not in use, and if result
+ // contains search string (case insensitive)
+ matchs = fieldValueToSearch.toLowerCase().contains(searchStrings[i].toLowerCase());
+ }
+ // If result matches to search string, creating new API
+ // Summary object and add it to result
+
+ if(matchs){
+ APIShortDescription sum = new APIShortDescription(
+ apiName
+ ,curId,
+ curSourceDesc);
+ // If API Details should be added to description
+ // then adding it
+ if(parameters.isDetailsMentToAddToDescriptions()){
+ sum.setAPIDetails(det);
+ }
+ summary.add(sum);
+ }
+ }
+ }
+ }
+
+ } catch (Exception e) {
+ DbgUtility.println(DbgUtility.PRIORITY_OPERATION, "Error when handling file: " + curId);//$NON-NLS-1$
+ e.printStackTrace();
+ examineAndHandleQueryFailureException(e);
+ }
+ return summary;
+ }
+
+ /**
+ * Update (load) data sources if not loaded yet, after done, launch real
+ * query
+ *
+ * @param storage
+ * @throws QueryOperationFailedException
+ */
+ private void startUpdateJobAndRunQueryWhenFinished(CacheEntryStorage storage)
+ throws QueryOperationFailedException {
+
+ try {
+
+ SdkInformation info = SDKFinder.getSDKInformation(storage.getCurrentlySelectedSDKID());
+ UpdateSDKSelectionJob job = new UpdateSDKSelectionJob(Messages.getString("LocalCacheSearchMethodExtension.UpdatingDataSourceMsg_Part1") +info.getSdkId() +Messages.getString("LocalCacheSearchMethodExtension.UpdatingDataSourceMsg_Part2"), info, false); //$NON-NLS-1$ //$NON-NLS-2$
+ if(job.isAllreadyRunning()){
+ return;
+ }
+ job.setPriority(Job.DECORATE);
+ job.addJobChangeListener(this);
+ job.schedule();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ examineAndHandleQueryFailureException(e);
+ }
+ }
+
+ /**
+ * Update (load) data sources if not loaded yet, after done, launch real
+ * query
+ *
+ * @param storage
+ * @throws QueryOperationFailedException
+ */
+ private void startUpdateJobAndWaitUntilFinished(CacheEntryStorage storage)
+ throws QueryOperationFailedException {
+
+ try {
+
+ SdkInformation info = SDKFinder.getSDKInformation(storage.getCurrentlySelectedSDKID());
+ UpdateSDKSelectionJob job = new UpdateSDKSelectionJob(Messages.getString("LocalCacheSearchMethodExtension.UpdatingDataSourceMsg_Part1") +info.getSdkId() +Messages.getString("LocalCacheSearchMethodExtension.UpdatingDataSourceMsg_Part2"), info, false); //$NON-NLS-1$ //$NON-NLS-2$
+ if(job.isAllreadyRunning()){
+ return;
+ }
+ job.setPriority(Job.DECORATE);
+ job.schedule();
+ job.join();
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ examineAndHandleQueryFailureException(e);
+ }
+ }
+
+
+ /**
+ * get search field by query type
+ *
+ * @param det
+ * @param queryType
+ * @return
+ */
+ private APIDetailField getSelectedSearchField(APIDetails det, int queryType) {
+
+ APIDetailField field;
+ switch (queryType) {
+ case APIQueryParameters.QUERY_BY_API_NAME:
+ field = det.getDetail(MetadataXMLToUIMappingRules.NAME);
+ break;
+ case APIQueryParameters.QUERY_BY_SUBSYSTEM_NAME:
+ field = det.getDetail(MetadataXMLToUIMappingRules.SUBSYSTEM);
+ break;
+ case APIQueryParameters.QUERY_BY_LIB_NAME:
+ field = det.getDetail(MetadataXMLToUIMappingRules.LIBS);
+ break;
+ case APIQueryParameters.QUERY_BY_HEADER_NAME:
+ field = det.getDetail(MetadataXMLToUIMappingRules.HEADERS);
+ break;
+ default:
+ field = det.getDetail(MetadataXMLToUIMappingRules.NAME);
+ break;
+ }
+ return field;
+ }
+
+
+ /**
+ * Handles (run) query for several search strings
+ *
+ * @param parameters
+ * @param runSynchronous
+ * @return APIs matching search criteria
+ * @throws QueryOperationFailedException
+ */
+ private Collection handleMultiEntryQuery(APIQueryParameters parameters, boolean runSynchronous) throws QueryOperationFailedException {
+
+ // Using table to make sure that same API:s does not exist more than
+ // once
+ Hashtable summary = new Hashtable();
+ String [] searchStrings = parameters.getSearchString().split(APIQueryParameters.SEARCH_ITEM_SEPARATOR_CHAR);
+
+ APIQueryParameters param ;
+ Collection temp;
+ // Adding all APIDetails to collection one by one
+ for (int i = 0; i < searchStrings.length; i++) {
+ param = new APIQueryParameters(parameters.getQueryType(), searchStrings[i]);
+
+ temp = handleSingleEntryQuery(param, runSynchronous);
+ for (APIShortDescription api : temp) {
+ summary.put(api.getName(), api);// One API can contain in
+ // results only once. HashTable
+ // does not allow multiple
+ // occurances as keys.
+ }
+
+ }
+ return summary.values();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getAPIDetails(java.util.Collection)
+ */
+ public Hashtable getAPIDetails(Collection apis) throws QueryOperationFailedException {
+
+ CacheEntryStorage storage = CacheEntryStorage.getInstance();
+ if(!storage.isLoaded()){
+ startUpdateJobAndWaitUntilFinished(storage);
+ }
+
+ Hashtable apiDetails = new Hashtable(apis.size());
+ for (APIShortDescription summary : apis) {
+ apiDetails.put(summary.getName(), getAPIDetails(summary));
+ }
+ return apiDetails;
+ }
+
+ /**
+ * Examines the type of throwable parameter, and adds appropriate error
+ * message or default message, and forwards the information for further
+ * processing.
+ *
+ * @param throwable
+ * Throwable to be examined.
+ * @throws QueryOperationFailedException
+ */
+ private void examineAndHandleQueryFailureException(Throwable throwable) throws QueryOperationFailedException{
+
+ String errMsg = Messages.getString("LocalCacheSearchMethodExtension.UnexpectedException_ErrMsg"); //$NON-NLS-1$
+
+ if(throwable instanceof IOException) {
+ errMsg = Messages.getString("LocalCacheSearchMethodExtension.IOException_ErrMsg"); //$NON-NLS-1$
+ }
+ else if(throwable instanceof XMLNotValidException) {
+ errMsg = Messages.getString("LocalCacheSearchMethodExtension.InvalidXML_ErrMsg"); //$NON-NLS-1$
+ }
+
+ queryFailed(errMsg, throwable.getMessage());
+ }
+ /**
+ * Throws an exception for user with the given message.
+ *
+ * @param errorMsg
+ * Main error message for the user.
+ * @param detailedMsg
+ * More detailed message shown in parenthesis.
+ * @throws QueryOperationFailedException
+ */
+ private void queryFailed(String errorMsg, String detailedMsg) throws QueryOperationFailedException {
+ APIQueryConsole.getInstance().println(errorMsg, APIQueryConsole.MSG_ERROR);
+ String combinedMsg = errorMsg + " (" + detailedMsg + ")."; //$NON-NLS-1$ //$NON-NLS-2$
+ throw new QueryOperationFailedException(combinedMsg);
+ }
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#done(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ * When data sources (metadata) is loaded, running real query
+ * @see com.nokia.s60tools.apiquery.ui.views.main.MainView#runAPIQueryFromExternalClass(int,
+ * java.lang.String)
+ */
+ public void done(IJobChangeEvent event) {
+
+ Job job = event.getJob();
+ UpdateSDKSelectionJob ifsJob = (UpdateSDKSelectionJob)job;
+ ifsJob.reportEndTime();
+ IStatus status = ifsJob.getResult();
+
+ // Chekc that job status was ok before launching query
+ if( status != null && status.getSeverity() == IStatus.OK) {
+
+ // Launching the the real query when XML:s was generated
+ Runnable runQueryRunnable = new Runnable(){
+ public void run(){
+ try {
+ QueryServices.runAPIQuery(apiQueryParameters.getQueryType(),
+ apiQueryParameters.getSearchString());
+ } catch (QueryOperationFailedException e) {
+ APIQueryConsole.getInstance().println(Messages.getString("LocalCacheSearchMethodExtension.Failed_To_Start_Query_ErrMsg") //$NON-NLS-1$
+ +e.getMessage(), APIQueryConsole.MSG_ERROR);
+ e.printStackTrace();
+ }
+ }
+ };
+
+ // Showing a visible message has to be done in its own thread
+ // in order not to cause invalid thread access
+ Display.getDefault().asyncExec(runQueryRunnable);
+ }
+
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#aboutToRun(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ */
+ public void aboutToRun(IJobChangeEvent event) {
+ // Not needed
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#awake(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ */
+ public void awake(IJobChangeEvent event) {
+ // Not needed
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#running(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ */
+ public void running(IJobChangeEvent event) {
+ // Not needed
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#scheduled(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ */
+ public void scheduled(IJobChangeEvent event) {
+ // Not needed
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.core.runtime.jobs.IJobChangeListener#sleeping(org.eclipse.core.runtime.jobs.IJobChangeEvent)
+ */
+ public void sleeping(IJobChangeEvent event) {
+ // Not needed
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getAPIDetailsToReport()
+ */
+ public String[] getAPIDetailsToReport(Set usedAPIs, Hashtable projectUsingAPIDetails) {
+
+ boolean containsCollection = false;
+ boolean containsSubsystem = false;
+ for (String api : usedAPIs) {
+ APIDetails det = projectUsingAPIDetails.get(api);
+ if(det == null || det.getKeys() == null){
+ continue;
+ }
+ if(det.getKeys().contains(MetadataXMLToUIMappingRules.COLLECTION)){
+ containsCollection = true;
+ }
+ if(det.getKeys().contains(MetadataXMLToUIMappingRules.SUBSYSTEM)){
+ containsSubsystem = true;
+ }
+ // If we found occurrence of both subsystems version (sybsystem in
+ // data version 1.0 collection in data version 2.0)
+ // we can continue because then both headers will occur in report
+ // anyway
+ if(containsCollection && containsSubsystem){
+ break;
+ }
+ }
+
+ String [] apiDetailsToReport;
+
+ // If both subsystem versions is found
+ if(containsCollection && containsSubsystem){
+ apiDetailsToReport= new String []{
+ MetadataXMLToUIMappingRules.COLLECTION,
+ MetadataXMLToUIMappingRules.SUBSYSTEM,
+ MetadataXMLToUIMappingRules.RELEASE_CATEGORY,
+ MetadataXMLToUIMappingRules.RELEASE_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.RELEASE_DEPRECATED_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.LIBS
+ };
+ }
+ // if we found only collections, not subsystems
+ else if(containsCollection && !containsSubsystem){
+ apiDetailsToReport= new String []{
+ MetadataXMLToUIMappingRules.COLLECTION,
+ MetadataXMLToUIMappingRules.RELEASE_CATEGORY,
+ MetadataXMLToUIMappingRules.RELEASE_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.RELEASE_DEPRECATED_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.LIBS
+ };
+ }
+ // else if we dont found collections or we did not found anything, using
+ // subsystem as default value
+ else {// if(!containsCollection){
+ apiDetailsToReport= new String []{
+ MetadataXMLToUIMappingRules.SUBSYSTEM,
+ MetadataXMLToUIMappingRules.RELEASE_CATEGORY,
+ MetadataXMLToUIMappingRules.RELEASE_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.RELEASE_DEPRECATED_SINCE_VERSION,
+ MetadataXMLToUIMappingRules.LIBS
+ };
+ }
+ return apiDetailsToReport;
+ }
+
+ /**
+ * Maps query type to API Detail topic in API Details.
+ *
+ * @param queryType
+ * Query type constant.
+ * @return Name of the API Detail.
+ */
+ public String getAPIDetailNameInDetailsByQueryType(int queryType){
+
+ String apiDetail = null;
+
+ switch (queryType) {
+
+ case APIQueryParameters.QUERY_BY_API_NAME:
+ apiDetail = MetadataXMLToUIMappingRules.NAME;
+ break;
+
+ case APIQueryParameters.QUERY_BY_SUBSYSTEM_NAME:
+ apiDetail = MetadataXMLToUIMappingRules.SUBSYSTEM;
+ break;
+
+ case APIQueryParameters.QUERY_BY_DLL_NAME:
+ apiDetail = XMLUtils.DESCRIPTION_DLLS;
+ break;
+
+ case APIQueryParameters.QUERY_BY_LIB_NAME:
+ apiDetail = MetadataXMLToUIMappingRules.LIBS;
+ break;
+
+ case APIQueryParameters.QUERY_BY_HEADER_NAME:
+ apiDetail = MetadataXMLToUIMappingRules.HEADERS;
+ break;
+
+ case APIQueryParameters.QUERY_BY_CRPS_KEY_NAME:
+ apiDetail = XMLUtils.DESCRIPTION_KEY_NAME;
+ break;
+
+ default:
+ throw new IllegalArgumentException(Messages.getString("APIQueryParameters.QueryTypePart1_ErrMsg") //$NON-NLS-1$
+ + queryType
+ + Messages.getString("APIQueryParameters.QueryTypePart2_ErrMsg") //$NON-NLS-1$
+ );
+ }
+
+ return apiDetail;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.nokia.s60tools.apiquery.shared.searchmethod.ISearchMethodExtension#getQueryTypeByAPIDetailNameInDetails(java.lang.String)
+ */
+ public int getQueryTypeByAPIDetailNameInDetails(String queryType) {
+ int queryInt = -1;
+
+ if(queryType == null){
+ return queryInt;
+ }
+
+ if(queryType.equals(MetadataXMLToUIMappingRules.NAME)){
+ queryInt = APIQueryParameters.QUERY_BY_API_NAME;
+ }
+ else if(queryType.equals( MetadataXMLToUIMappingRules.SUBSYSTEM)){
+ queryInt = APIQueryParameters.QUERY_BY_SUBSYSTEM_NAME;
+ }
+ else if(queryType.equals(XMLUtils.DESCRIPTION_DLLS)){
+ queryInt = APIQueryParameters.QUERY_BY_DLL_NAME;
+ }
+ else if(queryType.equals(MetadataXMLToUIMappingRules.LIBS)){
+ queryInt = APIQueryParameters.QUERY_BY_LIB_NAME;
+ }
+ else if(queryType.equals(MetadataXMLToUIMappingRules.HEADERS)){
+ queryInt = APIQueryParameters.QUERY_BY_HEADER_NAME;
+ }
+ else if(queryType.equals(XMLUtils.DESCRIPTION_KEY_NAME)){
+ queryInt = APIQueryParameters.QUERY_BY_CRPS_KEY_NAME;
+ }
+
+ return queryInt;
+ }
+
+ public boolean isAsyncQueryPreferred() {
+ return false;
+ }
+
+
+/**
+ * opens the header file in the workbench
+ */
+ /*
+ public int openHeaderFile(String headerName,String source) {
+ try{
+
+ String temp =source.replace(
+ "\\", "/");
+ System.out.println(temp);
+
+ temp = temp.substring(0, temp.lastIndexOf("/"))
+ + "/inc/" + headerName;
+ temp = "file://" + temp;
+ System.out.print("temp" + temp);
+
+
+
+ OpenFileAction action = new OpenFileAction();
+ action.openFile(new URI(temp), headerName);
+ }catch (Exception e) {
+ return 1;
+ }
+
+ return 0;
+ }
+ */
+
+
+
+ public boolean serachHeaderLinkEnable() {
+
+ return true;
+ }
+
+ public String[] getHeaderSourceList() {
+ return new String[]
+ {"http://s60lxr", "http://developer.symbian.org/xref/oss", "3.2RnDSDK", "pf_5250robot"};
+
+ }
+
+
+
+ public int openHeaderFile(String headerName, String APIName) {
+ try{
+ System.out.println("header" + headerName + "APINAME " +APIName);
+
+ // get the source
+ String source = LocalCacheUIComposite.headerSource;
+ String url = " ";
+ boolean isweb = false;
+ if(source.equalsIgnoreCase("http://s60lxr")){
+ url = "http://s60lxr/search?filestring=%2F"+headerName+"%24&advanced=1&string=";
+ isweb = true;
+ }
+ else if(source.equalsIgnoreCase("http://developer.symbian.org/xref/oss"))
+ {url="http://developer.symbian.org/xref/epl/search?q=&defs=&refs=&path="+headerName+"&hist=&project=%2FMCL";
+ isweb = true;
+ }
+
+
+
+ if(isweb)
+ { //open from the browser
+ IWorkbench workbench = PlatformUI.getWorkbench();
+ IWebBrowser browser;
+
+ browser = workbench.getBrowserSupport()
+ .createBrowser(null);
+
+ browser
+ .openURL(new java.net.URL(url));
+ }
+ else
+ { //open from the sdk
+ SDKUtil.headerOpen(source, APIName, headerName);
+ }
+ }catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return 0 ;
+
+ }
+
+
+
+
+
+
+
+
+
+}