fixed popup message and packagekit signals and slots
[opensuse:kupdateapplet.git] / src / packagekit / qpackagekitconnector.cpp
1 #include <kdebug.h>
2 #include <KLocale>
3
4 #include "qpackagekitinterface.h"
5 #include "qpackagekittransactioninterface.h"
6 #include "qpackagekitconnector.h"
7 #include "polkitclient.h"
8 #include "pkconstants.h"
9 #include "pkconstants.h"
10
11 QPackageKitConnector::QPackageKitConnector( QObject *parent ) 
12         : QObject( parent )
13         , _lastAction("none")
14         , _lastActionArg(false)
15 {
16 }
17
18
19 void QPackageKitConnector::disconnectFromInterface(QPackageKitTransactionInterface* transactioninterface)
20 {
21         disconnect(transactioninterface, 
22                 SIGNAL( Package(const QString, const QString, const QString) ), 
23                 this,
24                 SLOT( proxy_Package(const QString, const QString, const QString) )
25         );
26
27         disconnect(transactioninterface,
28                 SIGNAL( Finished(const QString, uint) ),
29                 this,
30                 SLOT( proxy_Finished(const QString, uint) )
31         );
32
33         disconnect(transactioninterface,
34                 SIGNAL( ProgressChanged(uint, uint, uint, uint) ),
35                 this,
36                 SLOT( proxy_ProgressChanged(uint,uint, uint, uint) )
37         );
38
39         disconnect(transactioninterface,
40                 SIGNAL( StatusChanged(const QString &) ),
41                 this,
42                 SLOT( proxy_StatusChanged(const QString &) )
43         );
44
45         disconnect(transactioninterface,
46              SIGNAL( Transaction(const QString &, const QString &, bool, const QString &, uint, const QString &) ),
47              this,
48              SLOT(proxy_Transaction(const QString &, const QString &, bool, const QString &, uint, const QString &) )
49         );
50
51         disconnect(transactioninterface, 
52                 SIGNAL( Details(const QString&, const QString&, const QString&,
53                                  const QString&, const QString&, qulonglong)),
54                 this,
55                 SLOT( proxy_Details(const QString&, const QString&, const QString&,
56                                 const QString&, const QString&, qulonglong))
57         );
58
59         disconnect (transactioninterface,
60                 SIGNAL( UpdateDetail(const QString&, const QString&, const QString&, const QString&, 
61                         const QString&, const QString&, const QString&, const QString&,
62                         const QString&, const QString&, const QString&, const QString&)),
63
64                 this,
65                 SLOT( proxy_UpdateDetail(const QString&, const QString&, const QString&, const QString&, 
66                         const QString&, const QString&, const QString&, const QString&,
67                         const QString&, const QString&, const QString&, const QString&))
68         );
69
70
71         disconnect(transactioninterface, 
72                 SIGNAL( ErrorCode(const QString&, const QString& )),
73                 this,
74                 SLOT( slotError( const QString&, const QString&))
75         );
76
77         
78         disconnect(transactioninterface,
79                 SIGNAL ( RepoSignatureRequired(const QString&,  const QString&,
80                         const QString&, const QString&, const QString&,
81                         const QString&, const QString&, const QString&)),
82                 this,
83                 SLOT (proxy_RepoSignatureRequired(const QString&, const QString&,
84                         const QString&, const QString&, const QString &,
85                         const QString&, const QString&, const QString &))
86         );
87
88
89         disconnect(transactioninterface,
90                 SIGNAL( EulaRequired(const QString&, const QString&, const QString&,
91                                 const QString&)),
92                 this,
93                 SLOT( proxy_EulaRequired(const QString&, const QString&, const QString&,
94                                 const QString&))
95         );
96
97         disconnect(transactioninterface,
98                 SIGNAL (RepoDetail(const QString&, const QString&, bool)),
99                 this,
100                 SLOT(proxy_RepoDetail(const QString&, const QString &, bool))
101         );
102
103         disconnect(transactioninterface,
104                 SIGNAL (RequireRestart(const QString&, const QString&)),
105                 this,
106                 SLOT(proxy_RequireRestart(const QString&, const QString &))
107         );
108
109
110         disconnect(transactioninterface,
111                 SIGNAL (Message(const QString&, const QString&)),
112                 this,
113                 SLOT(proxy_Message(const QString&, const QString &))
114         );
115
116         disconnect(transactioninterface,
117                    SIGNAL (DistroUpgrade(const QString&, const QString&, const QString &)),
118                    this,
119                    SLOT(proxy_DistroUpgrade(const QString&, const QString &, const QString &))
120             );
121
122         transactioninterface->deleteLater();
123
124 }
125
126 void QPackageKitConnector::slotError(const QString& code, const QString& message)
127 {
128         // ignore errors which can be handled by showing a 
129         // popup and restart transaction afterwards
130         
131         if (code == "no-license-agreement" ||
132             code == "bad-gpg-signature" ||
133             code == "gpg-failure" ||
134             code == "missing-gpg-signature" ) 
135         { 
136             kWarning() << "ignoring packagekit error: " << code << endl;
137                 
138             return;
139         }
140         emit ErrorMessage("PackageKit Error " + code + ": " + message);  
141 }
142
143 QPackageKitTransactionInterface* QPackageKitConnector::connectToInterface()
144 {
145
146         QString tid = getTid();
147         if (tid == QString())   // tid is not valid
148         {
149                 emit ErrorMessage( 
150                         "DBus error : Unable to get transaction id  from packagekit. DBUS/PackageKit not running? "
151                                  );
152                 return NULL;
153         }
154
155         QPackageKitTransactionInterface *transactioninterface = new QPackageKitTransactionInterface(QString::fromAscii(PK_DBUS_SERVICE),
156                                                                                               tid,
157                                                                                               QDBusConnection::systemBus() );
158
159         connect(transactioninterface, 
160                 SIGNAL( Package(const QString, const QString, const QString) ), 
161                 this,
162                 SLOT( proxy_Package(const QString, const QString, const QString) )
163         );
164
165         connect(transactioninterface,
166                 SIGNAL( Finished(const QString, uint ) ),
167                 this,
168                 SLOT( proxy_Finished(const QString, uint ) )
169         );
170
171         connect(transactioninterface,
172                 SIGNAL( Transaction(const QString &, const QString &, bool, const QString &, uint, const QString &) ),
173                 SLOT(proxy_Transaction(const QString &, const QString &, bool, const QString &, uint, const QString &) )
174         );
175   
176         connect(transactioninterface,
177                 SIGNAL( ProgressChanged(uint, uint, uint, uint) ),
178                 this,
179                 SLOT( proxy_ProgressChanged(uint,uint, uint, uint) )
180         );
181
182         connect(transactioninterface,
183                 SIGNAL( StatusChanged(const QString &) ),
184                 this,
185                 SLOT( proxy_StatusChanged(const QString &) )
186         );
187
188
189
190
191         connect(transactioninterface, 
192                 SIGNAL( Details(const QString&, const QString&, const QString&,
193                                  const QString&, const QString&, qulonglong)),
194                 this,
195                 SLOT( proxy_Details(const QString&, const QString&, const QString&,
196                                 const QString&, const QString&, qulonglong))
197         );
198
199         connect (transactioninterface,
200                 SIGNAL( UpdateDetail(const QString&, const QString&, const QString&, const QString&, 
201                         const QString&, const QString&, const QString&, const QString&,
202                         const QString&, const QString&, const QString&, const QString&)),
203
204                 this,
205                 SLOT( proxy_UpdateDetail(const QString&, const QString&, const QString&, const QString&, 
206                         const QString&, const QString&, const QString&, const QString&,
207                         const QString&, const QString&, const QString&, const QString&))
208         );
209
210         connect(transactioninterface, 
211                 SIGNAL( ErrorCode(const QString&, const QString& )),
212                 this,
213                 SLOT( slotError( const QString&, const QString&))
214         );
215
216         connect(transactioninterface,
217                 SIGNAL ( RepoSignatureRequired(const QString&,  const QString&,
218                         const QString&, const QString&, const QString&,
219                         const QString&, const QString&, const QString&)),
220                 this,
221                 SLOT (proxy_RepoSignatureRequired(const QString&, const QString&,
222                         const QString&, const QString&, const QString &,
223                         const QString&, const QString&, const QString &))
224         );
225
226
227         connect(transactioninterface,
228                 SIGNAL( EulaRequired(const QString&, const QString&, const QString&,
229                                 const QString&)),
230                 this,
231                 SLOT( proxy_EulaRequired(const QString&, const QString&, const QString&,
232                                 const QString&))
233         );
234
235         connect(transactioninterface,
236                 SIGNAL (RepoDetail(const QString&, const QString&, bool)),
237                 this,
238                 SLOT(proxy_RepoDetail(const QString&, const QString &, bool))
239         );
240
241         connect(transactioninterface,
242                 SIGNAL (RequireRestart(const QString&, const QString&)),
243                 this,
244                 SLOT(proxy_RequireRestart(const QString&, const QString &))
245         );
246
247         connect(transactioninterface,
248                 SIGNAL (Message(const QString&, const QString&)),
249                 this,
250                 SLOT(proxy_Message(const QString&, const QString &))
251         );
252
253         connect(transactioninterface,
254                 SIGNAL (DistroUpgrade(const QString&, const QString&, const QString &)),
255                 this,
256                 SLOT(proxy_DistroUpgrade(const QString&, const QString &, const QString &))
257         );
258
259         return transactioninterface;
260
261 }
262
263
264
265 void QPackageKitConnector::sendErrorMessage(QDBusAbstractInterface* interface)
266 {
267     emit ErrorMessage( "DBus error : " 
268                 + interface->lastError().name() +  " : " 
269                 + interface->lastError().message() );
270
271
272 }
273
274
275 bool QPackageKitConnector::getDetails(QStringList packageId)
276 {
277         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
278
279         if (!transactioninterface)
280                 return false;
281
282         QDBusReply<void> reply = transactioninterface->GetDetails(packageId);
283         if(reply.isValid())
284         {
285                 return true;
286         }
287         else
288         {
289                 sendErrorMessage(transactioninterface);
290                 return false;
291         }
292 }
293
294
295
296 bool QPackageKitConnector::getUpdateDetail(QStringList packageId)
297 {
298         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
299
300         if (!transactioninterface)
301                 return false;
302
303         QDBusReply<void> reply = transactioninterface->GetUpdateDetail(packageId);
304         if(reply.isValid())
305         {
306                 return true;
307         }
308         else
309         {
310                 sendErrorMessage(transactioninterface);
311                 return false;
312         }
313 }
314
315
316 bool QPackageKitConnector::acceptEula(QString eulaId)
317 {
318         if(!PackageKit::PolkitClient::instance()->getAuth(AUTH_PACKAGE_EULA_ACCEPT))
319         {
320             emit ErrorMessage( i18n( "User is not permitted: ") + AUTH_PACKAGE_EULA_ACCEPT );
321             return false;
322         }
323
324         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
325
326         if (!transactioninterface)
327                 return false;
328
329         QDBusReply<void> reply = transactioninterface->AcceptEula(eulaId);
330         if(reply.isValid())
331         {
332                 kDebug() << "accept eula valid";
333                 return true;
334         }
335         else
336         {
337                 kDebug() << "accept eula invalid";
338                 sendErrorMessage(transactioninterface);
339                 return false;
340         }
341         return false;
342 }
343
344 bool QPackageKitConnector::getUpdates()
345 {
346         _lastAction    = QString("getUpdates");
347         _lastActionArg = false;
348
349         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
350
351         kDebug() << "try to get updates1";
352         if (!transactioninterface)
353                 return false;
354         kDebug() << "try to get updates2";
355         QDBusReply<void> reply = transactioninterface->GetUpdates("none");
356         if(reply.isValid())
357         {
358                 kDebug() << "updates replay valid";
359                 return true;
360         }
361         else
362         {
363                 kDebug() << "updates replay not valid";
364                 sendErrorMessage(transactioninterface);
365                 return false;
366         }
367 }
368
369 bool QPackageKitConnector::getDistroUpgrades()
370 {
371         _lastAction    = QString("getDistroUpgrades");
372         _lastActionArg = false;
373
374         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
375
376         if (!transactioninterface)
377                 return false;
378         QDBusReply<void> reply = transactioninterface->GetDistroUpgrades();
379         if(reply.isValid())
380         {
381                 kDebug() << "get distro upgrades replay valid";
382                 return true;
383         }
384         else
385         {
386                 kDebug() << "get distro upgrades updates replay not valid";
387                 sendErrorMessage(transactioninterface);
388                 return false;
389         }
390 }
391
392 bool QPackageKitConnector::getDrivers()
393 {
394         _lastAction    = QString("getDrivers");
395         _lastActionArg = false;
396
397         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
398
399         if (!transactioninterface)
400                 return false;
401 //      QDBusReply<void> reply = transactioninterface->WhatProvides("none", "any", "drivers_for_attached_hardware");
402         QDBusReply<void> reply = transactioninterface->WhatProvides("none", "drivers", "");
403
404         if(reply.isValid())
405         {
406                 kDebug() << "drivers replay valid";
407                 return true;
408         }
409         else
410         {
411                 kDebug() << "drivers replay not valid";
412                 sendErrorMessage(transactioninterface);
413                 return false;
414         }
415 }
416
417
418 bool QPackageKitConnector::getRepoList()
419 {
420         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
421
422         if (!transactioninterface)
423                 return false;
424         QDBusReply<void> reply = transactioninterface->GetRepoList("none");
425         if(reply.isValid())
426         {
427                 kDebug() << "get repolist valid";
428                 return true;
429         }
430         else
431         {
432                 kDebug() << "get repolist not valid";
433                 sendErrorMessage(transactioninterface);
434                 return false;
435         }
436 }
437
438
439 bool QPackageKitConnector::refreshCache(bool force)
440 {
441         if(!PackageKit::PolkitClient::instance()->getAuth(AUTH_SYSTEM_SOURCES_REFRESH))
442         {
443             emit ErrorMessage( i18n( "User is not permitted: ") + AUTH_SYSTEM_SOURCES_REFRESH );
444             return false;
445         }
446
447         _lastAction    = QString("refreshCache");
448         _lastActionArg = force;
449
450         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
451
452         kDebug() << "try to refresh1";
453         if (!transactioninterface)
454                 return false;
455         kDebug() << "try to refresh2";
456         QDBusReply<void> reply = transactioninterface->RefreshCache(force);
457         if(reply.isValid())
458         {
459                 kDebug() << "refresh replay valid";
460                 return true;
461         }
462         else
463         {
464                 kDebug() << "refresh replay not valid";
465                 sendErrorMessage(transactioninterface);
466                 return false;
467         }
468         return false;
469 }
470
471
472 bool QPackageKitConnector::suggestDaemonQuit()
473 {
474         QPackageKitInterface *interface = new QPackageKitInterface( QString::fromAscii(PK_DBUS_SERVICE),
475                                                                 QString::fromAscii(PK_DBUS_PATH),
476                                                                 QDBusConnection::systemBus() );
477
478         QDBusReply<void> reply = interface->SuggestDaemonQuit();
479         // we can't expect a valig reply, as packagekitd
480         // isn't able to answer when it doesn't run anymore :-)
481
482         return true;
483         delete interface;
484 }
485
486
487
488
489
490
491 QString QPackageKitConnector::getTid()
492 {
493         QPackageKitInterface *interface = new QPackageKitInterface( QString::fromAscii(PK_DBUS_SERVICE),
494                                                                 QString::fromAscii(PK_DBUS_PATH),
495                                                                 QDBusConnection::systemBus() );
496
497         kDebug() << "try get a tid.";
498         QDBusReply<QString> tid = interface->GetTid();
499         if(tid.isValid())
500         {
501                 kDebug() << "tid: " << tid;
502                 return tid;
503         }
504         else
505         {
506                 sendErrorMessage(interface);
507                 return QString();
508         }
509         
510         delete interface;
511
512 }
513
514 bool QPackageKitConnector::triggerLastActionAgain()
515 {
516         kDebug() << "Starting last action again..."; 
517
518         if (_lastAction == QString("getUpdates"))
519                 return getUpdates();
520         else if (_lastAction == QString("getDrivers"))
521                 return getDrivers();
522         else if (_lastAction    == QString("refreshCache"))
523                 return refreshCache(_lastActionArg.toBool());
524         else if (_lastAction    == QString("installPackages"))
525                 return installPackages(_lastActionArg.toStringList());
526         else if (_lastAction    == QString("updatePackages"))
527                 return updatePackages(_lastActionArg.toStringList());
528         else if (_lastAction    == QString("searchFile"))
529                 return searchFile(_lastActionArg.toString());
530         else 
531                 return false;
532 }
533
534 bool QPackageKitConnector::installSignature(QString type, QString key_id, QString package_id)
535 {
536         if(!PackageKit::PolkitClient::instance()->getAuth(AUTH_SYSTEM_TRUST_SIGNING_KEY))
537         {
538             emit ErrorMessage( i18n( "User is not permitted: ") + AUTH_SYSTEM_TRUST_SIGNING_KEY );
539             return false;
540         }
541
542
543         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
544
545         if (!transactioninterface)
546                 return false;
547
548         QDBusReply<void> reply = transactioninterface->InstallSignature(type, key_id, package_id);
549         if(reply.isValid())
550         {
551
552                 kDebug() << "install sig valid";
553                 return true;
554         }
555         else
556         {
557                 kDebug() << "install sig not valid";
558                 sendErrorMessage(transactioninterface);
559                 return false;
560         }
561         sendErrorMessage(transactioninterface);
562         return false;
563 }
564
565 bool QPackageKitConnector::installPackages(QStringList packageIds)
566 {
567         if(!PackageKit::PolkitClient::instance()->getAuth(AUTH_PACKAGE_INSTALL))
568         {
569             emit ErrorMessage( i18n( "User is not permitted: ") + AUTH_PACKAGE_INSTALL );
570             return false;
571         }
572
573
574     _lastAction    = QString("installPackages");
575     _lastActionArg = packageIds;
576
577     QPackageKitTransactionInterface* transactioninterface = connectToInterface();
578
579     if (!transactioninterface)
580         return false;
581
582     QDBusReply<void> reply = transactioninterface->InstallPackages(packageIds);
583     if(reply.isValid())
584     {
585         kDebug() << "install valid";
586         return true;
587     }
588     else
589     {
590         kDebug() << "install not valid";
591         sendErrorMessage(transactioninterface);
592         return false;
593     }
594     return false;
595 }
596
597 bool QPackageKitConnector::updatePackages(QStringList packageIds)
598 {
599         if(!PackageKit::PolkitClient::instance()->getAuth(AUTH_SYSTEM_UPDATE))
600         {
601             emit ErrorMessage( i18n( "User is not permitted: ") + AUTH_SYSTEM_UPDATE );
602             return false;
603         }
604
605
606         _lastAction    = QString("updatePackages");
607         _lastActionArg = packageIds;
608
609
610         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
611
612         if (!transactioninterface)
613                 return false;
614
615         QDBusReply<void> reply = transactioninterface->UpdatePackages(packageIds);
616         if(reply.isValid())
617         {
618
619                 kDebug() << "updatepackages valid";
620                 return true;
621         }
622         else
623         {
624                 kDebug() << "updatepackages not valid";
625                 sendErrorMessage(transactioninterface);
626                 return false;
627         }
628         return false;
629 }
630
631
632 bool QPackageKitConnector::searchFile(const QString& search)
633 {
634         _lastAction    = QString("searchFile");
635         _lastActionArg = search;
636
637
638         QPackageKitTransactionInterface* transactioninterface = connectToInterface();
639
640         if (!transactioninterface)
641                 return false;
642
643         QDBusReply<void> reply = transactioninterface->SearchFile("none", search);
644         if(reply.isValid())
645         {
646
647                 kDebug() << "searchFile valid";
648                 return true;
649         }
650         else
651         {
652                 kDebug() << "searchFile not valid";
653                 sendErrorMessage(transactioninterface);
654                 return false;
655         }
656 }
657
658
659
660 void QPackageKitConnector::proxy_Package( const QString &info, const QString &package_id, const QString &summary)
661 {
662         emit Package(info, package_id, summary);
663 }
664
665 void QPackageKitConnector::proxy_DistroUpgrade( const QString &type, const QString &name, const QString &detail)
666 {
667         emit DistroUpgrade(type, name, detail);
668 }
669
670 void QPackageKitConnector::proxy_Finished(const QString &status, uint runtime)
671 {
672         kDebug() << "Finished [status: " << status << "] [runtime: " << runtime << "]";
673
674         QPackageKitTransactionInterface *transactioninterface = qobject_cast<QPackageKitTransactionInterface *>(QObject::sender());
675   
676         if ( transactioninterface )
677         {
678                 QString param;
679                 QDBusReply<QString> reply = transactioninterface->GetRole(param);
680                 if(!reply.isValid())
681                 {
682                         kDebug() << "role replay not valid";
683 //                      sendErrorMessage(transactioninterface);
684 //                      return;
685                 }
686                 else
687                 {
688                         kDebug() << "role replay valid: " << param << " " << reply.value();
689
690                         if (    reply.value() == "get-updates" ||  
691                                 reply.value() == "what-provides" ||
692                                 reply.value() == "search-file" )
693                                 emit GetUpdatesFinished();
694
695                         if ( reply.value() == "get-repo-list" )
696                                 emit RepoListFinished();
697
698                         if (    reply.value() == "update-system" ||
699                                 reply.value() == "install-package" ||
700                                 reply.value() == "install-packages" ||
701                                 reply.value() == "install-file" ||
702                                 reply.value() == "install-files" ||
703                                 reply.value() == "update-package" ||
704                                 reply.value() == "update-packages" )
705                                 emit InstallFinished();
706
707                         kDebug() <<  reply.value() ;
708                 
709
710                         disconnectFromInterface(transactioninterface);
711                         emit Finished(Exit::fromString(status), runtime);
712                 }
713         } 
714         else
715         {
716                 kDebug() << "Can't figure out which transaction is finishing";
717         }
718 }
719
720 void QPackageKitConnector::proxy_Transaction(const QString &old_tid, const QString &timespec, bool succeeded, const QString &role, uint duration, const QString &data)
721 {
722         Q_UNUSED(timespec);
723         Q_UNUSED(succeeded);
724         Q_UNUSED(duration);
725         Q_UNUSED(data);
726
727
728         kDebug() << "Transaction: " << old_tid << " " << role;
729 }
730
731
732 void QPackageKitConnector::proxy_ProgressChanged(uint percentage, uint subpercentage, uint elapsed, uint remaining)
733 {
734         if(percentage == 101)
735         {
736                 emit NoProgressUpdates();
737         }
738         else
739         {
740                 emit ProgressChanged(percentage, subpercentage, elapsed, remaining);
741         }
742 }
743
744 void QPackageKitConnector::proxy_StatusChanged(const QString &status)
745 {
746     kDebug() << "status changed to: " << status;
747     emit StatusChanged(status);
748 }
749
750
751 void QPackageKitConnector::proxy_RepoSignatureRequired(const QString &package_id, const QString &repository_name,
752          const QString  &key_url, const QString &key_userid, const QString &key_id,
753          const QString &key_fingerprint, const QString &key_timestamp, const QString &type)
754 {
755         kDebug() << "proxy_RepoSignatureRequired";
756
757         emit RepoSignatureRequired(package_id,  repository_name, key_url, key_userid, 
758                 key_id, key_fingerprint, key_timestamp, type); 
759 }
760
761
762 void QPackageKitConnector::proxy_Details(const QString &package_id, const QString &licence, const QString &group, const QString &detail,
763         const QString &url, qulonglong size) 
764 {
765         emit Details(package_id, licence, group, detail, url, size); 
766 }
767
768 void QPackageKitConnector::proxy_EulaRequired(const QString &eula_id, const QString &package_id, const QString &vendor_name, const QString &license_agreement)
769 {
770         emit EulaRequired(eula_id, package_id, vendor_name, license_agreement);
771 }       
772
773
774 void QPackageKitConnector::proxy_RepoDetail(const QString &repo_id, const QString &desc, bool enabled)
775 {
776         emit RepoDetail(repo_id, desc, enabled);
777 }
778
779 void QPackageKitConnector::proxy_UpdateDetail(const QString &package_id, const QString &updates, const QString &obsoletes, const QString &vendor_url,
780         const QString &bugzilla_url, const QString &cve_url, const QString &restart, const QString &update_text,
781         const QString &changelog, const QString &state, const QString &issued, const QString &updated)
782 {
783         emit UpdateDetail(package_id, updates, obsoletes, vendor_url, bugzilla_url, cve_url, restart, update_text,
784                 changelog, state, issued, updated);
785 }
786
787 void QPackageKitConnector::proxy_RequireRestart(const QString &type, const QString &details)
788 {
789         emit RequireRestart(type, details);
790 }
791
792 void QPackageKitConnector::proxy_Message(const QString &type, const QString &details)
793 {
794         emit Message(type, details);
795 }
796