1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 BogDan Vatra <bog_dan_ro@yahoo.com>
4 ** Copyright (C) 2016 The Qt Company Ltd.
5 ** Contact: https://www.qt.io/licensing/
6 **
7 ** This file is part of Qt Creator.
8 **
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see https://www.qt.io/terms-conditions. For further
15 ** information use the contact form at https://www.qt.io/contact-us.
16 **
17 ** GNU General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU
19 ** General Public License version 3 as published by the Free Software
20 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
21 ** included in the packaging of this file. Please review the following
22 ** information to ensure the GNU General Public License requirements will
23 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
24 **
25 ****************************************************************************/
26 
27 #include "androidbuildapkstep.h"
28 
29 #include "androidconfigurations.h"
30 #include "androidconstants.h"
31 #include "androidcreatekeystorecertificate.h"
32 #include "androidextralibrarylistmodel.h"
33 #include "androidmanager.h"
34 #include "androidqtversion.h"
35 #include "androidsdkmanager.h"
36 #include "certificatesmodel.h"
37 #include "createandroidmanifestwizard.h"
38 
39 #include "javaparser.h"
40 
41 #include <coreplugin/fileutils.h>
42 #include <coreplugin/icore.h>
43 
44 #include <projectexplorer/buildconfiguration.h>
45 #include <projectexplorer/buildstep.h>
46 #include <projectexplorer/buildsteplist.h>
47 #include <projectexplorer/buildsystem.h>
48 #include <projectexplorer/processparameters.h>
49 #include <projectexplorer/projectexplorerconstants.h>
50 #include <projectexplorer/project.h>
51 #include <projectexplorer/projectnodes.h>
52 #include <projectexplorer/target.h>
53 #include <projectexplorer/taskhub.h>
54 
55 #include <qtsupport/qtkitinformation.h>
56 
57 #include <utils/algorithm.h>
58 #include <utils/fancylineedit.h>
59 #include <utils/infolabel.h>
60 #include <utils/pathchooser.h>
61 #include <utils/qtcprocess.h>
62 
63 #include <QCheckBox>
64 #include <QComboBox>
65 #include <QDateTime>
66 #include <QDialogButtonBox>
67 #include <QFileDialog>
68 #include <QFormLayout>
69 #include <QGroupBox>
70 #include <QHBoxLayout>
71 #include <QJsonDocument>
72 #include <QJsonObject>
73 #include <QLabel>
74 #include <QLineEdit>
75 #include <QListView>
76 #include <QLoggingCategory>
77 #include <QMessageBox>
78 #include <QProcess>
79 #include <QPushButton>
80 #include <QTimer>
81 #include <QToolButton>
82 #include <QVBoxLayout>
83 
84 #include <algorithm>
85 #include <memory>
86 
87 using namespace ProjectExplorer;
88 using namespace QtSupport;
89 using namespace Utils;
90 
91 namespace Android {
92 namespace Internal {
93 
94 static Q_LOGGING_CATEGORY(buildapkstepLog, "qtc.android.build.androidbuildapkstep", QtWarningMsg)
95 
96 const char KeystoreLocationKey[] = "KeystoreLocation";
97 const char BuildTargetSdkKey[] = "BuildTargetSdk";
98 const char VerboseOutputKey[] = "VerboseOutput";
99 
100 class PasswordInputDialog : public QDialog
101 {
102     Q_DECLARE_TR_FUNCTIONS(Android::Internal::AndroidBuildApkStep)
103 
104 public:
105     enum Context{
106       KeystorePassword = 1,
107       CertificatePassword
108     };
109 
110     PasswordInputDialog(Context context, std::function<bool (const QString &)> callback,
111                         const QString &extraContextStr, QWidget *parent = nullptr);
112 
113     static QString getPassword(Context context, std::function<bool (const QString &)> callback,
114                                const QString &extraContextStr, bool *ok = nullptr,
115                                QWidget *parent = nullptr);
116 
117 private:
__anonaa514c360102(const QString &) 118     std::function<bool (const QString &)> verifyCallback = [](const QString &) { return true; };
119     QLabel *inputContextlabel = new QLabel(this);
120     QLineEdit *inputEdit = new QLineEdit(this);
121     Utils::InfoLabel *warningLabel = new Utils::InfoLabel(tr("Incorrect password."),
122                                                           Utils::InfoLabel::Warning, this);
123     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
124                                                        this);
125 };
126 
127 // AndroidBuildApkWidget
128 
129 class AndroidBuildApkWidget : public QWidget
130 {
131     Q_DECLARE_TR_FUNCTIONS(Android::Internal::AndroidBuildApkStep)
132 
133 public:
134     explicit AndroidBuildApkWidget(AndroidBuildApkStep *step);
135 
136 private:
137     void setCertificates();
138     void updateSigningWarning();
139     void signPackageCheckBoxToggled(bool checked);
140     void onOpenSslCheckBoxChanged();
141     bool isOpenSslLibsIncluded();
142     QString openSslIncludeFileContent(const FilePath &projectPath);
143 
144     QWidget *createApplicationGroup();
145     QWidget *createSignPackageGroup();
146     QWidget *createAdvancedGroup();
147     QWidget *createAdditionalLibrariesGroup();
148 
149 private:
150     AndroidBuildApkStep *m_step = nullptr;
151     QCheckBox *m_signPackageCheckBox = nullptr;
152     InfoLabel *m_signingDebugWarningLabel = nullptr;
153     QComboBox *m_certificatesAliasComboBox = nullptr;
154     QCheckBox *m_addDebuggerCheckBox = nullptr;
155     QCheckBox *m_openSslCheckBox = nullptr;
156 };
157 
AndroidBuildApkWidget(AndroidBuildApkStep * step)158 AndroidBuildApkWidget::AndroidBuildApkWidget(AndroidBuildApkStep *step)
159     : m_step(step)
160 {
161     auto vbox = new QVBoxLayout(this);
162     vbox->addWidget(createSignPackageGroup());
163     vbox->addWidget(createApplicationGroup());
164     vbox->addWidget(createAdvancedGroup());
165     vbox->addWidget(createAdditionalLibrariesGroup());
166 
167     connect(m_step->buildConfiguration(), &BuildConfiguration::buildTypeChanged,
168             this, &AndroidBuildApkWidget::updateSigningWarning);
169 
170     connect(m_signPackageCheckBox, &QAbstractButton::clicked,
171             m_addDebuggerCheckBox, &QWidget::setEnabled);
172 
173     signPackageCheckBoxToggled(m_step->signPackage());
174     updateSigningWarning();
175 }
176 
createApplicationGroup()177 QWidget *AndroidBuildApkWidget::createApplicationGroup()
178 {
179     QtSupport::BaseQtVersion *qt = QtSupport::QtKitAspect::qtVersion(m_step->target()->kit());
180     const int minApiSupported = AndroidManager::defaultMinimumSDK(qt);
181     QStringList targets = AndroidConfig::apiLevelNamesFor(AndroidConfigurations::sdkManager()->
182                                                           filteredSdkPlatforms(minApiSupported));
183     targets.removeDuplicates();
184 
185     auto group = new QGroupBox(tr("Application"), this);
186 
187     auto targetSDKComboBox = new QComboBox();
188     targetSDKComboBox->addItems(targets);
189     targetSDKComboBox->setCurrentIndex(targets.indexOf(m_step->buildTargetSdk()));
190 
191     const auto cbActivated = QOverload<int>::of(&QComboBox::activated);
192     connect(targetSDKComboBox, cbActivated, this, [this, targetSDKComboBox](int idx) {
193        const QString sdk = targetSDKComboBox->itemText(idx);
194        m_step->setBuildTargetSdk(sdk);
195        AndroidManager::updateGradleProperties(m_step->target(), QString()); // FIXME: Use real key.
196    });
197 
198     auto formLayout = new QFormLayout(group);
199     formLayout->addRow(tr("Android build SDK:"), targetSDKComboBox);
200 
201     auto createAndroidTemplatesButton = new QPushButton(tr("Create Templates"));
202     createAndroidTemplatesButton->setToolTip(
203         tr("Create an Android package for Custom Java code, assets, and Gradle configurations."));
204     connect(createAndroidTemplatesButton, &QAbstractButton::clicked, this, [this] {
205         CreateAndroidManifestWizard wizard(m_step->buildSystem());
206         wizard.exec();
207     });
208 
209     formLayout->addRow(tr("Android customization:"), createAndroidTemplatesButton);
210 
211     return group;
212 }
213 
createSignPackageGroup()214 QWidget *AndroidBuildApkWidget::createSignPackageGroup()
215 {
216     QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
217     sizePolicy.setHorizontalStretch(0);
218     sizePolicy.setVerticalStretch(0);
219 
220     auto group = new QGroupBox(tr("Application Signature"), this);
221 
222     auto keystoreLocationLabel = new QLabel(tr("Keystore:"), group);
223     keystoreLocationLabel->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
224 
225     auto keystoreLocationChooser = new PathChooser(group);
226     keystoreLocationChooser->setExpectedKind(PathChooser::File);
227     keystoreLocationChooser->lineEdit()->setReadOnly(true);
228     keystoreLocationChooser->setPath(m_step->keystorePath().toUserOutput());
229     keystoreLocationChooser->setInitialBrowsePathBackup(FileUtils::homePath());
230     keystoreLocationChooser->setPromptDialogFilter(tr("Keystore files (*.keystore *.jks)"));
231     keystoreLocationChooser->setPromptDialogTitle(tr("Select Keystore File"));
232     connect(keystoreLocationChooser, &PathChooser::pathChanged, this, [this](const QString &path) {
233         FilePath file = FilePath::fromString(path);
234         m_step->setKeystorePath(file);
235         m_signPackageCheckBox->setChecked(!file.isEmpty());
236         if (!file.isEmpty())
237             setCertificates();
238     });
239 
240     auto keystoreCreateButton = new QPushButton(tr("Create..."), group);
241     connect(keystoreCreateButton, &QAbstractButton::clicked, this, [this, keystoreLocationChooser] {
242         AndroidCreateKeystoreCertificate d;
243         if (d.exec() != QDialog::Accepted)
244             return;
245         keystoreLocationChooser->setPath(d.keystoreFilePath().toUserOutput());
246         m_step->setKeystorePath(d.keystoreFilePath());
247         m_step->setKeystorePassword(d.keystorePassword());
248         m_step->setCertificateAlias(d.certificateAlias());
249         m_step->setCertificatePassword(d.certificatePassword());
250         setCertificates();
251     });
252 
253     m_signPackageCheckBox = new QCheckBox(tr("Sign package"), group);
254     m_signPackageCheckBox->setChecked(m_step->signPackage());
255 
256     m_signingDebugWarningLabel = new Utils::InfoLabel(tr("Signing a debug package"),
257                                                       Utils::InfoLabel::Warning, group);
258     m_signingDebugWarningLabel->hide();
259 
260     auto certificateAliasLabel = new QLabel(tr("Certificate alias:"), group);
261     certificateAliasLabel->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
262 
263     m_certificatesAliasComboBox = new QComboBox(group);
264     m_certificatesAliasComboBox->setEnabled(false);
265     QSizePolicy sizePolicy2(QSizePolicy::Fixed, QSizePolicy::Fixed);
266     sizePolicy2.setHorizontalStretch(0);
267     sizePolicy2.setVerticalStretch(0);
268     m_certificatesAliasComboBox->setSizePolicy(sizePolicy2);
269     m_certificatesAliasComboBox->setMinimumSize(QSize(300, 0));
270 
271     auto horizontalLayout_2 = new QHBoxLayout;
272     horizontalLayout_2->addWidget(keystoreLocationLabel);
273     horizontalLayout_2->addWidget(keystoreLocationChooser);
274     horizontalLayout_2->addWidget(keystoreCreateButton);
275 
276     auto horizontalLayout_3 = new QHBoxLayout;
277     horizontalLayout_3->addWidget(m_signingDebugWarningLabel);
278     horizontalLayout_3->addWidget(certificateAliasLabel);
279     horizontalLayout_3->addWidget(m_certificatesAliasComboBox);
280 
281     auto vbox = new QVBoxLayout(group);
282     vbox->addLayout(horizontalLayout_2);
283     vbox->addWidget(m_signPackageCheckBox);
284     vbox->addLayout(horizontalLayout_3);
285 
286     connect(m_signPackageCheckBox, &QAbstractButton::toggled,
287             this, &AndroidBuildApkWidget::signPackageCheckBoxToggled);
288 
289     auto updateAlias = [this](int idx) {
290         QString alias = m_certificatesAliasComboBox->itemText(idx);
291         if (!alias.isEmpty())
292             m_step->setCertificateAlias(alias);
293     };
294 
295     const auto cbActivated = QOverload<int>::of(&QComboBox::activated);
296     const auto cbCurrentIndexChanged = QOverload<int>::of(&QComboBox::currentIndexChanged);
297 
298     connect(m_certificatesAliasComboBox, cbActivated, this, updateAlias);
299     connect(m_certificatesAliasComboBox, cbCurrentIndexChanged, this, updateAlias);
300 
301     return group;
302 }
303 
createAdvancedGroup()304 QWidget *AndroidBuildApkWidget::createAdvancedGroup()
305 {
306     auto group = new QGroupBox(tr("Advanced Actions"), this);
307 
308     auto openPackageLocationCheckBox = new QCheckBox(tr("Open package location after build"), group);
309     openPackageLocationCheckBox->setChecked(m_step->openPackageLocation());
310     connect(openPackageLocationCheckBox, &QAbstractButton::toggled,
311             this, [this](bool checked) { m_step->setOpenPackageLocation(checked); });
312 
313     m_addDebuggerCheckBox = new QCheckBox(tr("Add debug server"), group);
314     m_addDebuggerCheckBox->setEnabled(false);
315     m_addDebuggerCheckBox->setToolTip(tr("Packages debug server with "
316            "the APK to enable debugging. For the signed APK this option is unchecked by default."));
317     m_addDebuggerCheckBox->setChecked(m_step->addDebugger());
318     connect(m_addDebuggerCheckBox, &QAbstractButton::toggled,
319             m_step, &AndroidBuildApkStep::setAddDebugger);
320 
321     auto verboseOutputCheckBox = new QCheckBox(tr("Verbose output"), group);
322     verboseOutputCheckBox->setChecked(m_step->verboseOutput());
323 
324     auto vbox = new QVBoxLayout(group);
325     QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(m_step->kit());
326     if (version && version->qtVersion() >= QtSupport::QtVersionNumber{5, 14}) {
327         auto buildAAB = new QCheckBox(tr("Build Android App Bundle (*.aab)"), group);
328         buildAAB->setChecked(m_step->buildAAB());
329         connect(buildAAB, &QAbstractButton::toggled, m_step, &AndroidBuildApkStep::setBuildAAB);
330         vbox->addWidget(buildAAB);
331     }
332     vbox->addWidget(openPackageLocationCheckBox);
333     vbox->addWidget(verboseOutputCheckBox);
334     vbox->addWidget(m_addDebuggerCheckBox);
335 
336     connect(verboseOutputCheckBox, &QAbstractButton::toggled,
337             this, [this](bool checked) { m_step->setVerboseOutput(checked); });
338 
339     return group;
340 }
341 
createAdditionalLibrariesGroup()342 QWidget *AndroidBuildApkWidget::createAdditionalLibrariesGroup()
343 {
344     auto group = new QGroupBox(tr("Additional Libraries"));
345     group->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
346 
347     auto libsModel = new AndroidExtraLibraryListModel(m_step->buildSystem(), this);
348     connect(libsModel, &AndroidExtraLibraryListModel::enabledChanged, this,
349             [this, group](const bool enabled) {
350                 group->setEnabled(enabled);
351                 m_openSslCheckBox->setChecked(isOpenSslLibsIncluded());
352     });
353 
354     auto libsView = new QListView;
355     libsView->setSelectionMode(QAbstractItemView::ExtendedSelection);
356     libsView->setToolTip(tr("List of extra libraries to include in Android package and load on startup."));
357     libsView->setModel(libsModel);
358 
359     auto addLibButton = new QToolButton;
360     addLibButton->setText(tr("Add..."));
361     addLibButton->setToolTip(tr("Select library to include in package."));
362     addLibButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
363     addLibButton->setToolButtonStyle(Qt::ToolButtonTextOnly);
364     connect(addLibButton, &QAbstractButton::clicked, this, [this, libsModel] {
365         QStringList fileNames = QFileDialog::getOpenFileNames(this,
366                                                               tr("Select additional libraries"),
367                                                               QDir::homePath(),
368                                                               tr("Libraries (*.so)"));
369         if (!fileNames.isEmpty())
370             libsModel->addEntries(fileNames);
371     });
372 
373     auto removeLibButton = new QToolButton;
374     removeLibButton->setText(tr("Remove"));
375     removeLibButton->setToolTip(tr("Remove currently selected library from list."));
376     connect(removeLibButton, &QAbstractButton::clicked, this, [libsModel, libsView] {
377         QModelIndexList removeList = libsView->selectionModel()->selectedIndexes();
378         libsModel->removeEntries(removeList);
379     });
380 
381     auto libsButtonLayout = new QVBoxLayout;
382     libsButtonLayout->addWidget(addLibButton);
383     libsButtonLayout->addWidget(removeLibButton);
384     libsButtonLayout->addStretch(1);
385 
386     m_openSslCheckBox = new QCheckBox(tr("Include prebuilt OpenSSL libraries"));
387     m_openSslCheckBox->setToolTip(tr("This is useful for apps that use SSL operations. The path "
388                                      "can be defined in Tools > Options > Devices > Android."));
389     connect(m_openSslCheckBox, &QAbstractButton::clicked, this,
390             &AndroidBuildApkWidget::onOpenSslCheckBoxChanged);
391 
392     auto grid = new QGridLayout(group);
393     grid->addWidget(m_openSslCheckBox, 0, 0);
394     grid->addWidget(libsView, 1, 0);
395     grid->addLayout(libsButtonLayout, 1, 1);
396 
397     QItemSelectionModel *libSelection = libsView->selectionModel();
398     connect(libSelection, &QItemSelectionModel::selectionChanged, this, [libSelection, removeLibButton] {
399         removeLibButton->setEnabled(libSelection->hasSelection());
400     });
401 
402     Target *target = m_step->target();
403     const QString buildKey = target->activeBuildKey();
404     const ProjectNode *node = target->project()->findNodeForBuildKey(buildKey);
405     group->setEnabled(node && !node->parseInProgress());
406 
407     return group;
408 }
409 
signPackageCheckBoxToggled(bool checked)410 void AndroidBuildApkWidget::signPackageCheckBoxToggled(bool checked)
411 {
412     m_certificatesAliasComboBox->setEnabled(checked);
413     m_step->setSignPackage(checked);
414     m_addDebuggerCheckBox->setChecked(!checked);
415     updateSigningWarning();
416     if (!checked)
417         return;
418     if (!m_step->keystorePath().isEmpty())
419         setCertificates();
420 }
421 
onOpenSslCheckBoxChanged()422 void AndroidBuildApkWidget::onOpenSslCheckBoxChanged()
423 {
424     Utils::FilePath projectPath = m_step->buildConfiguration()->buildSystem()->projectFilePath();
425     QFile projectFile(projectPath.toString());
426     if (!projectFile.open(QIODevice::ReadWrite | QIODevice::Text)) {
427         qWarning() << "Cound't open project file to add OpenSSL extra libs: " << projectPath;
428         return;
429     }
430 
431     const QString searchStr = openSslIncludeFileContent(projectPath);
432     QTextStream textStream(&projectFile);
433 
434     QString fileContent = textStream.readAll();
435     if (!m_openSslCheckBox->isChecked()) {
436         fileContent.remove("\n" + searchStr);
437     } else if (!fileContent.contains(searchStr, Qt::CaseSensitive)) {
438         fileContent.append(searchStr + "\n");
439     }
440 
441     projectFile.resize(0);
442     textStream << fileContent;
443     projectFile.close();
444 }
445 
isOpenSslLibsIncluded()446 bool AndroidBuildApkWidget::isOpenSslLibsIncluded()
447 {
448     Utils::FilePath projectPath = m_step->buildConfiguration()->buildSystem()->projectFilePath();
449     const QString searchStr = openSslIncludeFileContent(projectPath);
450     QFile projectFile(projectPath.toString());
451     projectFile.open(QIODevice::ReadOnly);
452     QTextStream textStream(&projectFile);
453     QString fileContent = textStream.readAll();
454     projectFile.close();
455     return fileContent.contains(searchStr, Qt::CaseSensitive);
456 }
457 
openSslIncludeFileContent(const FilePath & projectPath)458 QString AndroidBuildApkWidget::openSslIncludeFileContent(const FilePath &projectPath)
459 {
460     QString openSslPath = AndroidConfigurations::currentConfig().openSslLocation().toString();
461     if (projectPath.endsWith(".pro"))
462         return "android: include(" + openSslPath + "/openssl.pri)";
463     if (projectPath.endsWith("CMakeLists.txt"))
464         return "if (ANDROID)\n    include(" + openSslPath + "/CMakeLists.txt)\nendif()";
465 
466     return QString();
467 }
468 
setCertificates()469 void AndroidBuildApkWidget::setCertificates()
470 {
471     QAbstractItemModel *certificates = m_step->keystoreCertificates();
472     if (certificates) {
473         m_signPackageCheckBox->setChecked(certificates);
474         m_certificatesAliasComboBox->setModel(certificates);
475     }
476 }
477 
updateSigningWarning()478 void AndroidBuildApkWidget::updateSigningWarning()
479 {
480     bool nonRelease = m_step->buildType() != BuildConfiguration::Release;
481     bool visible = m_step->signPackage() && nonRelease;
482     m_signingDebugWarningLabel->setVisible(visible);
483 }
484 
485 // AndroidBuildApkStep
486 
AndroidBuildApkStep(BuildStepList * parent,Utils::Id id)487 AndroidBuildApkStep::AndroidBuildApkStep(BuildStepList *parent, Utils::Id id)
488     : AbstractProcessStep(parent, id),
489       m_buildTargetSdk(AndroidConfig::apiLevelNameFor(AndroidConfigurations::
490                                          sdkManager()->latestAndroidSdkPlatform()))
491 {
492     setImmutable(true);
493     setDisplayName(tr("Build Android APK"));
494 }
495 
init()496 bool AndroidBuildApkStep::init()
497 {
498     if (!AbstractProcessStep::init())
499         return false;
500 
501     if (m_signPackage) {
502         qCDebug(buildapkstepLog) << "Signing enabled";
503         // check keystore and certificate passwords
504         if (!verifyKeystorePassword() || !verifyCertificatePassword()) {
505             qCDebug(buildapkstepLog) << "Init failed. Keystore/Certificate password verification failed.";
506             return false;
507         }
508 
509         if (buildType() != BuildConfiguration::Release) {
510             const QString error = tr("Warning: Signing a debug or profile package.");
511             emit addOutput(error, OutputFormat::ErrorMessage);
512             TaskHub::addTask(BuildSystemTask(Task::Warning, error));
513         }
514     }
515 
516     QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(kit());
517     if (!version)
518         return false;
519 
520     const QVersionNumber sdkToolsVersion = AndroidConfigurations::currentConfig().sdkToolsVersion();
521     if (sdkToolsVersion >= QVersionNumber(25, 3, 0)
522         || AndroidConfigurations::currentConfig().isCmdlineSdkToolsInstalled()) {
523         if (!version->sourcePath().pathAppended("src/3rdparty/gradle").exists()) {
524             const QString error
525                 = tr("The installed SDK tools version (%1) does not include Gradle "
526                      "scripts. The minimum Qt version required for Gradle build to work "
527                      "is %2")
528                       .arg(sdkToolsVersion.toString())
529                       .arg("5.9.0/5.6.3");
530             emit addOutput(error, OutputFormat::Stderr);
531             TaskHub::addTask(BuildSystemTask(Task::Error, error));
532             return false;
533         }
534     } else if (version->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0)) {
535         const QString error = tr("The minimum Qt version required for Gradle build to work is %1. "
536                                  "It is recommended to install the latest Qt version.")
537                                   .arg("5.4.0");
538         emit addOutput(error, OutputFormat::Stderr);
539         TaskHub::addTask(BuildSystemTask(Task::Error, error));
540         return false;
541     }
542 
543     const int minSDKForKit = AndroidManager::minimumSDK(kit());
544     if (AndroidManager::minimumSDK(target()) < minSDKForKit) {
545         const QString error
546             = tr("The API level set for the APK is less than the minimum required by the kit."
547                  "\nThe minimum API level required by the kit is %1.")
548                   .arg(minSDKForKit);
549         emit addOutput(error, OutputFormat::Stderr);
550         TaskHub::addTask(BuildSystemTask(Task::Error, error));
551         return false;
552     }
553 
554     m_openPackageLocationForRun = m_openPackageLocation;
555     const FilePath outputDir = AndroidManager::androidBuildDirectory(target());
556 
557     if (m_buildAAB) {
558         const QString bt = buildType() == BuildConfiguration::Release ? QLatin1String("release")
559                                                                       : QLatin1String("debug");
560         m_packagePath = outputDir.pathAppended(
561                     QString("build/outputs/bundle/%1/android-build-%1.aab").arg(bt)).toString();
562     } else {
563         m_packagePath = AndroidManager::apkPath(target()).toString();
564     }
565 
566     qCDebug(buildapkstepLog) << "APK or AAB path:" << m_packagePath;
567 
568     QString command = version->hostBinPath().toString();
569     if (!command.endsWith('/'))
570         command += '/';
571     command += Utils::HostOsInfo::withExecutableSuffix("androiddeployqt");
572 
573     m_inputFile = AndroidQtVersion::androidDeploymentSettings(target()).toString();
574     if (m_inputFile.isEmpty()) {
575         qCDebug(buildapkstepLog) << "no input file" << target()->activeBuildKey();
576         m_skipBuilding = true;
577         return true;
578     }
579     m_skipBuilding = false;
580 
581     if (m_buildTargetSdk.isEmpty()) {
582         const QString error = tr("Android build SDK not defined. Check Android settings.");
583         emit addOutput(error, OutputFormat::Stderr);
584         TaskHub::addTask(BuildSystemTask(Task::Error, error));
585         return false;
586     }
587 
588     QStringList arguments = {"--input", m_inputFile,
589                              "--output", outputDir.toString(),
590                              "--android-platform", m_buildTargetSdk,
591                              "--jdk", AndroidConfigurations::currentConfig().openJDKLocation().toString()};
592 
593     if (m_verbose)
594         arguments << "--verbose";
595 
596     arguments << "--gradle";
597 
598     if (m_buildAAB)
599         arguments << "--aab" <<  "--jarsigner";
600 
601     QStringList argumentsPasswordConcealed = arguments;
602 
603     if (m_signPackage) {
604         arguments << "--sign" << m_keystorePath.toString() << m_certificateAlias
605                   << "--storepass" << m_keystorePasswd;
606         argumentsPasswordConcealed << "--sign" << "******"
607                                    << "--storepass" << "******";
608         if (!m_certificatePasswd.isEmpty()) {
609             arguments << "--keypass" << m_certificatePasswd;
610             argumentsPasswordConcealed << "--keypass" << "******";
611         }
612 
613     }
614 
615     // Must be the last option, otherwise androiddeployqt might use the other
616     // params (e.g. --sign) to choose not to add gdbserver
617     if (version->qtVersion() >= QtSupport::QtVersionNumber(5, 6, 0)) {
618         if (m_addDebugger || buildType() == ProjectExplorer::BuildConfiguration::Debug)
619             arguments << "--gdbserver";
620         else
621             arguments << "--no-gdbserver";
622     }
623 
624     processParameters()->setCommandLine({command, arguments});
625 
626     // Generate arguments with keystore password concealed
627     ProjectExplorer::ProcessParameters pp2;
628     setupProcessParameters(&pp2);
629     pp2.setCommandLine({command, argumentsPasswordConcealed});
630     m_command = pp2.effectiveCommand().toString();
631     m_argumentsPasswordConcealed = pp2.prettyArguments();
632 
633     return true;
634 }
635 
setupOutputFormatter(OutputFormatter * formatter)636 void AndroidBuildApkStep::setupOutputFormatter(OutputFormatter *formatter)
637 {
638     const auto parser = new JavaParser;
639     parser->setProjectFileList(project()->files(Project::AllFiles));
640 
641     const QString buildKey = target()->activeBuildKey();
642     const ProjectNode *node = project()->findNodeForBuildKey(buildKey);
643     QString sourceDirName;
644     if (node)
645         sourceDirName = node->data(Constants::AndroidPackageSourceDir).toString();
646     QFileInfo sourceDirInfo(sourceDirName);
647     parser->setSourceDirectory(Utils::FilePath::fromString(sourceDirInfo.canonicalFilePath()));
648     parser->setBuildDirectory(AndroidManager::androidBuildDirectory(target()));
649     formatter->addLineParser(parser);
650     AbstractProcessStep::setupOutputFormatter(formatter);
651 }
652 
showInGraphicalShell()653 void AndroidBuildApkStep::showInGraphicalShell()
654 {
655     Core::FileUtils::showInGraphicalShell(Core::ICore::dialogParent(), m_packagePath);
656 }
657 
createConfigWidget()658 QWidget *AndroidBuildApkStep::createConfigWidget()
659 {
660     return new AndroidBuildApkWidget(this);
661 }
662 
processFinished(int exitCode,QProcess::ExitStatus status)663 void AndroidBuildApkStep::processFinished(int exitCode, QProcess::ExitStatus status)
664 {
665     AbstractProcessStep::processFinished(exitCode, status);
666     if (m_openPackageLocationForRun && status == QProcess::NormalExit && exitCode == 0)
667         QTimer::singleShot(0, this, &AndroidBuildApkStep::showInGraphicalShell);
668 }
669 
verifyKeystorePassword()670 bool AndroidBuildApkStep::verifyKeystorePassword()
671 {
672     if (!m_keystorePath.exists()) {
673         const QString error = tr("Cannot sign the package. Invalid keystore path (%1).")
674                                   .arg(m_keystorePath.toString());
675         emit addOutput(error, OutputFormat::ErrorMessage);
676         TaskHub::addTask(DeploymentTask(Task::Error, error));
677         return false;
678     }
679 
680     if (AndroidManager::checkKeystorePassword(m_keystorePath.toString(), m_keystorePasswd))
681         return true;
682 
683     bool success = false;
684     auto verifyCallback = std::bind(&AndroidManager::checkKeystorePassword,
685                                     m_keystorePath.toString(), std::placeholders::_1);
686     m_keystorePasswd = PasswordInputDialog::getPassword(PasswordInputDialog::KeystorePassword,
687                                                         verifyCallback, "", &success);
688     return success;
689 }
690 
verifyCertificatePassword()691 bool AndroidBuildApkStep::verifyCertificatePassword()
692 {
693     if (!AndroidManager::checkCertificateExists(m_keystorePath.toString(), m_keystorePasswd,
694                                                  m_certificateAlias)) {
695         const QString error = tr("Cannot sign the package. Certificate alias %1 does not exist.")
696                                   .arg(m_certificateAlias);
697         emit addOutput(error, OutputFormat::ErrorMessage);
698         TaskHub::addTask(BuildSystemTask(Task::Error, error));
699         return false;
700     }
701 
702     if (AndroidManager::checkCertificatePassword(m_keystorePath.toString(), m_keystorePasswd,
703                                                  m_certificateAlias, m_certificatePasswd)) {
704         return true;
705     }
706 
707     bool success = false;
708     auto verifyCallback = std::bind(&AndroidManager::checkCertificatePassword,
709                                     m_keystorePath.toString(), m_keystorePasswd,
710                                     m_certificateAlias, std::placeholders::_1);
711 
712     m_certificatePasswd = PasswordInputDialog::getPassword(PasswordInputDialog::CertificatePassword,
713                                                            verifyCallback, m_certificateAlias,
714                                                            &success);
715     return success;
716 }
717 
718 
copyFileIfNewer(const QString & sourceFileName,const QString & destinationFileName)719 static bool copyFileIfNewer(const QString &sourceFileName,
720                             const QString &destinationFileName)
721 {
722     if (sourceFileName == destinationFileName)
723         return true;
724     if (QFile::exists(destinationFileName)) {
725         QFileInfo destinationFileInfo(destinationFileName);
726         QFileInfo sourceFileInfo(sourceFileName);
727         if (sourceFileInfo.lastModified() <= destinationFileInfo.lastModified())
728             return true;
729         if (!QFile(destinationFileName).remove())
730             return false;
731     }
732 
733     if (!QDir().mkpath(QFileInfo(destinationFileName).path()))
734         return false;
735     return QFile::copy(sourceFileName, destinationFileName);
736 }
737 
doRun()738 void AndroidBuildApkStep::doRun()
739 {
740     if (m_skipBuilding) {
741         const QString error = tr("Android deploy settings file not found, not building an APK.");
742         emit addOutput(error, BuildStep::OutputFormat::ErrorMessage);
743         TaskHub::addTask(BuildSystemTask(Task::Error, error));
744         emit finished(true);
745         return;
746     }
747 
748     auto setup = [this] {
749         const auto androidAbis = AndroidManager::applicationAbis(target());
750         const QString buildKey = target()->activeBuildKey();
751 
752         QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(kit());
753         if (!version)
754             return false;
755 
756         const FilePath buildDir = buildDirectory();
757         const FilePath androidBuildDir = AndroidManager::androidBuildDirectory(target());
758         for (const auto &abi : androidAbis) {
759             FilePath androidLibsDir = androidBuildDir / "libs" / abi;
760             if (!androidLibsDir.exists()) {
761                 if (!QDir{buildDir.toString()}.mkpath(androidLibsDir.toString())) {
762                     const QString error = tr("The Android build folder %1 wasn't found and "
763                                              "couldn't be created.").arg(androidLibsDir.toString());
764                     emit addOutput(error, BuildStep::OutputFormat::ErrorMessage);
765                     TaskHub::addTask(BuildSystemTask(Task::Error, error));
766                     return false;
767                 } else if (version->qtVersion() >= QtSupport::QtVersionNumber{6, 0, 0}
768                            && version->qtVersion() <= QtSupport::QtVersionNumber{6, 1, 1}) {
769                     // 6.0.x <= Qt <= 6.1.1 used to need a manaul call to _prepare_apk_dir target,
770                     // and now it's made directly with ALL target, so this code below ensures
771                     // these versions are not broken.
772                     const QString fileName = QString("lib%1_%2.so").arg(buildKey, abi);
773                     const FilePath from = buildDir / fileName;
774                     const FilePath to = androidLibsDir / fileName;
775                     if (!from.exists() || to.exists())
776                         continue;
777 
778                     if (!QFile::copy(from.toString(), to.toString())) {
779                         const QString error = tr("Couldn't copy the target's lib file %1 to the "
780                                                  "Android build folder %2.")
781                                                 .arg(fileName, androidLibsDir.toString());
782                         emit addOutput(error, BuildStep::OutputFormat::ErrorMessage);
783                         TaskHub::addTask(BuildSystemTask(Task::Error, error));
784                         return false;
785                     }
786                 }
787             }
788 
789         }
790 
791         bool inputExists = QFile::exists(m_inputFile);
792         if (inputExists && !AndroidManager::isQtCreatorGenerated(FilePath::fromString(m_inputFile)))
793             return true; // use the generated file if it was not generated by qtcreator
794 
795         BuildSystem *bs = buildSystem();
796         auto targets = bs->extraData(buildKey, Android::Constants::AndroidTargets).toStringList();
797         if (targets.isEmpty())
798             return inputExists; // qmake does this job for us
799 
800         QJsonObject deploySettings = Android::AndroidManager::deploymentSettings(target());
801         QString applicationBinary;
802         if (!version->supportsMultipleQtAbis()) {
803             QTC_ASSERT(androidAbis.size() == 1, return false);
804             applicationBinary = buildSystem()->buildTarget(buildKey).targetFilePath.toString();
805             FilePath androidLibsDir = androidBuildDir / "libs" / androidAbis.first();
806             for (const auto &target : targets) {
807                 if (!copyFileIfNewer(target, androidLibsDir.pathAppended(QFileInfo{target}.fileName()).toString()))
808                     return false;
809             }
810             deploySettings["target-architecture"] = androidAbis.first();
811         } else {
812             applicationBinary = buildSystem()->buildTarget(buildKey).targetFilePath.fileName();
813             QJsonObject architectures;
814 
815             // Copy targets to android build folder
816             for (const auto &abi : androidAbis) {
817                 QString targetSuffix = QString{"_%1.so"}.arg(abi);
818                 if (applicationBinary.endsWith(targetSuffix)) {
819                     // Keep only TargetName from "lib[TargetName]_abi.so"
820                     applicationBinary.remove(0, 3).chop(targetSuffix.size());
821                 }
822 
823                 FilePath androidLibsDir = androidBuildDir / "libs" / abi;
824                 for (const auto &target : targets) {
825                     if (target.endsWith(targetSuffix)) {
826                         if (!copyFileIfNewer(target, androidLibsDir.pathAppended(QFileInfo{target}.fileName()).toString()))
827                             return false;
828                         architectures[abi] = AndroidManager::archTriplet(abi);
829                     }
830                 }
831             }
832             deploySettings["architectures"] = architectures;
833         }
834         deploySettings["application-binary"] = applicationBinary;
835 
836         QString extraLibs = bs->extraData(buildKey, Android::Constants::AndroidExtraLibs).toString();
837         if (!extraLibs.isEmpty())
838             deploySettings["android-extra-libs"] = extraLibs;
839 
840         QString androidSrcs = bs->extraData(buildKey, Android::Constants::AndroidPackageSourceDir).toString();
841         if (!androidSrcs.isEmpty())
842             deploySettings["android-package-source-directory"] = androidSrcs;
843 
844         QString qmlImportPath = bs->extraData(buildKey, "QML_IMPORT_PATH").toString();
845         if (!qmlImportPath.isEmpty())
846             deploySettings["qml-import-paths"] = qmlImportPath;
847 
848         QString qmlRootPath = bs->extraData(buildKey, "QML_ROOT_PATH").toString();
849         if (qmlRootPath.isEmpty())
850             qmlRootPath = target()->project()->rootProjectDirectory().toString();
851          deploySettings["qml-root-path"] = qmlRootPath;
852 
853         QFile f{m_inputFile};
854         if (!f.open(QIODevice::WriteOnly))
855             return false;
856         f.write(QJsonDocument{deploySettings}.toJson());
857         return true;
858     };
859 
860     if (!setup()) {
861         const QString error = tr("Cannot set up Android, not building an APK.");
862         emit addOutput(error, BuildStep::OutputFormat::ErrorMessage);
863         TaskHub::addTask(BuildSystemTask(Task::Error, error));
864         emit finished(false);
865         return;
866     }
867 
868     AbstractProcessStep::doRun();
869 }
870 
processStarted()871 void AndroidBuildApkStep::processStarted()
872 {
873     emit addOutput(tr("Starting: \"%1\" %2")
874                    .arg(QDir::toNativeSeparators(m_command),
875                         m_argumentsPasswordConcealed),
876                    BuildStep::OutputFormat::NormalMessage);
877 }
878 
fromMap(const QVariantMap & map)879 bool AndroidBuildApkStep::fromMap(const QVariantMap &map)
880 {
881     m_keystorePath = Utils::FilePath::fromString(map.value(KeystoreLocationKey).toString());
882     m_signPackage = false; // don't restore this
883     m_buildTargetSdk = map.value(BuildTargetSdkKey).toString();
884     if (m_buildTargetSdk.isEmpty()) {
885         m_buildTargetSdk = AndroidConfig::apiLevelNameFor(AndroidConfigurations::
886                                                           sdkManager()->latestAndroidSdkPlatform());
887     }
888     m_verbose = map.value(VerboseOutputKey).toBool();
889     return ProjectExplorer::BuildStep::fromMap(map);
890 }
891 
toMap() const892 QVariantMap AndroidBuildApkStep::toMap() const
893 {
894     QVariantMap map = ProjectExplorer::AbstractProcessStep::toMap();
895     map.insert(KeystoreLocationKey, m_keystorePath.toString());
896     map.insert(BuildTargetSdkKey, m_buildTargetSdk);
897     map.insert(VerboseOutputKey, m_verbose);
898     return map;
899 }
900 
keystorePath()901 Utils::FilePath AndroidBuildApkStep::keystorePath()
902 {
903     return m_keystorePath;
904 }
905 
buildTargetSdk() const906 QString AndroidBuildApkStep::buildTargetSdk() const
907 {
908     return m_buildTargetSdk;
909 }
910 
setBuildTargetSdk(const QString & sdk)911 void AndroidBuildApkStep::setBuildTargetSdk(const QString &sdk)
912 {
913     m_buildTargetSdk = sdk;
914 }
915 
stdError(const QString & output)916 void AndroidBuildApkStep::stdError(const QString &output)
917 {
918     AbstractProcessStep::stdError(output);
919 
920     QString newOutput = output;
921     newOutput.remove(QRegularExpression("^(\\n)+"));
922 
923     if (newOutput.isEmpty())
924         return;
925 
926     if (newOutput.startsWith("warning", Qt::CaseInsensitive)
927         || newOutput.startsWith("note", Qt::CaseInsensitive))
928         TaskHub::addTask(BuildSystemTask(Task::Warning, newOutput));
929     else
930         TaskHub::addTask(BuildSystemTask(Task::Error, newOutput));
931 }
932 
data(Utils::Id id) const933 QVariant AndroidBuildApkStep::data(Utils::Id id) const
934 {
935     if (id == Constants::AndroidNdkPlatform) {
936         if (auto qtVersion = QtKitAspect::qtVersion(kit()))
937             return AndroidConfigurations::currentConfig()
938                 .bestNdkPlatformMatch(AndroidManager::minimumSDK(target()), qtVersion).mid(8);
939         return {};
940     }
941     if (id == Constants::NdkLocation) {
942         if (auto qtVersion = QtKitAspect::qtVersion(kit()))
943             return QVariant::fromValue(AndroidConfigurations::currentConfig().ndkLocation(qtVersion));
944         return {};
945     }
946     if (id == Constants::SdkLocation)
947         return QVariant::fromValue(AndroidConfigurations::currentConfig().sdkLocation());
948     if (id == Constants::AndroidABIs)
949         return AndroidManager::applicationAbis(target());
950 
951     return AbstractProcessStep::data(id);
952 }
953 
setKeystorePath(const Utils::FilePath & path)954 void AndroidBuildApkStep::setKeystorePath(const Utils::FilePath &path)
955 {
956     m_keystorePath = path;
957     m_certificatePasswd.clear();
958     m_keystorePasswd.clear();
959 }
960 
setKeystorePassword(const QString & pwd)961 void AndroidBuildApkStep::setKeystorePassword(const QString &pwd)
962 {
963     m_keystorePasswd = pwd;
964 }
965 
setCertificateAlias(const QString & alias)966 void AndroidBuildApkStep::setCertificateAlias(const QString &alias)
967 {
968     m_certificateAlias = alias;
969 }
970 
setCertificatePassword(const QString & pwd)971 void AndroidBuildApkStep::setCertificatePassword(const QString &pwd)
972 {
973     m_certificatePasswd = pwd;
974 }
975 
signPackage() const976 bool AndroidBuildApkStep::signPackage() const
977 {
978     return m_signPackage;
979 }
980 
setSignPackage(bool b)981 void AndroidBuildApkStep::setSignPackage(bool b)
982 {
983     m_signPackage = b;
984 }
985 
buildAAB() const986 bool AndroidBuildApkStep::buildAAB() const
987 {
988     return m_buildAAB;
989 }
990 
setBuildAAB(bool aab)991 void AndroidBuildApkStep::setBuildAAB(bool aab)
992 {
993     m_buildAAB = aab;
994 }
995 
openPackageLocation() const996 bool AndroidBuildApkStep::openPackageLocation() const
997 {
998     return m_openPackageLocation;
999 }
1000 
setOpenPackageLocation(bool open)1001 void AndroidBuildApkStep::setOpenPackageLocation(bool open)
1002 {
1003     m_openPackageLocation = open;
1004 }
1005 
setVerboseOutput(bool verbose)1006 void AndroidBuildApkStep::setVerboseOutput(bool verbose)
1007 {
1008     m_verbose = verbose;
1009 }
1010 
addDebugger() const1011 bool AndroidBuildApkStep::addDebugger() const
1012 {
1013     return m_addDebugger;
1014 }
1015 
setAddDebugger(bool debug)1016 void AndroidBuildApkStep::setAddDebugger(bool debug)
1017 {
1018     m_addDebugger = debug;
1019 }
1020 
verboseOutput() const1021 bool AndroidBuildApkStep::verboseOutput() const
1022 {
1023     return m_verbose;
1024 }
1025 
keystoreCertificates()1026 QAbstractItemModel *AndroidBuildApkStep::keystoreCertificates()
1027 {
1028     // check keystore passwords
1029     if (!verifyKeystorePassword())
1030         return nullptr;
1031 
1032     CertificatesModel *model = nullptr;
1033     const QStringList params = {"-list", "-v", "-keystore", m_keystorePath.toUserOutput(),
1034         "-storepass", m_keystorePasswd, "-J-Duser.language=en"};
1035 
1036     QtcProcess keytoolProc;
1037     keytoolProc.setTimeoutS(30);
1038     keytoolProc.setCommand({AndroidConfigurations::currentConfig().keytoolPath(), params});
1039     keytoolProc.setProcessUserEventWhileRunning();
1040     keytoolProc.runBlocking();
1041     if (keytoolProc.result() > QtcProcess::FinishedWithError)
1042         QMessageBox::critical(nullptr, tr("Error"), tr("Failed to run keytool."));
1043     else
1044         model = new CertificatesModel(keytoolProc.stdOut(), this);
1045 
1046     return model;
1047 }
1048 
PasswordInputDialog(PasswordInputDialog::Context context,std::function<bool (const QString &)> callback,const QString & extraContextStr,QWidget * parent)1049 PasswordInputDialog::PasswordInputDialog(PasswordInputDialog::Context context,
1050                                          std::function<bool (const QString &)> callback,
1051                                          const QString &extraContextStr,
1052                                          QWidget *parent) :
1053     QDialog(parent, Qt::Dialog | Qt::CustomizeWindowHint | Qt::WindowTitleHint),
1054     verifyCallback(callback)
1055 
1056 {
1057     inputEdit->setEchoMode(QLineEdit::Password);
1058 
1059     warningLabel->hide();
1060 
1061     auto mainLayout = new QVBoxLayout(this);
1062     mainLayout->addWidget(inputContextlabel);
1063     mainLayout->addWidget(inputEdit);
1064     mainLayout->addWidget(warningLabel);
1065     mainLayout->addWidget(buttonBox);
1066 
1067     connect(inputEdit, &QLineEdit::textChanged,[this](const QString &text) {
1068         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!text.isEmpty());
1069     });
1070 
1071     connect(buttonBox, &QDialogButtonBox::accepted, [this]() {
1072         if (verifyCallback(inputEdit->text())) {
1073             accept(); // Dialog accepted.
1074         } else {
1075             warningLabel->show();
1076             inputEdit->clear();
1077             adjustSize();
1078         }
1079     });
1080 
1081     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
1082 
1083     setWindowTitle(context == KeystorePassword ? tr("Keystore") : tr("Certificate"));
1084 
1085     QString contextStr;
1086     if (context == KeystorePassword)
1087         contextStr = tr("Enter keystore password");
1088     else
1089         contextStr = tr("Enter certificate password");
1090 
1091     contextStr += extraContextStr.isEmpty() ? QStringLiteral(":") :
1092                                               QStringLiteral(" (%1):").arg(extraContextStr);
1093     inputContextlabel->setText(contextStr);
1094 }
1095 
getPassword(Context context,std::function<bool (const QString &)> callback,const QString & extraContextStr,bool * ok,QWidget * parent)1096 QString PasswordInputDialog::getPassword(Context context, std::function<bool (const QString &)> callback,
1097                                          const QString &extraContextStr, bool *ok, QWidget *parent)
1098 {
1099     std::unique_ptr<PasswordInputDialog> dlg(new PasswordInputDialog(context, callback,
1100                                                                      extraContextStr, parent));
1101     bool isAccepted = dlg->exec() == QDialog::Accepted;
1102     if (ok)
1103         *ok = isAccepted;
1104     return isAccepted ? dlg->inputEdit->text() : "";
1105 }
1106 
1107 
1108 // AndroidBuildApkStepFactory
1109 
AndroidBuildApkStepFactory()1110 AndroidBuildApkStepFactory::AndroidBuildApkStepFactory()
1111 {
1112     registerStep<AndroidBuildApkStep>(Constants::ANDROID_BUILD_APK_ID);
1113     setSupportedDeviceType(Constants::ANDROID_DEVICE_TYPE);
1114     setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
1115     setDisplayName(AndroidBuildApkStep::tr("Build Android APK"));
1116     setRepeatable(false);
1117 }
1118 
1119 } // namespace Internal
1120 } // namespace Android
1121