← Back to branch summary

~bzoltan/kubuntu-packaging/decouple_cmake_plugin

« back to all changes in this revision

Viewing changes to src/plugins/qnx/blackberryconfigurationmanager.cpp

  • Committer: Timo Jyrinki
  • Date: 2013-11-15 12:25:23 UTC
  • mfrom: (1.1.28)
  • Revision ID: timo.jyrinki@canonical.com-20131115122523-i2kyamsu4gs2mu1m
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/qnx/blackberryconfigurationmanager.cpp
 
1
/**************************************************************************
 
2
**
 
3
** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 
4
**
 
5
** Contact: BlackBerry (qt@blackberry.com)
 
6
** Contact: KDAB (info@kdab.com)
 
7
**
 
8
** This file is part of Qt Creator.
 
9
**
 
10
** Commercial License Usage
 
11
** Licensees holding valid commercial Qt licenses may use this file in
 
12
** accordance with the commercial license agreement provided with the
 
13
** Software or, alternatively, in accordance with the terms contained in
 
14
** a written agreement between you and Digia.  For licensing terms and
 
15
** conditions see http://qt.digia.com/licensing.  For further information
 
16
** use the contact form at http://qt.digia.com/contact-us.
 
17
**
 
18
** GNU Lesser General Public License Usage
 
19
** Alternatively, this file may be used under the terms of the GNU Lesser
 
20
** General Public License version 2.1 as published by the Free Software
 
21
** Foundation and appearing in the file LICENSE.LGPL included in the
 
22
** packaging of this file.  Please review the following information to
 
23
** ensure the GNU Lesser General Public License version 2.1 requirements
 
24
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
25
**
 
26
** In addition, as a special exception, Digia gives you certain additional
 
27
** rights.  These rights are described in the Digia Qt LGPL Exception
 
28
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
29
**
 
30
****************************************************************************/
 
31
 
 
32
#include "blackberryconfigurationmanager.h"
 
33
#include "blackberrycertificate.h"
 
34
#include "blackberryconfiguration.h"
 
35
 
 
36
#include "qnxutils.h"
 
37
 
 
38
#include <coreplugin/icore.h>
 
39
 
 
40
#include <utils/persistentsettings.h>
 
41
#include <utils/hostosinfo.h>
 
42
 
 
43
#include <projectexplorer/kit.h>
 
44
#include <projectexplorer/kitmanager.h>
 
45
#include <projectexplorer/kitinformation.h>
 
46
#include <projectexplorer/toolchainmanager.h>
 
47
 
 
48
#include <qtsupport/qtversionmanager.h>
 
49
#include <qtsupport/qtkitinformation.h>
 
50
 
 
51
#include <QMessageBox>
 
52
#include <QFileInfo>
 
53
 
 
54
using namespace ProjectExplorer;
 
