← Back to branch summary

~renatofilho/buteo-syncfw/more-verbose

« back to all changes in this revision

Viewing changes to msyncd/ClientPluginRunner.cpp

  • Committer: Sergey Gerasimenko
  • Date: 2010-06-29 12:51:21 UTC
  • Revision ID: git-v1:cd8dab07b102ac96752ece4f3cde5fc62697d717
Initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
msyncd/ClientPluginRunner.cpp
 
1
/*
 
2
 * This file is part of buteo-syncfw package
 
3
 *
 
4
 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 
5
 *
 
6
 * Contact: Sateesh Kavuri <sateesh.kavuri@nokia.com>
 
7
 *
 
8
 * This library is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public License
 
10
 * version 2.1 as published by the Free Software Foundation.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful, but
 
13
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
15
 * Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public
 
18
 * License along with this library; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
20
 * 02110-1301 USA
 
21
 *
 
22
 */
 
23
 
 
24
 
 
25
#include "ClientPluginRunner.h"
 
26
#include "ClientThread.h"
 
27
#include "ClientPlugin.h"
 
28
#include "LogMacros.h"
 
29
#include "PluginManager.h"
 
30
 
 
31
using namespace Buteo;
 
32
 
 
33
// Maximum time in milliseconds to wait for a thread to stop
 
34
static const unsigned long long MAX_THREAD_STOP_WAIT_TIME = 5000;
 
35
 
 
36
ClientPluginRunner::ClientPluginRunner(const QString &aPluginName,
 
37
    SyncProfile *aProfile, PluginManager *aPluginMgr,
 
38
    PluginCbInterface *aPluginCbIf, QObject *aParent)
 
39
:   PluginRunner(PLUGIN_CLIENT, aPluginName, aPluginMgr, aPluginCbIf, aParent),
 
40
    iProfile(aProfile),
 
41
    iPlugin(0),
 
42
    iThread(0)
 
43
{
 
44
    FUNCTION_CALL_TRACE;
 
45
}
 
46
 
 
47
ClientPluginRunner::~ClientPluginRunner()
 
48
{
 
49
    FUNCTION_CALL_TRACE;
 
50
 
 
51
    disconnect();
 
52
 
 
53
    if (iPlugin != 0 && iPluginMgr != 0)
 
54
    {
 
55
        iPluginMgr->destroyClient(iPlugin);
 
56
        iPlugin = 0;
 
57
    }
 
58
 
 
59
    if (iThread != 0)
 
60
    {
 
61
        delete iThread;
 
62
        iThread = 0;
 
63
    }
 
64
}
 
65
 
 
66
bool ClientPluginRunner::init()
 
67
{
 
68
    FUNCTION_CALL_TRACE;
 
69
 
 
70
    if (iInitialized)
 
71
        return true;
 
72
 
 
73
    if (iPluginMgr == 0 || iPluginCbIf == 0 || iProfile == 0)
 
74
    {
 
75
        LOG_WARNING("Invalid members, failed to initialize");
 
76
        return false;
 
77
    }
 
78
 
 
79
    iPlugin = iPluginMgr->createClient(iPluginName, *iProfile, iPluginCbIf);
 
80
    if (iPlugin == 0)
 
81
    {
 
82
        LOG_WARNING("Failed to create client plug-in:" << iPluginName);
 
83
        return false;
 
84
    }
 
85
 
 
86
    iThread = new ClientThread();
 
87
    if (iThread == 0)
 
88
    {
 
89
        LOG_WARNING("Failed to create client thread");
 
90
        return false;
 
91
    }
 
92
 
 
93
    // Pass connectivity state change signal to the plug-in.
 
94
    connect(this, SIGNAL(connectivityStateChanged(Sync::ConnectivityType, bool)),
 
95
        iPlugin, SLOT(connectivityStateChanged(Sync::ConnectivityType, bool)));
 
96
 
 
97
    // Connect signals from the plug-in.
 
98
 
 
99
    connect(iPlugin, SIGNAL(transferProgress(const QString &, Sync::TransferDatabase, Sync::TransferType, const QString &)),
 
100
        this, SLOT(onTransferProgress(const QString &, Sync::TransferDatabase, Sync::TransferType, const QString &)));
 
101
 
 
102
    connect(iPlugin, SIGNAL(error(const QString &, const QString &, int)),
 
103
        this, SLOT(onError(const QString &, const QString &, int)));
 
104
 
 
105
    connect(iPlugin, SIGNAL(success(const QString &, const QString &)),
 
106
        this, SLOT(onSuccess(const QString &, const QString &)));
 
107
 
 
108
    connect(iPlugin, SIGNAL(accquiredStorage(const QString &)),
 
109
        this, SLOT(onStorageAccquired(const QString &)));
 
110
    // Connect signals from the thread.
 
111
 
 
112
    connect(iThread, SIGNAL(initError(const QString &, const QString &, int)),
 
113
        this, SLOT(onError(const QString &, const QString &, int)));
 
114
 
 
115
    connect(iThread, SIGNAL(terminated()), this, SLOT(onThreadExit()));
 
116
 
 
117
    connect(iThread, SIGNAL(finished()), this, SLOT(onThreadExit()));
 
118
 
 
119
    iInitialized = true;
 
120
 
 
121
    return true;
 
122
}
 
