| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the qmake application of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "initprojectdeploy_symbian.h" |
| #include <QDirIterator> |
| #include <project.h> |
| #include <qxmlstream.h> |
| #include <qsettings.h> |
| #include <qdebug.h> |
| |
| // Included from tools/shared |
| #include <symbian/epocroot_p.h> |
| |
| #define SYSBIN_DIR "/sys/bin" |
| #define HW_Z_DIR "epoc32/data/z" |
| |
| #define SUFFIX_DLL "dll" |
| #define SUFFIX_EXE "exe" |
| #define SUFFIX_QTPLUGIN "qtplugin" |
| |
| static QString fixPathToEpocOS(const QString &src) |
| { |
| QString ret = Option::fixPathToTargetOS(src); |
| |
| bool pathHasDriveLetter = false; |
| if (ret.size() > 1) |
| pathHasDriveLetter = (ret.at(1) == QLatin1Char(':')); |
| |
| return pathHasDriveLetter ? ret.replace('/', '\\') : QDir::toNativeSeparators(ret); |
| } |
| |
| static bool isPlugin(const QFileInfo& info, const QString& devicePath) |
| { |
| // Libraries are plugins if deployment path is something else than |
| // SYSBIN_DIR with or without drive letter |
| if (0 == info.suffix().compare(QLatin1String(SUFFIX_DLL), Qt::CaseInsensitive) |
| && (devicePath.size() < 8 |
| || (0 != devicePath.compare(QLatin1String(SYSBIN_DIR), Qt::CaseInsensitive) |
| && 0 != devicePath.mid(1).compare(QLatin1String(":" SYSBIN_DIR), Qt::CaseInsensitive) |
| && 0 != devicePath.compare(qt_epocRoot() + QLatin1String(HW_Z_DIR SYSBIN_DIR))))) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| static bool isBinary(const QFileInfo& info) |
| { |
| if (0 == info.suffix().compare(QLatin1String(SUFFIX_DLL), Qt::CaseInsensitive) || |
| 0 == info.suffix().compare(QLatin1String(SUFFIX_EXE), Qt::CaseInsensitive)) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| static void createPluginStub(const QFileInfo& info, |
| const QString& devicePath, |
| DeploymentList &deploymentList, |
| QStringList& generatedDirs, |
| QStringList& generatedFiles) |
| { |
| QString pluginStubDir = Option::output_dir + QLatin1Char('/') + QLatin1String(PLUGIN_STUB_DIR); |
| QDir().mkpath(pluginStubDir); |
| if (!generatedDirs.contains(pluginStubDir)) |
| generatedDirs << pluginStubDir; |
| // Plugin stubs must have different name from the actual plugins, because |
| // the toolchain for creating ROM images cannot handle non-binary .dll files properly. |
| QFile stubFile(pluginStubDir + QLatin1Char('/') + info.completeBaseName() + QLatin1Char('.') + QLatin1String(SUFFIX_QTPLUGIN)); |
| if (stubFile.open(QIODevice::WriteOnly)) { |
| if (!generatedFiles.contains(stubFile.fileName())) |
| generatedFiles << stubFile.fileName(); |
| QTextStream t(&stubFile); |
| // Add note to stub so that people will not wonder what it is. |
| // Creation date is added to make new stub to deploy always to |
| // force plugin cache miss when loading plugins. |
| t << "This file is a Qt plugin stub file. The real Qt plugin is located in " SYSBIN_DIR ". Created:" << QDateTime::currentDateTime().toString(Qt::ISODate) << "\n"; |
| } else { |
| fprintf(stderr, "cannot deploy \"%s\" because of plugin stub file creation failed\n", info.fileName().toLatin1().constData()); |
| } |
| QFileInfo stubInfo(stubFile); |
| deploymentList.append(CopyItem(Option::fixPathToLocalOS(stubInfo.absoluteFilePath()), |
| fixPathToEpocOS(devicePath + "/" + stubInfo.fileName()))); |
| } |
| |
| QString generate_uid(const QString& target) |
| { |
| static QMap<QString, QString> targetToUid; |
| |
| QString tmp = targetToUid[target]; |
| |
| if (!tmp.isEmpty()) { |
| return tmp; |
| } |
| |
| quint32 hash = 5381; |
| int c; |
| |
| for (int i = 0; i < target.size(); ++i) { |
| c = target.at(i).toAscii(); |
| hash ^= c + ((c - i) << i % 20) + ((c + i) << (i + 5) % 20) + ((c - 2 * i) << (i + 10) % 20) + ((c + 2 * i) << (i + 15) % 20); |
| } |
| |
| tmp.setNum(hash, 16); |
| for (int i = tmp.size(); i < 8; ++i) |
| tmp.prepend("0"); |
| |
| targetToUid[target] = tmp; |
| |
| return tmp; |
| } |
| |
| // UIDs starting with 0xE are test UIDs in symbian |
| QString generate_test_uid(const QString& target) |
| { |
| QString tmp = generate_uid(target); |
| tmp.replace(0, 1, "E"); |
| tmp.prepend("0x"); |
| |
| return tmp; |
| } |
| |
| |
| void initProjectDeploySymbian(QMakeProject* project, |
| DeploymentList &deploymentList, |
| const QString &testPath, |
| bool deployBinaries, |
| bool epocBuild, |
| const QString &platform, |
| const QString &build, |
| QStringList& generatedDirs, |
| QStringList& generatedFiles) |
| { |
| QString targetPath = project->values("deploy.path").join(" "); |
| if (targetPath.isEmpty()) |
| targetPath = testPath; |
| if (targetPath.endsWith("/") || targetPath.endsWith("\\")) |
| targetPath = targetPath.mid(0, targetPath.size() - 1); |
| |
| bool targetPathHasDriveLetter = false; |
| if (targetPath.size() > 1) { |
| targetPathHasDriveLetter = targetPath.at(1) == QLatin1Char(':'); |
| } |
| |
| QString deploymentDrive; |
| if (0 == platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM))) { |
| deploymentDrive = qt_epocRoot() + HW_Z_DIR; |
| } else { |
| deploymentDrive = targetPathHasDriveLetter ? targetPath.left(2) : QLatin1String("c:"); |
| } |
| |
| foreach(QString item, project->values("DEPLOYMENT")) { |
| QString devicePath = project->first(item + ".path"); |
| QString devicePathWithoutDrive = devicePath; |
| |
| bool devicePathHasDriveLetter = false; |
| if (devicePath.size() > 1) { |
| devicePathHasDriveLetter = devicePath.at(1) == QLatin1Char(':'); |
| } |
| |
| // Sometimes devicePath can contain disk but APP_RESOURCE_DIR does not, |
| // so remove the drive letter for comparison purposes. |
| if (devicePathHasDriveLetter) |
| { |
| devicePathWithoutDrive.remove(0,2); |
| } |
| if (!deployBinaries |
| && 0 != platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM)) |
| && !devicePathWithoutDrive.isEmpty() |
| && (0 == devicePathWithoutDrive.compare(project->values("APP_RESOURCE_DIR").join(""), Qt::CaseInsensitive) |
| || 0 == devicePathWithoutDrive.compare(project->values("REG_RESOURCE_IMPORT_DIR").join(""), Qt::CaseInsensitive))) { |
| // Do not deploy resources in emulator builds, as that seems to cause conflicts |
| // If there is ever a real need to deploy pre-built resources for emulator, |
| // BLD_INF_RULES.prj_exports can be used as a workaround. |
| continue; |
| } |
| |
| if (devicePath.isEmpty() || devicePath == QLatin1String(".")) { |
| devicePath = targetPath; |
| } |
| // check if item.path is relative (! either / or \) |
| else if (!(devicePath.at(0) == QLatin1Char('/') |
| || devicePath.at(0) == QLatin1Char('\\') |
| || devicePathHasDriveLetter)) { |
| // Create output path |
| devicePath = Option::fixPathToLocalOS(QDir::cleanPath(targetPath + QLatin1Char('/') + devicePath)); |
| } else { |
| if (0 == platform.compare(QLatin1String(EMULATOR_DEPLOYMENT_PLATFORM))) { |
| if (devicePathHasDriveLetter) { |
| devicePath = qt_epocRoot() + "epoc32/winscw/" + devicePath.remove(1, 1); |
| } else { |
| devicePath = qt_epocRoot() + "epoc32/winscw/c" + devicePath; |
| } |
| } else { |
| if (devicePathHasDriveLetter |
| && 0 == platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM))) { |
| devicePath.remove(0,2); |
| } |
| if (0 == platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM)) |
| || (!devicePathHasDriveLetter && targetPathHasDriveLetter)) { |
| devicePath = deploymentDrive + devicePath; |
| } |
| } |
| } |
| |
| devicePath.replace(QLatin1String("\\"), QLatin1String("/")); |
| |
| if (!deployBinaries |
| && 0 == devicePath.right(8).compare(QLatin1String(SYSBIN_DIR), Qt::CaseInsensitive) |
| && 0 != platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM))) { |
| // Skip deploying to SYSBIN_DIR for anything but binary deployments |
| // Note: Deploying pre-built binaries also follow this rule, so emulator builds |
| // will not get those deployed. Since there is no way to differentiate currently |
| // between pre-built binaries for emulator and HW anyway, this is not a major issue. |
| continue; |
| } |
| |
| QStringList flags = project->values(item + ".flags"); |
| |
| foreach(QString source, project->values(item + ".sources")) { |
| source = Option::fixPathToLocalOS(source); |
| QString nameFilter; |
| QFileInfo info(source); |
| QString searchPath; |
| bool dirSearch = false; |
| |
| if (info.isDir()) { |
| nameFilter = QLatin1String("*"); |
| searchPath = info.absoluteFilePath(); |
| dirSearch = true; |
| } else { |
| if (info.exists() || source.indexOf('*') != -1) { |
| nameFilter = source.split(QDir::separator()).last(); |
| searchPath = info.absolutePath(); |
| } else { |
| // Entry was not found. That is ok if it is a binary, since those do not necessarily yet exist. |
| // Dlls need to be processed even when not deploying binaries for the stubs |
| if (isBinary(info)) { |
| if (deployBinaries) { |
| // Executables and libraries are deployed to \sys\bin |
| QFileInfo targetPath; |
| if (epocBuild) |
| targetPath.setFile(qt_epocRoot() + "epoc32/release/" + platform + "/" + build + "/"); |
| else |
| targetPath.setFile(info.path() + QDir::separator()); |
| if(devicePathHasDriveLetter) { |
| deploymentList.append(CopyItem( |
| Option::fixPathToLocalOS(targetPath.absolutePath() + "/" + info.fileName(), |
| false, true), |
| fixPathToEpocOS(devicePath.left(2) + QLatin1String(SYSBIN_DIR "/") |
| + info.fileName()), |
| flags)); |
| } else { |
| deploymentList.append(CopyItem( |
| Option::fixPathToLocalOS(targetPath.absolutePath() + "/" + info.fileName(), |
| false, true), |
| fixPathToEpocOS(deploymentDrive + QLatin1String("/" SYSBIN_DIR "/") |
| + info.fileName()), |
| flags)); |
| } |
| } |
| if (isPlugin(info, devicePath)) { |
| createPluginStub(info, devicePath, deploymentList, generatedDirs, generatedFiles); |
| continue; |
| } |
| } else { |
| // Generate deployment even if file doesn't exist, as this may be the case |
| // when generating .pkg files. |
| deploymentList.append(CopyItem(Option::fixPathToLocalOS(info.absoluteFilePath()), |
| fixPathToEpocOS(devicePath + "/" + info.fileName()), |
| flags)); |
| continue; |
| } |
| } |
| } |
| |
| int pathSize = info.absolutePath().size(); |
| QDirIterator iterator(searchPath, QStringList() << nameFilter |
| , QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks |
| , dirSearch ? QDirIterator::Subdirectories : QDirIterator::NoIteratorFlags); |
| |
| while (iterator.hasNext()) { |
| iterator.next(); |
| QFileInfo iteratorInfo(iterator.filePath()); |
| QString absoluteItemPath = Option::fixPathToLocalOS(iteratorInfo.absolutePath()); |
| int diffSize = absoluteItemPath.size() - pathSize; |
| |
| if (!iteratorInfo.isDir()) { |
| if (isPlugin(iterator.fileInfo(), devicePath)) { |
| // This deploys pre-built plugins. Other pre-built binaries will deploy normally, |
| // as they have SYSBIN_DIR target path. |
| if (deployBinaries |
| || (0 == platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM)))) { |
| if (devicePathHasDriveLetter) { |
| deploymentList.append(CopyItem( |
| Option::fixPathToLocalOS(absoluteItemPath + "/" + iterator.fileName()), |
| fixPathToEpocOS(devicePath.left(2) + QLatin1String(SYSBIN_DIR "/") |
| + iterator.fileName()), |
| flags)); |
| } else { |
| deploymentList.append(CopyItem( |
| Option::fixPathToLocalOS(absoluteItemPath + "/" + iterator.fileName()), |
| fixPathToEpocOS(deploymentDrive + QLatin1String("/" SYSBIN_DIR "/") |
| + iterator.fileName()), |
| flags)); |
| } |
| } |
| createPluginStub(info, devicePath + "/" + absoluteItemPath.right(diffSize), |
| deploymentList, generatedDirs, generatedFiles); |
| continue; |
| } else { |
| deploymentList.append(CopyItem( |
| Option::fixPathToLocalOS(absoluteItemPath + "/" + iterator.fileName()), |
| fixPathToEpocOS(devicePath + "/" + absoluteItemPath.right(diffSize) |
| + "/" + iterator.fileName()), |
| flags)); |
| } |
| } |
| } |
| } |
| } |
| |
| // Remove deployments that do not actually do anything |
| if (0 == platform.compare(QLatin1String(EMULATOR_DEPLOYMENT_PLATFORM)) |
| || 0 == platform.compare(QLatin1String(ROM_DEPLOYMENT_PLATFORM))) { |
| QMutableListIterator<CopyItem> i(deploymentList); |
| while(i.hasNext()) { |
| CopyItem &item = i.next(); |
| QFileInfo fromItem(item.from); |
| QFileInfo toItem(item.to); |
| #if defined(Q_OS_WIN) |
| if (0 == fromItem.absoluteFilePath().compare(toItem.absoluteFilePath(), Qt::CaseInsensitive)) |
| #else |
| if (0 == fromItem.absoluteFilePath().compare(toItem.absoluteFilePath())) |
| #endif |
| i.remove(); |
| } |
| } |
| } |