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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsISupports.idl"
interface nsIHandlerInfo;
interface nsISimpleEnumerator;
[scriptable, uuid(53f0ad17-ec62-46a1-adbc-efccc06babcd)]
interface nsIHandlerService : nsISupports
{
/**
* Asynchronously performs any IO that the nsIHandlerService needs to do
* before it can be of use.
*/
void asyncInit();
/**
* Retrieve a list of all handlers in the datastore. This list is not
* guaranteed to be in any particular order, and callers should not assume
* it will remain in the same order in the future.
*
* @returns a list of all handlers in the datastore
*/
nsISimpleEnumerator enumerate();
/**
* Fill a handler info object with information from the datastore.
*
* Note: because of the way the external helper app service currently mixes
* OS and user handler info in the same handler info object, this method
* takes an existing handler info object (probably retrieved from the OS)
* and "fills it in" with information from the datastore, overriding any
* existing properties on the object with properties from the datastore.
*
* Ultimately, however, we're going to separate OS and user handler info
* into separate objects, at which point this method should be renamed to
* something like "get" or "retrieve", take a class and type (or perhaps
* a type whose class can be determined by querying the type, for example
* an nsIContentType which is also an nsIMIMEType or an nsIProtocolScheme),
* and return a handler info object representing only the user info.
*
* Note: if you specify an override type, then the service will fill in
* the handler info object with information about that type instead of
* the type specified by the object's nsIHandlerInfo::type attribute.
*
* This is useful when you are trying to retrieve information about a MIME
* type that doesn't exist in the datastore, but you have a file extension
* for that type, and nsIHandlerService::getTypeFromExtension returns another
* MIME type that does exist in the datastore and can handle that extension.
*
* For example, the user clicks on a link, and the content has a MIME type
* that isn't in the datastore, but the link has a file extension, and that
* extension is associated with another MIME type in the datastore (perhaps
* an unofficial MIME type preceded an official one, like with image/x-png
* and image/png).
*
* In that situation, you can call this method to fill in the handler info
* object with information about that other type by passing the other type
* as the aOverrideType parameter.
*
* @param aHandlerInfo the handler info object
* @param aOverrideType a type to use instead of aHandlerInfo::type
*
* Note: if there is no information in the datastore about this type,
* this method throws NS_ERROR_NOT_AVAILABLE. Callers are encouraged to
* check exists() before calling fillHandlerInfo(), to prevent spamming the
* console with XPCOM exception errors.
*/
void fillHandlerInfo(in nsIHandlerInfo aHandlerInfo,
in ACString aOverrideType);
/**
* Save the preferred action, preferred handler, possible handlers, and
* always ask properties of the given handler info object to the datastore.
* Updates an existing record or creates a new one if necessary.
*
* Note: if preferred action is undefined or invalid, then we assume
* the default value nsIHandlerInfo::useHelperApp.
*
* @param aHandlerInfo the handler info object
*/
void store(in nsIHandlerInfo aHandlerInfo);
/**
* Whether or not a record for the given handler info object exists
* in the datastore. If the datastore is corrupt (or some other error
* is caught in the implementation), false will be returned.
*
* @param aHandlerInfo a handler info object
*
* @returns whether or not a record exists
*/
boolean exists(in nsIHandlerInfo aHandlerInfo);
/**
* Remove the given handler info object from the datastore. Deletes all
* records associated with the object, including the preferred handler, info,
* and type records plus the entry in the list of types, if they exist.
* Otherwise, it does nothing and does not return an error.
*
* @param aHandlerInfo the handler info object
*/
void remove(in nsIHandlerInfo aHandlerInfo);
/**
* Get the MIME type mapped to the given file extension in the datastore.
*
* XXX If we ever support extension -> protocol scheme mappings, then this
* method should work for those as well.
*
* Note: in general, you should use nsIMIMEService::getTypeFromExtension
* to get a MIME type from a file extension, as that method checks a variety
* of other sources besides just the datastore. Use this only when you want
* to specifically get only the mapping available in the datastore.
*
* @param aFileExtension the file extension
*
* @returns the MIME type, if any; otherwise returns an empty string ("").
*/
ACString getTypeFromExtension(in ACString aFileExtension);
/**
* Whether or not there is a handler known to the OS for the
* specified protocol type.
*
* @param aProtocolScheme scheme to check for support
*
* @returns whether or not a handler exists
*/
boolean existsForProtocolOS(in ACString aProtocolScheme);
/**
* Whether or not there is a handler in the datastore or OS for
* the specified protocol type. If there is no handler in the datastore,
* falls back to a check for an OS handler.
*
* @param aProtocolScheme scheme to check for support
*
* @returns whether or not a handler exists
*/
boolean existsForProtocol(in ACString aProtocolScheme);
/*
* Fill in a handler info object using information from the OS, taking into
* account the MIME type and file extension. When the OS handler
* for the MIME type and extension match, |aFound| is returned as true. If
* either the MIME type or extension is the empty string and a handler is
* found, |aFound| is returned as true.
*/
void getMIMEInfoFromOS(in nsIHandlerInfo aHandlerInfo,
in ACString aMIMEType,
in ACString aExtension,
out bool aFound);
/*
* Get a description for the application responsible for handling
* the provided protocol.
*/
AString getApplicationDescription(in ACString aProtocolScheme);
};
|