55
 
 
56
namespace Qnx {
 
57
namespace Internal {
 
58
 
 
59
namespace {
 
60
const QLatin1String SettingsGroup("BlackBerryConfiguration");
 
61
const QLatin1String NDKLocationKey("NDKLocation"); // For 10.1 NDK support (< QTC 3.0)
 
62
const QLatin1String NDKEnvFileKey("NDKEnvFile");
 
63
const QLatin1String CertificateGroup("Certificates");
 
64
const QLatin1String ManualNDKsGroup("ManualNDKs");
 
65
const QLatin1String ActiveNDKsGroup("ActiveNDKs");
 
66
}
 
67
 
 
68
BlackBerryConfigurationManager::BlackBerryConfigurationManager(QObject *parent)
 
69
    :QObject(parent)
 
70
{
 
71
    connect(Core::ICore::instance(), SIGNAL(saveSettingsRequested()), this, SLOT(saveSettings()));
 
72
}
 
73
 
 
74
void BlackBerryConfigurationManager::loadManualConfigurations()
 
75
{
 
76
    QSettings *settings = Core::ICore::settings();
 
77
 
 
78
    settings->beginGroup(SettingsGroup);
 
79
    settings->beginGroup(ManualNDKsGroup);
 
80
 
 
81
    foreach (const QString &manualNdk, settings->childGroups()) {
 
82
        settings->beginGroup(manualNdk);
 
83
        QString ndkEnvPath = settings->value(NDKEnvFileKey).toString();
 
84
        // For 10.1 NDK support (< QTC 3.0):
 
85
        // Since QTC 3.0 BBConfigurations are based on the bbndk-env file
 
86
        // to support multiple targets per NDK
 
87
        if (ndkEnvPath.isEmpty()) {
 
88
            QString ndkPath = settings->value(NDKLocationKey).toString();
 
89
            ndkEnvPath = QnxUtils::envFilePath(ndkPath);
 
90
        }
 
91
 
 
92
        BlackBerryConfiguration *config = new BlackBerryConfiguration(Utils::FileName::fromString(ndkEnvPath),
 
93
                                                                      false);
 
94
        if (!addConfiguration(config))
 
95
            delete config;
 
96
 
 
97
        settings->endGroup();
 
98
    }
 
99
 
 
100
    settings->endGroup();
 
101
    settings->endGroup();
 
102
}
 
103
 
 
104
void BlackBerryConfigurationManager::loadAutoDetectedConfigurations()
 
105
{
 
106
    QStringList activePaths = activeConfigurationNdkEnvPaths();
 
107
    foreach (const NdkInstallInformation &ndkInfo, QnxUtils::installedNdks()) {
 
108
        QString envFilePath = QnxUtils::envFilePath(ndkInfo.path, ndkInfo.version);
 
109
        BlackBerryConfiguration *config = new BlackBerryConfiguration(Utils::FileName::fromString(envFilePath),
 
110
                                                                      true, ndkInfo.name);
 
111
        if (!addConfiguration(config)) {
 
112
            delete config;
 
113
            continue;
 
114
        }
 
115
 
 
116
        // Activate targets
 
117
        foreach (const QString activeNdkEnvPath, activePaths) {
 
118
            if (config->ndkEnvFile().toString() == activeNdkEnvPath)
 
119
                config->activate();
 
120
        }
 
121
    }
 
122
 
 
123
    // If no target was/is activated, activate one since it's needed by
 
124
    // device connection and CSK code.
 
125
    if (activeConfigurations().isEmpty() && !m_configs.isEmpty())
 
126
        m_configs.first()->activate();
 
127
}
 
128
 
 
129
QStringList BlackBerryConfigurationManager::activeConfigurationNdkEnvPaths()
 
130
{
 
131
    QStringList actives;
 
132
    QSettings *settings = Core::ICore::settings();
 
133
 
 
134
    settings->beginGroup(SettingsGroup);
 
135
    settings->beginGroup(ActiveNDKsGroup);
 
136
 
 
137
    foreach (const QString &activeNdkEnvPath, settings->childGroups()) {
 
138
        settings->beginGroup(activeNdkEnvPath);
 
139
        actives.append(settings->value(NDKEnvFileKey).toString());
 
140
        settings->endGroup();
 
141
    }
 
142
 
 
143
    settings->endGroup();
 
144
    settings->endGroup();
 
145
 
 
146
    return actives;
 
147
}
 
148
 
 
149
void BlackBerryConfigurationManager::saveManualConfigurations()
 
150
{
 
151
    if (manualConfigurations().isEmpty())
 
152
        return;
 
153
 
 
154
    QSettings *settings = Core::ICore::settings();
 
155
    settings->beginGroup(SettingsGroup);
 
156
    settings->beginGroup(ManualNDKsGroup);
 
157
 
 
158
    foreach (BlackBerryConfiguration *config, manualConfigurations()) {
 
159
        settings->beginGroup(config->displayName());
 
160
        settings->setValue(NDKEnvFileKey, config->ndkEnvFile().toString());
 
161
        settings->endGroup();
 
162
    }
 
163
 
 
164
    settings->endGroup();
 
165
    settings->endGroup();
 
166
}
 
167
 
 
168
void BlackBerryConfigurationManager::saveActiveConfigurationNdkEnvPath()
 
169
{
 
170
    if (activeConfigurations().isEmpty())
 
171
        return;
 
172
 
 
173
    QSettings *settings = Core::ICore::settings();
 
174
    settings->beginGroup(SettingsGroup);
 
175
    settings->beginGroup(ActiveNDKsGroup);
 
176
 
 
177
    settings->remove(QString());
 
178
 
 
179
    foreach (BlackBerryConfiguration *config, activeConfigurations()) {
 
180
        settings->beginGroup(config->displayName());
 
181
        settings->setValue(NDKEnvFileKey, config->ndkEnvFile().toString());
 
182
        settings->endGroup();
 
183
    }
 
184
 
 
185
    settings->endGroup();
 
186
    settings->endGroup();
 
187
}
 
188
 
 
189
// Remove no longer available/valid 'auto detected' BlackBerry kits and qt versions
 
190
void BlackBerryConfigurationManager::clearInvalidConfigurations()
 
191
{
 
192
    // Deregister invalid auto deteted BlackBerry Kits
 
193
    foreach (Kit *kit, KitManager::kits()) {
 
194
        if (!kit->isAutoDetected())
 
195
            continue;
 
196
 
 
197
        if (DeviceTypeKitInformation::deviceTypeId(kit) == Constants::QNX_BB_OS_TYPE
 
198
                && !kit->isValid())
 
199
        KitManager::deregisterKit(kit);
 
200
    }
 
201
 
 
202
    // Remove invalid auto detected BlackBerry qtVerions
 
203
    foreach (QtSupport::BaseQtVersion *qtVersion, QtSupport::QtVersionManager::versions()) {
 
204
        if (!qtVersion->isAutodetected())
 
205
            continue;
 
206
 
 
207
        if (qtVersion->platformName() == QLatin1String(Constants::QNX_BB_PLATFORM_NAME)
 
208
                && !qtVersion->isValid())
 
209
           QtSupport::QtVersionManager::removeVersion(qtVersion);
 
210
    }
 
211
}
 
212
 
 
213
bool BlackBerryConfigurationManager::addConfiguration(BlackBerryConfiguration *config)
 
214
{
 
215
    foreach (BlackBerryConfiguration *c, m_configs) {
 
216
        if (c->ndkPath() == config->ndkPath()
 
217
                && c->targetName() == config->targetName()) {
 
218
            if (!config->isAutoDetected())
 
219
                QMessageBox::warning(0, tr("NDK Already Known"),
 
220
                                 tr("The NDK already has a configuration."), QMessageBox::Ok);
 
221
            return false;
 
222
        }
 
223
    }
 
224
 
 
225
    if (config->isValid()) {
 
226
        m_configs.append(config);
 
227
        return true;
 
228
    }
 
229
 
 
230
    return false;
 
231
}
 
232
 
 
233
void BlackBerryConfigurationManager::removeConfiguration(BlackBerryConfiguration *config)
 
234
{
 
235
    if (!config)
 
236
        return;
 
237
 
 
238
    if (config->isActive())
 
239
        config->deactivate();
 
240
 
 
241
    clearConfigurationSettings(config);
 
242
 
 
243
    m_configs.removeAt(m_configs.indexOf(config));
 
244
    delete config;
 
245
}
 
246
 
 
247
QList<BlackBerryConfiguration *> BlackBerryConfigurationManager::configurations() const
 
248
{
 
249
    return m_configs;
 
250
}
 
251
 
 
252
QList<BlackBerryConfiguration *> BlackBerryConfigurationManager::manualConfigurations() const
 
253
{
 
254
    QList<BlackBerryConfiguration*> manuals;
 
255
    foreach (BlackBerryConfiguration *config, m_configs) {
 
256
        if (!config->isAutoDetected())
 
257
            manuals << config;
 
258
    }
 
259
 
 
260
    return manuals;
 
261
}
 
262
 
 
263
QList<BlackBerryConfiguration *> BlackBerryConfigurationManager::activeConfigurations() const
 
264
{
 
265
    QList<BlackBerryConfiguration*> actives;
 
266
    foreach (BlackBerryConfiguration *config, m_configs) {
 
267
        if (config->isActive())
 
268
            actives << config;
 
269
    }
 
270
 
 
271
    return actives;
 
272
}
 
273
 
 
274
BlackBerryConfiguration *BlackBerryConfigurationManager::configurationFromEnvFile(const Utils::FileName &envFile) const
 
275
{
 
276
    foreach (BlackBerryConfiguration *config, m_configs) {
 
277
        if (config->ndkEnvFile() == envFile)
 
278
            return config;
 
279
    }
 
280
 
 
281
    return 0;
 
282
}
 
283
 
 
284
// Returns a valid qnxEnv from a valid configuration;
 
285
// Needed by other classes to get blackberry process path (keys registration, debug token...)
 
286
QList<Utils::EnvironmentItem> BlackBerryConfigurationManager::defaultQnxEnv()
 
287
{
 
288
    foreach (BlackBerryConfiguration *config, m_configs) {
 
289
        if (config->isActive() && config->qnxEnv().size())
 
290
            return config->qnxEnv();
 
291
    }
 
292
 
 
293
    return QList<Utils::EnvironmentItem>();
 
294
}
 
295
 
 
296
void BlackBerryConfigurationManager::loadSettings()
 
297
{
 
298
    clearInvalidConfigurations();
 
299
    loadAutoDetectedConfigurations();
 
300
    loadManualConfigurations();
 
301
 
 
302
    emit settingsLoaded();
 
303
}
 
304
 
 
305
void BlackBerryConfigurationManager::clearConfigurationSettings(BlackBerryConfiguration *config)
 
306
{
 
307
    if (!config)
 
308
        return;
 
309
 
 
310
    QSettings *settings = Core::ICore::settings();
 
311
    settings->beginGroup(SettingsGroup);
 
312
    settings->beginGroup(ManualNDKsGroup);
 
313
 
 
314
    foreach (const QString &manualNdk, settings->childGroups()) {
 
315
        if (manualNdk == config->displayName()) {
 
316
            settings->remove(manualNdk);
 
317
            break;
 
318
        }
 
319
    }
 
320
 
 
321
    settings->endGroup();
 
322
    settings->endGroup();
 
323
}
 
324
 
 
325
void BlackBerryConfigurationManager::saveSettings()
 
326
{
 
327
    saveActiveConfigurationNdkEnvPath();
 
328
    saveManualConfigurations();
 
329
}
 
330
 
 
331
BlackBerryConfigurationManager &BlackBerryConfigurationManager::instance()
 
332
{
 
333
    if (m_instance == 0)
 
334
        m_instance = new BlackBerryConfigurationManager();
 
335
 
 
336
    return *m_instance;
 
337
}
 
338
 
 
339
BlackBerryConfigurationManager::~BlackBerryConfigurationManager()
 
340
{
 
341
    qDeleteAll(m_configs);
 
342
}
 
343
 
 
344
QString BlackBerryConfigurationManager::barsignerCskPath() const
 
345
{
 
346
    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.csk");
 
347
}
 
348
 
 
349
QString BlackBerryConfigurationManager::idTokenPath() const
 
350
{
 
351
    return QnxUtils::dataDirPath() + QLatin1String("/bbidtoken.csk");
 
352
}
 
353
 
 
354
QString BlackBerryConfigurationManager::barsignerDbPath() const
 
355
{
 
356
    return QnxUtils::dataDirPath() + QLatin1String("/barsigner.db");
 
357
}
 
358
 
 
359
QString BlackBerryConfigurationManager::defaultKeystorePath() const
 
360
{
 
361
    return QnxUtils::dataDirPath() + QLatin1String("/author.p12");
 
362
}
 
363
 
 
364
QString BlackBerryConfigurationManager::defaultDebugTokenPath() const
 
365
{
 
366
    return QnxUtils::dataDirPath() + QLatin1String("/debugtoken.bar");
 
367
}
 
368
 
 
369
BlackBerryConfigurationManager* BlackBerryConfigurationManager::m_instance = 0;
 
370
 
 
371
} // namespace Internal
 
372
} // namespace Qnx