mirror of
https://github.com/overte-org/overte.git
synced 2025-04-06 22:13:11 +02:00
688 lines
26 KiB
Groovy
688 lines
26 KiB
Groovy
import de.undercouch.gradle.tasks.download.Download
|
|
import de.undercouch.gradle.tasks.download.Verify
|
|
import groovy.io.FileType
|
|
import groovy.json.JsonSlurper
|
|
import groovy.xml.XmlUtil
|
|
import org.apache.tools.ant.taskdefs.condition.Os
|
|
|
|
import java.util.regex.Matcher
|
|
import java.util.regex.Pattern
|
|
|
|
buildscript {
|
|
repositories {
|
|
jcenter()
|
|
google()
|
|
}
|
|
dependencies {
|
|
classpath 'com.android.tools.build:gradle:3.2.1'
|
|
}
|
|
}
|
|
|
|
plugins {
|
|
id 'de.undercouch.download' version '3.3.0'
|
|
id "cz.malohlava" version "1.0.3"
|
|
id "io.github.http-builder-ng.http-plugin" version "0.1.1"
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
jcenter()
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
|
|
task clean(type: Delete) {
|
|
delete rootProject.buildDir
|
|
}
|
|
|
|
ext {
|
|
RELEASE_NUMBER = project.hasProperty('RELEASE_NUMBER') ? project.getProperty('RELEASE_NUMBER') : '0'
|
|
VERSION_CODE = project.hasProperty('VERSION_CODE') ? project.getProperty('VERSION_CODE') : '0'
|
|
RELEASE_TYPE = project.hasProperty('RELEASE_TYPE') ? project.getProperty('RELEASE_TYPE') : 'DEV'
|
|
STABLE_BUILD = project.hasProperty('STABLE_BUILD') ? project.getProperty('STABLE_BUILD') : '0'
|
|
EXEC_SUFFIX = Os.isFamily(Os.FAMILY_WINDOWS) ? '.exe' : ''
|
|
QT5_DEPS = [
|
|
'Qt5Concurrent',
|
|
'Qt5Core',
|
|
'Qt5Gui',
|
|
'Qt5Multimedia',
|
|
'Qt5Network',
|
|
'Qt5OpenGL',
|
|
'Qt5Qml',
|
|
'Qt5Quick',
|
|
'Qt5QuickControls2',
|
|
'Qt5QuickTemplates2',
|
|
'Qt5Script',
|
|
'Qt5ScriptTools',
|
|
'Qt5Svg',
|
|
'Qt5WebChannel',
|
|
'Qt5WebSockets',
|
|
'Qt5Widgets',
|
|
'Qt5XmlPatterns',
|
|
// Android specific
|
|
'Qt5AndroidExtras',
|
|
'Qt5WebView',
|
|
]
|
|
}
|
|
|
|
def baseFolder = new File(HIFI_ANDROID_PRECOMPILED)
|
|
def appDir = new File(projectDir, 'app')
|
|
def jniFolder = new File(appDir, 'src/main/jniLibs/arm64-v8a')
|
|
def baseUrl = 'https://hifi-public.s3.amazonaws.com/dependencies/android/'
|
|
def breakpadDumpSymsDir = new File("${appDir}/build/tmp/breakpadDumpSyms")
|
|
|
|
def qtFile='qt-5.11.1_linux_armv8-libcpp_openssl_patched.tgz'
|
|
def qtChecksum='aa449d4bfa963f3bc9a9dfe558ba29df'
|
|
def qtVersionId='3S97HBM5G5Xw9EfE52sikmgdN3t6C2MN'
|
|
if (Os.isFamily(Os.FAMILY_MAC)) {
|
|
qtFile = 'qt-5.11.1_osx_armv8-libcpp_openssl_patched.tgz'
|
|
qtChecksum='c83cc477c08a892e00c71764dca051a0'
|
|
qtVersionId='OxBD7iKINv1HbyOXmAmDrBb8AF3N.Kup'
|
|
} else if (Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
qtFile = 'qt-5.11.1_win_armv8-libcpp_openssl_patched.tgz'
|
|
qtChecksum='0582191cc55431aa4f660848a542883e'
|
|
qtVersionId='JfWM0P_Mz5Qp0LwpzhrsRwN3fqlLSFeT'
|
|
}
|
|
|
|
def packages = [
|
|
qt: [
|
|
file: qtFile,
|
|
versionId: qtVersionId,
|
|
checksum: qtChecksum,
|
|
],
|
|
bullet: [
|
|
file: 'bullet-2.88_armv8-libcpp.tgz',
|
|
versionId: 'S8YaoED0Cl8sSb8fSV7Q2G1lQJSNDxqg',
|
|
checksum: '81642779ccb110f8c7338e8739ac38a0',
|
|
],
|
|
draco: [
|
|
file: 'draco_armv8-libcpp.tgz',
|
|
versionId: '3.B.uBj31kWlgND3_R2xwQzT_TP6Dz_8',
|
|
checksum: '617a80d213a5ec69fbfa21a1f2f738cd',
|
|
],
|
|
glad: [
|
|
file: 'glad_armv8-libcpp.zip',
|
|
versionId: 'r5Zran.JSCtvrrB6Q4KaqfIoALPw3lYY',
|
|
checksum: 'a8ee8584cf1ccd34766c7ddd9d5e5449',
|
|
],
|
|
gvr: [
|
|
file: 'gvrsdk_v1.101.0.tgz',
|
|
versionId: 'nqBV_j81Uc31rC7bKIrlya_Hah4v3y5r',
|
|
checksum: '57fd02baa069176ba18597a29b6b4fc7',
|
|
],
|
|
nvtt: [
|
|
file: 'nvtt_armv8-libcpp.zip',
|
|
versionId: 'lmkBVR5t4UF1UUwMwEirnk9H_8Nt90IO',
|
|
checksum: 'eb46d0b683e66987190ed124aabf8910',
|
|
sharedLibFolder: 'lib',
|
|
includeLibs: ['libnvtt.so', 'libnvmath.so', 'libnvimage.so', 'libnvcore.so'],
|
|
],
|
|
openssl: [
|
|
file: 'openssl-1.1.0g_armv8.tgz',
|
|
versionId: 'AiiPjmgUZTgNj7YV1EEx2lL47aDvvvAW',
|
|
checksum: 'cabb681fbccd79594f65fcc266e02f32',
|
|
],
|
|
polyvox: [
|
|
file: 'polyvox_armv8-libcpp.tgz',
|
|
versionId: 'A2kbKiNhpIenGq23bKRRzg7IMAI5BI92',
|
|
checksum: 'dba88b3a098747af4bb169e9eb9af57e',
|
|
sharedLibFolder: 'lib',
|
|
includeLibs: ['Release/libPolyVoxCore.so', 'libPolyVoxUtil.so'],
|
|
],
|
|
tbb: [
|
|
file: 'tbb-2018_U1_armv8_libcpp.tgz',
|
|
versionId: 'mrRbWnv4O4evcM1quRH43RJqimlRtaKB',
|
|
checksum: '20768f298f53b195e71b414b0ae240c4',
|
|
sharedLibFolder: 'lib/release',
|
|
includeLibs: ['libtbb.so', 'libtbbmalloc.so'],
|
|
],
|
|
hifiAC: [
|
|
baseUrl: 'http://s3.amazonaws.com/hifi-public/dependencies/',
|
|
file: 'codecSDK-android_armv8-2.0.zip',
|
|
checksum: '1cbef929675818fc64c4101b72f84a6a'
|
|
],
|
|
etc2comp: [
|
|
file: 'etc2comp-patched-armv8-libcpp.tgz',
|
|
versionId: 'bHhGECRAQR1vkpshBcK6ByNc1BQIM8gU',
|
|
checksum: '14b02795d774457a33bbc60e00a786bc'
|
|
],
|
|
breakpad: [
|
|
file: 'breakpad.tgz',
|
|
versionId: '8VrYXz7oyc.QBxNia0BVJOUBvrFO61jI',
|
|
checksum: 'ddcb23df336b08017042ba4786db1d9e',
|
|
sharedLibFolder: 'lib',
|
|
includeLibs: ['libbreakpad_client.a']
|
|
]
|
|
]
|
|
|
|
def options = [
|
|
files: new TreeSet<File>(),
|
|
features: new HashSet<String>(),
|
|
permissions: new HashSet<String>()
|
|
]
|
|
|
|
def qmlRoot = new File(HIFI_ANDROID_PRECOMPILED, 'qt')
|
|
|
|
def captureOutput = { String command, List<String> commandArgs ->
|
|
def result
|
|
new ByteArrayOutputStream().withStream { os ->
|
|
def execResult = exec {
|
|
executable = command
|
|
args = commandArgs
|
|
standardOutput = os
|
|
errorOutput = new ByteArrayOutputStream()
|
|
}
|
|
result = os.toString()
|
|
}
|
|
return result;
|
|
}
|
|
|
|
def relativize = { File root, File absolute ->
|
|
def relativeURI = root.toURI().relativize(absolute.toURI())
|
|
return new File(relativeURI.toString())
|
|
}
|
|
|
|
def scanQmlImports = { File qmlRootPath ->
|
|
def qmlImportCommandFile = new File(qmlRoot, 'bin/qmlimportscanner' + EXEC_SUFFIX)
|
|
if (!qmlImportCommandFile.exists()) {
|
|
throw new GradleException('Unable to find required qmlimportscanner executable at ' + qmlImportCommandFile.parent.toString())
|
|
}
|
|
|
|
def command = qmlImportCommandFile.absolutePath
|
|
def args = [
|
|
'-rootPath', qmlRootPath.absolutePath,
|
|
'-importPath', "${qmlRoot.absolutePath}/qml"
|
|
]
|
|
|
|
def commandResult = captureOutput(command, args)
|
|
new JsonSlurper().parseText(commandResult).each {
|
|
if (!it.containsKey('path')) {
|
|
println "Warning: QML import could not be resolved in any of the import paths: ${it.name}"
|
|
return
|
|
}
|
|
def file = new File(it.path)
|
|
// Ignore non-existent files
|
|
if (!file.exists()) {
|
|
return
|
|
}
|
|
// Ignore files in the import path
|
|
if (file.canonicalPath.startsWith(qmlRootPath.canonicalPath)) {
|
|
return
|
|
}
|
|
if (file.isFile()) {
|
|
options.files.add(file)
|
|
} else {
|
|
file.eachFileRecurse(FileType.FILES, {
|
|
options.files.add(it)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
def parseQtDependencies = { List qtLibs ->
|
|
qtLibs.each({
|
|
def libFile = new File(qmlRoot, "lib/lib${it}.so")
|
|
options.files.add(libFile)
|
|
|
|
def androidDeps = new File(qmlRoot, "lib/${it}-android-dependencies.xml")
|
|
if (!libFile.exists()) return
|
|
if (!androidDeps.exists()) return
|
|
|
|
new XmlSlurper().parse(androidDeps).dependencies.lib.depends.'*'.each{ node ->
|
|
switch (node.name()) {
|
|
case 'lib':
|
|
case 'bundled':
|
|
def relativeFilename = node.@file.toString()
|
|
|
|
// Special case, since this is handled by qmlimportscanner instead
|
|
if (relativeFilename.startsWith('qml'))
|
|
return
|
|
|
|
def file = new File(qmlRoot, relativeFilename)
|
|
|
|
if (!file.exists())
|
|
return
|
|
|
|
if (file.isFile()) {
|
|
options.files.add(file)
|
|
} else {
|
|
file.eachFileRecurse(FileType.FILES, { options.files.add(it) })
|
|
}
|
|
break
|
|
|
|
|
|
case 'jar':
|
|
if (node.@bundling == "1") {
|
|
def jar = new File(qmlRoot, node.@file.toString())
|
|
if (!jar.exists()) {
|
|
throw new GradleException('Unable to find required JAR ' + jar.path)
|
|
}
|
|
options.files.add(jar)
|
|
}
|
|
break
|
|
|
|
case 'permission':
|
|
options.permissions.add(node.@name)
|
|
break
|
|
|
|
case 'feature':
|
|
options.features.add(node.@name)
|
|
break
|
|
|
|
default:
|
|
throw new GradleException('Unhandled Android Dependency node ' + node.name())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
def generateLibsXml = {
|
|
def libDestinationDirectory = jniFolder
|
|
def jarDestinationDirectory = new File(appDir, 'libs')
|
|
def assetDestinationDirectory = new File(appDir, 'src/main/assets/--Added-by-androiddeployqt--');
|
|
def libsXmlFile = new File(appDir, 'src/main/res/values/libs.xml')
|
|
def libPrefix = 'lib' + File.separator
|
|
def jarPrefix = 'jar' + File.separator
|
|
|
|
def xmlParser = new XmlParser()
|
|
def libsXmlRoot = xmlParser.parseText('<?xml version="1.0" encoding="UTF-8"?><resources/>')
|
|
def qtLibsNode = xmlParser.createNode(libsXmlRoot, 'array', [name: 'qt_libs'])
|
|
def bundledLibsNode = xmlParser.createNode(libsXmlRoot, 'array', [name: 'bundled_in_lib'])
|
|
def bundledAssetsNode = xmlParser.createNode(libsXmlRoot, 'array', [name: 'bundled_in_assets'])
|
|
|
|
options.files.each {
|
|
def sourceFile = it
|
|
if (!sourceFile.exists()) {
|
|
throw new GradleException("Unable to find dependency file " + sourceFile.toString())
|
|
}
|
|
|
|
def relativePath = relativize( qmlRoot, sourceFile ).toString()
|
|
def destinationFile
|
|
if (relativePath.endsWith('.so')) {
|
|
def garbledFileName
|
|
if (relativePath.startsWith(libPrefix)) {
|
|
garbledFileName = relativePath.substring(libPrefix.size())
|
|
Pattern p = ~/lib(Qt5.*).so/
|
|
Matcher m = p.matcher(garbledFileName)
|
|
assert m.matches()
|
|
def libName = m.group(1)
|
|
xmlParser.createNode(qtLibsNode, 'item', [:]).setValue(libName)
|
|
} else {
|
|
garbledFileName = 'lib' + relativePath.replace(File.separator, '_'[0])
|
|
xmlParser.createNode(bundledLibsNode, 'item', [:]).setValue("${garbledFileName}:${relativePath}".replace(File.separator, '/'))
|
|
}
|
|
destinationFile = new File(libDestinationDirectory, garbledFileName)
|
|
} else if (relativePath.startsWith('jar')) {
|
|
destinationFile = new File(jarDestinationDirectory, relativePath.substring(jarPrefix.size()))
|
|
} else {
|
|
xmlParser.createNode(bundledAssetsNode, 'item', [:]).setValue("--Added-by-androiddeployqt--/${relativePath}:${relativePath}".replace(File.separator, '/'))
|
|
destinationFile = new File(assetDestinationDirectory, relativePath)
|
|
}
|
|
|
|
copy { from sourceFile; into destinationFile.parent; rename(sourceFile.name, destinationFile.name) }
|
|
assert destinationFile.exists() && destinationFile.isFile()
|
|
}
|
|
def xml = XmlUtil.serialize(libsXmlRoot)
|
|
new FileWriter(libsXmlFile).withPrintWriter { writer ->
|
|
writer.write(xml)
|
|
}
|
|
}
|
|
|
|
task downloadDependencies {
|
|
doLast {
|
|
packages.each { entry ->
|
|
def filename = entry.value['file'];
|
|
def dependencyBaseUrl = entry.value['baseUrl']
|
|
def url = (dependencyBaseUrl?.trim() ? dependencyBaseUrl : baseUrl) + filename;
|
|
if (entry.value.containsKey('versionId')) {
|
|
url = url + '?versionId=' + entry.value['versionId']
|
|
}
|
|
download {
|
|
src url
|
|
dest new File(baseFolder, filename)
|
|
onlyIfNewer true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task verifyQt(type: Verify) { def p = packages['qt']; src new File(baseFolder, p['file']); checksum p['checksum']; }
|
|
task verifyBullet(type: Verify) { def p = packages['bullet']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyDraco(type: Verify) { def p = packages['draco']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyGvr(type: Verify) { def p = packages['gvr']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyOpenSSL(type: Verify) { def p = packages['openssl']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyPolyvox(type: Verify) { def p = packages['polyvox']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyTBB(type: Verify) { def p = packages['tbb']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyHifiAC(type: Verify) { def p = packages['hifiAC']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyEtc2Comp(type: Verify) { def p = packages['etc2comp']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
task verifyBreakpad(type: Verify) { def p = packages['breakpad']; src new File(baseFolder, p['file']); checksum p['checksum'] }
|
|
|
|
task verifyDependencyDownloads(dependsOn: downloadDependencies) { }
|
|
verifyDependencyDownloads.dependsOn verifyQt
|
|
verifyDependencyDownloads.dependsOn verifyBullet
|
|
verifyDependencyDownloads.dependsOn verifyDraco
|
|
verifyDependencyDownloads.dependsOn verifyGvr
|
|
verifyDependencyDownloads.dependsOn verifyOpenSSL
|
|
verifyDependencyDownloads.dependsOn verifyPolyvox
|
|
verifyDependencyDownloads.dependsOn verifyTBB
|
|
verifyDependencyDownloads.dependsOn verifyHifiAC
|
|
verifyDependencyDownloads.dependsOn verifyEtc2Comp
|
|
verifyDependencyDownloads.dependsOn verifyBreakpad
|
|
|
|
task extractDependencies(dependsOn: verifyDependencyDownloads) {
|
|
doLast {
|
|
packages.each { entry ->
|
|
def folder = entry.key
|
|
def filename = entry.value['file']
|
|
def localFile = new File(HIFI_ANDROID_PRECOMPILED, filename)
|
|
def localFolder = new File(HIFI_ANDROID_PRECOMPILED, folder)
|
|
def fileTree;
|
|
if (filename.endsWith('zip')) {
|
|
fileTree = zipTree(localFile)
|
|
} else {
|
|
fileTree = tarTree(resources.gzip(localFile))
|
|
}
|
|
copy {
|
|
from fileTree
|
|
into localFolder
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Copies the non Qt dependencies. Qt dependencies (primary libraries and plugins) are handled by the qtBundle task
|
|
task copyDependencies() {
|
|
doLast {
|
|
packages.each { entry ->
|
|
def packageName = entry.key
|
|
def currentPackage = entry.value;
|
|
if (currentPackage.containsKey('sharedLibFolder')) {
|
|
def localFolder = new File(baseFolder, packageName + '/' + currentPackage['sharedLibFolder'])
|
|
def tree = fileTree(localFolder);
|
|
if (currentPackage.containsKey('includeLibs')) {
|
|
currentPackage['includeLibs'].each { includeSpec -> tree.include includeSpec }
|
|
}
|
|
tree.visit { element ->
|
|
if (!element.file.isDirectory()) {
|
|
println "Copying " + element.file + " to " + jniFolder
|
|
copy { from element.file; into jniFolder }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task extractGvrBinaries() {
|
|
doLast {
|
|
def gvrLibFolder = new File(HIFI_ANDROID_PRECOMPILED, 'gvr/gvr-android-sdk-1.101.0/libraries');
|
|
zipTree(new File(HIFI_ANDROID_PRECOMPILED, 'gvr/gvr-android-sdk-1.101.0/libraries/sdk-audio-1.101.0.aar')).visit { element ->
|
|
def fileName = element.file.toString();
|
|
if (fileName.endsWith('libgvr_audio.so') && fileName.contains('arm64-v8a')) {
|
|
copy { from element.file; into gvrLibFolder }
|
|
}
|
|
}
|
|
zipTree(new File(HIFI_ANDROID_PRECOMPILED, 'gvr/gvr-android-sdk-1.101.0/libraries/sdk-base-1.101.0.aar')).visit { element ->
|
|
def fileName = element.file.toString();
|
|
if (fileName.endsWith('libgvr.so') && fileName.contains('arm64-v8a')) {
|
|
copy { from element.file; into gvrLibFolder }
|
|
}
|
|
}
|
|
fileTree(gvrLibFolder).visit { element ->
|
|
if (element.file.toString().endsWith('.so')) {
|
|
copy { from element.file; into jniFolder }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def generateAssetsFileList = {
|
|
def assetsPath = "${appDir}/src/main/assets/"
|
|
def addedByAndroidDeployQtName = "--Added-by-androiddeployqt--/"
|
|
|
|
def addedByAndroidDeployQtPath = assetsPath + addedByAndroidDeployQtName
|
|
|
|
def addedByAndroidDeployQt = new File(addedByAndroidDeployQtPath)
|
|
if (!addedByAndroidDeployQt.exists() && !addedByAndroidDeployQt.mkdirs()) {
|
|
throw new GradleScriptException("Failed to create directory " + addedByAndroidDeployQtPath, null);
|
|
}
|
|
def outputFilename = "/qt_cache_pregenerated_file_list"
|
|
def outputFile = new File(addedByAndroidDeployQtPath + outputFilename);
|
|
Map<String, List<String>> directoryContents = new TreeMap<>();
|
|
|
|
def dir = new File(assetsPath)
|
|
dir.eachFileRecurse (FileType.ANY) { file ->
|
|
|
|
def name = file.path.substring(assetsPath.length())
|
|
int slashIndex = name.lastIndexOf('/')
|
|
def pathName = slashIndex >= 0 ? name.substring(0, slashIndex) : "/"
|
|
def fileName = slashIndex >= 0 ? name.substring(pathName.length() + 1) : name
|
|
if (!fileName.isEmpty() && file.isDirectory() && !fileName.endsWith("/")) {
|
|
fileName += "/"
|
|
}
|
|
|
|
if (!directoryContents.containsKey(pathName)) {
|
|
directoryContents[pathName] = new ArrayList<String>()
|
|
}
|
|
if (!fileName.isEmpty()) {
|
|
directoryContents[pathName].add(fileName);
|
|
}
|
|
}
|
|
DataOutputStream fos = new DataOutputStream(new FileOutputStream(outputFile));
|
|
for (Map.Entry<String, List<String>> e: directoryContents.entrySet()) {
|
|
def entryList = e.getValue()
|
|
fos.writeInt(e.key.length()*2); // 2 bytes per char
|
|
fos.writeChars(e.key);
|
|
fos.writeInt(entryList.size());
|
|
for (String entry: entryList) {
|
|
fos.writeInt(entry.length()*2);
|
|
fos.writeChars(entry);
|
|
}
|
|
}
|
|
fos.close();
|
|
}
|
|
|
|
|
|
// Copy required Qt main libraries and required plugins based on the predefined list here
|
|
// FIXME eventually we would like to use the readelf functionality to automatically detect dependencies
|
|
// from our built applications and use that during the full build process. However doing so would mean
|
|
// hooking existing Android build tasks since the output from the qtBundle logic adds JNI libs, asset
|
|
// files and resources files and potentially modifies the AndroidManifest.xml
|
|
task qtBundle {
|
|
doLast {
|
|
parseQtDependencies(QT5_DEPS)
|
|
def qmlImportFolder = new File("${appDir}/../../interface/resources/qml/")
|
|
//def qmlImportFolder = new File("${projectDir}/app/src/main/cpp")
|
|
scanQmlImports(qmlImportFolder)
|
|
generateLibsXml()
|
|
generateAssetsFileList()
|
|
}
|
|
}
|
|
|
|
task setupDependencies(dependsOn: [copyDependencies, extractGvrBinaries, qtBundle]) { }
|
|
|
|
task cleanDependencies(type: Delete) {
|
|
delete HIFI_ANDROID_PRECOMPILED
|
|
delete 'app/src/main/jniLibs/arm64-v8a'
|
|
delete 'app/src/main/assets/--Added-by-androiddeployqt--'
|
|
delete 'app/src/main/res/values/libs.xml'
|
|
}
|
|
|
|
def runBreakpadDumpSyms = { buildType ->
|
|
gradle.startParameter.showStacktrace = ShowStacktrace.ALWAYS
|
|
|
|
def objDir = new File("${appDir}/build/intermediates/cmake/${buildType}/obj/arm64-v8a")
|
|
def stripDebugSymbol = "${appDir}/build/intermediates/transforms/stripDebugSymbol/${buildType}/0/lib/arm64-v8a/"
|
|
def outputDir = new File(breakpadDumpSymsDir, buildType)
|
|
if (!outputDir.exists()) {
|
|
outputDir.mkdirs()
|
|
}
|
|
|
|
objDir.eachFileRecurse (FileType.FILES) { file ->
|
|
if (file.name.endsWith('.so')) {
|
|
def output = file.name + ".sym"
|
|
def cmdArgs = [
|
|
file.toString(),
|
|
stripDebugSymbol
|
|
]
|
|
def result = exec {
|
|
workingDir HIFI_ANDROID_PRECOMPILED + '/breakpad/bin'
|
|
commandLine './dump_syms'
|
|
args cmdArgs
|
|
ignoreExitValue true
|
|
standardOutput = new BufferedOutputStream(new FileOutputStream(new File(outputDir, output)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
task runBreakpadDumpSymsDebug() {
|
|
doLast {
|
|
runBreakpadDumpSyms("debug");
|
|
}
|
|
}
|
|
|
|
task runBreakpadDumpSymsRelease() {
|
|
doLast {
|
|
runBreakpadDumpSyms("release");
|
|
}
|
|
}
|
|
|
|
task zipDumpSymsDebug(type: Zip, dependsOn: runBreakpadDumpSymsDebug) {
|
|
from (new File(breakpadDumpSymsDir, "debug").absolutePath)
|
|
archiveName "symbols-${RELEASE_NUMBER}-debug.zip"
|
|
destinationDir(new File("${appDir}/build/tmp/"))
|
|
}
|
|
|
|
task zipDumpSymsRelease(type: Zip, dependsOn: runBreakpadDumpSymsRelease) {
|
|
from (new File(breakpadDumpSymsDir, "release").absolutePath)
|
|
archiveName "symbols-${RELEASE_NUMBER}-release.zip"
|
|
destinationDir(new File("${appDir}/build/tmp/"))
|
|
}
|
|
|
|
task uploadBreakpadDumpSymsDebug(type:io.github.httpbuilderng.http.HttpTask, dependsOn: zipDumpSymsDebug) {
|
|
onlyIf {
|
|
System.getenv("CMAKE_BACKTRACE_URL") && System.getenv("CMAKE_BACKTRACE_SYMBOLS_TOKEN")
|
|
}
|
|
config {
|
|
request.uri = System.getenv("CMAKE_BACKTRACE_URL")
|
|
}
|
|
post {
|
|
request.uri.path = '/post'
|
|
request.uri.query = [format: 'symbols', token: System.getenv("CMAKE_BACKTRACE_SYMBOLS_TOKEN")]
|
|
request.body = new File("${appDir}/build/tmp/", "symbols-${RELEASE_NUMBER}-debug.zip").bytes
|
|
request.contentType = 'application/octet-stream'
|
|
response.success {
|
|
println ("${appDir}/build/tmp/symbols-${RELEASE_NUMBER}-debug.zip uploaded")
|
|
}
|
|
}
|
|
}
|
|
|
|
task uploadBreakpadDumpSymsRelease(type:io.github.httpbuilderng.http.HttpTask, dependsOn: zipDumpSymsRelease) {
|
|
onlyIf {
|
|
System.getenv("CMAKE_BACKTRACE_URL") && System.getenv("CMAKE_BACKTRACE_SYMBOLS_TOKEN")
|
|
}
|
|
config {
|
|
request.uri = System.getenv("CMAKE_BACKTRACE_URL")
|
|
}
|
|
post {
|
|
request.uri.path = '/post'
|
|
request.uri.query = [format: 'symbols', token: System.getenv("CMAKE_BACKTRACE_SYMBOLS_TOKEN")]
|
|
request.body = new File("${appDir}/build/tmp/", "symbols-${RELEASE_NUMBER}-release.zip").bytes
|
|
request.contentType = 'application/octet-stream'
|
|
response.success {
|
|
println ("${appDir}/build/tmp/symbols-${RELEASE_NUMBER}-release.zip uploaded")
|
|
}
|
|
}
|
|
}
|
|
|
|
task renameHifiACTaskDebug() {
|
|
doLast {
|
|
def sourceFile = new File("${appDir}/build/intermediates/cmake/debug/obj/arm64-v8a/","libhifiCodec.so")
|
|
def destinationFile = new File("${appDir}/src/main/jniLibs/arm64-v8a", "libplugins_libhifiCodec.so")
|
|
copy { from sourceFile; into destinationFile.parent; rename(sourceFile.name, destinationFile.name) }
|
|
}
|
|
}
|
|
task renameHifiACTaskRelease(type: Copy) {
|
|
doLast {
|
|
def sourceFile = new File("${appDir}/build/intermediates/cmake/release/obj/arm64-v8a/","libhifiCodec.so")
|
|
def destinationFile = new File("${appDir}/src/main/jniLibs/arm64-v8a", "libplugins_libhifiCodec.so")
|
|
copy { from sourceFile; into destinationFile.parent; rename(sourceFile.name, destinationFile.name) }
|
|
}
|
|
}
|
|
|
|
// FIXME this code is prototyping the desired functionality for doing build time binary dependency resolution.
|
|
// See the comment on the qtBundle task above
|
|
/*
|
|
// FIXME derive the path from the gradle environment
|
|
def toolchain = [
|
|
version: '4.9',
|
|
prefix: 'aarch64-linux-android',
|
|
// FIXME derive from the host OS
|
|
ndkHost: 'windows-x86_64',
|
|
]
|
|
|
|
def findDependentLibrary = { String name ->
|
|
def libFolders = [
|
|
new File(qmlRoot, 'lib'),
|
|
new File("${HIFI_ANDROID_PRECOMPILED}/tbb/lib/release"),
|
|
new File("${HIFI_ANDROID_PRECOMPILED}/polyvox/lib/Release"),
|
|
new File("${HIFI_ANDROID_PRECOMPILED}/polyvox/lib/"),
|
|
new File("${HIFI_ANDROID_PRECOMPILED}/gvr/gvr-android-sdk-1.101.0/libraries"),
|
|
]
|
|
|
|
}
|
|
|
|
def readElfBinary = new File(android.ndkDirectory, "/toolchains/${toolchain.prefix}-${toolchain.version}/prebuilt/${toolchain.ndkHost}/bin/${toolchain.prefix}-readelf${EXEC_SUFFIX}")
|
|
|
|
def getDependencies = { File elfBinary ->
|
|
Set<File> result = []
|
|
Queue<File> pending = new LinkedList<>()
|
|
pending.add(elfBinary)
|
|
Set<File> scanned = []
|
|
|
|
Pattern p = ~/.*\(NEEDED\).*Shared library: \[(.*\.so)\]/
|
|
while (!pending.isEmpty()) {
|
|
File current = pending.remove()
|
|
if (scanned.contains(current)) {
|
|
continue
|
|
}
|
|
scanned.add(current)
|
|
def command = "${readElfBinary} -d -W ${current.absolutePath}"
|
|
captureOutput(command).split('[\r\n]').each { line ->
|
|
Matcher m = p.matcher(line)
|
|
if (!m.matches()) {
|
|
return
|
|
}
|
|
def libName = m.group(1)
|
|
def file = new File(qmlRoot, "lib/${libName}")
|
|
if (file.exists()) {
|
|
result.add(file)
|
|
pending.add(file)
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
task testElf (dependsOn: 'externalNativeBuildDebug') {
|
|
doLast {
|
|
def appLibraries = new HashSet<File>()
|
|
def qtDependencies = new HashSet<File>()
|
|
externalNativeBuildDebug.nativeBuildConfigurationsJsons.each { File file ->
|
|
def json = new JsonSlurper().parse(file)
|
|
json.libraries.each { node ->
|
|
def outputFile = new File(node.value.output)
|
|
if (outputFile.canonicalPath.startsWith(projectDir.canonicalPath)) {
|
|
appLibraries.add(outputFile)
|
|
}
|
|
}
|
|
}
|
|
|
|
appLibraries.each { File file ->
|
|
println getDependencies(file)
|
|
}
|
|
}
|
|
}
|
|
*/
|