You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by pu...@apache.org on 2012/02/22 09:15:23 UTC
[19/29] stage 2 - fix errors
http://git-wip-us.apache.org/repos/asf/incubator-cordova-wp7/blob/4789ce6d/framework/Cordova/Commands/File.cs
----------------------------------------------------------------------
diff --git a/framework/Cordova/Commands/File.cs b/framework/Cordova/Commands/File.cs
new file mode 100644
index 0000000..8bf37c3
--- /dev/null
+++ b/framework/Cordova/Commands/File.cs
@@ -0,0 +1,1430 @@
+/*
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.IsolatedStorage;
+using System.Runtime.Serialization;
+using System.Security;
+using System.Text;
+
+namespace WP7GapClassLib.Cordova.Commands
+{
+ /// <summary>
+ /// Provides access to isolated storage
+ /// </summary>
+ public class File : BaseCommand
+ {
+ // Error codes
+ public const int NOT_FOUND_ERR = 1;
+ public const int SECURITY_ERR = 2;
+ public const int ABORT_ERR = 3;
+ public const int NOT_READABLE_ERR = 4;
+ public const int ENCODING_ERR = 5;
+ public const int NO_MODIFICATION_ALLOWED_ERR = 6;
+ public const int INVALID_STATE_ERR = 7;
+ public const int SYNTAX_ERR = 8;
+ public const int INVALID_MODIFICATION_ERR = 9;
+ public const int QUOTA_EXCEEDED_ERR = 10;
+ public const int TYPE_MISMATCH_ERR = 11;
+ public const int PATH_EXISTS_ERR = 12;
+
+ // File system options
+ public const int TEMPORARY = 0;
+ public const int PERSISTENT = 1;
+ public const int RESOURCE = 2;
+ public const int APPLICATION = 3;
+
+ /// <summary>
+ /// Temporary directory name
+ /// </summary>
+ private readonly string TMP_DIRECTORY_NAME = "tmp";
+
+ /// <summary>
+ /// Represents error code for callback
+ /// </summary>
+ [DataContract]
+ public class ErrorCode
+ {
+ /// <summary>
+ /// Error code
+ /// </summary>
+ [DataMember(IsRequired = true, Name = "code")]
+ public int Code { get; set; }
+
+ /// <summary>
+ /// Creates ErrorCode object
+ /// </summary>
+ public ErrorCode(int code)
+ {
+ this.Code = code;
+ }
+ }
+
+ /// <summary>
+ /// Represents File action options.
+ /// </summary>
+ [DataContract]
+ public class FileOptions
+ {
+ /// <summary>
+ /// File path
+ /// </summary>
+ [DataMember(Name = "fileName")]
+ public string FilePath { get; set; }
+
+ /// <summary>
+ /// Full entryPath
+ /// </summary>
+ [DataMember(Name = "fullPath")]
+ public string FullPath { get; set; }
+
+ /// <summary>
+ /// Directory name
+ /// </summary>
+ [DataMember(Name = "dirName")]
+ public string DirectoryName { get; set; }
+
+ /// <summary>
+ /// Path to create file/directory
+ /// </summary>
+ [DataMember(Name = "path")]
+ public string Path { get; set; }
+
+ /// <summary>
+ /// The encoding to use to encode the file's content. Default is UTF8.
+ /// </summary>
+ [DataMember(Name = "encoding")]
+ public string Encoding { get; set; }
+
+ /// <summary>
+ /// Uri to get file
+ /// </summary>
+ [DataMember(Name = "uri")]
+ public string Uri { get; set; }
+
+ /// <summary>
+ /// Size to truncate file
+ /// </summary>
+ [DataMember(Name = "size")]
+ public long Size { get; set; }
+
+ /// <summary>
+ /// Data to write in file
+ /// </summary>
+ [DataMember(Name = "data")]
+ public string Data { get; set; }
+
+ /// <summary>
+ /// Position the writing starts with
+ /// </summary>
+ [DataMember(Name = "position")]
+ public int Position { get; set; }
+
+ /// <summary>
+ /// Type of file system requested
+ /// </summary>
+ [DataMember(Name = "type")]
+ public int FileSystemType { get; set; }
+
+ /// <summary>
+ /// New file/directory name
+ /// </summary>
+ [DataMember(Name = "newName")]
+ public string NewName { get; set; }
+
+ /// <summary>
+ /// Destination directory to copy/move file/directory
+ /// </summary>
+ [DataMember(Name = "parent")]
+ public FileEntry Parent { get; set; }
+
+ /// <summary>
+ /// Options for getFile/getDirectory methods
+ /// </summary>
+ [DataMember(Name = "options")]
+ public CreatingOptions CreatingOpt { get; set; }
+
+ /// <summary>
+ /// Creates options object with default parameters
+ /// </summary>
+ public FileOptions()
+ {
+ this.SetDefaultValues(new StreamingContext());
+ }
+
+ /// <summary>
+ /// Initializes default values for class fields.
+ /// Implemented in separate method because default constructor is not invoked during deserialization.
+ /// </summary>
+ /// <param name="context"></param>
+ [OnDeserializing()]
+ public void SetDefaultValues(StreamingContext context)
+ {
+ this.Encoding = "UTF-8";
+ this.FilePath = "";
+ this.FileSystemType = -1;
+ }
+ }
+
+ /// <summary>
+ /// Stores image info
+ /// </summary>
+ [DataContract]
+ public class FileMetadata
+ {
+ [DataMember(Name = "fileName")]
+ public string FileName { get; set; }
+
+ [DataMember(Name = "fullPath")]
+ public string FullPath { get; set; }
+
+ [DataMember(Name = "type")]
+ public string Type { get; set; }
+
+ [DataMember(Name = "lastModifiedDate")]
+ public string LastModifiedDate { get; set; }
+
+ [DataMember(Name = "size")]
+ public long Size { get; set; }
+
+ public FileMetadata(string filePath)
+ {
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if ((string.IsNullOrEmpty(filePath)) || (!isoFile.FileExists(filePath)))
+ {
+ throw new FileNotFoundException("File doesn't exist");
+ }
+ //TODO get file size the other way if possible
+ using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(filePath, FileMode.Open, FileAccess.Read, isoFile))
+ {
+ this.Size = stream.Length;
+ }
+ this.FullPath = filePath;
+ this.FileName = System.IO.Path.GetFileName(filePath);
+ this.Type = MimeTypeMapper.GetMimeType(filePath);
+ this.LastModifiedDate = isoFile.GetLastWriteTime(filePath).DateTime.ToString();
+ }
+ }
+ }
+
+ /// <summary>
+ /// Represents file or directory modification metadata
+ /// </summary>
+ [DataContract]
+ public class ModificationMetadata
+ {
+ /// <summary>
+ /// Modification time
+ /// </summary>
+ [DataMember]
+ public string modificationTime { get; set; }
+ }
+
+ /// <summary>
+ /// Represents file or directory entry
+ /// </summary>
+ [DataContract]
+ public class FileEntry
+ {
+
+ /// <summary>
+ /// File type
+ /// </summary>
+ [DataMember(Name = "isFile")]
+ public bool IsFile { get; set; }
+
+ /// <summary>
+ /// Directory type
+ /// </summary>
+ [DataMember(Name = "isDirectory")]
+ public bool IsDirectory { get; set; }
+
+ /// <summary>
+ /// File/directory name
+ /// </summary>
+ [DataMember(Name = "name")]
+ public string Name { get; set; }
+
+ /// <summary>
+ /// Full path to file/directory
+ /// </summary>
+ [DataMember(Name = "fullPath")]
+ public string FullPath { get; set; }
+
+ public static FileEntry GetEntry(string filePath)
+ {
+ try
+ {
+ FileEntry entry = new FileEntry(filePath);
+ return entry;
+ }
+ catch (Exception)
+ {
+ return null;
+ }
+ }
+
+ /// <summary>
+ /// Creates object and sets necessary properties
+ /// </summary>
+ /// <param name="filePath"></param>
+ private FileEntry(string filePath)
+ {
+ if (string.IsNullOrEmpty(filePath))
+ {
+ throw new ArgumentException();
+ }
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ this.IsFile = isoFile.FileExists(filePath);
+ this.IsDirectory = isoFile.DirectoryExists(filePath);
+ if (IsFile)
+ {
+ this.Name = Path.GetFileName(filePath);
+ }
+ else if (IsDirectory)
+ {
+ this.Name = this.GetDirectoryName(filePath);
+ if (string.IsNullOrEmpty(Name))
+ {
+ this.Name = "/";
+ }
+ }
+ else
+ {
+ throw new FileNotFoundException();
+ }
+
+ this.FullPath = new Uri(filePath).LocalPath;
+ }
+ }
+
+ /// <summary>
+ /// Extracts directory name from path string
+ /// Path should refer to a directory, for example \foo\ or /foo.
+ /// </summary>
+ /// <param name="path"></param>
+ /// <returns></returns>
+ private string GetDirectoryName(string path)
+ {
+ if (String.IsNullOrEmpty(path))
+ {
+ return path;
+ }
+
+ string[] split = path.Split(new char[] {'/', '\\'}, StringSplitOptions.RemoveEmptyEntries);
+ if (split.Length < 1)
+ {
+ return null;
+ }
+ else
+ {
+ return split[split.Length-1];
+ }
+ }
+ }
+
+
+ /// <summary>
+ /// Represents info about requested file system
+ /// </summary>
+ [DataContract]
+ public class FileSystemInfo
+ {
+ /// <summary>
+ /// file system type
+ /// </summary>
+ [DataMember(Name = "name", IsRequired = true)]
+ public string Name { get; set; }
+
+ /// <summary>
+ /// Root directory entry
+ /// </summary>
+ [DataMember(Name = "root", EmitDefaultValue = false)]
+ public FileEntry Root { get; set; }
+
+ /// <summary>
+ /// Creates class instance
+ /// </summary>
+ /// <param name="name"></param>
+ /// <param name="rootEntry"> Root directory</param>
+ public FileSystemInfo(string name, FileEntry rootEntry = null)
+ {
+ Name = name;
+ Root = rootEntry;
+ }
+ }
+
+ [DataContract]
+ public class CreatingOptions
+ {
+ /// <summary>
+ /// Create file/directory if is doesn't exist
+ /// </summary>
+ [DataMember(Name = "create")]
+ public bool Create { get; set; }
+
+ /// <summary>
+ /// Generate an exception if create=true and file/directory already exists
+ /// </summary>
+ [DataMember(Name = "exclusive")]
+ public bool Exclusive { get; set; }
+
+
+ }
+
+ /// <summary>
+ /// File options
+ /// </summary>
+ private FileOptions fileOptions;
+
+ /// <summary>
+ /// Gets amount of free space available for Isolated Storage
+ /// </summary>
+ /// <param name="options">No options is needed for this method</param>
+ public void getFreeDiskSpace(string options)
+ {
+ try
+ {
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, isoFile.AvailableFreeSpace));
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+ /// <summary>
+ /// Check if file exists
+ /// </summary>
+ /// <param name="options">File path</param>
+ public void testFileExists(string options)
+ {
+ IsDirectoryOrFileExist(options, false);
+ }
+
+ /// <summary>
+ /// Check if directory exists
+ /// </summary>
+ /// <param name="options">directory name</param>
+ public void testDirectoryExists(string options)
+ {
+ IsDirectoryOrFileExist(options, true);
+ }
+
+ /// <summary>
+ /// Check if file or directory exist
+ /// </summary>
+ /// <param name="options">File path/Directory name</param>
+ /// <param name="isDirectory">Flag to recognize what we should check</param>
+ public void IsDirectoryOrFileExist(string options, bool isDirectory)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ bool isExist;
+ if (isDirectory)
+ {
+ isExist = isoFile.DirectoryExists(fileOptions.DirectoryName);
+ }
+ else
+ {
+ isExist = isoFile.FileExists(fileOptions.FilePath);
+ }
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, isExist));
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+
+ }
+
+ public void readAsDataURL(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ string base64URL = null;
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (!isoFile.FileExists(fileOptions.FilePath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ string mimeType = MimeTypeMapper.GetMimeType(fileOptions.FilePath);
+
+ using (IsolatedStorageFileStream stream = isoFile.OpenFile(fileOptions.FilePath, FileMode.Open, FileAccess.Read))
+ {
+ string base64String = GetFileContent(stream);
+ base64URL = "data:" + mimeType + ";base64," + base64String;
+ }
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, base64URL));
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+ public void readAsText(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ string text;
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (!isoFile.FileExists(fileOptions.FilePath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ Encoding encoding = Encoding.GetEncoding(fileOptions.Encoding);
+
+ using (TextReader reader = new StreamReader(isoFile.OpenFile(fileOptions.FilePath, FileMode.Open, FileAccess.Read), encoding))
+ {
+ text = reader.ReadToEnd();
+ }
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, text));
+ }
+ catch (ArgumentException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+
+ public void truncate(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ long streamLength = 0;
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (!isoFile.FileExists(fileOptions.FilePath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+
+ using (FileStream stream = new IsolatedStorageFileStream(fileOptions.FilePath, FileMode.Open, FileAccess.ReadWrite, isoFile))
+ {
+ if (0 <= fileOptions.Size && fileOptions.Size < stream.Length)
+ {
+ stream.SetLength(fileOptions.Size);
+ }
+
+ streamLength = stream.Length;
+ }
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, streamLength));
+ }
+ catch (ArgumentException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+ public void write(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (string.IsNullOrEmpty(fileOptions.Data))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ // create the file if not exists
+ if (!isoFile.FileExists(fileOptions.FilePath))
+ {
+ var file = isoFile.CreateFile(fileOptions.FilePath);
+ file.Close();
+ }
+
+ using (FileStream stream = new IsolatedStorageFileStream(fileOptions.FilePath, FileMode.Open, FileAccess.ReadWrite, isoFile))
+ {
+ if (0 <= fileOptions.Position && fileOptions.Position < stream.Length)
+ {
+ stream.SetLength(fileOptions.Position);
+ }
+ using (BinaryWriter writer = new BinaryWriter(stream))
+ {
+ writer.Seek(0, SeekOrigin.End);
+ writer.Write(fileOptions.Data.ToCharArray());
+ }
+ }
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, fileOptions.Data.Length));
+ }
+ catch (ArgumentException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(INVALID_MODIFICATION_ERR)));
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+ /// <summary>
+ /// Look up metadata about this entry.
+ /// </summary>
+ /// <param name="options">filePath to entry</param>
+ public void getMetadata(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (isoFile.FileExists(fileOptions.FullPath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK,
+ new ModificationMetadata() {modificationTime = isoFile.GetLastWriteTime(fileOptions.FullPath).DateTime.ToString()},
+ "window.localFileSystem._castDate"));
+ }
+ else if (isoFile.DirectoryExists(fileOptions.FullPath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK,
+ new ModificationMetadata() { modificationTime = isoFile.GetLastWriteTime(fileOptions.FullPath).DateTime.ToString() },
+ "window.localFileSystem._castDate"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+
+ /// <summary>
+ /// Returns a File that represents the current state of the file that this FileEntry represents.
+ /// </summary>
+ /// <param name="filePath">filePath to entry</param>
+ /// <returns></returns>
+ public void getFileMetadata(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+ FileMetadata metaData = new FileMetadata(fileOptions.FullPath);
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, metaData, "window.localFileSystem._castDate"));
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ catch (FileNotFoundException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+
+ /// <summary>
+ /// Look up the parent DirectoryEntry containing this Entry.
+ /// If this Entry is the root of IsolatedStorage, its parent is itself.
+ /// </summary>
+ /// <param name="options"></param>
+ public void getParent(string options)
+ {
+
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (string.IsNullOrEmpty(fileOptions.FullPath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ FileEntry entry;
+
+ if (isoFile.FileExists(fileOptions.FullPath) || isoFile.DirectoryExists(fileOptions.FullPath))
+ {
+ string path = this.GetParentDirectory(fileOptions.FullPath);
+ entry = FileEntry.GetEntry(path);
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, entry, "window.localFileSystem._castEntry"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_READABLE_ERR)));
+ }
+ }
+
+ public void remove(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (isoFile.FileExists(fileOptions.FullPath))
+ {
+ isoFile.DeleteFile(fileOptions.FullPath);
+ }
+ else
+ {
+ if (isoFile.DirectoryExists(fileOptions.FullPath))
+ {
+ isoFile.DeleteDirectory(fileOptions.FullPath);
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ }
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(INVALID_MODIFICATION_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ public void removeRecursively(string options)
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+ if (string.IsNullOrEmpty(fileOptions.FullPath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ removeDirRecursively(fileOptions.FullPath);
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+
+ public void readEntries(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (string.IsNullOrEmpty(fileOptions.FullPath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (isoFile.DirectoryExists(fileOptions.FullPath))
+ {
+ string path = File.AddSlashToDirectory(fileOptions.FullPath);
+ List<FileEntry> entries = new List<FileEntry>();
+ string[] files = isoFile.GetFileNames(path + "*");
+ string[] dirs = isoFile.GetDirectoryNames(path + "*");
+ foreach (string file in files)
+ {
+ entries.Add(FileEntry.GetEntry(path + file));
+ }
+ foreach (string dir in dirs)
+ {
+ entries.Add(FileEntry.GetEntry(path + dir + "/"));
+ }
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, entries, "window.localFileSystem._castEntries"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ public void requestFileSystem(string options)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (fileOptions.Size != 0)
+ {
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ long availableSize = isoFile.AvailableFreeSpace;
+ if (fileOptions.Size > availableSize)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(QUOTA_EXCEEDED_ERR)));
+ return;
+ }
+ }
+ }
+
+ if (fileOptions.FileSystemType == PERSISTENT)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, new FileSystemInfo("persistent", FileEntry.GetEntry("/")), "window.localFileSystem._castFS"));
+ }
+ else if (fileOptions.FileSystemType == TEMPORARY)
+ {
+
+ using (IsolatedStorageFile isoStorage = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (!isoStorage.FileExists(TMP_DIRECTORY_NAME))
+ {
+ isoStorage.CreateDirectory(TMP_DIRECTORY_NAME);
+ }
+ }
+
+ string tmpFolder = "/" + TMP_DIRECTORY_NAME + "/";
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, new FileSystemInfo("temporary", FileEntry.GetEntry(tmpFolder)), "window.localFileSystem._castFS"));
+ }
+ else if (fileOptions.FileSystemType == RESOURCE)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, new FileSystemInfo("resource"), "window.localFileSystem._castFS"));
+ }
+ else if (fileOptions.FileSystemType == APPLICATION)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, new FileSystemInfo("application"), "window.localFileSystem._castFS"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (FileNotFoundException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ public void resolveLocalFileSystemURI(string options)
+ {
+ try
+ {
+
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (!Uri.IsWellFormedUriString(fileOptions.Uri, UriKind.RelativeOrAbsolute))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ return;
+ }
+
+ string path = (new Uri(Uri.UnescapeDataString(fileOptions.Uri))).LocalPath;
+
+ FileEntry uriEntry = FileEntry.GetEntry(path);
+ if (uriEntry != null)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, uriEntry, "window.localFileSystem._castEntry"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ public void copyTo(string options)
+ {
+ TransferTo(options, false);
+ }
+
+ public void moveTo(string options)
+ {
+ TransferTo(options, true);
+ }
+
+ public void getFile(string options)
+ {
+ GetFileOrDirectory(options, false);
+ }
+
+ public void getDirectory(string options)
+ {
+ GetFileOrDirectory(options, true);
+ }
+
+ #region internal functionality
+
+ /// <summary>
+ /// Retrieves the parent directory name of the specified path,
+ /// </summary>
+ /// <param name="path">Path</param>
+ /// <returns>Parent directory name</returns>
+ private string GetParentDirectory(string path)
+ {
+ if (String.IsNullOrEmpty(path) || path == "/")
+ {
+ return "/";
+ }
+
+ if (path.EndsWith(@"/") || path.EndsWith(@"\"))
+ {
+ return this.GetParentDirectory(Path.GetDirectoryName(path));
+ }
+
+ return Path.GetDirectoryName(path);
+ }
+
+ private void removeDirRecursively(string fullPath)
+ {
+ try
+ {
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (isoFile.DirectoryExists(fullPath))
+ {
+ string path = File.AddSlashToDirectory(fullPath);
+ string[] files = isoFile.GetFileNames(path + "*");
+ if (files.Length > 0)
+ {
+ foreach (string file in files)
+ {
+ isoFile.DeleteFile(path + file);
+ }
+ }
+ string[] dirs = isoFile.GetDirectoryNames(path + "*");
+ if (dirs.Length > 0)
+ {
+ foreach (string dir in dirs)
+ {
+ removeDirRecursively(path + dir + "/");
+ }
+ }
+ isoFile.DeleteDirectory(Path.GetDirectoryName(path));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ private void TransferTo(string options, bool move)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if ((fileOptions.Parent == null) || (string.IsNullOrEmpty(fileOptions.Parent.FullPath)) || (string.IsNullOrEmpty(fileOptions.FullPath)))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+
+ string parentPath = File.AddSlashToDirectory(fileOptions.Parent.FullPath);
+ string currentPath = fileOptions.FullPath;
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ bool isFileExist = isoFile.FileExists(currentPath);
+ bool isDirectoryExist = isoFile.DirectoryExists(currentPath);
+ bool isParentExist = isoFile.DirectoryExists(parentPath);
+
+ if (((!isFileExist) && (!isDirectoryExist)) || (!isParentExist))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ string newName;
+ string newPath;
+ if (isFileExist)
+ {
+ newName = (string.IsNullOrEmpty(fileOptions.NewName))
+ ? Path.GetFileName(currentPath)
+ : fileOptions.NewName;
+
+ newPath = Path.Combine(parentPath, newName);
+
+ // remove destination file if exists, in other case there will be exception
+ if (!newPath.Equals(currentPath) && isoFile.FileExists(newPath))
+ {
+ isoFile.DeleteFile(newPath);
+ }
+
+ if (move)
+ {
+ isoFile.MoveFile(currentPath, newPath);
+ }
+ else
+ {
+ isoFile.CopyFile(currentPath, newPath, true);
+ }
+ }
+ else
+ {
+ newName = (string.IsNullOrEmpty(fileOptions.NewName))
+ ? currentPath
+ : fileOptions.NewName;
+
+ newPath = Path.Combine(parentPath, newName);
+
+ if (move)
+ {
+
+ // remove destination directory if exists, in other case there will be exception
+ // target directory should be empty
+ if (!newPath.Equals(currentPath) && isoFile.DirectoryExists(newPath))
+ {
+ isoFile.DeleteDirectory(newPath);
+ }
+
+ isoFile.MoveDirectory(currentPath, newPath);
+ }
+ else
+ {
+ this.CopyDirectory(currentPath, newPath, isoFile);
+ }
+ }
+ FileEntry entry = FileEntry.GetEntry(newPath);
+ if (entry != null)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, entry, "window.localFileSystem._castEntry"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (FileNotFoundException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ catch (ArgumentException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ }
+ catch (IsolatedStorageException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(INVALID_MODIFICATION_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ private void CopyDirectory(string sourceDir, string destDir, IsolatedStorageFile isoFile)
+ {
+ string path = File.AddSlashToDirectory(sourceDir);
+
+ if (!isoFile.DirectoryExists(destDir))
+ {
+ isoFile.CreateDirectory(destDir);
+ }
+ destDir = File.AddSlashToDirectory(destDir);
+ string[] files = isoFile.GetFileNames(path + "*");
+ if (files.Length > 0)
+ {
+ foreach (string file in files)
+ {
+ isoFile.CopyFile(path + file, destDir + file);
+ }
+ }
+ string[] dirs = isoFile.GetDirectoryNames(path + "*");
+ if (dirs.Length > 0)
+ {
+ foreach (string dir in dirs)
+ {
+ CopyDirectory(path + dir, destDir + dir, isoFile);
+ }
+ }
+ }
+
+ private void GetFileOrDirectory(string options, bool getDirectory)
+ {
+ try
+ {
+ try
+ {
+ fileOptions = JSON.JsonHelper.Deserialize<FileOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if ((string.IsNullOrEmpty(fileOptions.Path)) || (string.IsNullOrEmpty(fileOptions.FullPath)))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+
+ string path;
+
+ try
+ {
+ path = Path.Combine(fileOptions.FullPath, fileOptions.Path);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(ENCODING_ERR)));
+ return;
+ }
+
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ bool isFile = isoFile.FileExists(path);
+ bool isDirectory = isoFile.DirectoryExists(path);
+ bool create = (fileOptions.CreatingOpt == null) ? false : fileOptions.CreatingOpt.Create;
+ bool exclusive = (fileOptions.CreatingOpt == null) ? false : fileOptions.CreatingOpt.Exclusive;
+ if (create)
+ {
+ if (exclusive && (isoFile.FileExists(path) || isoFile.DirectoryExists(path)))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(PATH_EXISTS_ERR)));
+ return;
+ }
+
+ if ((getDirectory) && (!isDirectory))
+ {
+ isoFile.CreateDirectory(path);
+ }
+ else
+ {
+ if ((!getDirectory) && (!isFile))
+ {
+
+ IsolatedStorageFileStream fileStream = isoFile.CreateFile(path);
+ fileStream.Close();
+ }
+ }
+
+ }
+ else
+ {
+ if ((!isFile) && (!isDirectory))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ return;
+ }
+ if (((getDirectory) && (!isDirectory)) || ((!getDirectory) && (!isFile)))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(TYPE_MISMATCH_ERR)));
+ return;
+ }
+ }
+ FileEntry entry = FileEntry.GetEntry(path);
+ if (entry != null)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, entry, "window.localFileSystem._castEntry"));
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ }
+ }
+ catch (SecurityException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(SECURITY_ERR)));
+ }
+ catch (FileNotFoundException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NOT_FOUND_ERR)));
+ }
+ catch (DirectoryNotFoundException)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(PATH_EXISTS_ERR)));
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new ErrorCode(NO_MODIFICATION_ALLOWED_ERR)));
+ }
+ }
+
+ private static string AddSlashToDirectory(string dirPath)
+ {
+ if (dirPath.EndsWith("/"))
+ {
+ return dirPath;
+ }
+ else
+ {
+ return dirPath + "/";
+ }
+ }
+
+ /// <summary>
+ /// Returns file content in a form of base64 string
+ /// </summary>
+ /// <param name="stream">File stream</param>
+ /// <returns>Base64 representation of the file</returns>
+ private string GetFileContent(Stream stream)
+ {
+ int streamLength = (int)stream.Length;
+ byte[] fileData = new byte[streamLength + 1];
+ stream.Read(fileData, 0, streamLength);
+ stream.Close();
+ return Convert.ToBase64String(fileData);
+ }
+
+ #endregion
+
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-cordova-wp7/blob/4789ce6d/framework/Cordova/Commands/FileTransfer.cs
----------------------------------------------------------------------
diff --git a/framework/Cordova/Commands/FileTransfer.cs b/framework/Cordova/Commands/FileTransfer.cs
new file mode 100644
index 0000000..527521e
--- /dev/null
+++ b/framework/Cordova/Commands/FileTransfer.cs
@@ -0,0 +1,317 @@
+/*
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.IsolatedStorage;
+using System.Net;
+using System.Runtime.Serialization;
+using System.Windows;
+
+namespace WP7GapClassLib.Cordova.Commands
+{
+ public class FileTransfer : BaseCommand
+ {
+ /// <summary>
+ /// Boundary symbol
+ /// </summary>
+ private string Boundary = "----------------------------" + DateTime.Now.Ticks.ToString("x");
+
+ // Error codes
+ public const int FileNotFoundError = 1;
+ public const int InvalidUrlError = 2;
+ public const int ConnectionError = 3;
+
+ /// <summary>
+ /// Options for uploading file
+ /// </summary>
+ [DataContract]
+ public class UploadOptions
+ {
+ /// <summary>
+ /// File path to upload
+ /// </summary>
+ [DataMember(Name = "filePath", IsRequired = true)]
+ public string FilePath { get; set; }
+
+ /// <summary>
+ /// Server address
+ /// </summary>
+ [DataMember(Name="server", IsRequired = true)]
+ public string Server { get; set; }
+
+ /// <summary>
+ /// File key
+ /// </summary>
+ [DataMember(Name = "fileKey")]
+ public string FileKey { get; set; }
+
+ /// <summary>
+ /// File name on the server
+ /// </summary>
+ [DataMember(Name = "fileName")]
+ public string FileName { get; set; }
+
+ /// <summary>
+ /// File Mime type
+ /// </summary>
+ [DataMember(Name = "mimeType")]
+ public string MimeType { get; set; }
+
+
+ /// <summary>
+ /// Additional options
+ /// </summary>
+ [DataMember(Name="params")]
+ public Dictionary<string,object> Params { get; set; }
+
+ /// <summary>
+ /// Flag to recognize if we should trust every host (only in debug environments)
+ /// </summary>
+ [DataMember (Name="debug")]
+ public bool Debug { get; set; }
+
+ /// <summary>
+ /// Creates options object with default parameters
+ /// </summary>
+ public UploadOptions()
+ {
+ this.SetDefaultValues(new StreamingContext());
+ }
+
+ /// <summary>
+ /// Initializes default values for class fields.
+ /// Implemented in separate method because default constructor is not invoked during deserialization.
+ /// </summary>
+ /// <param name="context"></param>
+ [OnDeserializing()]
+ public void SetDefaultValues(StreamingContext context)
+ {
+ this.FileKey = "file";
+ this.FileName = "image.jpg";
+ this.MimeType = "image/jpeg";
+ }
+
+ }
+
+ /// <summary>
+ /// Uploading response info
+ /// </summary>
+ [DataContract]
+ public class FileUploadResult
+ {
+ /// <summary>
+ /// Amount of sent bytes
+ /// </summary>
+ [DataMember(Name="bytesSent")]
+ public long BytesSent { get; set; }
+
+ /// <summary>
+ /// Server response code
+ /// </summary>
+ [DataMember(Name = "responseCode")]
+ public long ResponseCode { get; set; }
+
+ /// <summary>
+ /// Server response
+ /// </summary>
+ [DataMember(Name = "response",EmitDefaultValue = false)]
+ public string Response { get; set; }
+
+ /// <summary>
+ /// Creates FileUploadResult object with response values
+ /// </summary>
+ /// <param name="bytesSent">Amount of sent bytes</param>
+ /// <param name="responseCode">Server response code</param>
+ /// <param name="response">Server response</param>
+ public FileUploadResult(long bytesSent, long responseCode, string response)
+ {
+ this.BytesSent = bytesSent;
+ this.ResponseCode = responseCode;
+ this.Response = response;
+ }
+ }
+
+ /// <summary>
+ /// Represents transfer error codes for callback
+ /// </summary>
+ [DataContract]
+ public class FileTransferError
+ {
+ /// <summary>
+ /// Error code
+ /// </summary>
+ [DataMember(Name="code", IsRequired = true)]
+ public int Code { get; set; }
+
+ /// <summary>
+ /// Creates FileTransferError object
+ /// </summary>
+ /// <param name="errorCode">Error code</param>
+ public FileTransferError(int errorCode)
+ {
+ this.Code = errorCode;
+ }
+ }
+
+ /// <summary>
+ /// Upload options
+ /// </summary>
+ private UploadOptions uploadOptions;
+
+ /// <summary>
+ /// Bytes sent
+ /// </summary>
+ private long bytesSent;
+
+ /// <summary>
+ /// sends a file to a server
+ /// </summary>
+ /// <param name="options">Upload options</param>
+ public void upload(string options)
+ {
+ try
+ {
+ try
+ {
+ uploadOptions = JSON.JsonHelper.Deserialize<UploadOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Uri serverUri;
+ try
+ {
+ serverUri = new Uri(uploadOptions.Server);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR,new FileTransferError(InvalidUrlError)));
+ return;
+ }
+ HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(serverUri);
+ webRequest.ContentType = "multipart/form-data;boundary=" + Boundary;
+ webRequest.Method = "POST";
+ webRequest.BeginGetRequestStream(WriteCallback, webRequest);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(ConnectionError)));
+ }
+ }
+
+ /// <summary>
+ /// Read file from Isolated Storage and sends it to server
+ /// </summary>
+ /// <param name="asynchronousResult"></param>
+ private void WriteCallback(IAsyncResult asynchronousResult)
+ {
+ try
+ {
+ HttpWebRequest webRequest = (HttpWebRequest)asynchronousResult.AsyncState;
+ using (Stream requestStream = (webRequest.EndGetRequestStream(asynchronousResult)))
+ {
+ string lineStart = "--";
+ string lineEnd = Environment.NewLine;
+ byte[] boundaryBytes = System.Text.Encoding.UTF8.GetBytes(lineStart + Boundary + lineEnd);
+ string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"" + lineEnd + lineEnd + "{1}" + lineEnd;
+
+ if (uploadOptions.Params != null)
+ {
+ Dictionary<string, object> customParams = uploadOptions.Params;
+ foreach (string key in customParams.Keys)
+ {
+ requestStream.Write(boundaryBytes, 0, boundaryBytes.Length);
+ string formItem = string.Format(formdataTemplate, key, customParams[key]);
+ byte[] formItemBytes = System.Text.Encoding.UTF8.GetBytes(formItem);
+ requestStream.Write(formItemBytes, 0, formItemBytes.Length);
+ }
+ requestStream.Write(boundaryBytes, 0, boundaryBytes.Length);
+ }
+ using (IsolatedStorageFile isoFile = IsolatedStorageFile.GetUserStoreForApplication())
+ {
+ if (!isoFile.FileExists(uploadOptions.FilePath))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(FileNotFoundError)));
+ return;
+ }
+
+ using (FileStream fileStream = new IsolatedStorageFileStream(uploadOptions.FilePath, FileMode.Open, isoFile))
+ {
+ string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"" + lineEnd + "Content-Type: {2}" + lineEnd + lineEnd;
+ string header = string.Format(headerTemplate, uploadOptions.FileKey, uploadOptions.FileName, uploadOptions.MimeType);
+ byte[] headerBytes = System.Text.Encoding.UTF8.GetBytes(header);
+ requestStream.Write(headerBytes, 0, headerBytes.Length);
+ byte[] buffer = new byte[4096];
+ int bytesRead = 0;
+
+ while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0)
+ {
+ requestStream.Write(buffer, 0, bytesRead);
+ bytesSent += bytesRead;
+ }
+ }
+ byte[] endRequest = System.Text.Encoding.UTF8.GetBytes(lineEnd + lineStart + Boundary + lineStart + lineEnd);
+ requestStream.Write(endRequest, 0, endRequest.Length);
+ }
+ }
+ webRequest.BeginGetResponse(ReadCallback, webRequest);
+ }
+ catch(Exception)
+ {
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(ConnectionError)));
+ });
+ }
+ }
+
+ /// <summary>
+ /// Reads response into FileUploadResult
+ /// </summary>
+ /// <param name="asynchronousResult"></param>
+ private void ReadCallback(IAsyncResult asynchronousResult)
+ {
+ try
+ {
+ HttpWebRequest webRequest = (HttpWebRequest)asynchronousResult.AsyncState;
+ using (HttpWebResponse response = (HttpWebResponse)webRequest.EndGetResponse(asynchronousResult))
+ {
+ using (Stream streamResponse = response.GetResponseStream())
+ {
+ using (StreamReader streamReader = new StreamReader(streamResponse))
+ {
+ string responseString = streamReader.ReadToEnd();
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, new FileUploadResult(bytesSent, (long)response.StatusCode, responseString)));
+ });
+ }
+ }
+ }
+ }
+ catch (Exception)
+ {
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, new FileTransferError(ConnectionError)));
+ });
+ }
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-cordova-wp7/blob/4789ce6d/framework/Cordova/Commands/GeoLocation.cs
----------------------------------------------------------------------
diff --git a/framework/Cordova/Commands/GeoLocation.cs b/framework/Cordova/Commands/GeoLocation.cs
new file mode 100644
index 0000000..545fc46
--- /dev/null
+++ b/framework/Cordova/Commands/GeoLocation.cs
@@ -0,0 +1,34 @@
+/*
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Threading;
+using System.Device.Location;
+
+namespace WP7GapClassLib.Cordova.Commands
+{
+ /// <summary>
+ /// This is a command stub, the browser provides the correct implementation. We use this to trigger the static analyzer that we require this permission
+ /// </summary>
+ public class GeoLocation
+ {
+ /* Unreachable code, by design -jm */
+ private void triggerGeoInclusion()
+ {
+ new GeoCoordinateWatcher();
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-cordova-wp7/blob/4789ce6d/framework/Cordova/Commands/Media.cs
----------------------------------------------------------------------
diff --git a/framework/Cordova/Commands/Media.cs b/framework/Cordova/Commands/Media.cs
new file mode 100644
index 0000000..d9539fb
--- /dev/null
+++ b/framework/Cordova/Commands/Media.cs
@@ -0,0 +1,450 @@
+/*
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.Windows;
+
+namespace WP7GapClassLib.Cordova.Commands
+{
+ /// <summary>
+ /// Provides the ability to record and play back audio files on a device.
+ /// </summary>
+ public class Media : BaseCommand
+ {
+ /// <summary>
+ /// Audio player objects
+ /// </summary>
+ private static Dictionary<string, AudioPlayer> players = new Dictionary<string,AudioPlayer>();
+
+ /// <summary>
+ /// Represents Media action options.
+ /// </summary>
+ [DataContract]
+ public class MediaOptions
+ {
+ /// <summary>
+ /// Audio id
+ /// </summary>
+ [DataMember(Name = "id", IsRequired = true)]
+ public string Id { get; set; }
+
+ /// <summary>
+ /// Path to audio file
+ /// </summary>
+ [DataMember(Name = "src")]
+ public string Src { get; set; }
+
+ /// <summary>
+ /// New track position
+ /// </summary>
+ [DataMember(Name = "milliseconds")]
+ public int Milliseconds { get; set; }
+ }
+
+ /// <summary>
+ /// Releases the audio player instance to save memory.
+ /// </summary>
+ private void release(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (!Media.players.ContainsKey(mediaOptions.Id))
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, false));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+ Media.players.Remove(mediaOptions.Id);
+ audio.Dispose();
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, true));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+ /// <summary>
+ /// Starts recording and save the specified file
+ /// </summary>
+ public void startRecordingAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ if (!Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = new AudioPlayer(this, mediaOptions.Id);
+ Media.players.Add(mediaOptions.Id, audio);
+ audio.startRecording(mediaOptions.Src);
+ }
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+
+ });
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+ /// <summary>
+ /// Stops recording and save to the file specified when recording started
+ /// </summary>
+ public void stopRecordingAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+ audio.stopRecording();
+ Media.players.Remove(mediaOptions.Id);
+ }
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+ catch(Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+ /// <summary>
+ /// Starts or resume playing audio file
+ /// </summary>
+ public void startPlayingAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ AudioPlayer audio;
+
+ if (!Media.players.ContainsKey(mediaOptions.Id))
+ {
+ audio = new AudioPlayer(this, mediaOptions.Id);
+ Media.players.Add(mediaOptions.Id, audio);
+ }
+ else
+ {
+ audio = Media.players[mediaOptions.Id];
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ audio.startPlaying(mediaOptions.Src);
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+ catch(Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+
+ /// <summary>
+ /// Seeks to a location
+ /// </summary>
+ public void seekToAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+ audio.seekToPlaying(mediaOptions.Milliseconds);
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+ /// <summary>
+ /// Pauses playing
+ /// </summary>
+ public void pausePlayingAudio(string options)
+ {
+
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+ audio.pausePlaying();
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+
+
+ /// <summary>
+ /// Stops playing the audio file
+ /// </summary>
+ public void stopPlayingAudio(String options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ try
+ {
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+ audio.stopPlaying();
+ }
+
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+ }
+ catch(Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ });
+ }
+ catch(Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+
+ }
+
+ /// <summary>
+ /// Gets current position of playback
+ /// </summary>
+ public void getCurrentPositionAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ AudioPlayer audio = Media.players[mediaOptions.Id];
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, audio.getCurrentPosition()));
+ });
+ return;
+ }
+ else
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, -1));
+ }
+ }
+ catch (Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+
+ /// <summary>
+ /// Gets the duration of the audio file
+ /// </summary>
+ public void getDurationAudio(string options)
+ {
+ try
+ {
+ MediaOptions mediaOptions;
+
+ try
+ {
+ mediaOptions = JSON.JsonHelper.Deserialize<MediaOptions>(options);
+ }
+ catch (Exception)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.JSON_EXCEPTION));
+ return;
+ }
+
+ AudioPlayer audio;
+ if (Media.players.ContainsKey(mediaOptions.Id))
+ {
+ audio = Media.players[mediaOptions.Id];
+ }
+ else
+ {
+ audio = new AudioPlayer(this, mediaOptions.Id);
+ Media.players.Add(mediaOptions.Id, audio);
+ }
+
+ Deployment.Current.Dispatcher.BeginInvoke(() =>
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.OK, audio.getDuration(mediaOptions.Src)));
+ });
+ }
+ catch(Exception e)
+ {
+ DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+ }
+ }
+
+ }
+}