Copying and moving files and directories are common and simple operations. The File class defines methods for each of these operations: copyTo(), copyToAsync(), moveTo(), and moveToAsync(). None of these methods distinguish between directo- ries or files.
Copying and moving are extremely similar. If you think about it, both move a file or directory to a new location in a file structure hierarchy. The difference between them is that the copying operation keeps a copy of the file or directory in the original location as well. Because the two operations are similar, the methods are similar as well. In all cases, the methods require one parameter: a FileReference object point- ing to the new location. And all the methods also allow for a second Boolean parame- ter indicating whether to overwrite any existing content at the new location should it already be there.
NOTE The File class that we’ve talked about extensively in this chapter is a sub- class of FileReference. That means that you can use a File object any time a FileReference object is required. The copying and moving meth- ods require a FileReference parameter. For all practical purposes, in this chapter you’ll always use a File object for this parameter.
As with other synchronous and asynchronous operations, you’ll generally find that it’s best to have a bias toward the asynchronous copying and moving methods. If you move or copy a large file or directory, the asynchronous methods work better in that they prevent the AIR application from freezing while the file or directory is moved or copied.
In the following example, we’re copying a zipFiles directory in the user documents directory to the desktop directory:
var source:File = File.documentsDirectory.resolvePath("zipFiles");
var destination:File = File.desktopDirectory.resolvePath("zipFiles");
source.copyToAsync(destination);
Reference source directory B
Reference destination
directory C
Copy directory D
119 Copying and moving files and directories
In this case, we’re assuming a directory named zipFiles exists in the documents direc- tory B and that a directory named zipFiles does not exist in the desktop directory C. This is an important point. As we’ll see in a minute, the destination directory must not yet exist for this code to work. Once we’ve created the references to the source and destination directories, we can copy the source using the copyToAsync() method D. If you run this code twice, it will throw an I/O error the second time because the destinationFile object would point to an existing directory. As written, the code assumes that the destination must not yet exist. But if we know that the destination directory could possibly exist, we have a choice: do we want to overwrite the destina- tion with whatever we copy to it? If we do, we need only to pass true for the second parameter in the copyToAsync() method:
source.copyToAsync(destination, true)
This optional parameter is false by default, but if true, copyToAsync() will first delete the destination file or folder before copying. Note that this is different from your normal overwrite in that it deletes all files and directories in the destination regardless of whether they’re found in the source.
NOTE Everything we’ve discussed using the specific example of copyToAsync() is applicable to the other copy and move methods as well.
All of the copying and moving operations will also throw an I/O error if the source doesn’t exist or if the OS is preventing an action due to file locking. The synchronous methods will throw the error directly, and you should wrap them in try/catch state- ments as in the following example:
try {
file.moveTo(destination);
}
catch (error:IOError) { trace("an error occurred");
}
The asynchronous methods throw errors using error events. You should register lis- teners for those events if there’s a possibility of such an error occurring.
Next we’ll revisit the earlier example from listing 3.11. In listing 3.12, you can see how we’ve now updated the code to actually move the files to the directories based on file extension. The changes are shown in bold.
package {
import flash.display.MovieClip;
import flash.events.MouseEvent;
import flash.display.Stage;
import flash.filesystem.File;
import flash.events.FileListEvent;
import flash.events.Event;
Listing 3.12 Moving files to new directories based on file extension
import fl.controls.Button;
import fl.controls.TextArea;
public class DesktopOrganizer extends MovieClip { public function DesktopOrganizer() {
_button.addEventListener(MouseEvent.CLICK, startOrganize);
}
private function startOrganize(event:MouseEvent):void { var organized:File = File.desktopDirectory.resolvePath(
➥"Files Organized By Type");
if(!organized.exists) {
organized.createDirectory();
print("created directory: " + organized.nativePath);
}
var desktop:File = File.desktopDirectory.resolvePath(
➥"To Organize");
desktop.addEventListener(FileListEvent.DIRECTORY_LISTING, directoryListingHandler);
desktop.getDirectoryListingAsync();
}
private function directoryListingHandler(event:FileListEvent):
➥void {
var files:Array = event.files;
var file:File;
var organized:File = File.desktopDirectory.resolvePath(
➥"Files Organized By Type");
var extension:File;
for(var i:Number = 0; i < files.length; i++) { file = files[i] as File;
if(!file.isDirectory) {
extension = organized.resolvePath(file.extension);
if(!extension.exists) {
extension.createDirectory();
print("created directory: " +
➥extension.nativePath);
}
file.addEventListener(Event.COMPLETE, completeHandler);
file.moveToAsync(extension.resolvePath(file.name));
print("moving file: " + file.name);
} } }
private function completeHandler(event:Event):void { print("moved file: " + event.target.name);
}
private function print(message:String):void { _textArea.text += message + "\n";
} } }
Listen for complete event B
Move file C
Notify user when complete
D
121 Reading from and writing to files
You can see that in this example we’ve opted to move files asynchronously using the moveToAsync() method C. To be polite, we’re listening for the complete event B
and then notifying the user when the file has actually moved D.
You’ve learned how to work with directories extensively, and you’ve also seen how to copy and move directories and files. Now we’re ready to look at some file-specific operations. In the next section, you’ll learn how to work with files to do things like read and write and delete files.