← Back to branch summary

~ubuntuone-hackers/ubuntu-download-manager/vivid

« back to all changes in this revision

Viewing changes to src/downloads/client/ubuntu/download_manager/download_interface.h

  • Committer: CI Train Bot
  • Author(s): Manuel de la Pena, CI Train Bot
  • Date: 2015-09-22 15:27:23 UTC
  • mfrom: (338.2.14 vivid-add-appid-metadata)
  • Revision ID: ci-train-bot@canonical.com-20150922152723-gyk5ul6h0d4d0l0h
The download object now carries the app id of the application that created the download. Fixes: #1481673
Approved by: Alfonso Sanchez-Beato

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/downloads/client/ubuntu/download_manager/download_interface.h
2
2
 * This file was generated by qdbusxml2cpp version 0.8
3
3
 * Command line was: qdbusxml2cpp com.canonical.applications.download.xml -i metatypes.h -p download_interface -c DownloadInterface
4
4
 *
5
 
 * qdbusxml2cpp is Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
 
5
 * qdbusxml2cpp is Copyright (C) 2015 Digia Plc and/or its subsidiary(-ies).
6
6
 *
7
7
 * This is an auto-generated file.
8
8
 * Do not edit! All changes made to it will be lost.
9
9
 */
10
10
 
11
 
#ifndef DOWNLOAD_INTERFACE_H_1392136772
12
 
#define DOWNLOAD_INTERFACE_H_1392136772
 
11
#ifndef DOWNLOAD_INTERFACE_H_1442932929
 
12
#define DOWNLOAD_INTERFACE_H_1442932929
13
13
 
14
14
#include <QtCore/QObject>
15
15
#include <QtCore/QByteArray>
40
40
    inline QString clickPackage() const
41
41
    { return qvariant_cast< QString >(property("ClickPackage")); }
42
42
 
 
43
    Q_PROPERTY(QString DestinationApp READ destinationApp)
 
44
    inline QString destinationApp() const
 
45
    { return qvariant_cast< QString >(property("DestinationApp")); }
 
46
 
43
47
    Q_PROPERTY(bool ShowInIndicator READ showInIndicator)
44
48
    inline bool showInIndicator() const
45
49
    { return qvariant_cast< bool >(property("ShowInIndicator")); }
53
57
    {
54
58
        QList<QVariant> argumentList;
55
59
        argumentList << QVariant::fromValue(allowed);
56
 
        return asyncCallWithArgumentList(QLatin1String("allowGSMDownload"), argumentList);
 
60
        return asyncCallWithArgumentList(QStringLiteral("allowGSMDownload"), argumentList);
57
61
    }
58
62
 
59
63
    inline QDBusPendingReply<> cancel()
60
64
    {
61
65
        QList<QVariant> argumentList;
62
 
        return asyncCallWithArgumentList(QLatin1String("cancel"), argumentList);
 
66
        return asyncCallWithArgumentList(QStringLiteral("cancel"), argumentList);
63
67
    }
64
68
 
65
69
    inline QDBusPendingReply<StringMap> headers()
66
70
    {
67
71
        QList<QVariant> argumentList;
68
 
        return asyncCallWithArgumentList(QLatin1String("headers"), argumentList);
 
72
        return asyncCallWithArgumentList(QStringLiteral("headers"), argumentList);
69
73
    }
70
74
 
71
75
    inline QDBusPendingReply<bool> isGSMDownloadAllowed()
72
76
    {
73
77
        QList<QVariant> argumentList;
74
 
        return asyncCallWithArgumentList(QLatin1String("isGSMDownloadAllowed"), argumentList);
 
78
        return asyncCallWithArgumentList(QStringLiteral("isGSMDownloadAllowed"), argumentList);
75
79
    }
76
80
 
77
81
    inline QDBusPendingReply<QVariantMap> metadata()
78
82
    {
79
83
        QList<QVariant> argumentList;
80
 
        return asyncCallWithArgumentList(QLatin1String("metadata"), argumentList);
 
84
        return asyncCallWithArgumentList(QStringLiteral("metadata"), argumentList);
81
85
    }
82
86
 
83
87
    inline QDBusPendingReply<> pause()