123
 
 
124
bool ClientPluginRunner::start()
 
125
{
 
126
    FUNCTION_CALL_TRACE;
 
127
 
 
128
    bool rv = false;
 
129
    if (iInitialized && iThread != 0)
 
130
    {
 
131
        rv = iThread->startThread(iPlugin);
 
132
    }
 
133
 
 
134
    return rv;
 
135
}
 
136
 
 
137
void ClientPluginRunner::stop()
 
138
{
 
139
    FUNCTION_CALL_TRACE;
 
140
 
 
141
    if (iThread != 0)
 
142
    {
 
143
        iThread->stopThread();
 
144
        iThread->wait();
 
145
    }
 
146
}
 
147
 
 
148
void ClientPluginRunner::abort()
 
149
{
 
150
    FUNCTION_CALL_TRACE;
 
151
 
 
152
    if (iPlugin != 0)
 
153
    {
 
154
        iPlugin->abortSync();
 
155
    }
 
156
}
 
157
 
 
158
SyncPluginBase *ClientPluginRunner::plugin()
 
159
{
 
160
    FUNCTION_CALL_TRACE;
 
161
 
 
162
    return iPlugin;
 
163
}
 
164
 
 
165
SyncResults ClientPluginRunner::syncResults()
 
166
{
 
167
    FUNCTION_CALL_TRACE;
 
168
 
 
169
    if (iPlugin != 0)
 
170
    {
 
171
        return iPlugin->getSyncResults();
 
172
    }
 
173
    else
 
174
    {
 
175
        return SyncResults();
 
176
    }
 
177
}
 
178
 
 
179
bool ClientPluginRunner::cleanUp()
 
180
{
 
181
    FUNCTION_CALL_TRACE;
 
182
 
 
183
    bool retval = false;
 
184
    if (iPlugin != 0)
 
185
    {
 
186
        retval = iPlugin->cleanUp();
 
187
    }
 
188
    return retval;
 
189
}
 
190
 
 
191
void ClientPluginRunner::onTransferProgress(const QString &aProfileName,
 
192
    Sync::TransferDatabase aDatabase, Sync::TransferType aType,
 
193
    const QString &aMimeType)
 
194
{
 
195
    FUNCTION_CALL_TRACE;
 
196
 
 
197
    emit transferProgress(aProfileName, aDatabase, aType, aMimeType);
 
198
}
 
199
 
 
200
void ClientPluginRunner::onError(const QString &aProfileName,
 
201
                                 const QString &aMessage, int aErrorCode)
 
202
{
 
203
    FUNCTION_CALL_TRACE;
 
204
 
 
205
    emit error(aProfileName, aMessage, aErrorCode);
 
206
    stop();
 
207
}
 
208
 
 
209
void ClientPluginRunner::onSuccess(const QString &aProfileName,
 
210
                                   const QString &aMessage)
 
211
{
 
212
    FUNCTION_CALL_TRACE;
 
213
 
 
214
    emit success(aProfileName, aMessage);
 
215
    stop();
 
216
 
 
217
}
 
218
 
 
219
void ClientPluginRunner::onStorageAccquired(const QString &aMimeType )
 
220
{
 
221
    FUNCTION_CALL_TRACE;
 
222
 
 
223
    emit storageAccquired(aMimeType);
 
224
}
 
225
 
 
226
void ClientPluginRunner::onThreadExit()
 
227
{
 
228
    FUNCTION_CALL_TRACE;
 
229
 
 
230
    emit done();
 
231
}
 
232