feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Android: remove old android tool

Browse Source 
Follows af7c218d95, the old android
tool is not useful anymore.

Change-Id: I126ecc24622f2e90465440c86b84cdfb30c103e1
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
This commit is contained in:
Assam Boudjelthia
2020-06-30 09:50:28 +03:00
parent 784420e911
commit 0cfb9e2bce
9 changed files with 8 additions and 443 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/android/CMakeLists.txt
View File

@@ -44,7 +44,6 @@ add_qtc_plugin(Android
androidsettingswidget.cpp androidsettingswidget.h androidsettingswidget.ui
androidsignaloperation.cpp androidsignaloperation.h
androidtoolchain.cpp androidtoolchain.h
androidtoolmanager.cpp androidtoolmanager.h
avddialog.cpp avddialog.h
certificatesmodel.cpp certificatesmodel.h
createandroidmanifestwizard.cpp createandroidmanifestwizard.h

2
src/plugins/android/android.pro
View File

@@ -43,7 +43,6 @@ HEADERS += \
android_global.h \
androidbuildapkstep.h \
androidbuildapkwidget.h \
androidtoolmanager.h \
androidsdkmanager.h \
androidavdmanager.h \
adbcommandswidget.h \
@@ -90,7 +89,6 @@ SOURCES += \
avddialog.cpp \
androidbuildapkstep.cpp \
androidbuildapkwidget.cpp \
androidtoolmanager.cpp \
androidsdkmanager.cpp \
androidavdmanager.cpp \
adbcommandswidget.cpp \

2
src/plugins/android/android.qbs
View File

@@ -103,8 +103,6 @@ Project {
"androidsignaloperation.h",
"androidtoolchain.cpp",
"androidtoolchain.h",
"androidtoolmanager.cpp",
"androidtoolmanager.h",
"avddialog.cpp",
"avddialog.h",
"certificatesmodel.cpp",

3
src/plugins/android/androidavdmanager.cpp
View File

@@ -24,8 +24,6 @@
****************************************************************************/
#include "androidavdmanager.h"
#include "androidtoolmanager.h"
#include <coreplugin/icore.h>
#include <utils/algorithm.h>
#include <utils/qtcassert.h>
@@ -222,7 +220,6 @@ private:
AndroidAvdManager::AndroidAvdManager(const AndroidConfig &config):
m_config(config),
m_androidTool(new AndroidToolManager(m_config)),
m_parser(new AvdManagerOutputParser)
{

2
src/plugins/android/androidavdmanager.h
View File

@@ -32,7 +32,6 @@
namespace Android {
namespace Internal {
class AndroidToolManager;
class AvdManagerOutputParser;
class AndroidAvdManager
@@ -63,7 +62,6 @@ private:
private:
const AndroidConfig &m_config;
std::unique_ptr<AndroidToolManager> m_androidTool;
std::unique_ptr<AvdManagerOutputParser> m_parser;
};

1
src/plugins/android/androidconfigurations.cpp
View File

@@ -31,7 +31,6 @@
#include "androidqtversion.h"
#include "androiddevicedialog.h"
#include "androidsdkmanager.h"
#include "androidtoolmanager.h"
#include "avddialog.h"
#include <coreplugin/icore.h>

30
src/plugins/android/androidsdkmanager.cpp
View File

@@ -25,9 +25,9 @@
#include "androidsdkmanager.h"
#include "androidconfigurations.h"
#include "androidconstants.h"
#include "androidmanager.h"
#include "androidtoolmanager.h"
#include <utils/algorithm.h>
#include <utils/qtcassert.h>
@@ -49,10 +49,6 @@ static Q_LOGGING_CATEGORY(sdkManagerLog, "qtc.android.sdkManager", QtWarningMsg)
namespace Android {
namespace Internal {
// Though sdk manager is introduced in 25.2.3 but the verbose mode is avaialble in 25.3.0
// and android tool is supported in 25.2.3
const QVersionNumber sdkManagerIntroVersion(25, 3 ,0);
const char installLocationKey[] = "Installed Location:";
const char revisionKey[] = "Version:";
const char descriptionKey[] = "Description:";
@@ -916,23 +912,13 @@ void AndroidSdkManagerPrivate::reloadSdkPackages()
return;
}
if (m_config.sdkToolsVersion() < sdkManagerIntroVersion && !m_config.isCmdlineSdkToolsInstalled()) {
// Old Sdk tools.
m_packageListingSuccessful = true;
AndroidToolManager toolManager(m_config);
auto toAndroidSdkPackages = [](SdkPlatform *p) -> AndroidSdkPackage *{
return p;
};
m_allPackages = Utils::transform(toolManager.availableSdkPlatforms(), toAndroidSdkPackages);
} else {
QString packageListing;
QStringList args({"--list", "--verbose"});
args << m_config.sdkManagerToolArgs();
m_packageListingSuccessful = sdkManagerCommand(m_config, args, &packageListing);
if (m_packageListingSuccessful) {
SdkManagerOutputParser parser(m_allPackages);
parser.parsePackageListing(packageListing);
}
QString packageListing;
QStringList args({"--list", "--verbose"});
args << m_config.sdkManagerToolArgs();
m_packageListingSuccessful = sdkManagerCommand(m_config, args, &packageListing);
if (m_packageListingSuccessful) {
SdkManagerOutputParser parser(m_allPackages);
parser.parsePackageListing(packageListing);
}
emit m_sdkManager.packageReloadFinished();
}

339
src/plugins/android/androidtoolmanager.cpp
View File

@@ -1,339 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "androidtoolmanager.h"
#include "androidmanager.h"
#include <utils/algorithm.h>
#include <utils/environment.h>
#include <utils/qtcassert.h>
#include <utils/runextensions.h>
#include <utils/synchronousprocess.h>
#include <QLoggingCategory>
namespace {
static Q_LOGGING_CATEGORY(androidToolLog, "qtc.android.sdkManager", QtWarningMsg)
}
namespace Android {
namespace Internal {
using namespace Utils;
class AndroidToolOutputParser
{
public:
void parseTargetListing(const QString &output, const FilePath &sdkLocation,
SdkPlatformList &platformList);
QList<SdkPlatform> m_installedPlatforms;
};
/*!
Runs the \c android tool located at \a toolPath with arguments \a args and environment \a
environment. Returns \c true for successful execution. Command's output is copied to \a
output.
*/
static bool androidToolCommand(Utils::FilePath toolPath, const QStringList &args,
const QProcessEnvironment &environment, QString *output)
{
SynchronousProcess proc;
proc.setProcessEnvironment(environment);
SynchronousProcessResponse response = proc.runBlocking({toolPath, args});
if (response.result == SynchronousProcessResponse::Finished) {
if (output)
*output = response.allOutput();
return true;
}
return false;
}
static QStringList cleanAndroidABIs(const QStringList &abis)
{
QStringList res;
foreach (const QString &abi, abis) {
int index = abi.lastIndexOf(QLatin1Char('/'));
if (index == -1)
res << abi;
else
res << abi.mid(index + 1);
}
return res;
}
AndroidToolManager::AndroidToolManager(const AndroidConfig &config) :
m_config(config),
m_parser(new AndroidToolOutputParser)
{
}
AndroidToolManager::~AndroidToolManager() = default;
SdkPlatformList AndroidToolManager::availableSdkPlatforms(bool *ok) const
{
bool success = false;
SdkPlatformList list;
QString targetListing;
if (androidToolCommand(m_config.androidToolPath(), QStringList({"list", "target"}),
AndroidConfigurations::toolsEnvironment(m_config), &targetListing)) {
m_parser->parseTargetListing(targetListing, m_config.sdkLocation(), list);
success = true;
} else {
qCDebug(androidToolLog) << "Android tool target listing failed";
}
if (ok)
*ok = success;
return list;
}
QFuture<CreateAvdInfo> AndroidToolManager::createAvd(CreateAvdInfo info) const
{
return Utils::runAsync(&AndroidToolManager::createAvdImpl, info,
m_config.androidToolPath(),
AndroidConfigurations::toolsEnvironment(m_config));
}
bool AndroidToolManager::removeAvd(const QString &name) const
{
SynchronousProcess proc;
proc.setTimeoutS(5);
proc.setProcessEnvironment(AndroidConfigurations::toolsEnvironment(m_config));
SynchronousProcessResponse response
= proc.runBlocking({m_config.androidToolPath(), {"delete", "avd", "-n", name}});
return response.result == SynchronousProcessResponse::Finished && response.exitCode == 0;
}
QFuture<AndroidDeviceInfoList> AndroidToolManager::androidVirtualDevicesFuture() const
{
return Utils::runAsync(&AndroidToolManager::androidVirtualDevices,
m_config.androidToolPath(), m_config.sdkLocation(),
AndroidConfigurations::toolsEnvironment(m_config));
}
CreateAvdInfo AndroidToolManager::createAvdImpl(CreateAvdInfo info, FilePath androidToolPath,
QProcessEnvironment env)
{
QProcess proc;
proc.setProcessEnvironment(env);
QStringList arguments;
arguments << QLatin1String("create") << QLatin1String("avd")
<< QLatin1String("-t") << QString("android-%1").arg(info.systemImage->apiLevel())
<< QLatin1String("-n") << info.name
<< QLatin1String("-b") << info.abi;
if (info.sdcardSize > 0)
arguments << QLatin1String("-c") << QString::fromLatin1("%1M").arg(info.sdcardSize);
proc.start(androidToolPath.toString(), arguments);
if (!proc.waitForStarted()) {
info.error = tr("Could not start process \"%1 %2\"")
.arg(androidToolPath.toString(), arguments.join(QLatin1Char(' ')));
return info;
}
QTC_CHECK(proc.state() == QProcess::Running);
proc.write(QByteArray("yes\n")); // yes to "Do you wish to create a custom hardware profile"
QByteArray question;
while (true) {
proc.waitForReadyRead(500);
question += proc.readAllStandardOutput();
if (question.endsWith(QByteArray("]:"))) {
// truncate to last line
int index = question.lastIndexOf(QByteArray("\n"));
if (index != -1)
question = question.mid(index);
if (question.contains("hw.gpu.enabled"))
proc.write(QByteArray("yes\n"));
else
proc.write(QByteArray("\n"));
question.clear();
}
if (proc.state() != QProcess::Running)
break;
}
QTC_CHECK(proc.state() == QProcess::NotRunning);
QString errorOutput = QString::fromLocal8Bit(proc.readAllStandardError());
// The exit code is always 0, so we need to check stderr
// For now assume that any output at all indicates a error
if (!errorOutput.isEmpty()) {
info.error = errorOutput;
}
return info;
}
AndroidDeviceInfoList AndroidToolManager::androidVirtualDevices(const Utils::FilePath &androidTool,
const FilePath &sdkLocationPath,
const QProcessEnvironment &env)
{
AndroidDeviceInfoList devices;
QString output;
if (!androidToolCommand(androidTool, QStringList({"list", "avd"}), env, &output))
return devices;
QStringList avds = output.split('\n');
if (avds.empty())
return devices;
for (const QString &line : avds) // remove the daemon logs
if (line.startsWith("* daemon"))
avds.removeOne(line);
avds.removeFirst(); // remove "List of devices attached" header line
bool nextLineIsTargetLine = false;
AndroidDeviceInfo dev;
for (int i = 0; i < avds.size(); i++) {
QString line = avds.at(i);
if (!line.contains(QLatin1String("Name:")))
continue;
int index = line.indexOf(QLatin1Char(':')) + 2;
if (index >= line.size())
break;
dev.avdname = line.mid(index).trimmed();
dev.sdk = -1;
dev.cpuAbi.clear();
++i;
for (; i < avds.size(); ++i) {
line = avds.at(i);
if (line.contains(QLatin1String("---------")))
break;
if (line.contains(QLatin1String("Target:")) || nextLineIsTargetLine) {
if (line.contains(QLatin1String("Google APIs"))) {
nextLineIsTargetLine = true;
continue;
}
nextLineIsTargetLine = false;
int lastIndex = line.lastIndexOf(QLatin1Char(' '));
if (lastIndex == -1) // skip line
break;
QString tmp = line.mid(lastIndex).remove(QLatin1Char(')')).trimmed();
dev.sdk = AndroidManager::findApiLevel(
sdkLocationPath.pathAppended(QString("/platforms/android-%1").arg(tmp)));
}
if (line.contains(QLatin1String("Tag/ABI:"))) {
int lastIndex = line.lastIndexOf(QLatin1Char('/')) + 1;
if (lastIndex >= line.size())
break;
dev.cpuAbi = QStringList(line.mid(lastIndex));
} else if (line.contains(QLatin1String("ABI:"))) {
int lastIndex = line.lastIndexOf(QLatin1Char(' ')) + 1;
if (lastIndex >= line.size())
break;
dev.cpuAbi = QStringList(line.mid(lastIndex).trimmed());
}
}
// armeabi-v7a devices can also run armeabi code
if (dev.cpuAbi == QStringList("armeabi-v7a"))
dev.cpuAbi << QLatin1String("armeabi");
dev.state = AndroidDeviceInfo::OkState;
dev.type = AndroidDeviceInfo::Emulator;
if (dev.cpuAbi.isEmpty() || dev.sdk == -1)
continue;
devices.push_back(dev);
}
Utils::sort(devices);
return devices;
}
void AndroidToolOutputParser::parseTargetListing(const QString &output,
const Utils::FilePath &sdkLocation,
SdkPlatformList &platformList)
{
auto addSystemImage = [](const QStringList& abiList, SdkPlatform *platform) {
QTC_ASSERT(platform, return);
foreach (auto imageAbi, abiList) {
auto image = new SystemImage(QVersionNumber(), "", imageAbi, platform);
platform->addSystemImage(image);
}
};
class {
public:
QStringList abiList;
QVersionNumber revision;
int apiLevel = -1;
QString description;
Utils::FilePath installedLocation;
void clear() {
abiList.clear();
revision = QVersionNumber();
apiLevel = -1;
description.clear();
installedLocation.clear();
}
} platformParams;
QStringList outputLines = output.split('\n');
for (int index = 0; index < outputLines.count(); ++index) {
const QString line = outputLines.at(index).trimmed();
if (line.startsWith(QLatin1String("id:")) && line.contains(QLatin1String("android-"))) {
int index = line.indexOf(QLatin1String("\"android-"));
if (index == -1)
continue;
QString androidTarget = line.mid(index + 1, line.length() - index - 2);
const QString tmp = androidTarget.mid(androidTarget.lastIndexOf(QLatin1Char('-')) + 1);
platformParams.installedLocation = sdkLocation.pathAppended(QString("/platforms/android-%1").arg(tmp));
platformParams.apiLevel = AndroidManager::findApiLevel(platformParams.installedLocation);
} else if (line.startsWith(QLatin1String("Name:"))) {
platformParams.description = line.mid(6);
} else if (line.startsWith(QLatin1String("Revision:"))) {
platformParams.revision = QVersionNumber::fromString(line.mid(10));
} else if (line.startsWith(QLatin1String("Tag/ABIs :"))) {
platformParams.abiList = cleanAndroidABIs(line.mid(10).trimmed().split(QLatin1String(", ")));
} else if (line.startsWith(QLatin1String("ABIs"))) {
platformParams.abiList = cleanAndroidABIs(line.mid(6).trimmed().split(QLatin1String(", ")));
} else if (line.startsWith(QLatin1String("---"))
|| line.startsWith(QLatin1String("==="))
|| index == outputLines.count() - 1) {
if (platformParams.apiLevel == -1)
continue;
auto platform = new SdkPlatform(platformParams.revision,
QString("platforms;android-%1").arg(platformParams.apiLevel),
platformParams.apiLevel);
platform->setState(AndroidSdkPackage::Installed);
platform->setDescriptionText(platformParams.description);
platform->setInstalledLocation(platformParams.installedLocation);
addSystemImage(platformParams.abiList, platform);
platformList << platform;
platformParams.clear();
}
}
Utils::sort(platformList);
}
} // namespace Internal
} // namespace Android

71
src/plugins/android/androidtoolmanager.h
View File

@@ -1,71 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include "androidconfigurations.h"
#include <utils/fileutils.h>
#include <QStringList>
#include <memory>
namespace Android {
class AndroidConfig;
namespace Internal {
class AndroidToolOutputParser;
/*!
Wraps the \c android tool's usage. The tool itself is deprecated since SDK tools version 25.3.0.
*/
class AndroidToolManager
{
Q_DECLARE_TR_FUNCTIONS(AndroidToolManager)
public:
AndroidToolManager(const AndroidConfig &config);
~AndroidToolManager();
SdkPlatformList availableSdkPlatforms(bool *ok = nullptr) const;
QFuture<CreateAvdInfo> createAvd(CreateAvdInfo info) const;
bool removeAvd(const QString &name) const;
QFuture<AndroidDeviceInfoList> androidVirtualDevicesFuture() const;
// Helper methods
private:
static CreateAvdInfo createAvdImpl(CreateAvdInfo info, Utils::FilePath androidToolPath,
QProcessEnvironment env);
static AndroidDeviceInfoList androidVirtualDevices(const Utils::FilePath &androidTool,
const Utils::FilePath &sdkLlocationPath,
const QProcessEnvironment &env);
private:
const AndroidConfig &m_config;
std::unique_ptr<AndroidToolOutputParser> m_parser;
};
} // namespace Internal
} // namespace Android