1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Use the <code>chrome.fileSystem</code> API to create, read, navigate,
// and write to a sandboxed section of the user's local file system. With this
// API, packaged apps can read and write to a user-selected location. For
// example, a text editor app can use the API to read and write local documents.
namespace fileSystem {
dictionary AcceptOption {
// This is the optional text description for this option. If not present,
// a description will be automatically generated; typically containing an
// expanded list of valid extensions (e.g. "text/html" may expand to
// "*.html, *.htm").
DOMString? description;
// Mime-types to accept, e.g. "image/jpeg" or "audio/*". One of mimeTypes or
// extensions must contain at least one valid element.
DOMString[]? mimeTypes;
// Extensions to accept, e.g. "jpg", "gif", "crx".
DOMString[]? extensions;
};
enum ChooseEntryType {
// Prompts the user to open an existing file and returns a FileEntry on
// success. From Chrome 31 onwards, the FileEntry will be writable if the
// application has the 'write' permission under 'fileSystem'; otherwise, the
// FileEntry will be read-only.
openFile,
// Prompts the user to open an existing file and returns a writable
// FileEntry on success. Calls using this type will fail unless the
// application has the 'write' permission under 'fileSystem'.
openWritableFile,
// Prompts the user to open an existing file or a new file and returns a
// writable FileEntry on success. Calls using this type will fail unless the
// application has the 'write' permission under 'fileSystem'.
saveFile
};
dictionary ChooseEntryOptions {
// Type of the prompt to show. The default is 'openFile'. From Chrome 31
// onwards, 'openWritableFile' is deprecated and 'openFile' will return a
// writable file entry for apps with the 'write' permission under
// 'fileSystem'.
ChooseEntryType? type;
// The suggested file name that will be presented to the user as the
// default name to read or write. This is optional.
DOMString? suggestedName;
// The optional list of accept options for this file opener. Each option
// will be presented as a unique group to the end-user.
AcceptOption[]? accepts;
// Whether to accept all file types, in addition to the options specified
// in the accepts argument. The default is true. If the accepts field is
// unset or contains no valid entries, this will always be reset to true.
boolean? acceptsAllTypes;
// Whether to accept multiple files. This is only supported for openFile and
// openWritableFile. The callback to chooseEntry will be called with a list
// of entries if this is set to true. Otherwise it will be called with a
// single Entry.
boolean? acceptsMultiple;
};
callback GetDisplayPathCallback = void (DOMString displayPath);
callback FileEntryCallback = void ([instanceOf=FileEntry] object fileEntry);
callback FileEntriesCallback = void (
[instanceOf=FileEntry] optional object fileEntry,
[instanceOf=FileEntry] optional object[] fileEntries);
callback IsWritableCallback = void (boolean isWritable);
callback IsRestorableCallback = void (boolean isRestorable);
interface Functions {
// Get the display path of a FileEntry object. The display path is based on
// the full path of the file on the local file system, but may be made more
// readable for display purposes.
static void getDisplayPath([instanceOf=FileEntry] object fileEntry,
GetDisplayPathCallback callback);
// Get a writable FileEntry from another FileEntry. This call will fail if
// the application does not have the 'write' permission under 'fileSystem'.
static void getWritableEntry([instanceOf=FileEntry] object fileEntry,
FileEntryCallback callback);
// Gets whether this FileEntry is writable or not.
static void isWritableEntry([instanceOf=FileEntry] object fileEntry,
IsWritableCallback callback);
// Ask the user to choose a file.
static void chooseEntry(optional ChooseEntryOptions options,
FileEntriesCallback callback);
// Returns the file entry with the given id if it can be restored. This call
// will fail otherwise. This method is new in Chrome 30.
static void restoreEntry(DOMString id, FileEntryCallback callback);
// Returns whether a file entry for the given id can be restored, i.e.
// whether restoreEntry would succeed with this id now. This method is new
// in Chrome 30.
static void isRestorable(DOMString id, IsRestorableCallback callback);
// Returns an id that can be passed to restoreEntry to regain access to a
// given file entry. Only the 500 most recently used entries are retained,
// where calls to retainEntry and restoreEntry count as use. If the app has
// the 'retainEntries' permission under 'fileSystem' (currently restricted
// to dev channel), entries are retained indefinitely. Otherwise, entries
// are retained only while the app is running and across restarts. This
// method is new in Chrome 30.
static DOMString retainEntry([instanceOf=FileEntry] object fileEntry);
};
};
|
