diff -r 000000000000 -r a02c979e8dfd srcanaapps/apiquerytool/com.nokia.s60tools.apiquery.cache/src/com/nokia/s60tools/apiquery/cache/configuration/CacheEntryStorage.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/configuration/CacheEntryStorage.java Sat Jan 09 10:04:11 2010 +0530 @@ -0,0 +1,744 @@ +/* +* 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.configuration; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Map; +import java.util.Set; +import java.util.Vector; + +import org.eclipse.core.runtime.IProgressMonitor; + +import com.nokia.s60tools.apiquery.cache.plugin.CachePlugin; +import com.nokia.s60tools.apiquery.cache.resources.Messages; +import com.nokia.s60tools.apiquery.shared.datatypes.APIDetailField; +import com.nokia.s60tools.apiquery.shared.datatypes.APIDetails; +import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry; +import com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage; +import com.nokia.s60tools.apiquery.shared.datatypes.config.DuplicateEntryException; +import com.nokia.s60tools.apiquery.shared.datatypes.config.EntryNotFoundException; +import com.nokia.s60tools.apiquery.shared.datatypes.config.IConfigurationChangedListener; +import com.nokia.s60tools.apiquery.shared.exceptions.XMLNotValidException; +import com.nokia.s60tools.apiquery.shared.job.JobCancelledByUserException; +import com.nokia.s60tools.apiquery.shared.util.console.APIQueryConsole; +import com.nokia.s60tools.apiquery.shared.util.xml.XMLElementData; +import com.nokia.s60tools.apiquery.shared.util.xml.XMLUtils; +import com.nokia.s60tools.sdk.SdkInformation; +import com.nokia.s60tools.util.debug.DbgUtility; +import com.nokia.s60tools.util.resource.FileUtils; + +/** + * Singleton class that is created on plugin startup, and is kept active as long + * as plugin is active. + * + * The purpose of this class is to store If Sheet entries configured by user. + * + * The format of used XML: + * + * + * + * + */ +public class CacheEntryStorage extends AbstractEntryStorage { + + /** + * Singleton instance. + */ + static private CacheEntryStorage instance = null; + + /** + * Public Singleton instance accessor. + * + * @return Returns instance of this singleton class- + */ + public static CacheEntryStorage getInstance() { + if (instance == null) { + instance = new CacheEntryStorage(); + } + return instance; + } + + // + // Variables for creating XML file from server entry data. + // + private static final String XML_HEADER = "";//$NON-NLS-1$ + + private static final String XML_ROOT_START_ELEMENT = "";//$NON-NLS-1$ + + private static final String XML_ROOT_END_ELEMENT = "";//$NON-NLS-1$ + + private static final String XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START = "=\"";//$NON-NLS-1$ + + private static final String CARRIAGE_RETURN_AND_NEWLINE = "\r\n";//$NON-NLS-1$ + + private static final String SINGLE_SPACE = " ";//$NON-NLS-1$ + + private static final String QUOTE_AND_SINGLE_SPACE = "\" ";//$NON-NLS-1$ + + private static final String ELEMENT_START_STR = "<";//$NON-NLS-1$ + + private static final String ELEMENT_END_STR = "/>"; //$NON-NLS-1$ + + // + // XML element and attribute names used for storing configuration + // + private static final String METADATA_ELEMENT = "metadata";//$NON-NLS-1$ + + private static final String ID_ATTRIBUTE = "id";//$NON-NLS-1$ + + private static final String SDK_ID_ATTRIBUTE = "sdkid";//$NON-NLS-1$ + + private static final String SIZE_ATTRIBUTE = "size";//$NON-NLS-1$ + + private static final String SELECTION_ATTRIBUTE = "selected";//$NON-NLS-1$ + + private static final String DATE_ATTRIBUTE = "last_modified";//$NON-NLS-1$ + + private static final String API_NAME = "api_name";//$NON-NLS-1$ + + private Vector loadErrors = null; + + private boolean isLoaded = false; + + /** + * Private default constructor. + */ + private CacheEntryStorage() { + super(); + DbgUtility.println(DbgUtility.PRIORITY_CLASS, + "-- <> --> " + getClass().getName()); //$NON-NLS-1$ + } + + /* + * (non-Javadoc) + * + * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#save(java.lang.String) + */ + public void save(String destinationFileAbsolutePathName) throws IOException { + // System.out.println("save" + destinationFileAbsolutePathName); + + StringBuffer xmlDataBuf = new StringBuffer(); + + File f = new File(destinationFileAbsolutePathName); + // Deleting possibly old + if (f.exists()) { + if (!f.canWrite()) { + String cannotWriteToFileErrMsg = Messages + .getString("CacheEntry.Destination_File_Is_Write_Protected_ErrMsg") //$NON-NLS-1$ + + destinationFileAbsolutePathName; + APIQueryConsole.getInstance().println(cannotWriteToFileErrMsg, + APIQueryConsole.MSG_ERROR); + throw new RuntimeException(cannotWriteToFileErrMsg); + } + if (!f.delete()) { + String cannotWriteToFileErrMsg = Messages + .getString("CacheEntry.Destination_File_Is_In_Use_ErrMsg") //$NON-NLS-1$ + + destinationFileAbsolutePathName; + APIQueryConsole.getInstance().println(cannotWriteToFileErrMsg, + APIQueryConsole.MSG_ERROR); + throw new RuntimeException(cannotWriteToFileErrMsg); + } + } + + FileOutputStream fos = new FileOutputStream(f); + + BufferedOutputStream bos = new BufferedOutputStream(fos); + + xmlDataBuf.append(XML_HEADER); + xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE); + xmlDataBuf.append(XML_ROOT_START_ELEMENT); + xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE); + Collection entriesColl = getEntries(); + // Create ... XML -elements from entries + for (AbstractEntry entryBeforeCast : entriesColl) { + CacheEntry entry = (CacheEntry) entryBeforeCast; + xmlDataBuf.append(ELEMENT_START_STR + METADATA_ELEMENT + + SINGLE_SPACE); + xmlDataBuf.append(ID_ATTRIBUTE + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + entry.getId() + + QUOTE_AND_SINGLE_SPACE); + xmlDataBuf.append(SELECTION_ATTRIBUTE + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + + Boolean.toString(entry.isSelected()) + + QUOTE_AND_SINGLE_SPACE); + xmlDataBuf.append(SDK_ID_ATTRIBUTE + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + + entry.getSDKID() + QUOTE_AND_SINGLE_SPACE); + xmlDataBuf.append(SIZE_ATTRIBUTE + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + + entry.getSize() + QUOTE_AND_SINGLE_SPACE); + xmlDataBuf.append(DATE_ATTRIBUTE + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + + entry.getDate() + QUOTE_AND_SINGLE_SPACE); + xmlDataBuf.append(API_NAME + + XML_ATTRIBUTE_ASSIGNMENT_WITH_QUOTE_START + + entry.getAPIName() + QUOTE_AND_SINGLE_SPACE); + //System.out.println("apiname" +entry.getAPIName()); + xmlDataBuf.append(ELEMENT_END_STR); + xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE); + } + xmlDataBuf.append(XML_ROOT_END_ELEMENT); + xmlDataBuf.append(CARRIAGE_RETURN_AND_NEWLINE); + + // Writing data to file + byte[] writeData = xmlDataBuf.toString().getBytes(); + bos.write(writeData, 0, writeData.length); + bos.flush(); + bos.close(); + fos.close(); + + } + + /* + * (non-Javadoc) + * + * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#load(java.lang.String) + */ + public void load(String storageFilePathName) throws IOException { + //System.out.println("storage file path" + storageFilePathName); + + // Setting elements to be parsed + Set elemNameSet = new LinkedHashSet(); + elemNameSet.add(METADATA_ELEMENT); // server element + // Setting attributes to be parsed for server element + Map attrNameSet = new LinkedHashMap(); + attrNameSet.put(ID_ATTRIBUTE, ID_ATTRIBUTE); + attrNameSet.put(SELECTION_ATTRIBUTE, SELECTION_ATTRIBUTE); + attrNameSet.put(SDK_ID_ATTRIBUTE, SDK_ID_ATTRIBUTE); + attrNameSet.put(SIZE_ATTRIBUTE, SIZE_ATTRIBUTE); + attrNameSet.put(DATE_ATTRIBUTE, DATE_ATTRIBUTE); + attrNameSet.put(API_NAME, API_NAME); + Map> attributeMap = new LinkedHashMap>(); + attributeMap.put(METADATA_ELEMENT, attrNameSet); + + try { + // Loading XML data into memory + StringBuffer xmlData = FileUtils + .loadDataFromFile(storageFilePathName); + // Parsing elements from the XML data and adding found server + // entries to storage + XMLElementData[] elementArr = XMLUtils.parseXML(xmlData.toString(), + elemNameSet, attributeMap); + ArrayList foundEntries = convertElementDataToEntryList(elementArr); + // Removing the old server entries and adding new ones + // When we are really sure that the whole load opearation was + // successful. + entriesMap.clear(); + for (AbstractEntry entry : foundEntries) { + // CacheEntry ent = (CacheEntry) entry; + + entriesMap.put(entry.getId(), entry); + } + + } catch (Exception e) { + e.printStackTrace(); + String msg = Messages + .getString("CacheEntry.LoadFailed_Part_1_ErrMsg") + e.getMessage() //$NON-NLS-1$ + + ". " + Messages.getString("CacheEntry.LoadFailed_Part_2_ErrMsg"); //$NON-NLS-1$ //$NON-NLS-2$ + APIQueryConsole.getInstance().println(msg, + APIQueryConsole.MSG_ERROR); + File f = new File(storageFilePathName); + if (f.exists()) { + f.delete(); + } + } + } + + /** + * Converts element data into server entry list. + * + * @param elementArr + * XML Element data to be converted. + * @return Server entry list. + */ + private ArrayList convertElementDataToEntryList( + XMLElementData[] elementArr) { + ArrayList foundEntries = new ArrayList(); + + // Temporary data used during attribute fetching + String id = null; + String sdkid = null; + boolean isSelected = false; + String apiName = null; + long size = -1; + long date = -1; + + for (int i = 0; i < elementArr.length; i++) { + XMLElementData data = elementArr[i]; + Map params = data.getAttributes(); + + try { + + id = params.get(ID_ATTRIBUTE); + isSelected = Boolean.parseBoolean(params + .get(SELECTION_ATTRIBUTE)); + sdkid = params.get(SDK_ID_ATTRIBUTE); + size = Long.parseLong(params.get(SIZE_ATTRIBUTE)); + date = Long.parseLong(params.get(DATE_ATTRIBUTE)); + apiName = params.get(API_NAME); + //System.out.println("api name" + apiName); + } catch (Exception e) { + throw new RuntimeException( + Messages + .getString("CacheEntry.Unexpected_Attribute_ErrMsg") + data.getElementName()); //$NON-NLS-1$ + } + + File file = new File(id); + if (file.exists()) { + String fileName = file.getName(); + // Adding an entry + foundEntries.add(new CacheEntry(id, fileName, sdkid, + isSelected, size, date, apiName)); + } + } + return foundEntries; + } + + /** + * Get currentry selected SDK ID + * + * @return SDK ID or null if not found. + */ + public String getCurrentlySelectedSDKID() { + for (AbstractEntry entry : getEntries()) { + CacheEntry cacheEntry = (CacheEntry) entry; + if (cacheEntry.getSDKID() != null && cacheEntry.isSelected()) { + return cacheEntry.getSDKID(); + } + } + return null; + } + + /** + * Updates an entry to the storage. Additional not recommended possibility + * to update entry without notifying listeners. It's not recommended to use + * this, but if used, make sure that listeners is notified afterwards by + * using + * {@link AbstractEntryStorage#notifyConfigurationChangeListeners(int)}. + * + * @param entryWithNewData + * Entry object containing new data. + * @throws EntryNotFoundException + * @param dontNotifyListeners + * if true listeners will not be notified. + */ + public void updateEntry(AbstractEntry entryWithNewData, + boolean dontNotifyListeners) throws EntryNotFoundException { + + if (dontNotifyListeners) { + AbstractEntry entryWithOldData = (AbstractEntry) entriesMap + .get(entryWithNewData.getId()); + if (entryWithOldData == null) { + String nonExistingEntryMsg = Messages + .getString("AbstractEntryStorage.NonExistingEntry_ErrMsg") + entryWithNewData.getId(); //$NON-NLS-1$ + throw new EntryNotFoundException(nonExistingEntryMsg); + } + // Updating data fields (which triggers notification to + // configuration change listeners) + entryWithOldData + .updateEntryTypeSpecificDataFields(entryWithNewData); + } else { + updateEntry(entryWithNewData); + } + this.isLoaded = false; + + } + + /* + * (non-Javadoc) + * + * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#updateEntry(com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry) + */ + public void updateEntry(AbstractEntry entryWithNewData) + throws EntryNotFoundException { + super.updateEntry(entryWithNewData); + this.isLoaded = false; + + } + + /** + * Adds an entry to the storage. Additional not recommended possibility to + * add entry without notifying listeners. It's not recommended to use this, + * but if used, make sure that listeners is notified afterwards by using + * {@link AbstractEntryStorage#notifyConfigurationChangeListeners(int)}. + * + * @param entry + * Entry to be added. + * @param dontNotifyListeners + * if true listeners will not be notified. + * @throws DuplicateEntryException + */ + public void addEntry(AbstractEntry entry, boolean dontNotifyListeners) + throws DuplicateEntryException { + + if (!dontNotifyListeners) { + super.addEntry(entry); + } else { + if (entriesMap.get(entry.getId()) != null) { + String duplicateEntriesErrMsg = Messages + .getString("AbstractEntryStorage.Duplicate_ErrMsg"); //$NON-NLS-1$ + throw new DuplicateEntryException(duplicateEntriesErrMsg); + } + entriesMap.put(entry.getId(), entry); + } + this.isLoaded = false; + } + + /* + * (non-Javadoc) + * + * @see com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntryStorage#addEntry(com.nokia.s60tools.apiquery.shared.datatypes.config.AbstractEntry) + */ + public void addEntry(AbstractEntry entry) throws DuplicateEntryException { + super.addEntry(entry); + this.isLoaded = false; + } + + /** + * Load all selected entrys to storage. Parsing XML:s for all items, by + * calling {@link CacheEntry#load()}. + * + * Also {@link CacheEntry#unload()} for entry if not selected. + * + * If want to know if there was some errors, ask it by + * {@link CacheEntryStorage#isLoadErros()}. If there was errors, ask them + * by {@link CacheEntryStorage#getLoadErrors()}. + * + * @param monitor + * to check for cancellations + * @param newSelectedSDKInfo + * SDK info to be selected + * @throws JobCancelledByUserException + * if canceled by user + * + */ + + public void selectSDKAndLoadAllSelectedDatasToMemory( + IProgressMonitor monitor, SdkInformation newSelectedSDKInfo) + throws JobCancelledByUserException { + selectSDKAndLoadAllSelectedDatasToMemory(monitor, newSelectedSDKInfo, + true); + } + + /** + * Load all selected entrys to storage. Parsing XML:s for all items, by + * calling {@link CacheEntry#load()}. + * + * Also {@link CacheEntry#unload()} for entry if not selected. + * + * If want to know if there was some errors, ask it by + * {@link CacheEntryStorage#isLoadErros()}. If there was errors, ask them + * by {@link CacheEntryStorage#getLoadErrors()}. + * + * @param monitor + * to check for cancellations + * @param newSelectedSDKInfo + * SDK info to be selected + * @param selectSDK + * if newSelectedSDKInfo is to be selected as new selected SDK + * @throws JobCancelledByUserException + * if canceled by user + * + */ + private void selectSDKAndLoadAllSelectedDatasToMemory( + IProgressMonitor monitor, SdkInformation newSelectedSDKInfo, + boolean selectSDK) throws JobCancelledByUserException { + + // set to data store that all are deselected + Collection entrys = getEntries(); + + // Store current situation for restoring it in cases of cancel + Set keys = entriesMap.keySet(); + Map storedEntriesMap = new LinkedHashMap( + entriesMap.size()); + for (String key : keys) { + CacheEntry ent = (CacheEntry) entriesMap.get(key); + APIDetails det = ent.getAPIDetails();// If details is null, it + // must not be loaded now, + // because of lot of time + // taken + CacheEntry ent_ = new CacheEntry(ent.getId(), ent.getName(), ent + .getSDKID(), ent.isSelected(), ent.getSize(), + ent.getDate(), ent.getAPIName()); + ent_.setAPIDetails(det); + storedEntriesMap.put(new String(key), ent_); + } + + try { + + // select new SDK + if (selectSDK) { + selectNewSDK(monitor, newSelectedSDKInfo, entrys); + } + + // For XML validity errors + loadErrors = null; + Vector entrysToBeUnloaded = new Vector(); + // Loading all selected entrys to to memory by using entry.load() + for (AbstractEntry entry : entrys) { + // If canceled, throwing exception and catch will handle data + // restore + if (monitor.isCanceled()) { + throw new JobCancelledByUserException( + Messages + .getString("CacheEntryStorage.JobCanceledByUserMsg")); + } + CacheEntry ce = (CacheEntry) entry; + if (ce.isSelected()) { + try { + ce.load(); + } catch (XMLNotValidException e) { + addLoadError(e); + } + } + // If entry is not selected, unloading it from memory. + else { + entrysToBeUnloaded.add(ce); + } + } + // If canceled during operation, we unload entrys just when all is + // loaded, unload does not really take any time. + // So for here cancel wont occur anymore + for (CacheEntry ce : entrysToBeUnloaded) { + ce.unload(); + } + + this.isLoaded = true; + + } catch (JobCancelledByUserException e) { + entriesMap = storedEntriesMap; + throw e; + } + } + + /** + * Sets selected sdk as true and un selects not selected SDK + * + * @param monitor + * @param newSelectedSDKInfo + * @param entrys + * @throws JobCancelledByUserException + */ + private void selectNewSDK(IProgressMonitor monitor, + SdkInformation newSelectedSDKInfo, Collection entrys) + throws JobCancelledByUserException { + for (AbstractEntry entry : entrys) { + if (monitor.isCanceled()) { + // If canceled, throwing exception and catch will handle data + // restore + throw new JobCancelledByUserException(Messages + .getString("CacheEntryStorage.JobCanceledByUserMsg")); + } + CacheEntry ce = (CacheEntry) entry; + if (ce.getSDKID().equalsIgnoreCase(newSelectedSDKInfo.getSdkId())) { + entry.setSelected(true, true); + } else { + ce.setSelected(false, true); + } + } + } + + /** + * Load all selected entrys to storage. Parsing XML:s for all items, by + * calling {@link CacheEntry#load()}. + * + * Also {@link CacheEntry#unload()} for entry if not selected. + * + * If want to know if there was some errors, ask it by + * {@link CacheEntryStorage#isLoadErros()}. If there was errors, ask them + * by {@link CacheEntryStorage#getLoadErrors()}. + * + * @param monitor + * to check for cancellations + * @throws JobCancelledByUserException + * if canceled by user + */ + public void loadAllSelectedDatasToMemory(IProgressMonitor monitor) + throws JobCancelledByUserException { + + selectSDKAndLoadAllSelectedDatasToMemory(monitor, null, false); + + } + + /** + * Check if there was load errors. + * + * @return true if there was load errors false + * otherwise. + */ + public boolean isLoadErros() { + return loadErrors != null; + } + + /** + * Get load errors + * + * @return load errors or null if there was no errors on + * CacheEntryStorage#loadAllSelectedDatasToMemory(). + */ + public Vector getLoadErrors() { + return loadErrors; + } + + /** + * Adds load error to errors + * + * @param e + */ + private void addLoadError(XMLNotValidException e) { + + if (loadErrors == null) { + loadErrors = new Vector(); + } + loadErrors.add(e); + + } + + /** + * Removes all selected entrys. + */ + public void removeSelectedEntrys(String currentlySelectedSDKID) { + + Collection entrys = getEntries(); + Vector ids = new Vector(); + for (AbstractEntry aEntry : entrys) { + CacheEntry entry = (CacheEntry) aEntry; + if (entry.isSelected() + || entry.getSDKID().equals(currentlySelectedSDKID)) { + ids.add(entry.getId()); + } + + } + for (String id : ids) { + entriesMap.remove(id); + } + + notifyConfigurationChangeListeners(IConfigurationChangedListener.ALL_SELECTED_ENTRYS_REMOVED); + } + + /** + * Unloads all entrys + */ + public void unload() { + Collection entrys = getEntries(); + // For XML validity errors + loadErrors = null;// Now there are no loads -> no load Errors eather + // Unload all items + for (AbstractEntry entry : entrys) { + CacheEntry ce = (CacheEntry) entry; + ce.unload(); + } + this.isLoaded = false; + } + + /** + * Check if source is loaded. + * + * @return true if is loaded, false otherwise + */ + public boolean isLoaded() { + return isLoaded; + } + + /** + * Return the path to xml file. + * @param sdkID : SDK name as given in metadata_cache_entries.xml file + * @param APIName : API Name + * @param headerFile : header file name + * @return + */ + + public String getID(String sdkID, String APIName, String headerFile) { + // System.out.println("SDK ID" +sdkID + "apiame " + APIName + " + // headerfile : " + headerFile); + try { + //CacheEntryStorage instance = getInstance(); + //instance.load(CachePlugin.getconfigFilePath()); + + Set elemNameSet = new LinkedHashSet(); + elemNameSet.add(METADATA_ELEMENT); // server element + // Setting attributes to be parsed for server element + Map attrNameSet = new LinkedHashMap(); + attrNameSet.put(ID_ATTRIBUTE, ID_ATTRIBUTE); + attrNameSet.put(SELECTION_ATTRIBUTE, SELECTION_ATTRIBUTE); + attrNameSet.put(SDK_ID_ATTRIBUTE, SDK_ID_ATTRIBUTE); + attrNameSet.put(SIZE_ATTRIBUTE, SIZE_ATTRIBUTE); + attrNameSet.put(DATE_ATTRIBUTE, DATE_ATTRIBUTE); + attrNameSet.put(API_NAME, API_NAME); + Map> attributeMap = new LinkedHashMap>(); + attributeMap.put(METADATA_ELEMENT, attrNameSet); + + // Loading XML data into memory + StringBuffer xmlData = FileUtils.loadDataFromFile(CachePlugin + .getconfigFilePath()); + // Parsing elements from the XML data and adding found server + // entries to storage + XMLElementData[] elementArr = XMLUtils.parseXML(xmlData.toString(), + elemNameSet, attributeMap); + for (int i = 0; i < elementArr.length; i++) { + XMLElementData data = elementArr[i]; + Map params = data.getAttributes(); + + if (params.get(API_NAME).equalsIgnoreCase(APIName) + && params.get(SDK_ID_ATTRIBUTE).equalsIgnoreCase(sdkID)) { + //System.out.println("found"); + // serach in the list of avaliable folders + String id = params.get(ID_ATTRIBUTE); + // c:\.....\xyz.xml + + String folder = id.substring(0, id.lastIndexOf("\\")) + + "\\inc"; + //System.out.println( "Folder" + folder); + + File directory = new File(folder); + + if (directory.isDirectory()) { // check to make sure it + // is a directory + String filenames[] = directory.list(); // make array of + // filenames. + + for (int j = 0; j < filenames.length; j++) { + if (filenames[j].equalsIgnoreCase(headerFile)) + return id; + } + + } // is directory + + } + } //forloop + } catch (Exception e) { + e.printStackTrace(); + } + + + + + return null; + } + +}