1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * |
|
5 * This program is free software: you can redistribute it and/or modify |
|
6 * it under the terms of the GNU Lesser General Public License as published by |
|
7 * the Free Software Foundation, version 2.1 of the License. |
|
8 * |
|
9 * This program is distributed in the hope that it will be useful, |
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 * GNU Lesser General Public License for more details. |
|
13 * |
|
14 * You should have received a copy of the GNU Lesser General Public License |
|
15 * along with this program. If not, |
|
16 * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/". |
|
17 * |
|
18 * Description: |
|
19 * |
|
20 */ |
|
21 |
|
22 #include <xqservicerequest.h> |
|
23 #include <xqservicemanager.h> |
|
24 #include <QList> |
|
25 #include <xqsettingsmanager.h> |
|
26 #include <xqsettingskey.h> |
|
27 #include <e32std.h> |
|
28 |
|
29 #include "xqservicelog.h" |
|
30 #include "xqaiwutils.h" |
|
31 #include "xqaiwuridriver.h" |
|
32 #include "xqaiwdecl.h" |
|
33 #include "xqappmgr_p.h" |
|
34 |
|
35 /*! |
|
36 \class XQApplicationManagerPrivate |
|
37 \brief Private implementation of the XQApplicationManager |
|
38 */ |
|
39 |
|
40 XQApplicationManagerPrivate::XQApplicationManagerPrivate(): |
|
41 serviceMgr(0), |
|
42 aiwUtilities(0) |
|
43 |
|
44 { |
|
45 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate"); |
|
46 serviceMgr = new XQServiceManager(); |
|
47 } |
|
48 |
|
49 XQApplicationManagerPrivate::~XQApplicationManagerPrivate() |
|
50 { |
|
51 XQSERVICE_DEBUG_PRINT("~XQApplicationManagerPrivate"); |
|
52 delete serviceMgr; |
|
53 delete aiwUtilities; |
|
54 } |
|
55 |
|
56 XQAiwRequest* XQApplicationManagerPrivate::create( const QString &interface, const QString &operation, bool embedded) |
|
57 { |
|
58 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create(interface)"); |
|
59 return create("", interface, operation, embedded); |
|
60 } |
|
61 |
|
62 XQAiwRequest* XQApplicationManagerPrivate::create( |
|
63 const QString &service, const QString &interface, const QString &operation, bool embedded) |
|
64 { |
|
65 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create(service+interface)"); |
|
66 |
|
67 QList<XQAiwInterfaceDescriptor> impls; |
|
68 if (service.isEmpty()) |
|
69 impls = serviceMgr->findFirstInterface(interface); |
|
70 else |
|
71 impls = serviceMgr->findFirstInterface(service, interface); |
|
72 |
|
73 // Pick up the first implementation |
|
74 if (impls.count()) |
|
75 { |
|
76 return new XQAiwRequest(impls[0], operation, embedded); |
|
77 } |
|
78 return 0; |
|
79 } |
|
80 |
|
81 |
|
82 XQAiwRequest* XQApplicationManagerPrivate::create( |
|
83 const XQAiwInterfaceDescriptor &implementation, const QString &operation, bool embedded) |
|
84 { |
|
85 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create (impl)"); |
|
86 return new XQAiwRequest(implementation, operation, embedded); |
|
87 } |
|
88 |
|
89 XQAiwRequest* XQApplicationManagerPrivate::create( |
|
90 const QUrl &uri, const XQAiwInterfaceDescriptor *implementation, bool embedded) |
|
91 { |
|
92 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create (uri)"); |
|
93 XQSERVICE_DEBUG_PRINT("uri=%s", qPrintable(uri.toString())); |
|
94 |
|
95 if (!uri.isValid()) |
|
96 { |
|
97 XQSERVICE_CRITICAL_PRINT("Invalid URI %s", qPrintable(uri.toString())); |
|
98 return 0; |
|
99 } |
|
100 |
|
101 if (hasCustomHandler(uri)) |
|
102 { |
|
103 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::custom handler applied"); |
|
104 XQAiwInterfaceDescriptor nullDescr; |
|
105 return new XQAiwRequest(uri, nullDescr, XQOP_URI_VIEW); |
|
106 } |
|
107 |
|
108 const XQAiwInterfaceDescriptor *impl = implementation; |
|
109 QList<XQAiwInterfaceDescriptor> impls; |
|
110 if (impl == 0) |
|
111 { |
|
112 // Implementation not given, find first one |
|
113 impls = list(uri); |
|
114 if (impls.count()) |
|
115 { |
|
116 impl = &impls[0]; |
|
117 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create (impl) use first)"); |
|
118 } |
|
119 } |
|
120 |
|
121 XQAiwRequest *req = 0; |
|
122 if (impl != 0) |
|
123 { |
|
124 // Create service request for viewing the URI |
|
125 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create (impl) creating request)"); |
|
126 req = new XQAiwRequest(uri, *impl, XQOP_URI_VIEW); |
|
127 if (req) |
|
128 { |
|
129 req->setEmbedded(embedded); |
|
130 } |
|
131 } |
|
132 |
|
133 return req; |
|
134 |
|
135 |
|
136 } |
|
137 |
|
138 XQAiwRequest* XQApplicationManagerPrivate::create( |
|
139 const QFile &file, const XQAiwInterfaceDescriptor *implementation, bool embedded) |
|
140 { |
|
141 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create(file)"); |
|
142 XQSERVICE_DEBUG_PRINT("file=%s", qPrintable(file.fileName())); |
|
143 |
|
144 const XQAiwInterfaceDescriptor *impl = implementation; |
|
145 QList<XQAiwInterfaceDescriptor> impls; |
|
146 if (impl == 0) |
|
147 { |
|
148 // Implementation not given, find services capable of handling the "file" |
|
149 impls = list(file); |
|
150 if (impls.count()) |
|
151 { |
|
152 impl = &impls[0]; |
|
153 } |
|
154 } |
|
155 |
|
156 XQAiwRequest * req = 0; |
|
157 if (impl != 0) |
|
158 { |
|
159 QVariant v = impl->property(XQAiwInterfaceDescriptor::ImplementationId); |
|
160 req = new XQAiwRequest(file, *impl, XQOP_FILE_VIEW); |
|
161 if (req) |
|
162 { |
|
163 req->setEmbedded(embedded); |
|
164 XQSERVICE_DEBUG_PRINT("File handled by %x", v.toInt()); |
|
165 } |
|
166 } |
|
167 |
|
168 return req; |
|
169 } |
|
170 |
|
171 XQAiwRequest* XQApplicationManagerPrivate::create( |
|
172 const XQSharableFile &file, const XQAiwInterfaceDescriptor *implementation, bool embedded) |
|
173 { |
|
174 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::create(XQSharableFile)"); |
|
175 if (!file.isValid()) |
|
176 { |
|
177 XQSERVICE_DEBUG_PRINT("\tInvalid XQSharableFile)"); |
|
178 return 0; |
|
179 } |
|
180 |
|
181 const XQAiwInterfaceDescriptor *impl = implementation; |
|
182 QList<XQAiwInterfaceDescriptor> impls; |
|
183 if (impl == 0) |
|
184 { |
|
185 // Implementation not given, find services capable of handling the "file" |
|
186 impls = list(file); |
|
187 if (impls.count()) |
|
188 { |
|
189 impl = &impls[0]; |
|
190 } |
|
191 } |
|
192 |
|
193 XQAiwRequest * req = 0; |
|
194 if (impl != 0) |
|
195 { |
|
196 QVariant v = impl->property(XQAiwInterfaceDescriptor::ImplementationId); |
|
197 req = new XQAiwRequest(file, *impl, XQOP_FILE_VIEW_SHARABLE); |
|
198 if (req) |
|
199 { |
|
200 req->setEmbedded(embedded); |
|
201 XQSERVICE_DEBUG_PRINT("File handled by %x", v.toInt()); |
|
202 } |
|
203 } |
|
204 |
|
205 return req; |
|
206 } |
|
207 |
|
208 |
|
209 |
|
210 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::list( |
|
211 const QString &interface, const QString& operation) |
|
212 { |
|
213 |
|
214 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::list(interface)"); |
|
215 Q_UNUSED(operation); |
|
216 |
|
217 return serviceMgr->findInterfaces(interface); |
|
218 } |
|
219 |
|
220 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::list( |
|
221 const QString &service, const QString& interface, const QString& operation) |
|
222 { |
|
223 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::list (service+interface)"); |
|
224 Q_UNUSED(operation); |
|
225 |
|
226 return serviceMgr->findInterfaces(service, interface); |
|
227 } |
|
228 |
|
229 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::list( |
|
230 const QUrl &uri) |
|
231 { |
|
232 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::list (uri) %s", qPrintable(uri.toString())); |
|
233 |
|
234 QList<XQAiwInterfaceDescriptor> result; |
|
235 if (!uri.isValid()) |
|
236 { |
|
237 XQSERVICE_CRITICAL_PRINT("Invalid URI %s", qPrintable(uri.toString())); |
|
238 return result; // Empty |
|
239 } |
|
240 |
|
241 QString scheme = uri.scheme(); |
|
242 |
|
243 if (scheme.compare(XQURI_SCHEME_FILE,Qt::CaseInsensitive) == 0) |
|
244 { |
|
245 QFile file (uri.toLocalFile()); |
|
246 return list(file); // Apply file based listing |
|
247 } |
|
248 |
|
249 // Find all services implementing URI interface and support URI scheme |
|
250 QList<XQAiwInterfaceDescriptor> uriHandlers; |
|
251 uriHandlers = list(XQI_URI_VIEW, ""); |
|
252 |
|
253 // Pick up services supporting the required scheme |
|
254 foreach (XQAiwInterfaceDescriptor uh, uriHandlers) |
|
255 { |
|
256 // Find services that support the scheme |
|
257 if (uh.customProperty(XQCUSTOM_PROP_SCHEMES).contains(scheme,Qt::CaseInsensitive)) // Allow multiple schemes in same string |
|
258 { |
|
259 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Service %s can handle scheme %s", |
|
260 qPrintable(uh.serviceName()), qPrintable(scheme)) |
|
261 result.append(uh); |
|
262 } |
|
263 } |
|
264 |
|
265 return result; |
|
266 } |
|
267 |
|
268 // |
|
269 // List services capable of handling the file by MIME type |
|
270 // |
|
271 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::list(const QFile &file) |
|
272 { |
|
273 |
|
274 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::list (file) %s", qPrintable(file.fileName())); |
|
275 |
|
276 // List first MIME handlers for file |
|
277 QList<XQAiwInterfaceDescriptor> mimeHandlers; |
|
278 mimeHandlers = listMimeHandlers(file); |
|
279 |
|
280 // Then list those file services that can support the MIME type |
|
281 return listFileHandlers(mimeHandlers); |
|
282 } |
|
283 |
|
284 // |
|
285 // List services capable of handling the sharable file by MIME type |
|
286 // |
|
287 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::list(const XQSharableFile &file) |
|
288 { |
|
289 |
|
290 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::list (handle)"); |
|
291 |
|
292 // List first MIME handlers for the sharable file |
|
293 QList<XQAiwInterfaceDescriptor> mimeHandlers; |
|
294 if (!file.isValid()) |
|
295 { |
|
296 return mimeHandlers; // Empty set |
|
297 } |
|
298 mimeHandlers = listMimeHandlers(file); |
|
299 |
|
300 // Then list those file services that can support the MIME type |
|
301 return listFileHandlers(mimeHandlers); |
|
302 } |
|
303 |
|
304 |
|
305 int XQApplicationManagerPrivate::lastError() const |
|
306 { |
|
307 int err=0; |
|
308 err = serviceMgr->latestError(); |
|
309 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: lastError=%d", err); |
|
310 return err; |
|
311 } |
|
312 |
|
313 bool XQApplicationManagerPrivate::isRunning(const XQAiwInterfaceDescriptor& implementation) const |
|
314 { |
|
315 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate isRunning"); |
|
316 return serviceMgr->isRunning(implementation); |
|
317 } |
|
318 |
|
319 bool XQApplicationManagerPrivate::getDrmAttributes(const QFile &file, const QList<int> &attributeNames, QVariantList &attributeValues) |
|
320 { |
|
321 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate drmAttributes"); |
|
322 if (aiwUtilities == 0) |
|
323 aiwUtilities = new XQAiwUtils(); |
|
324 return aiwUtilities->getDrmAttributes(file.fileName(), attributeNames, attributeValues); |
|
325 } |
|
326 |
|
327 bool XQApplicationManagerPrivate::getDrmAttributes(const XQSharableFile &file, const QList<int> &attributeNames, QVariantList &attributeValues) |
|
328 { |
|
329 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate drmAttributes"); |
|
330 if (aiwUtilities == 0) |
|
331 aiwUtilities = new XQAiwUtils(); |
|
332 return aiwUtilities->getDrmAttributes(file,attributeNames, attributeValues); |
|
333 } |
|
334 |
|
335 int XQApplicationManagerPrivate::status(const XQAiwInterfaceDescriptor& implementation) |
|
336 { |
|
337 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate status"); |
|
338 QString statusKeyValue = implementation.customProperty(XQCUSTOM_PROP_AIW_SERVICE_STATUS); |
|
339 if (statusKeyValue.isEmpty()) |
|
340 { |
|
341 // No custom property, have to assume service is enabled |
|
342 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate no custom property %s", |
|
343 XQCUSTOM_PROP_AIW_SERVICE_STATUS); |
|
344 return XQApplicationManager::Unknown; |
|
345 } |
|
346 |
|
347 if (aiwUtilities == 0) |
|
348 aiwUtilities = new XQAiwUtils(); |
|
349 |
|
350 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate custom property value=%s", |
|
351 qPrintable(statusKeyValue)); |
|
352 |
|
353 bool b=false; |
|
354 int keyId = aiwUtilities->toIntFromHex(statusKeyValue, &b); |
|
355 if (!b) |
|
356 { |
|
357 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate bad custom property value"); |
|
358 return XQApplicationManager::Unknown; |
|
359 } |
|
360 |
|
361 XQSettingsManager settingsManager; |
|
362 int implId = implementation.property(XQAiwInterfaceDescriptor::ImplementationId).toInt(); |
|
363 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate %x,%x", keyId, implId); |
|
364 |
|
365 XQSettingsKey statusKey (XQSettingsKey::TargetCentralRepository, implId, keyId); |
|
366 QVariant value = settingsManager.readItemValue(statusKey); |
|
367 if (value.isNull()) |
|
368 { |
|
369 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate Cenrep %x does not contain key %x", |
|
370 implId, keyId); |
|
371 return XQApplicationManager::Unknown; |
|
372 } |
|
373 |
|
374 |
|
375 int status = value.toInt(&b); |
|
376 if (!b) |
|
377 { |
|
378 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate invalid status value %s", |
|
379 qPrintable(value.toString())); |
|
380 return XQApplicationManager::Unknown; |
|
381 } |
|
382 |
|
383 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate status=%d", status); |
|
384 |
|
385 return status; |
|
386 |
|
387 } |
|
388 |
|
389 // ---- PRIVATE FUNCTIONS ---- |
|
390 |
|
391 bool XQApplicationManagerPrivate::hasCustomHandler(const QUrl &uri) const |
|
392 { |
|
393 return XQAiwUriDriver::hasCustomHandler(uri); |
|
394 } |
|
395 |
|
396 // |
|
397 // Get file handlers |
|
398 // TODO: Currently only one, default handler is returned !!! |
|
399 // Possibly later all handlers need to be returned. |
|
400 // |
|
401 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::listMimeHandlers(const QFile &file) |
|
402 { |
|
403 |
|
404 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::listMimeHandlers %s", qPrintable(file.fileName())); |
|
405 QList<XQAiwInterfaceDescriptor> mimeHandlers; |
|
406 |
|
407 if (aiwUtilities == 0) |
|
408 aiwUtilities = new XQAiwUtils(); |
|
409 if (aiwUtilities == 0) |
|
410 { |
|
411 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Can not create aiw utils"); |
|
412 return mimeHandlers; |
|
413 } |
|
414 |
|
415 XQAiwInterfaceDescriptor descriptor; |
|
416 |
|
417 // Find default application that can handle MIME type (only one at the moment) |
|
418 int applicationId = 0; |
|
419 if (aiwUtilities->findApplication(file, applicationId) != XQService::ENoError) |
|
420 { |
|
421 return mimeHandlers; // Empty set |
|
422 } |
|
423 |
|
424 // Set incomplete descriptor |
|
425 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Found file handler %x", applicationId); |
|
426 descriptor.setProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(applicationId)); |
|
427 |
|
428 mimeHandlers.append(descriptor); |
|
429 |
|
430 return mimeHandlers; |
|
431 } |
|
432 |
|
433 // |
|
434 // Get handlers for sharable file |
|
435 // TODO: Currently only one, default handler is returned !!! |
|
436 // Possibly later all handlers need to be returned. |
|
437 // |
|
438 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::listMimeHandlers(const XQSharableFile &file) |
|
439 { |
|
440 |
|
441 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::listMimeHandlers (handle)"); |
|
442 QList<XQAiwInterfaceDescriptor> mimeHandlers; |
|
443 |
|
444 if (aiwUtilities == 0) |
|
445 aiwUtilities = new XQAiwUtils(); |
|
446 if (aiwUtilities == 0) |
|
447 { |
|
448 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Can not create aiw utils"); |
|
449 return mimeHandlers; |
|
450 } |
|
451 |
|
452 XQAiwInterfaceDescriptor descriptor; |
|
453 |
|
454 // Find default application that can handle MIME type (only one at the moment) |
|
455 int applicationId = 0; |
|
456 if (aiwUtilities->findApplication(file, applicationId) != XQService::ENoError) |
|
457 { |
|
458 return mimeHandlers; // Empty set |
|
459 } |
|
460 |
|
461 // Set incomplete descriptor |
|
462 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Found file handler %x", applicationId); |
|
463 descriptor.setProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(applicationId)); |
|
464 |
|
465 mimeHandlers.append(descriptor); |
|
466 |
|
467 return mimeHandlers; |
|
468 } |
|
469 |
|
470 |
|
471 // To be called only for URI having scheme XQURI_SCHEME_ACTIVITY |
|
472 // Check that application exists and fill in only the implementationId |
|
473 bool XQApplicationManagerPrivate::getAppDescriptor(const QUrl &uri, XQAiwInterfaceDescriptor *descriptor) |
|
474 { |
|
475 |
|
476 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::getAppDescriptor %s)", qPrintable(uri.toString())); |
|
477 |
|
478 if (aiwUtilities == 0) |
|
479 aiwUtilities = new XQAiwUtils(); |
|
480 if (aiwUtilities == 0) |
|
481 { |
|
482 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Can not create aiw utils"); |
|
483 return false; |
|
484 } |
|
485 |
|
486 int applicationId = 0; |
|
487 if (aiwUtilities->findApplication(uri, applicationId) != XQService::ENoError) |
|
488 { |
|
489 return false; // No application registered for file |
|
490 } |
|
491 |
|
492 // Create incomplete descriptor |
|
493 descriptor->setProperty(XQAiwInterfaceDescriptor::ImplementationId, QVariant(applicationId)); |
|
494 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Found uri handler %x", applicationId); |
|
495 |
|
496 return true; |
|
497 } |
|
498 |
|
499 |
|
500 // |
|
501 // Get file handlers that can support the give MIME type |
|
502 // |
|
503 QList<XQAiwInterfaceDescriptor> XQApplicationManagerPrivate::listFileHandlers( |
|
504 const QList<XQAiwInterfaceDescriptor> &mimeHandlers) |
|
505 { |
|
506 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate::listFileHandlers"); |
|
507 |
|
508 // Find all services implementing URI interface, support "file" scheme and can handle the file |
|
509 // by MIME type |
|
510 QList<XQAiwInterfaceDescriptor> fileServices; |
|
511 fileServices = list(XQI_FILE_VIEW, ""); |
|
512 if (fileServices.count() == 0) |
|
513 { |
|
514 return fileServices; // Empty set |
|
515 } |
|
516 |
|
517 QList<XQAiwInterfaceDescriptor> result; |
|
518 foreach (XQAiwInterfaceDescriptor fs, fileServices) |
|
519 { |
|
520 // Find services that support the file scheme |
|
521 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Service %s can handle file", qPrintable(fs.serviceName())); |
|
522 int serviceAppId = fs.property(XQAiwInterfaceDescriptor::ImplementationId).toInt(); |
|
523 foreach (XQAiwInterfaceDescriptor mh, mimeHandlers) |
|
524 { |
|
525 int mimeAppId = mh.property(XQAiwInterfaceDescriptor::ImplementationId).toInt(); |
|
526 if (mimeAppId == serviceAppId) |
|
527 { |
|
528 // Return only those services that support file scheme and claim to support also MIME type |
|
529 XQSERVICE_DEBUG_PRINT("XQApplicationManagerPrivate:: Service %s (UID=%x) can handle file and MIME type", |
|
530 qPrintable(fs.serviceName()), serviceAppId); |
|
531 result.append(fs); |
|
532 } |
|
533 } |
|
534 } |
|
535 |
|
536 if (result.isEmpty()) |
|
537 { |
|
538 // No service support present, try using the MIME handlers via old way |
|
539 return mimeHandlers; |
|
540 } |
|
541 return result; |
|
542 } |
|