JAVASCRIPT   905

cffile.js

Guest on 22nd July 2021 05:36:10 PM

  1. /*************************************************************************
  2. *
  3. * ADOBE CONFIDENTIAL
  4.  
  5. * ___________________
  6. *
  7. *  Copyright  Adobe Systems Incorporated
  8. *  All Rights Reserved.
  9. *
  10. * NOTICE:  All information contained herein is, and remains
  11. * the property of Adobe Systems Incorporated and its suppliers,
  12. * if any.  The intellectual and technical concepts contained
  13. * herein are proprietary to Adobe Systems Incorporated and its
  14. * suppliers and may be covered by U.S. and Foreign Patents,
  15. * patents in process, and are protected by trade secret or copyright law.
  16. * Dissemination of this information or reproduction of this material
  17. * is strictly forbidden unless prior written permission is obtained
  18. * from Adobe Systems Incorporated.
  19. **************************************************************************/
  20.  
  21. /**
  22.  * @author P.N. Anantharaman (ananth@adobe.com)
  23.  * this is a wrapper that invokes the underlying DNFI layer classes
  24.  * in order to distinguish DNFI class names with the class names in the wrapper, we prepend the class name with W
  25.  * thus, WFile would invoke Camera class from DNFI layer. It is the job of the code generator from CF server to convert File() from
  26.  * the code embedded in Cfclient to WFile
  27.  * 5 Aug 2012
  28.  */
  29.  
  30. /*
  31.  * Class: WFileManager
  32.  * Methods:
  33.  */
  34.         var WFileManager = function(context)
  35.         {
  36.                 if(typeof File != "undefined" && typeof FileTransfer != "undefined")
  37.                 {
  38.                 var self = this;               
  39.                 this.successObject = new DnfiStatus('WFileManager', dnfi.SUCCESS.code, dnfi.SUCCESS.message);
  40.                
  41.                 // the var statements below define the properties of the object
  42.                 this.fileSystem = null; //this variable holds the current file system in use
  43.                 this.persistentFileSystem = null;
  44.                 this.tempFileSystem = null;
  45.                
  46.                 this.FILE_NOT_FOUND_ERR = FileTransferError.FILE_NOT_FOUND_ERR;
  47.                 this.INVALID_URL_ERR = FileTransferError.INVALID_URL_ERR;
  48.                 this.CONNECTION_ERR = FileTransferError.CONNECTION_ERR;
  49.                 this.ABORT_ERR = FileTransferError.ABORT_ERR;
  50.  
  51.                 this.currentWorkingDirEntryObject = null; //directory entry for the current working directory
  52.                
  53.                 this.source = {
  54.                         type: null,
  55.                         provider: 'local',
  56.                         url: null,
  57.                         path: null,
  58.                         name: null,
  59.                         auth: {}
  60.                 };
  61.                
  62.                 this.destination = {
  63.                         type: 'local',
  64.                         provider: '',
  65.                         url: '',
  66.                         path: null,
  67.                         name: null,
  68.                         auth: {}
  69.                 };
  70.                
  71.         var _validateEntry = function(context, path, type)
  72.         {
  73.                 if(typeof path == "string")
  74.                 {
  75.                         if(path != null && trim(path) != "")
  76.                                 return true;
  77.                         else
  78.                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_INVALID_NAME_ERROR.code,
  79.                                                                                                                         wFileManagerError.FILE_INVALID_NAME_ERROR.message), null);
  80.                         return false;
  81.                 }
  82.                
  83.                 if(type == "dir" && path.isDirectory)
  84.                         return true;
  85.                 else if(type == "file" && path.isFile)
  86.                         return true;
  87.                 else if(type == "both" &&(typeof path.isFile != "undefined"))
  88.                         return true;
  89.                        
  90.                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  91.                
  92.                 return false;
  93.         }
  94.                
  95.         var syncFileEntry = function(entry)
  96.         {
  97.                 if(entry != null)
  98.                 {
  99.                         entry.isfile = entry.isFile;
  100.                         entry.isdirectory = entry.isDirectory;
  101.                         entry.fullpath = entry.fullPath;
  102.                 }
  103.         }
  104.        
  105.         var syncDirectoryEntry = function(entry)
  106.         {
  107.                 if(entry != null)
  108.                 {
  109.                         entry.isfile = entry.isFile;
  110.                         entry.isdirectory = entry.isDirectory;
  111.                         entry.fullpath = entry.fullPath;
  112.                 }
  113.         }
  114.        
  115.         var handleError = function(context,e,retVal)
  116.         {
  117.                 var dnfiError = null;
  118.                        
  119.                 if (e.code == FileError.NOT_FOUND_ERR)
  120.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_NOT_FOUND_ERROR.code, wFileManagerError.FILE_NOT_FOUND_ERROR.message);
  121.                 else if(e.code == FileError.SECURITY_ERR)
  122.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.SECURITY_ERROR.code, wFileManagerError.SECURITY_ERROR.message);
  123.                 else if(e.code == FileError.ABORT_ERR || e.code == FileError.INVALID_MODIFICATION_ERR)
  124.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.ABORT_ERROR.code, wFileManagerError.ABORT_ERROR.message);
  125.                 else if(e.code == FileError.NOT_READABLE_ERR)
  126.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_READ_ERROR.code, wFileManagerError.FILE_READ_ERROR.message);
  127.                 else if(e.code == FileError.ENCODING_ERR)
  128.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_ENCODING_ERROR.code, wFileManagerError.FILE_ENCODING_ERROR.message);
  129.                 else if(e.code == FileError.NO_MODIFICATION_ALLOWED_ERR)
  130.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_MODIFICATION_NOT_ALLOWED_ERROR.code, wFileManagerError.FILE_MODIFICATION_NOT_ALLOWED_ERROR.message);
  131.                 else if(e.code == FileError.INVALID_STATE_ERR)
  132.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_STATE_ERROR.code, wFileManagerError.FILE_STATE_ERROR.message);
  133.                 else if(e.code == FileError.SYNTAX_ERR)
  134.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_SYNTAX_ERROR.code, wFileManagerError.FILE_SYNTAX_ERROR.message);             
  135.                 else if(e.code == FileError.QUOTA_EXCEEDED_ERR)
  136.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_QUOTA_ERROR.code, wFileManagerError.FILE_QUOTA_ERROR.message);
  137.                 else if(e.code == FileError.TYPE_MISMATCH_ERR)
  138.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message);
  139.                 else if(e.code == FileError.PATH_EXISTS_ERR)
  140.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.FILE_EXISTS_ERROR.code, wFileManagerError.FILE_EXISTS_ERROR.message);             
  141.                
  142.                 if(dnfiError == null)
  143.                         dnfiError = new DnfiStatus('wFileManager', wFileManagerError.GENERAL_ERROR.code,
  144.                                                         wFileManagerError.GENERAL_ERROR.message);
  145.                 runCallBacks(context.cb, dnfiError, retVal);
  146.         }
  147.        
  148.         var getFilePathFromURL = function(str)
  149.         {
  150.                 var tempStr = str;
  151.                 var strA;
  152.                 if (str.indexOf("file://localhost") == 0) //for ios
  153.                         strA = str.split("file://localhost");
  154.                 else
  155.                         strA = str.split("file://");
  156.                 if (strA.length > 1)
  157.                         tempStr = strA[1];
  158.                
  159.                 return tempStr;
  160.         }
  161.        
  162.         var sortEntries = function(list,sortorder)
  163.         {
  164.                 if(list instanceof Array)
  165.                 {
  166.                         function sortControl()
  167.                         {
  168.                                 this.col;
  169.                                 this.sortType;
  170.                         }
  171.                         var controller = [];
  172.                         if(typeof sortorder != "undefined")
  173.                         {
  174.                                 var tokens = sortorder.split(",");
  175.                                 var rowIndex = 0;
  176.                                 for(token in tokens)
  177.                                 {
  178.                                        
  179.                                         var singleColumn = tokens[token].split(" ");
  180.                                         if (singleColumn.length == 2)
  181.                                         {
  182.                                                 var obj = new sortControl();
  183.                                                 obj.col = singleColumn[0];
  184.                                                 obj.sortType = singleColumn[1];
  185.                                                 controller[rowIndex] = obj;
  186.                                         }              
  187.                                        
  188.                                 }
  189.                         }
  190.                         else
  191.                         {
  192.                                 var obj = new sortControl();
  193.                                 obj.col = "name";
  194.                                 obj.sortType = "asc";
  195.                                 controller[0] = obj;
  196.                         }
  197.                        
  198.                 if(controller.length > 0)
  199.                 {
  200.                         var column = controller[0].col;
  201.                         var sortType= controller[0].sortType;
  202.                        
  203.                         list.sort(function(a, b)
  204.                         {
  205.                                
  206.                                 var val1 = a.name + "";
  207.                                 var val2 = b.name + "";
  208.                                
  209.                                                                
  210.                                 if(column.toLowerCase() == "datemodified")
  211.                                 {
  212.                                        
  213.                                         if(typeof a.modificationTime != null && typeof b.modificationTime != null)
  214.                                         {
  215.                                                 //compare only when you have valid time
  216.                                                 var val1 = a.modificationTime.getTime() ;
  217.                                                 var val2 = b.modificationTime.getTime();
  218.                                                
  219.                                                 if(val1 > val2)
  220.                                                         return 1;
  221.                                                 else if(val1 < val2)
  222.                                                         return -1;
  223.                                         }
  224.                                        
  225.                                         return 0;
  226.                                 }
  227.                                 return val1.localeCompare(val2);
  228.                         });
  229.                        
  230.                         if(sortType.toLowerCase() == "desc")
  231.                                 list.reverse();
  232.                 }              
  233.                
  234.         }
  235.         }
  236.                
  237.         var gettempfileName = function(context) {
  238.                 var str =  self.tempFileSystem.root.fullPath + "/" +  new Date().getTime();
  239.                 var strA = str.split("file://");
  240.                 if (strA.length > 1)
  241.                         str = strA[1];
  242.                
  243.         if (!context)
  244.             return str;
  245.         else
  246.                 runCallBacks(context.cb, self.successObject, str);
  247.         }
  248.        
  249.         var getdirectoryname = function (fn)
  250.         {
  251.                 //example: fname, /fname, /d/fname
  252.                
  253.                 var arr = fn.split("/");
  254.                 if (arr.length == 0) return null;
  255.                 if (arr.length == 1) return ("root");
  256.                 if (arr.length > 1)     return arr[arr.length - 2];
  257.         }
  258.        
  259.         /* returns resolved path based on given path is absolute or relative */
  260.         var getResolvedPath = function(path)
  261.         {
  262.                 if(typeof path == "string")
  263.                 {
  264.                         var resolvedPath = path;
  265.                         if (path != null && typeof path == 'string')
  266.                         {
  267.                                 var workDir = self.currentWorkingDirEntryObject.fullPath;
  268.                                 var workDirRelative = "";
  269.                                        
  270.                                 if(workDir.indexOf(self.fileSystem.root.fullPath) == 0)
  271.                                 {
  272.                                         workDir = workDir.substring(self.fileSystem.root.fullPath.length);
  273.                                 }
  274.                                
  275.                                 if(workDir.length > 0 && workDir[0] == "/")
  276.                                         workDirRelative = workDir.substring(1);
  277.                                          
  278.                                 resolvedPath = getFilePathFromURL(path);       
  279.                                                                
  280.                                 if (resolvedPath[0] != '/') //relative path
  281.                                 {
  282.                                         //resolved path w.r.t working directory                                          
  283.                                         if(workDirRelative.length > 0 && workDirRelative[workDirRelative.length - 1] != "/")
  284.                                                 resolvedPath = workDirRelative + "/" + resolvedPath;   
  285.                                         else
  286.                                                 resolvedPath = workDirRelative + resolvedPath; 
  287.                                 }
  288.                                 else
  289.                                 {
  290.                                         if(resolvedPath.length > 1 && resolvedPath[0] == "/" && resolvedPath[1] == "/")
  291.                                                 resolvedPath = resolvedPath.substring(1);
  292.                                                
  293.                                         if(resolvedPath.indexOf(self.fileSystem.root.fullPath) == 0)
  294.                                         {
  295.                                                 resolvedPath = resolvedPath.substring(self.fileSystem.root.fullPath.length);
  296.                                         }
  297.                                 }
  298.                                
  299.                         }
  300.                        
  301.                         if(resolvedPath.length > 0 && resolvedPath[0] == "/")
  302.                                         resolvedPath = resolvedPath.substring(1);
  303.                        
  304.                         return resolvedPath;
  305.                 }
  306.                 else if(typeof path.isFile != "undefined")
  307.                         return getResolvedPath(path.toURL());
  308.                
  309.         }
  310.        
  311.         var getResolvedURI = function(path)
  312.         {
  313.                 if(typeof path == "string")
  314.                 {
  315.                         var resolvedPath = path;
  316.  
  317.                         if(path.indexOf("://") == -1)
  318.                         {
  319.                        
  320.                        
  321.                         if (__cfclient_os != undefined && __cfclient_os != null)
  322.                         {
  323.                                 if (__cfclient_os.toLowerCase() == "ios" && (resolvedPath.indexOf("file://localhost") != 0 && resolvedPath.indexOf("file://") != 0 )) //for ios
  324.                                         resolvedPath = "file://localhost" + appendSlash(convertToAbsolutePath(resolvedPath));
  325.                                 else if(resolvedPath.indexOf("file://") != 0 && resolvedPath.indexOf("file://localhost") != 0)
  326.                                         resolvedPath = "file://" + appendSlash(convertToAbsolutePath(resolvedPath));
  327.                         }
  328.                         else
  329.                                 resolvedPath = convertToAbsolutePath(resolvedPath);
  330.                        
  331.                                
  332.                         function convertToAbsolutePath(p)
  333.                         {
  334.                                 if (p != null && typeof p == 'string')
  335.                                 {                                                              
  336.                                         if (p[0] != '/') //relative path
  337.                                                 return self.getWorkingDirectory() + "/" + p;    //resolved path w.r.t working directory                        
  338.                                 }
  339.                                
  340.                                 return p;
  341.                         }
  342.                         function appendSlash(p)
  343.                         {
  344.                                 if(p.length > 0)
  345.                                 {
  346.                                         if(p.charAt(0) != "/")
  347.                                                 return "/" + p;
  348.                                         else
  349.                                                 return p;
  350.                                 }
  351.                                
  352.                                 return "/";
  353.                         }
  354.                         }
  355.                        
  356.                         return resolvedPath;
  357.                 }
  358.                 else if(typeof path.isFile != "undefined") //check for FileEntry or DirectoryEntry object
  359.                         return path.toURL();
  360.         }
  361.        
  362.         var getFileEntryForPath = function(path, callback, getDir)
  363.         {
  364.                 function onResolveSuccess(entry)
  365.                 {
  366.                         var args = [1,entry];//return success 1 and file/dir entry
  367.                         callback.apply(callback,args);
  368.                 }
  369.                 function fail(event)
  370.                 {                              
  371.                         var args = [0,event];//return failure 0 and error
  372.                         callback.apply(callback, args);
  373.                 }
  374.                 //need to make sure fileName isin URI format eg. file:// or file://localhost
  375.                 if(typeof path == "string")
  376.                 {
  377.                         if(path.indexOf("://") != -1) // fileName in URL format
  378.                         {
  379.                                 window.resolveLocalFileSystemURI(path, onResolveSuccess, fail);
  380.                         }
  381.                         else
  382.                         {
  383.                                 flags = {create: false};
  384.                                
  385.                                 var resolvedPath = getResolvedPath(path);                              
  386.                                 if(!getDir)                                                                    
  387.                                         self.fileSystem.root.getFile(resolvedPath, flags, onResolveSuccess, fail);
  388.                                 else
  389.                                         self.fileSystem.root.getDirectory(resolvedPath, flags, onResolveSuccess, fail);
  390.                         }
  391.                 }
  392.                 else if(typeof path.isFile != "undefined") //check for FileEntry or DirectoryEntry object
  393.                         onResolveSuccess(path);
  394.                
  395.         }
  396.                                
  397.         var open = function(context, fileName, mode, data, throwErrorIfExists)
  398.         {
  399.                 var flags = {};
  400.                
  401.                 if (self.fileSystem != null)
  402.                 {
  403.                         if(_validateEntry(context,fileName,"file"))
  404.                         {
  405.                                 function _append(entry)
  406.                                 {
  407.                                         var append = false;
  408.                                         if(mode == 'append')
  409.                                        
  410.                                                 append = true;
  411.  
  412.                                         entry.createWriter(function(writer)
  413.                                         {
  414.                                                 writer.onwriteend = function(evt)
  415.                                                 {
  416.                                                         __$cf._log("file write completed");
  417.                                                         runCallBacks(context.cb, self.successObject, null);
  418.                                                 } //this.fileWriteEnd;
  419.                                                 if (data != null)
  420.                                                 {
  421.                                                         if(append)
  422.                                                                 writer.seek(writer.length);
  423.                                                                
  424.                                                         writer.write(data);
  425.                                                 }
  426.                                                 else
  427.                                                 {
  428.                                                         runCallBacks(context.cb, self.successObject, null);
  429.                                                 }
  430.                                         }, function (e) {
  431.                                                         handleError(context,e,null);
  432.                                                         return;
  433.                                         });
  434.                                        
  435.                                 }
  436.                                
  437.                                 function _process(entry)
  438.                                 {
  439.                                         if(mode == "get")
  440.                                         {                                              
  441.                                                 runCallBacks(context.cb, self.successObject, entry);
  442.                                                 return;
  443.                                         }
  444.                                         else if(mode == "create")
  445.                                         {
  446.                                                 __$cf._log("created file " +entry.fullPath);
  447.                                                 runCallBacks(context.cb, self.successObject, entry.fullPath);
  448.                                                 return;
  449.                                         }                                                                                      
  450.                                         else if ((mode == 'write') || (mode == 'createandwrite') || (mode == 'append'))
  451.                                         {
  452.                                                
  453.                                                 _append(entry);                                        
  454.                                                 return;
  455.                                         }
  456.                                 }
  457.                        
  458.                         if(typeof fileName == "string")
  459.                         {
  460.                                 name = getResolvedPath(fileName);
  461.                                
  462.                                 if(typeof throwErrorIfExists == "undefined")
  463.                                         throwErrorIfExists = false;
  464.                                        
  465.                                 if ((mode == 'create') || (mode == 'createandwrite'))                                  
  466.                                         flags = {create: true, exclusive: throwErrorIfExists};
  467.                                 else                             
  468.                                         flags = {create: false};
  469.                                        
  470.                                
  471.                                 self.fileSystem.root.getFile(name, flags, function (entry)
  472.                                 {
  473.                                         __$cf._log("File entry found for "+name);
  474.                                         _process(entry);
  475.                                 }
  476.                                 , function (e)
  477.                                 {
  478.                                         __$cf._log("File operation error "+e.code);
  479.                                         handleError(context,e,null);                   
  480.                                 });
  481.                                
  482.                                
  483.                         }
  484.                         else
  485.                         {
  486.                                 _process(fileName);
  487.                         }
  488.                                                                        
  489.                        
  490.                         }
  491.                 }
  492.         }  
  493.        
  494.         /* **************************************************************************************************************************************
  495.  * moveTo - moves the file from the src to dest
  496.  * Usage example: moveTo(context, "/sdcard/abc", "/sdcard/ananth/abc")
  497.  * inputs:
  498.  *              context - context variable that holds the callback and return value
  499.  *              src             - source object (can be a string or object)
  500.  *              dest    - destination object (can be a string or object)
  501.  *              copy    - if copy is true do the file copy otherwise just move it to the new location
  502.  *              1. Get the fileEntry corresponding to the source object
  503.  *              2. Get the parent directory name as a string
  504.  *              3. Create the name to a directory entry
  505.  *              4. Use the phonegap's moveTo method to move the file to destination
  506.  * Key questions to be addressed in spec
  507.  *              1. what happens if the path specified in destination directory didnt exist? Should we create it?
  508.   ***************************************************************************************************************************************/             
  509.                 var moveOrCopy = function (context, src, dest, copy)
  510.                 {
  511.                         //TODO: Need to implement this function for src and dest as general objects than strings
  512.                         var parent = null;
  513.                         var fileName = null;
  514.                         if (self.fileSystem != null) {
  515.                                
  516.                         if(_validateEntry(context,src,"file"))
  517.                         {                              
  518.                                 fileName = getResolvedPath(dest);
  519.                                
  520.                                 var dPath = getdirectorypath(fileName);
  521.                                 if(dPath == null)
  522.                                         dPath = self.currentWorkingDirEntryObject.fullPath;                            
  523.                                
  524.                                 var srcEntry = null;
  525.                                 var destEntry = null; //self.fileEntryObject;
  526.                                
  527.                                 //get the file entry for the destination
  528.                                 getFileEntryForPath(dPath,function(status, parentEntry)
  529.                                 {
  530.                                         if(status == 1)
  531.                                         {
  532.                                                 //get the file entry of the src
  533.                                         getFileEntryForPath(src,function(status, retVal)
  534.                                         {
  535.                                
  536.                                                 if (status == 1)
  537.                                                 {
  538.                                                         if(retVal instanceof FileEntry)                                
  539.                                                         {
  540.                                                         var fileEntry = retVal;
  541.  
  542.                                                         var name1 =  fileName.substring(fileName.lastIndexOf('/')+1);
  543.                                                                                                                
  544.                                                         var func = null;
  545.                                                        
  546.                                                         if (copy)
  547.                                                         {
  548.                                                                 fileEntry.copyTo(parentEntry, name1, function (entry) {
  549.                                                                         __$cf._log("File successfully moved/copied to: " + entry.fullPath);
  550.                                                                         runCallBacks(context.cb, self.successObject, entry);
  551.                                                                 }, function (e) {
  552.                                                                         //need to process the error that occured during file rename
  553.                                                                         __$cf._log("Error while trying to copy file - code = " + e.code);
  554.                                                                         handleError(context,e,null);                                                           
  555.                                                                 });
  556.                                                         }
  557.                                                         else
  558.                                                         {
  559.                                                                 fileEntry.moveTo(parentEntry, name1, function (entry) {
  560.                                                                         __$cf._log("File successfully moved/copied to: " + entry.fullPath);
  561.                                                                         runCallBacks(context.cb, self.successObject, entry);
  562.                                                                 }, function (e) {
  563.                                                                         //need to process the error that occured during file rename
  564.                                                                         __$cf._log("Error while trying to rename file - code = " + e.code);
  565.                                                                         handleError(context,e,null);                                                           
  566.                                                                 });
  567.                                                         }
  568.                                                        
  569.                                                         }//
  570.                                                         else
  571.                                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  572.                                                        
  573.                                                 } //open for getting src entry
  574.                                                 else //open failed
  575.                                                 {
  576.                                                         __$cf._log("error: " + retVal.code + " message: " + retVal.message);
  577.                                                         handleError(context,retVal,null);
  578.                                                         return;                                                
  579.                                                 }
  580.                                         });
  581.                                         }
  582.                                         else
  583.                                         {
  584.                                                 handleError(context,parentEntry,null);
  585.                                                 return;
  586.                                         }
  587.                                        
  588.                                 },true);
  589.                                
  590.                                 }                                                                                                              
  591.                         }                      
  592.                         else //if fileSystem is null return error
  593.                         {
  594.                                 runCallBacks(context.cb, new DnfiStatus('WFileManager', WFileManager.NULL_FILESYSTEM_ERROR.code, WFileManager.NULL_FILESYSTEM_ERROR.message), null);
  595.                                 return;
  596.                         }                      
  597.                 }
  598.                
  599.                 /* **************************************************************************************************************************************
  600.  * moveOrCopyDirectory - moves or copies the dir from the src to dest
  601.  * Usage example: moveOrCopyDirectory(context, "/sdcard/abc", "/sdcard/ananth/abc", false)
  602.  * inputs:
  603.  *              context - context variable that holds the callback and return value
  604.  *              src             - source object (can be a string or object)
  605.  *              dest    - destination object (can be a string or object)
  606.  *              copy    - if copy is true do the file copy otherwise just move it to the new location
  607.  *              1. Get the DirectoryEntry corresponding to the source object
  608.  *              2. Get the DirectoryEntry corresponding to the destination object
  609.  *              3. Use the phonegap's moveTo or copyTo method to move the directory to destination
  610.  * Key questions to be addressed in spec
  611.  *              1. what happens if the path specified in destination directory didnt exist? Should we create it?
  612.   ***************************************************************************************************************************************/             
  613.                 var moveOrCopyDirectory = function (context, source, destination, copy, ren)
  614.                 {
  615.                         var newName = null;
  616.                        
  617.                         var parent = null;
  618.                         var dirName = null;
  619.                        
  620.                         if (self.fileSystem != null)
  621.                         {
  622.                                 if(_validateEntry(context,source,"dir") && _validateEntry(context,destination,"dir"))
  623.                                 {
  624.                                 var src = getResolvedPath(source);
  625.                                 var dest = getResolvedPath(destination);
  626.                                
  627.                                 if (typeof dest == 'string')
  628.                                 {
  629.                                         dirName = dest;
  630.                                         if (ren)
  631.                                         {
  632.                                                 dirName = getdirectorypath(dest);
  633.                                                 newName = dest.substring(dest.lastIndexOf('/') + 1);
  634.                                         }
  635.                                 }
  636.                                
  637.                                 //get the dir entry for the destination - it is an error if it doesn't exist
  638.                                 self.getDirectory({cb:[function(e, entry) {
  639.                                         if (e.code == dnfi.SUCCESS.code)
  640.                                         {
  641.                                                 __$cf._log("Destination directory found, fullPath:" + entry.fullPath);
  642.                                                 //TODO: lookup for the src directory                           
  643.                                                 if (typeof src == 'string')
  644.                                                 {
  645.                                                         //get the dir entry of the src
  646.                                                         self.getDirectory({cb: [function(e, srcEntry)
  647.                                                         {
  648.                                                                 __$cf._log("Found source directory");
  649.                                                                                                                
  650.                                                                 if (e.code == dnfi.SUCCESS.code)
  651.                                                                 //if(e.code == 0)
  652.                                                                 {                                                                                                                              
  653.                                                                         var func = null;                                                       
  654.                                                                         if (copy)
  655.                                                                         {
  656.                                                                                 srcEntry.copyTo(entry, null, function (entry) {
  657.                                                                                         __$cf._log("Directory successfully copied to: " + entry.fullPath);
  658.                                                                                         runCallBacks(context.cb, self.successObject, entry);
  659.                                                                                 }, function (e) {
  660.                                                                                         //need to process the error that occured during file rename
  661.                                                                                         __$cf._log("Error while copying the directory - code = " + e.code);
  662.                                                                                         handleError(context,e,null);                                                           
  663.                                                                                 });
  664.                                                                         } // end for copy
  665.                                                                         else
  666.                                                                         {  //do the dir move
  667.                                                                                 srcEntry.moveTo(entry, newName, function (entry) {
  668.                                                                                         __$cf._log("Directory successfully moved to: " + entry.fullPath);
  669.                                                                                         runCallBacks(context.cb, self.successObject, entry);
  670.                                                                                 }, function (e) {
  671.                                                                                         //need to process the error that occured during dir move
  672.                                                                                         __$cf._log("Error while trying to move directory - code = " + e.code);
  673.                                                                                         handleError(context,e,null);                                                           
  674.                                                                                 });
  675.                                                                         } // enf of dir move
  676.                                                        
  677.                                                 } // lookup for getting src entry
  678.                                                 else // lookup failed
  679.                                                 {
  680.                                                         __$cf._log("error: " + e.code + " message: " + e.message);
  681.                                                         runCallBacks(context.cb, e, null);
  682.                                                         return;                                                
  683.                                                 }
  684.                                         }], ret:'ret'}, src);
  685.                                 }
  686.                                 else //src is an object not a simple string
  687.                                 {
  688.                                        
  689.                                 }
  690.                                                 return;
  691.                                 }
  692.                                 else
  693.                                 {
  694.                                         runCallBacks(context.cb, e, null);                                                                                                                                                                     
  695.                                 }                      
  696.                                 }], ret:"ret"}, dirName);
  697.                                
  698.                                 }                      
  699.                                
  700.                         }                      
  701.                         else //if fileSystem is null return error
  702.                         {
  703.                                 runCallBacks(context.cb, new DnfiStatus('WFileManager', WFileManager.NULL_FILESYSTEM_ERROR.code, WFileManager.NULL_FILESYSTEM_ERROR.message), null);
  704.                                 return;
  705.                         }                      
  706.                 }
  707.                
  708. /* *******************************************************************************************************************
  709.                 setfilesystem(context, fsName) - sets the file system to the specified value - either PERSISTENT or TEMPORARY
  710. ******************************************************************************************************************** */
  711.                 this.setFileSystem = function(context, fsName)
  712.                 {
  713.                         if(_validateDeviceAPI(context, arguments.length-1, 1, "setFileSystem"))
  714.                         {
  715.                         var t = null;
  716.                        
  717.                         if (typeof fsName != "undefined" && fsName != null)
  718.                         {
  719.                                 switch (fsName.toLowerCase())
  720.                                 {
  721.                                         case "persistent":
  722.                                         {
  723.                                                 if (self.persistentFileSystem != null)
  724.                                                 {
  725.                                                         self.fileSystem = self.persistentFileSystem;
  726.                                                         self.currentWorkingDirEntryObject = self.persistentFileSystem.root;
  727.                                                         runCallBacks(context.cb, self.successObject, self.fileSystem);
  728.                                                         return;
  729.                                                 }
  730.                                                
  731.                                                 t = LocalFileSystem.PERSISTENT;
  732.                                                 break;
  733.                                         }
  734.                                         case "temporary":
  735.                                         {
  736.                                                 if (self.tempFileSystem != null)
  737.                                                 {                                                      
  738.                                                         self.fileSystem = self.tempFileSystem;
  739.                                                         self.currentWorkingDirEntryObject = self.tempFileSystem.root;
  740.                                                         runCallBacks(context.cb, self.successObject, self.fileSystem);                         
  741.                                                         return;
  742.                                                 }
  743.                                                 t = LocalFileSystem.TEMPORARY;
  744.                                                 break;
  745.                                                
  746.                                         }
  747.                                         default:
  748.                                         {
  749.                                                 __$cf._log("invalid file system");
  750.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.INVALID_FILESYSTEM_ERROR.code,
  751.                                                                         wFileManagerError.INVALID_FILESYSTEM_ERROR.message), null);
  752.                                                 return;
  753.                                         }
  754.                                 }
  755.                                
  756.                                 window.requestFileSystem(t, 0, function(fs)
  757.                                 {                                      
  758.                                         self.fileSystem = fs;
  759.  
  760.                                         __$cf._log("valid file system obtained");
  761.                                
  762.                                         if (t == LocalFileSystem.PERSISTENT)
  763.                                                 self.persistentFileSystem = fs;
  764.                                         else if (t == LocalFileSystem.TEMPORARY)
  765.                                                 self.tempFileSystem = fs;
  766.                                
  767.                                         self.currentWorkingDirEntryObject = fs.root;                           
  768.                                         runCallBacks(context.cb, self.successObject, fs);                              
  769.                                 return;                        
  770.                                 },
  771.                                 function(error)
  772.                                 {
  773.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILESYSTEM_SET_ERROR.code,
  774.                                                                         wFileManagerError.FILESYSTEM_SET_ERROR.message + " "+ error.code), null);
  775.                                 });    
  776.                                 return;
  777.                         }
  778.                 }
  779.                 }
  780.  
  781.  
  782.                 this.write = function(context, name, data)
  783.                 {      
  784.                         if(_validateDeviceAPI(context, arguments.length-1, 1, "write"))
  785.                         {
  786.                                 var myself = this;
  787.  
  788.                                 if(_validateEntry(context,name,"file"))                                
  789.                                         open(context, name, 'createandwrite', data);
  790.                                
  791.                         }
  792.                        
  793.                 } //write method
  794.                
  795.                 this.append = function(context, name, data)
  796.                 {
  797.                         if(_validateDeviceAPI(context, arguments.length-1, 2, "append"))
  798.                         {                      
  799.                                
  800.                                         if(_validateEntry(context,name,"file"))
  801.                                         {
  802.                                                                        
  803.                                                         open(context, name, 'append', data);
  804.                                         }
  805.                                         else
  806.                                         {
  807.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_INVALID_NAME_ERROR.code,
  808.                                                                                                                         wFileManagerError.FILE_INVALID_NAME_ERROR.message), null);
  809.                                         }
  810.                                
  811.                         }
  812.                        
  813.                 } //write method
  814.                
  815.                
  816.                 var _read = function(context, name, mode)
  817.                 {
  818.                         getFileEntryForPath(name,function(status,ret)
  819.                         {
  820.                                 if(status === 1)
  821.                                 {
  822.                                         if(ret instanceof FileEntry)
  823.                                         {
  824.                                                 ret.file(function(f)
  825.                                                 {
  826.                                                         var reader1 = new FileReader();
  827.                                                         reader1.onloadend = function(evt)
  828.                                                         {
  829.                                                                 runCallBacks(context.cb, self.successObject, evt.target.result);
  830.                                                         } //onload function for reader;
  831.                                                         if (mode == 'readdataurl')
  832.                                                         {
  833.                                                                 reader1.readAsDataURL(f); //read the file as base64 data
  834.                                                         }
  835.                                                         else
  836.                                                         {
  837.                                                                 reader1.readAsText(f); //read the file as text
  838.                                                         }
  839.                                                         },
  840.                                                         function (e)
  841.                                                         {
  842.                                                                 handleError(context,e,null);
  843.                                                 });
  844.                                        
  845.                                         }                                      
  846.                                         else
  847.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  848.                                        
  849.                                 }
  850.                                 else
  851.                                 {
  852.                                         __$cf._log("read error " + ret);
  853.                                         handleError(context,ret,null);
  854.                                 }
  855.                         });
  856.                 }
  857.                
  858.                 this.read = function(context, name)
  859.                 {      
  860.                         if(_validateDeviceAPI(context, arguments.length-1, 1, "read"))
  861.                         {      
  862.                                 /*
  863.                                  * Step 2 - set up the parameters required
  864.                                  */
  865.                                  this.ret; //variable to hold return value from sequencer
  866.                                  var readObj = this;
  867.        
  868.                                 if (name != null) // we need first to open the file and then do the writing
  869.                                 {              
  870.                                         //open(context, name, 'read');
  871.                                         _read(context,name,'read');
  872.                                        
  873.                                 }
  874.                         }
  875.                        
  876.                 } //read method
  877.                
  878.                 //the method readDataURL is similar to read but reads the data in binary form
  879.                 this.readAsBase64 = function(context, name)
  880.                 {
  881.                         if(_validateDeviceAPI(context, arguments.length-1, 1, "readAsBase64"))
  882.                         {                      
  883.                                 /*
  884.                                  * Step 2 - set up the parameters required
  885.                                  */
  886.                                 if (name != null) // we need first to open the file and then do the writing
  887.                                 {                              
  888.                                         //open(context, name, 'readdataurl');
  889.                                         _read(context,name,'readdataurl');
  890.                                 }
  891.                         }
  892.                        
  893.                 } //read method
  894.                
  895. /* ************************************************************************************************************************************
  896.  * getdirectoryname(fileName_with_path)
  897.  *
  898.  * This function is intended to cull out the directory name in which the given file resides.
  899.  * The file name may be a full path or a relative path
  900.  * NOTE:
  901.  *
  902.  * 1. For determining the directory name we search and split against a separator '/'. In systems where '/' is not the separator for directory
  903.  * we need to rewrite this function
  904.  * 2. Suppose just the file name (without the directory path) is specified, we need to interpret this as the file in the current working dir - we return null
  905.  * 3. If the file name is specified like: /filename, this refers to a file under the root directory and we return 'root'
  906.  ****************************************************************************************************************************************/
  907.                                                
  908. /* ************************************************************************************************************************************
  909.  * getdirectorypath(fileName_with_path)
  910.  *
  911.  * This function is intended to cull out the directory full path in which the given file resides.
  912.  * The file name may be a full path or a relative path
  913.  * NOTE:
  914.  *
  915.  * 1. For determining the directory name we search and split against a separator '/'. In systems where '/' is not the separator for directory
  916.  * we need to rewrite this function
  917.  * 2. Suppose just the file name (without the directory path) is specified, we need to interpret this as the file in the current working dir - we return null
  918.  * 3. If the file name is specified like: /filename, this refers to a file under the root directory and we return 'root' ISSUE: what happens for a/b?
  919.  ****************************************************************************************************************************************/
  920.                 var getdirectorypath = function (path)
  921.                 {
  922.                         var fn = path;
  923.                         if(typeof path != "string")
  924.                         {
  925.                                 if(typeof path.isFile != "undefined")
  926.                                         fn =path.fullPath;
  927.                         }
  928.                        
  929.                         var arr = fn.split("/");
  930.                         if (arr.length == 1) return null;
  931.                         if (arr.length == 2) {
  932.                                 if (fn[0] == '/') return ("/");
  933.                                 else return(fn.substring(0, fn.lastIndexOf('/')));
  934.                         }      
  935.                         if (arr.length > 2)     return fn.substring(0, fn.lastIndexOf('/'));
  936.                        
  937.                 }
  938.                
  939.                
  940.  
  941.                
  942. /* **************************************************************************************************************************************
  943.  * move
  944.  */
  945.         this.move = function(context, src, dest)
  946.         {
  947.                 if(_validateDeviceAPI(context, arguments.length-1, 2, "move"))
  948.                 {                      
  949.                         moveOrCopy({cb: [function(e, entry) {
  950.                                         if (e.code == dnfi.SUCCESS.code)
  951.                                         {
  952.                                                 runCallBacks(context.cb, self.successObject, entry);                                                   
  953.                                         }
  954.                                         else
  955.                                         {
  956.                                                 runCallBacks(context.cb, e, null);                                                                                                                     
  957.                                         }                      
  958.                         }]}, src, dest, false);
  959.                         return;
  960.                 }
  961.                        
  962.         }              
  963. /* **************************************************************************************************************************************
  964.  * copy
  965.  */
  966.         this.copy = function(context, src, dest)
  967.         {
  968.                 if(_validateDeviceAPI(context, arguments.length-1, 2, "copy"))
  969.                 {
  970.                         moveOrCopy({cb: [function(e, entry)
  971.                         {
  972.                                 if (e.code == dnfi.SUCCESS.code)
  973.                                 {
  974.                                         runCallBacks(context.cb, self.successObject, null);                                                    
  975.                                 }
  976.                                 else
  977.                                 {
  978.                                         runCallBacks(context.cb, e, null);                                                                                                                     
  979.                                 }                      
  980.                         }]}, src, dest, true);
  981.                         return;
  982.                 }
  983.                                
  984.         }              
  985.                
  986. /* *****************************************************************************************************************************
  987.  * rename(src, dest) - rename the src file to destination
  988.  *
  989.  * Inputs:
  990.  *              src:    Full path name of the file to be renamed
  991.  *              dest:   Full path name of the new name of the file
  992.  *              Example: rename("/sdcard/ananth/a.txt", "/sdcard/ananth/b.txt")
  993.  *
  994.  * It is an error if rename is invoked with files whose parent directories are different
  995.  *
  996.  * TODO: Explore later whether we should support the concept of current working directory and allow renames like: rename(a.txt, b.txt) on current directory
  997.  *
  998.  ******************************************************************************************************************************/                               
  999.                 this.rename = function(context, source, destination)
  1000.                 {
  1001.                         if(_validateDeviceAPI(context, arguments.length-1, 2, "rename"))
  1002.                         {
  1003.                                 if(_validateEntry(context,source,"file"))
  1004.                                 {
  1005.                                 var src = getResolvedPath(source);
  1006.                                 var dest = getResolvedPath(destination);
  1007.                                
  1008.                                 var srcDir = getdirectorypath(src);
  1009.                                 var destDir = getdirectorypath(dest);
  1010.                                 if (srcDir == destDir)
  1011.                                 {                                      
  1012.                                         self.move({
  1013.                                                 cb: [function(e, entry){
  1014.                                                         if (e.code == dnfi.SUCCESS.code)
  1015.                                                         {
  1016.                                                                 runCallBacks(context.cb, self.successObject, entry);                                                   
  1017.                                                         }
  1018.                                                         else
  1019.                                                         {
  1020.                                                                 runCallBacks(context.cb, e, null);                                                                                                                     
  1021.                                                         }
  1022.                                                 }], ret:"ret"
  1023.                                         }, src, dest);
  1024.                                         return;
  1025.                                 }
  1026.                                 else
  1027.                                 {
  1028.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.SOURCE_DESTINATION_SAME_PATH_ERROR.code, wFileManagerError.SOURCE_DESTINATION_SAME_PATH_ERROR.message), null);
  1029.                                         return;                                                                                                                                                        
  1030.                                 }
  1031.                                 }
  1032.                         }
  1033.                 }
  1034.                
  1035. /* ***********************************************************************************************************************************
  1036.  *      remove(fileName) - deletes the file
  1037.  *             
  1038.  *************************************************************************************************************************************/
  1039.         this.remove = function(context, fileName)
  1040.         {
  1041.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "remove"))
  1042.                 {
  1043.                        
  1044.                         if(_validateEntry(context,fileName,"file"))
  1045.                         {                      
  1046.                         getFileEntryForPath(fileName, function(status, ret)
  1047.                         {
  1048.                                 if(status == 1)
  1049.                                 {
  1050.                                         if(ret instanceof FileEntry)
  1051.                                         {
  1052.                                         function success(entry) {
  1053.                                                 __$cf._log("File removed successfully");
  1054.                                                 runCallBacks(context.cb, self.successObject, true);
  1055.                                                 }
  1056.                                                
  1057.                                                 function fail(error) {
  1058.                                                         handleError(context,error,null);
  1059.                                                 }
  1060.                                         ret.remove(success,fail);
  1061.                                         }                                      
  1062.                                         else
  1063.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1064.                                 }
  1065.                                 else
  1066.                                         handleError(context,ret,null);
  1067.                         //open(context,fileName,"delete");
  1068.                         });
  1069.                         }
  1070.                 }
  1071.         }
  1072. /* ***********************************************************************************************************************************
  1073.  *      getParent - gets the parent directory entry of the file
  1074.  *             
  1075.  *************************************************************************************************************************************/
  1076.         this.getParent = function(context, fileName)
  1077.         {
  1078.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "getParent"))
  1079.                 {
  1080.                         if(_validateEntry(context,fileName,"both"))
  1081.                         {
  1082.                         getFileEntryForPath(fileName, function(status, ret)
  1083.                         {
  1084.                                 if(status == 1)
  1085.                                 {
  1086.                                         ret.getParent(function(entry)
  1087.                                         {                                      
  1088.                                                 //syncDirectoryEntry(entry);
  1089.                                                 runCallBacks(context.cb, self.successObject, entry);                                                                                                                                   
  1090.                                         }, function (e) {
  1091.                                                 handleError(context, e,null);                                                                                                                                                                                  
  1092.                                         });
  1093.                                 }
  1094.                                 else
  1095.                                         handleError(context,ret,null);
  1096.                         });            
  1097.                         return;
  1098.                         }      
  1099.                 }
  1100.         }
  1101. /* ***********************************************************************************************************************************
  1102.  *      toURI - gets the parent directory entry of the file
  1103.  *             
  1104.  *************************************************************************************************************************************/
  1105.         this.toURI = function(context, fileName)
  1106.         {
  1107.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "toURI"))
  1108.                 {
  1109.                         if(_validateEntry(context,fileName,"both"))
  1110.                         {
  1111.                                 getFileEntryForPath(fileName, function(status, ret)
  1112.                                 {
  1113.                                         if(status == 1)
  1114.                                         {
  1115.                                                 runCallBacks(context.cb, self.successObject, ret.toURL());
  1116.                                         }
  1117.                                         else
  1118.                                                 handleError(context,ret,null);
  1119.                                 });    
  1120.                         }              
  1121.                 }
  1122.         }
  1123.        
  1124.  /* ********************************************************************************************************************************
  1125.  *              exists - check whether a given file or directory exists
  1126.  *
  1127.  *************************************************************************************************************************************/
  1128.         this.exists = function(context, name)
  1129.         {
  1130.                
  1131.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "exists"))
  1132.                 {
  1133.                         if(_validateEntry(context,name,"file"))
  1134.                         {
  1135.                                 //process here for local file system
  1136.                                 if(self.fileSystem != null)
  1137.                                 {
  1138.                                         var fileName = name;
  1139.                                         if(typeof name.fullPath == "string")
  1140.                                                 fileName = name.fullPath;
  1141.                                                
  1142.                                         getFileEntryForPath(fileName, function(status, ret)
  1143.                                         {
  1144.                                                 if(status == 1)
  1145.                                                 {
  1146.                                                         if(ret instanceof FileEntry)
  1147.                                                         {
  1148.                                                                 runCallBacks(context.cb,self.successObject,true);
  1149.                                                         }
  1150.                                                         else
  1151.                                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1152.                                                 }
  1153.                                                 else
  1154.                                                 {
  1155.                                                         __$cf._log("File operation error "+ret.code);                              
  1156.                                                         runCallBacks(context.cb,self.successObject,false);
  1157.                                                 }
  1158.                                         });
  1159.                                 }      
  1160.                         }
  1161.                 }                      
  1162.         }
  1163.        
  1164.         this.directoryExists = function(context, dPath)
  1165.         {
  1166.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "directoryExists"))
  1167.                 {
  1168.                         if(_validateEntry(context,dPath,"dir"))
  1169.                         {
  1170.                                 //process here for local file system
  1171.                                 if(self.fileSystem != null)
  1172.                                 {
  1173.                                         var fileName = dPath;
  1174.                                         if(typeof dPath.fullPath == "string")
  1175.                                                 fileName = dPath.fullPath;
  1176.                                                
  1177.                                         getFileEntryForPath(fileName, function(status, ret)
  1178.                                         {
  1179.                                                 if(status == 1)
  1180.                                                 {
  1181.                                                         if(ret instanceof DirectoryEntry)
  1182.                                                                 runCallBacks(context.cb,self.successObject,true);
  1183.                                                         else
  1184.                                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1185.                                                        
  1186.                                                 }
  1187.                                                 else
  1188.                                                 {
  1189.                                                         __$cf._log("Directory operation error "+ret.code);                                 
  1190.                                                         runCallBacks(context.cb,self.successObject,false);
  1191.                                                 }
  1192.                                         },true);                               
  1193.                                 }      
  1194.                         }
  1195.                 }                                      
  1196.         }              
  1197. /* ++++++++++++++++++++++++++++++++++++++ Directory related functions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  1198.  
  1199.         this.getWorkingDirectory = function(context)
  1200.         {      
  1201.                
  1202.                 var str = self.currentWorkingDirEntryObject.fullPath;
  1203.                 str = getFilePathFromURL(str);
  1204.                 if(!context)
  1205.                         return str;
  1206.                 runCallBacks(context.cb, self.successObject, str);
  1207.                
  1208.         }
  1209.  
  1210. /* ********************************************************************************************************************************
  1211.  *              setCurrentWorkingDirectory - creates a directory entry for the current working directory and sets it in the global variable
  1212.  *              dirPath - absolute path or relative
  1213.  *              TODO: need to run tests for dirpath values: /a/b/c, /a, a, where some or all of the directory components exist
  1214.  *************************************************************************************************************************************/
  1215.         this.setWorkingDirectory = function(context, dPath)
  1216.         {
  1217.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "setWorkingDirectory"))
  1218.                 {
  1219.                         if(_validateEntry(context,dPath,"dir"))
  1220.                         {
  1221.                                 var dirPath = getResolvedPath(dPath);
  1222.                                
  1223.                                 var dEntry = self.getDirectory({cb:[function(e, entry) {
  1224.                                         if (e.code == dnfi.SUCCESS.code)
  1225.                                         {
  1226.                                                 __$cf._log("Successfully set working directory to:" + entry.fullPath);
  1227.                                                 self.currentWorkingDirEntryObject = entry;     
  1228.                                                 runCallBacks(context.cb, self.successObject, null);                                                                                                                                    
  1229.                                         }
  1230.                                         else
  1231.                                         {
  1232.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.DIRECTORY_LOOKUP_ERROR.code, wFileManagerError.DIRECTORY_LOOKUP_ERROR.message), null);                                                                                                                                                                       
  1233.                                         }                      
  1234.                                 }], ret:"ret"}, dirPath);
  1235.                         }
  1236.                 }
  1237.         }
  1238. /* ********************************************************************************************************************************
  1239.  *              createDirectory - creates the directory on the file system given the directory entry
  1240.  *              dirPath - absolute path or relative
  1241.  *              throwError - boolean - true - throw error if directory already exists
  1242.  *                                                         false - create if dire not present else return existing directory entry
  1243.  *              TODO: need to run tests for dirpath values: /a/b/c, /a, a, where some or all of the directory components exist
  1244.  *                        Also need to support creation of intermediate directory components if they don't exist
  1245.  *************************************************************************************************************************************/
  1246.         this.createDirectory = function(context, dirPath, throwError)
  1247.         {
  1248.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "createDirectory"))
  1249.                 {
  1250.                         var dEntry = null;
  1251.                         var throwErr = true;
  1252.                         if(throwError)
  1253.                                 throwErr = throwError;
  1254.                         if (dirPath == null || trim(dirPath) == "")
  1255.                         {
  1256.                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_INVALID_NAME_ERROR.code,
  1257.                                                                 wFileManagerError.FILE_INVALID_NAME_ERROR.message), null);
  1258.                         }
  1259.                        
  1260.                         dirPath = getFilePathFromURL(dirPath);
  1261.                                                                                                                
  1262.                         if (typeof dirPath == 'string')
  1263.                         {
  1264.                                 if (dirPath[0] == '/') //absolute path is specified, we will use the dirEntry: self.fileSystem.root
  1265.                                 {
  1266.                                         dEntry = self.fileSystem.root;
  1267.                                 }
  1268.                                 else
  1269.                                 {
  1270.                                         dEntry = self.currentWorkingDirEntryObject;
  1271.                                 }
  1272.                                 dEntry.getDirectory(dirPath, {create:true, exclusive:throwErr}, function (entry)
  1273.                                 {
  1274.                                         __$cf._log("directory created: " + entry.name + "  full path: " + entry.fullPath);
  1275.                                         //syncDirectoryEntry(entry);
  1276.                                         runCallBacks(context.cb, self.successObject, entry);                                                                                                                                   
  1277.                                 },
  1278.                                 function(e)
  1279.                                 {
  1280.                                         __$cf._log("Error while creating the directory, code: " + e.code);
  1281.                                         handleError(context,e,null);                                                                                                                                                                                                   
  1282.                                 });            
  1283.                                 return;
  1284.                         }
  1285.                         else
  1286.                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1287.                        
  1288.                 }
  1289.         }
  1290.  
  1291. /* ********************************************************************************************************************************
  1292.  *              lookup - lookup the file on the file system
  1293.  *              fileName - name of file for lookup
  1294.  *************************************************************************************************************************************/
  1295.         this.get = function(context, name)
  1296.         {
  1297.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "get"))
  1298.                 {
  1299.                 if(self.fileSystem != null)
  1300.                 {
  1301.                         var fileName = name;
  1302.                         if(typeof name.fullPath == "string")
  1303.                                 fileName = name.fullPath;
  1304.                                                
  1305.                         getFileEntryForPath(fileName, function(status,ret)
  1306.                         {
  1307.                                 if(status == 1)
  1308.                                 {
  1309.                                         if(ret instanceof FileEntry)
  1310.                                                 runCallBacks(context.cb, self.successObject, ret);
  1311.                                         else
  1312.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1313.                                 }
  1314.                                 else
  1315.                                 {
  1316.                                         __$cf._log("Error getting file/directory - error code "+ret.code);
  1317.                                         handleError(context,ret,null);
  1318.                                 }
  1319.                         });            
  1320.                 }
  1321.                 else
  1322.                         runCallBacks(context.cb, new DnfiStatus('WFileManager', WFileManager.NULL_FILESYSTEM_ERROR.code, WFileManager.NULL_FILESYSTEM_ERROR.message), null);
  1323.                 }
  1324.         }
  1325.        
  1326. /* ********************************************************************************************************************************
  1327.  *              getdirectory - looks up to a given directory in the current working directory
  1328.  *              dirPath - absolute path or relative
  1329.  *              TODO: need to run tests for dirpath values: /a/b/c, /a, a, where some or all of the directory components exist
  1330.  *************************************************************************************************************************************/
  1331.         this.getDirectory = function(context, dPath)
  1332.         {              
  1333.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "getDirectory"))
  1334.                 {
  1335.                         if(self.fileSystem != null)
  1336.                 {
  1337.                         var fileName = dPath;
  1338.                         if(typeof dPath.fullPath == "string")
  1339.                                 fileName = dPath.fullPath;
  1340.                                
  1341.                         getFileEntryForPath(fileName, function(status,ret)
  1342.                         {
  1343.                                 if(status == 1)
  1344.                                 {
  1345.                                         if(ret instanceof DirectoryEntry)
  1346.                                                 runCallBacks(context.cb, self.successObject, ret);
  1347.                                         else
  1348.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1349.                                 }
  1350.                                 else
  1351.                                 {
  1352.                                         __$cf._log("Error getting file/directory - error code "+ret.code);
  1353.                                         handleError(context,ret,null);
  1354.                                 }
  1355.                         },true);               
  1356.                 }
  1357.                 else
  1358.                         runCallBacks(context.cb, new DnfiStatus('WFileManager', WFileManager.NULL_FILESYSTEM_ERROR.code, WFileManager.NULL_FILESYSTEM_ERROR.message), null);
  1359.                 }              
  1360.         }
  1361.        
  1362.         this.getFileSystem = function(context)
  1363.         {
  1364.                 runCallBacks(context.cb, self.successObject, self.fileSystem);
  1365.         }
  1366. /* ********************************************************************************************************************************
  1367.  *              listDirectory - lists the contents of a given directory in the current working directory
  1368.  *              dirPath - absolute path or relative
  1369.  *              TODO: need to run tests for dirpath values: /a/b/c, /a, a, where some or all of the directory components exist
  1370.  *************************************************************************************************************************************/
  1371.         this.listDirectory = function(context, dirPath, sortType)
  1372.         {
  1373.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "listDirectory"))
  1374.                 {
  1375.                         var dirReader = null;
  1376.                                
  1377.                         /* if ((typeof dirPath != 'string') && (dirPath != null) )
  1378.                         {
  1379.                                 invokeProviderAction(context, dirPath.provider, "listDirectory", dirPath.path);
  1380.                                 return;
  1381.                         }
  1382.                        
  1383.                         if (dirPath == null) //list the current working directory
  1384.                         {
  1385.                                 dirReader = self.currentWorkingDirEntryObject.createReader();  
  1386.                                 dirReader.readEntries(function (entries) {
  1387.                                         runCallBacks(context.cb, self.successObject, entries);                                                                                                                                                                 
  1388.                                 }, function (e) {
  1389.                                         handleError(context,e,null);                                                                                                                                                                                                   
  1390.                                 });
  1391.                         } */
  1392.                        
  1393.                         if(_validateEntry(context,dirPath,"dir"))                      
  1394.                         {
  1395.                                 //look up to the directory specified and then read the entries
  1396.                                 getFileEntryForPath(dirPath, function(status, ret)
  1397.                                 {
  1398.                                         if (status == 1)
  1399.                                         {
  1400.                                                 if(ret instanceof DirectoryEntry)
  1401.                                                 {                                              
  1402.                                                 ret.createReader().readEntries(function(entries)
  1403.                                                 {
  1404.                                                         /*
  1405.                                                         for(var i=0; i<entries.length;i++)
  1406.                                                         {
  1407.                                                                 var entry = entries[i];
  1408.                                                                 if(entry instanceof FileEntry)
  1409.                                                                         syncFileEntry(entry);
  1410.                                                                 else if(entry instanceof DirectoryEntry)
  1411.                                                                         syncDirectoryEntry(entry);
  1412.                                                         }
  1413.                                                         */
  1414.                                                         if (typeof sortType != "undefined")
  1415.                                                         {
  1416.                                                                 function returnSortedEntries(entries,s)
  1417.                                                                 {
  1418.                                                                         sortEntries(entries,s);
  1419.                                                                         runCallBacks(context.cb, self.successObject, entries);
  1420.                                                                 }
  1421.                                                                
  1422.                                                                 function getModificationDate(index)
  1423.                                                                 {
  1424.                                                                         if(index >= 0)
  1425.                                                                         {
  1426.                                                                                 var tempEntry = entries[index];
  1427.                                                                                
  1428.                                                                                 function success(metadata)
  1429.                                                                                 {
  1430.                                                                                         entries[index].modificationTime = metadata.modificationTime;
  1431.                                                                                         index = index - 1;
  1432.                                                                                         getModificationDate(index);
  1433.                                                                                 }
  1434.                                                                                
  1435.                                                                                 function error()
  1436.                                                                                 {
  1437.                                                                                         __$cf._log("error getting metadata for "+entries[index].name);
  1438.                                                                                         entries[index].modificationTime = null;
  1439.                                                                                 }
  1440.                                                                                
  1441.                                                                                 tempEntry.getMetadata(success, error);
  1442.                                                                         }
  1443.                                                                         else
  1444.                                                                         {
  1445.                                                                                 returnSortedEntries(entries,sortType);
  1446.                                                                         }
  1447.                                                                 }
  1448.                                                                
  1449.                                                                 if(findNoCase("datemodified",sortType) > 0)
  1450.                                                                 {
  1451.                                                                         getModificationDate(entries.length - 1);
  1452.                                                                 }
  1453.                                                                 else
  1454.                                                                         returnSortedEntries(entries,sortType);
  1455.                                                                
  1456.                                                                
  1457.                                                         }
  1458.                                                         else
  1459.                                                                 runCallBacks(context.cb, self.successObject, entries);                                                                                                                                                                 
  1460.                                                 }, function(e)
  1461.                                                 {
  1462.                                                         handleError(context,e,null);                                                                                                                                                                                                                                                   
  1463.                                                 });
  1464.                                                 return;
  1465.                                                 //runCallBacks(context.cb, self.successObject, entry);         
  1466.                                                 }                                                                      
  1467.                                                 else
  1468.                                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);                                           
  1469.                                         }
  1470.                                         else
  1471.                                         {
  1472.                                                 handleError(context,ret,null);                                                                                                                                                                 
  1473.                                         }                      
  1474.                                 },true);                       
  1475.                         }
  1476.                 }
  1477.                
  1478.         }  
  1479.  
  1480. /* ********************************************************************************************************************************
  1481.  *              removeDirectory - removes the specified directory
  1482.  *              the directory needs to be empty for removal or we should remove recursively
  1483.  *              dirPath - absolute path or relative, if this is null remove the CWD
  1484.  *              TODO: need to run tests for dirpath values: /a/b/c, /a, a, where some or all of the directory components exist
  1485.  *************************************************************************************************************************************/
  1486.         this.removeDirectory = function(context, dirPath, recurse)
  1487.         {
  1488.                 if(_validateDeviceAPI(context, arguments.length-1, 1, "removeDirectory"))
  1489.                 {
  1490.                        
  1491.                 var err;
  1492.                
  1493.                 var removeSuccess = function(entry) {
  1494.                         __$cf._log("successfully removed directory");
  1495.                         runCallBacks(context.cb, self.successObject, true);                                                                                                                                                                    
  1496.                 }
  1497.                
  1498.                 var removeFail = function(e) {
  1499.                         __$cf._log("Erro while removing directory - code: " + e.code);
  1500.                         handleError(context,e,null);                                                                                                                                                                                                                   
  1501.                 }
  1502.                
  1503.                 var _remove = function(entry)
  1504.                 {
  1505.                         if (recurse == true)
  1506.                                 entry.removeRecursively(removeSuccess, removeFail);
  1507.                         else
  1508.                                 entry.remove(removeSuccess, removeFail);       
  1509.                 }
  1510.                
  1511.                 if(_validateEntry(context,dirPath,"dir"))                      
  1512.                 {
  1513.                         getFileEntryForPath(dirPath, function(status, ret)
  1514.                         {
  1515.                                 if(status == 1)
  1516.                                 {
  1517.                                         if(ret instanceof DirectoryEntry)
  1518.                                                 _remove(ret);
  1519.                                         else
  1520.                                                 runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.FILE_TYPE_MISMATCH_ERROR.code, wFileManagerError.FILE_TYPE_MISMATCH_ERROR.message), null);
  1521.                                        
  1522.                                 }
  1523.                                 else
  1524.                                 {
  1525.                                         __$cf._log("Directory operation error "+ret.code);     
  1526.                                         handleError(context,ret,null);
  1527.                                 }
  1528.                         },true);
  1529.                        
  1530.                        
  1531.                 }
  1532.                
  1533.                 }              
  1534.                
  1535.         }
  1536.  
  1537.                
  1538. /* **************************************************************************************************************************************
  1539.  * move
  1540.  */
  1541.         this.moveDirectory = function(context, src, dest, ren)
  1542.         {
  1543.                 if(_validateDeviceAPI(context, arguments.length-1, 2, "moveDirectory"))
  1544.                 {
  1545.                         /* if ((typeof src != 'string') && (typeof dest != 'string'))
  1546.                         {
  1547.                                 invokeProviderAction(context, src.provider, "moveDirectory", dest.path, src.path);
  1548.                                 return;
  1549.                         }*/
  1550.                        
  1551.                         moveOrCopyDirectory({cb: [function(e, entry) {
  1552.                                         if (e.code == dnfi.SUCCESS.code)
  1553.                                         {
  1554.                                                 //syncDirectoryEntry(entry);
  1555.                                                 runCallBacks(context.cb, self.successObject, entry);                                                   
  1556.                                         }
  1557.                                         else
  1558.                                         {
  1559.                                                 runCallBacks(context.cb, e, null);                                                                                                                     
  1560.                                         }                      
  1561.                         }]}, src, dest, false, ren);
  1562.                         return;
  1563.                 }      
  1564.         }              
  1565. /* **************************************************************************************************************************************
  1566.  * copy
  1567.  */
  1568.         this.copyDirectory = function(context, src, dest)
  1569.         {
  1570.                 if(_validateDeviceAPI(context, arguments.length-1, 2, "copyDirectory"))
  1571.                 {
  1572.                         /* if ((typeof src != 'string') && (typeof dest != 'string'))
  1573.                         {
  1574.                                 invokeProviderAction(context, src.provider, "copyDirectory", dest.path, src.path);
  1575.                                 return;
  1576.                         }*/
  1577.                        
  1578.                         moveOrCopyDirectory({cb: [function(e, entry)
  1579.                         {
  1580.                                 if (e.code == dnfi.SUCCESS.code)
  1581.                                 {
  1582.                                         runCallBacks(context.cb, self.successObject, null);                                                    
  1583.                                 }
  1584.                                 else
  1585.                                 {
  1586.                                         runCallBacks(context.cb, e, null);                                                                                                                     
  1587.                                 }                      
  1588.                         }]}, src, dest, true);
  1589.                         return;
  1590.                 }      
  1591.         }
  1592. /* *****************************************************************************************************************************
  1593.  * renameDir(src, dest) - rename the src dir to destination
  1594.  *
  1595.  * Inputs:
  1596.  *              src:    name of the dir to be renamed
  1597.  *              dest:   name of the new name of the dir
  1598.  *              Example: rename("/sdcard/ananth/a.txt", "/sdcard/ananth/b.txt")
  1599.  *
  1600.  * It is an error if rename is invoked with files whose parent directories are different
  1601.  *
  1602.  * TODO: Explore later whether we should support the concept of current working directory and allow renames like: rename(a.txt, b.txt) on current directory
  1603.  *
  1604.  ******************************************************************************************************************************/                               
  1605.                 this.renameDirectory = function(context, src, dest)
  1606.                 {
  1607.                         if(_validateDeviceAPI(context, arguments.length-1, 2, "renameDirectory"))
  1608.                         {
  1609.                                
  1610.                         if(_validateEntry(context,src,"dir"))
  1611.                         {
  1612.                                 var srcDir = getdirectorypath(getResolvedPath(src));
  1613.                                 var destDir = getdirectorypath(getResolvedPath(dest));
  1614.                                 if (srcDir == destDir)
  1615.                                 {
  1616.                                         if (typeof src == "string" && src[0] != '/') //if relative path is specified, prefix the src and dest with the current working directory
  1617.                                         {
  1618.                                                 src = self.getWorkingDirectory() + "/" + src;
  1619.                                                 dest = self.getWorkingDirectory() + "/" + dest;
  1620.                                         }
  1621.        
  1622.                                         moveOrCopyDirectory({
  1623.                                                 cb: [function(e, entry){
  1624.                                                         if (e.code == dnfi.SUCCESS.code)
  1625.                                                         {
  1626.                                                                 runCallBacks(context.cb, self.successObject, entry);                                                   
  1627.                                                         }
  1628.                                                         else
  1629.                                                         {
  1630.                                                                 runCallBacks(context.cb, e);                                                                                                                   
  1631.                                                         }
  1632.                                                 }], ret:"ret"
  1633.                                         }, src, dest, false,true);
  1634.                                         return;
  1635.                                 }
  1636.                                 else
  1637.                                 {
  1638.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.SOURCE_DESTINATION_SAME_PATH_ERROR.code, wFileManagerError.SOURCE_DESTINATION_SAME_PATH_ERROR.message), null);
  1639.                                         return;                                                                                                                                                        
  1640.                                 }
  1641.                         }
  1642.                         }
  1643.                 }
  1644.                
  1645.                 this.upload = function(context, filePath,url,success,error,opts)
  1646.                 {
  1647.                         if(_validateDeviceAPI(context, arguments.length-1, 4, "upload"))
  1648.                         {
  1649.                                 var failcb = function(e)
  1650.                                 {
  1651.                                         var argsArray = [e];           
  1652.                                         errorCallback.apply(error,argsArray);
  1653.                                 };
  1654.        
  1655.                                 var callbackFunction = null;
  1656.                                 var errorCallback = null;
  1657.                                
  1658.                                 if(typeof success == "undefined")
  1659.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1660.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1661.                                 if(typeof success == "string")
  1662.                                         callbackFunction =_getFunctionForName(success);
  1663.                                 else
  1664.                                         callbackFunction = success;
  1665.                                        
  1666.                                 if(typeof error == "string")
  1667.                                                 errorCallback =_getFunctionForName(error);
  1668.                                         else
  1669.                                                 errorCallback = error;
  1670.                                        
  1671.                                 var _cb = function(pos)
  1672.                                 {
  1673.                                         __$cf._log("file upload successful");
  1674.                                        
  1675.                                         var argsArray = [pos];         
  1676.                                         callbackFunction.apply(success,argsArray);
  1677.                                 }
  1678.        
  1679.                                 if (typeof callbackFunction == "function")
  1680.                                 {
  1681.                                         if(errorCallback != null)
  1682.                                         {
  1683.        
  1684.                                                 if(!(typeof errorCallback == "function"))
  1685.                                                 {
  1686.                                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1687.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1688.                                                 return;
  1689.                                                 }
  1690.                                         }
  1691.        
  1692.                                         var ft = new FileTransfer();
  1693.                                         var fileURI = "";
  1694.                                        
  1695.                                         fileURI = getResolvedURI(filePath);
  1696.                                         var options = new FileUploadOptions();
  1697.                                         options.fileKey = "file";
  1698.                                         options.fileName = fileURI.substr(fileURI.lastIndexOf('/') + 1);
  1699.                                         options.mimeType = "text/plain";                               
  1700.                                        
  1701.                                         var trustAllHosts = false;
  1702.                                         if(typeof opts != "undefined" )
  1703.                                         {
  1704.                                                 if(opts.trustAllHosts)
  1705.                                                         trustAllHosts = opts.trustAllHosts;
  1706.                                                 if(opts.mimeType)
  1707.                                                         options.mimeType = opts.mimeType;
  1708.                                                        
  1709.                                                 if(opts.fileKey)
  1710.                                                         options.fileKey = opts.fileKey;
  1711.                                         }
  1712.                                                        
  1713.                                         ft.upload(fileURI,encodeURI(url),_cb,failcb,options,trustAllHosts);
  1714.                                                
  1715.                                         runCallBacks(context.cb, self.successObject, null);
  1716.                                 }
  1717.                                 else
  1718.                                 {
  1719.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1720.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1721.                                 }
  1722.                                 return;
  1723.                         }
  1724.                        
  1725.                 }
  1726.                
  1727.                 this.download = function(context, url,filepath,success,error,opts)
  1728.                 {
  1729.                         if(_validateDeviceAPI(context, arguments.length-1, 4, "download"))
  1730.                         {
  1731.                                 var failcb = function(e)
  1732.                                 {
  1733.                                         var argsArray = [e];           
  1734.                                         errorCallback.apply(error,argsArray);
  1735.                                 };
  1736.                                
  1737.                                 var callbackFunction = null;
  1738.                                 var errorCallback = null;
  1739.                                
  1740.                                 if(typeof success == "undefined")
  1741.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1742.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1743.                                 if(typeof success == "string")
  1744.                                         callbackFunction =_getFunctionForName(success);
  1745.                                 else
  1746.                                         callbackFunction = success;
  1747.                                        
  1748.                                 if(typeof error == "string")
  1749.                                                 errorCallback =_getFunctionForName(error);
  1750.                                         else
  1751.                                                 errorCallback = error;
  1752.                                        
  1753.                                 var _cb = function(pos)
  1754.                                 {
  1755.                                         __$cf._log("file download successful");
  1756.                                         var argsArray = [pos];         
  1757.                                         callbackFunction.apply(success,argsArray);
  1758.                                 }
  1759.                                 if (typeof callbackFunction == "function")
  1760.                                 {
  1761.                                         if(errorCallback != null)
  1762.                                         {
  1763.                                                 if(!(typeof errorCallback == "function"))
  1764.                                                 {
  1765.                                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1766.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1767.                                                         return;
  1768.                                                 }
  1769.                                         }
  1770.        
  1771.                                         var ft = new FileTransfer();
  1772.                                         var fileURI = getResolvedPath(filepath);
  1773.                                         var options = new FileUploadOptions();
  1774.                                        
  1775.                                         var trustAllHosts = false;
  1776.                                         if(typeof opts != "undefined" )
  1777.                                         {
  1778.                                                 if(opts.trustAllHosts)
  1779.                                                         trustAllHosts = opts.trustAllHosts;
  1780.                                                 if(opts.headers)
  1781.                                                         options.headers = opts.headers;
  1782.                                         }
  1783.                                                        
  1784.                                                
  1785.                                         ft.download(encodeURI(url),fileURI,_cb,failcb,trustAllHosts,options);
  1786.                                                
  1787.                                         runCallBacks(context.cb, self.successObject, null);
  1788.                                 }
  1789.                                 else
  1790.                                 {
  1791.                                         runCallBacks(context.cb, new DnfiStatus('wFileManager', wFileManagerError.CALLBACK_ERROR.code,
  1792.                                                                                                                 wFileManagerError.CALLBACK_ERROR.message),null);
  1793.                                 }
  1794.                                 return;
  1795.                         }
  1796.                        
  1797.                 }
  1798. /* -------------------------------------------------------------------------------------------------------------------------------------- */
  1799.         this.toString = function()
  1800.         {
  1801.                 return("WFileManager");
  1802.         }
  1803. /* ---------------------------Set up file system as a part of constructor-------------------------------------- */             
  1804.         if (typeof context != 'undefined' && context != null) {
  1805.                 __$cf._log("Initializing FileManager...");
  1806.                 self.setFileSystem({cb: [function(e, fs) {
  1807.                                 if (e.code == dnfi.SUCCESS.code)
  1808.                                 {
  1809.                                         __$cf._log("temporary file system obtained:" + self.tempFileSystem.root.fullPath);
  1810.                                         //syncDirectoryEntry(self.tempFileSystem.root);
  1811.                                        
  1812.                                         self.setFileSystem({cb: [function(e, fs) {
  1813.  
  1814.                                                                 __$cf._log("persistent file system obtained: " + self.persistentFileSystem.root.fullPath);
  1815.                                                                 //syncDirectoryEntry(self.persistentFileSystem.root);
  1816.                                                                 this.successObject = new DnfiStatus('DNFI', dnfi.SUCCESS.code, dnfi.SUCCESS.message);
  1817.                                                                 runCallBacks(context.cb, self.successObject, self);                                                                    
  1818.                                                         }]}, 'persistent');
  1819.                                         return;
  1820.                                 }
  1821.                                 else //failure in getting temp file system
  1822.                                 {
  1823.                                         runCallBacks(context.cb, self.successObject, null);
  1824.                                 }
  1825.                                        
  1826.                 }]}, 'temporary');
  1827.         }
  1828. }
  1829. /* ------------------------------------------------------------------------------------------------------------------- */                                      
  1830. } //WFileManager

Raw Paste


Login or Register to edit or fork this paste. It's free.