84
88
    {
85
89
        QList<QVariant> argumentList;
86
 
        return asyncCallWithArgumentList(QLatin1String("pause"), argumentList);
 
90
        return asyncCallWithArgumentList(QStringLiteral("pause"), argumentList);
87
91
    }
88
92
 
89
93
    inline QDBusPendingReply<qulonglong> progress()
90
94
    {
91
95
        QList<QVariant> argumentList;
92
 
        return asyncCallWithArgumentList(QLatin1String("progress"), argumentList);
 
96
        return asyncCallWithArgumentList(QStringLiteral("progress"), argumentList);
93
97
    }
94
98
 
95
99
    inline QDBusPendingReply<> resume()
96
100
    {
97
101
        QList<QVariant> argumentList;
98
 
        return asyncCallWithArgumentList(QLatin1String("resume"), argumentList);
 
102
        return asyncCallWithArgumentList(QStringLiteral("resume"), argumentList);
99
103
    }
100
104
 
101
105
    inline QDBusPendingReply<> setDestinationDir(const QString &path)
102
106
    {
103
107
        QList<QVariant> argumentList;
104
108
        argumentList << QVariant::fromValue(path);
105
 
        return asyncCallWithArgumentList(QLatin1String("setDestinationDir"), argumentList);
 
109
        return asyncCallWithArgumentList(QStringLiteral("setDestinationDir"), argumentList);
106
110
    }
107
111
 
108
112
    inline QDBusPendingReply<> setHeaders(StringMap headers)
109
113
    {
110
114
        QList<QVariant> argumentList;
111
115
        argumentList << QVariant::fromValue(headers);
112
 
        return asyncCallWithArgumentList(QLatin1String("setHeaders"), argumentList);
 
116
        return asyncCallWithArgumentList(QStringLiteral("setHeaders"), argumentList);
113
117
    }
114
118
 
115
119
    inline QDBusPendingReply<> setMetadata(const QVariantMap &data)
116
120
    {
117
121
        QList<QVariant> argumentList;
118
122
        argumentList << QVariant::fromValue(data);
119
 
        return asyncCallWithArgumentList(QLatin1String("setMetadata"), argumentList);
 
123
        return asyncCallWithArgumentList(QStringLiteral("setMetadata"), argumentList);
120
124
    }
121
125
 
122
126
    inline QDBusPendingReply<> setThrottle(qulonglong speed)
123
127
    {
124
128
        QList<QVariant> argumentList;
125
129
        argumentList << QVariant::fromValue(speed);
126
 
        return asyncCallWithArgumentList(QLatin1String("setThrottle"), argumentList);
 
130
        return asyncCallWithArgumentList(QStringLiteral("setThrottle"), argumentList);
127
131
    }
128
132
 
129
133
    inline QDBusPendingReply<> start()
130
134
    {
131
135
        QList<QVariant> argumentList;
132
 
        return asyncCallWithArgumentList(QLatin1String("start"), argumentList);
 
136
        return asyncCallWithArgumentList(QStringLiteral("start"), argumentList);
133
137
    }
134
138
 
135
139
    inline QDBusPendingReply<qulonglong> throttle()
136
140
    {
137
141
        QList<QVariant> argumentList;
138
 
        return asyncCallWithArgumentList(QLatin1String("throttle"), argumentList);
 
142
        return asyncCallWithArgumentList(QStringLiteral("throttle"), argumentList);
139
143
    }
140
144
 
141
145
    inline QDBusPendingReply<qulonglong> totalSize()
142
146
    {
143
147
        QList<QVariant> argumentList;
144
 
        return asyncCallWithArgumentList(QLatin1String("totalSize"), argumentList);
 
148
        return asyncCallWithArgumentList(QStringLiteral("totalSize"), argumentList);
145
149
    }
146
150
 
147
151
Q_SIGNALS: // SIGNALS
149
153
    void canceled(bool success);
150
154
    void error(const QString &error);
151
155
    void finished(const QString &path);
 
156
    void hashError(HashErrorStruct error);
152
157
    void httpError(HttpErrorStruct error);
153
158
    void networkError(NetworkErrorStruct error);
154
159
    void paused(bool success);