디버그 Mapbox 안드로이드 NDK 라이브러리

Question

나는에있는 안드로이드 스튜디오 실험 플러그인 사용 설명서의 지시 사항을 따르 시도하고있다 :

http://tools.android.com/tech-docs/new-build-system/gradle-experimental

에있는 Mapbox GL 네이티브 라이브러리 수정 :

https://github.com/mapbox/mapbox-gl-native

을

구체적으로 다음 Android 파일을 수정했습니다.

https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/MapboxGLAndroidSDK/build.gradle

https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/MapboxGLAndroidSDKTestApp/build.gradle

내 목표는 그래서 그것을 디버깅 할 수있는 라이브러리를 수정하는 것입니다 https://github.com/mapbox/mapbox-gl-native/blob/master/platform/android/build.gradle

76,

. 이상적으로는 Android Studio를 사용하여 라이브러리를 만들고 C/C++ 코드를 디버깅 할 수 있습니다. 지금까지는 빌드 할 수 있지만 디버깅 할 수는 없습니다. Mapbox에서 일하는 프로그래머는 안드로이드 코드를 디버깅하는 방법이 없다고 말했기 때문에 이것이 도달하기 쉬운 목표는 아니라고 생각합니다.

나는 안드로이드 스튜디오 실험 플러그인 사용 설명서의 지침을 적용하는 방법에는 여러 시도를했지만, 나는 Gradle을에 경험이 아니에요 내 최신 시도가 이해가 안 다음 오류 메시지와 함께 나를 떠나 :

Gradle 'android' project refresh failed Error:Cause:org.gradle.api.internal.ExtensibleDynamicObject

누구든지 디버깅 할 수있는 Android NDK 라이브러리를 만들려면이 파일을 수정하는 방법을 알고 있습니까? 위의 오류의 원인은 무엇입니까?

내가 사용하고 있습니다 : 나는 현재 그들이 수정 한 아래

> Linux Mint 17.2 
> Android Studio 2.1.1 
> Build #AI-143.2821654, built on April 28, 2016 
> JRE: 1.8.0_65-b17 amd64 
> JVM: Java HotSpot(TM) 64-Bit Server VM by Oracle Corporation 

은 4 개 파일입니다. 나는 Gradle을 처음 사용하기 때문에 modfication을 올바르게 작성했다고 가정하지 마십시오. 빌드를 성공적으로 완료하기 전까지 Android Studio 실험용 플러그인 사용자 가이드 지침을 적용하려고 시도했을뿐입니다.

감사

---

#// mapbox-gl-native/platform/android/gradle/wrapper/gradle-wrapper.properties 

#Thu Apr 07 14:21:05 CDT 2016 

distributionBase=GRADLE_USER_HOME 
distributionPath=wrapper/dists 
zipStoreBase=GRADLE_USER_HOME 
zipStorePath=wrapper/dists 
#//distributionUrl=https\://services.gradle.org/distributions/gradle-2.12-bin.zip 
#//distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip 
distributionUrl=https\://services.gradle.org/distributions/gradle-2.11-all.zip 
distributionSha256Sum=e77064981906cd0476ff1e0de3e6fef747bd18e140960f1915cca8ff6c33ab5c 

---

// mapbox-gl-native/platform/android/MapboxGLAndroidSDKTestApp/build.gradle 

// Top-level build file where you can add configuration options common to all sub-projects/modules. 

buildscript { 
    repositories { 
     jcenter() 
     maven { url 'https://jitpack.io' } 
    } 
    dependencies { 
     // classpath 'com.android.tools.build:gradle:2.1.0' 
     //classpath 'com.android.tools.build:gradle-experimental:0.7.0' 
     classpath 'com.android.tools.build:gradle-experimental:0.8.0-alpha2' 
     classpath 'com.github.JakeWharton:sdk-manager-plugin:220bf7a88a7072df3ed16dc8466fb144f2817070' 

     // NOTE: Do not place your application dependencies here; they belong 
     // in the individual module build.gradle files 
    } 
} 

allprojects { 
    repositories { 
     jcenter() 
     maven { url "http://oss.sonatype.org/content/repositories/snapshots/" } 
    } 
} 

task wrapper(type: Wrapper) { 
    gradleVersion = '2.12' 
} 

---

// mapbox-gl-native/platform/android/MapboxGLAndroidSDK/build.gradle 

apply plugin: 'android-sdk-manager' 
apply plugin: 'com.android.model.library' 
apply plugin: 'checkstyle' 
apply plugin: 'maven' 
apply plugin: 'signing' 

allprojects { 
    group project.GROUP 
    version project.VERSION_NAME 

    repositories { 
     mavenCentral() 
    } 
} 

repositories { 
    mavenCentral() 
} 

ext { 
    supportLibVersion = '23.4.0' 
} 

dependencies { 
    compile "com.android.support:support-annotations:${supportLibVersion}" 
    compile "com.android.support:support-v4:${supportLibVersion}" 
    compile "com.android.support:design:${supportLibVersion}" 
    compile 'com.squareup.okhttp3:okhttp:3.3.0' 
    compile 'com.mapzen.android:lost:1.1.0' 
} 

model { 
android { 
    compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION) 
    buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION 

    defaultConfig { 
     minSdkVersion Integer.parseInt(project.ANDROID_MIN_SDK) 
     targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION) 
    } 

    sourceSets { 
     main.res.srcDirs += 'src/main/res-public' 
    } 

    repositories { 
     mavenCentral() 
    } 

    compileOptions { 
     sourceCompatibility JavaVersion.VERSION_1_7 
     targetCompatibility JavaVersion.VERSION_1_7 
    } 

    lintOptions { 
     checkAllWarnings true 
     warningsAsErrors true 
    } 

    buildTypes { 
     debug { 
      jniDebuggable true 
      buildConfigField "String", "MAPBOX_EVENTS_USER_AGENT_BASE", new StringBuilder().append("\"").append("MapboxEventsAndroid/").append(project.VERSION_NAME).append("\"").toString() 
     } 

     release { 
      jniDebuggable false 
      buildConfigField "String", "MAPBOX_EVENTS_USER_AGENT_BASE", new StringBuilder().append("\"").append("MapboxEventsAndroid/").append(project.VERSION_NAME).append("\"").toString() 
      consumerProguardFiles 'proguard-rules.pro' 
     } 
    } 
} 
} 

configurations { 
    all*.exclude group: 'commons-logging', module: 'commons-logging' 
    all*.exclude group: 'commons-collections', module: 'commons-collections' 
} 

model { 
android.libraryVariants.all { variant -> 
    def name = variant.name 
    task "javadoc$name"(type: Javadoc) { 
     description = "Generates javadoc for build $name" 
     failOnError = false 
     destinationDir = new File(destinationDir, variant.baseName) 
     source = files(variant.javaCompile.source) 
     classpath = files(variant.javaCompile.classpath.files) + files(android.bootClasspath) 
     exclude '**/R.java', '**/BuildConfig.java', 'com/almeros/**' 
     options.windowTitle("Mapbox Android SDK $VERSION_NAME Reference") 
     options.docTitle("Mapbox Android SDK $VERSION_NAME") 
     options.header("Mapbox Android SDK $VERSION_NAME Reference") 
     options.bottom("© 2015–2016 Mapbox. All rights reserved.") 
     options.links("http://docs.oracle.com/javase/7/docs/api/") 
     options.linksOffline("http://d.android.com/reference/", "$System.env.ANDROID_HOME/docs/reference") 
     options.overview("src/main/java/overview.html") 
     options.group("Mapbox Android SDK", "com.mapbox.*") 
     options.group("Third Party Libraries", "com.almeros.*") 
     // TODO exclude generated R, BuildConfig, com.almeros.* 
    } 
} 
} 

checkstyle { 
    configFile project.file('../checks.xml') 
    showViolations true 
} 

/* 
task cleanJNIBuilds { 
    def jniLibsDir = new File("MapboxGLAndroidSDK/src/main/jniLibs") 
    delete jniLibsDir.absolutePath 
} 
*/ 

model 
{ 
android.libraryVariants.all { variant -> 
    def name = variant.buildType.name 
    def checkstyle = project.tasks.create "checkstyle${name.capitalize()}", Checkstyle 
    checkstyle.dependsOn variant.javaCompile 
    checkstyle.source variant.javaCompile.source 
    checkstyle.classpath = project.fileTree(variant.javaCompile.destinationDir) 
    checkstyle.exclude('**/BuildConfig.java') 
    checkstyle.exclude('**/R.java') 
    checkstyle.exclude('**/com/almeros/android/multitouch/**') 
    project.tasks.getByName("check").dependsOn checkstyle 
} 

// From https://raw.github.com/mcxiaoke/gradle-mvn-push/master/jar.gradle 
android.libraryVariants.all { variant -> 
    def jarTask = project.tasks.create(name: "jar${variant.name.capitalize()}", type: Jar) { 
     from variant.javaCompile.destinationDir 
     exclude "**/R.class" 
     exclude "**/BuildConfig.class" 
    } 
    jarTask.dependsOn variant.javaCompile 
    artifacts.add('archives', jarTask); 
} 
} 

// From https://raw.github.com/mcxiaoke/gradle-mvn-push/master/gradle-mvn-push.gradle 
def isReleaseBuild() { 
    return VERSION_NAME.contains("SNAPSHOT") == false 
} 

def getReleaseRepositoryUrl() { 
    return hasProperty('RELEASE_REPOSITORY_URL') ? RELEASE_REPOSITORY_URL : 
      "https://oss.sonatype.org/service/local/staging/deploy/maven2/" 
} 

def getSnapshotRepositoryUrl() { 
    return hasProperty('SNAPSHOT_REPOSITORY_URL') ? SNAPSHOT_REPOSITORY_URL : 
      "https://oss.sonatype.org/content/repositories/snapshots/" 
} 

def getRepositoryUsername() { 
    return hasProperty('USERNAME') ? USERNAME : 
      (hasProperty('NEXUS_USERNAME') ? NEXUS_USERNAME : "") 
} 

def getRepositoryPassword() { 
    return hasProperty('PASSWORD') ? PASSWORD : 
      (hasProperty('NEXUS_PASSWORD') ? NEXUS_PASSWORD : "") 
} 


task apklib(type: Zip) { 
    appendix = extension = 'apklib' 

    from 'AndroidManifest.xml' 
    into('res') { 
     from 'res' 
    } 
    into('src') { 
     from 'src' 
    } 
} 

artifacts { 
    archives apklib 
} 

afterEvaluate { project -> 
    uploadArchives { 
     repositories { 
      mavenDeployer { 
       beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) } 

       pom.groupId = GROUP 
       pom.artifactId = POM_ARTIFACT_ID 
       pom.version = VERSION_NAME 

       repository(url: getReleaseRepositoryUrl()) { 
        authentication(userName: getRepositoryUsername(), 
          password: getRepositoryPassword()) 
       } 
       snapshotRepository(url: getSnapshotRepositoryUrl()) { 
        authentication(userName: getRepositoryUsername(), 
          password: getRepositoryPassword()) 
       } 

/* 
       // Leaving out as artifact was incorrectly named when found 
       addFilter('aar') { artifact, file -> 
        artifact.name == archivesBaseName 
       } 
       addFilter('apklib') { artifact, file -> 
        artifact.name == archivesBaseName + '-apklib' 
       } 
*/ 

       pom.project { 
        name POM_NAME 
        packaging POM_PACKAGING 
        description POM_DESCRIPTION 
        url POM_URL 

        scm { 
         url POM_SCM_URL 
         connection POM_SCM_CONNECTION 
         developerConnection POM_SCM_DEV_CONNECTION 
        } 

        licenses { 
         license { 
          name POM_LICENCE_NAME 
          url POM_LICENCE_URL 
          distribution POM_LICENCE_DIST 
         } 
        } 

        developers { 
         developer { 
          id POM_DEVELOPER_ID 
          name POM_DEVELOPER_NAME 
         } 
        } 
       } 
      } 
     } 
    } 

    signing { 
     required { isReleaseBuild() && gradle.taskGraph.hasTask("uploadArchives") } 
     sign configurations.archives 
    } 

    model { 
    task androidJavadocs(type: Javadoc) { 
     source = android.sourceSets.main.java.sourceFiles 
     classpath = files(android.bootClasspath) 
    } 
    } 

    task androidJavadocsJar(type: Jar, dependsOn: androidJavadocs) { 
     classifier = 'javadoc' 
     from androidJavadocs.destinationDir 
    } 

    model { 
    task androidSourcesJar(type: Jar) { 
     classifier = 'sources' 
     from android.sourceSets.main.java.sourceFiles 
    } 
    } 

    artifacts { 
     archives androidSourcesJar 
     archives androidJavadocsJar 
    } 
} 


task makeClean(type: Exec) { 
    workingDir '../../' 
    commandLine 'make', 'clean' 
} 

task makeAndroid(type: Exec) { 
    workingDir '../../' 
    commandLine 'make', 'android' 
} 

task makeAndroidAll(type: Exec) { 
    workingDir '../../' 
    commandLine 'make', 'apackage' 
} 

---

// mapbox-gl-native/platform/android/MapboxGLAndroidSDKTestApp/build.gradle 

apply plugin: 'android-sdk-manager' 
apply plugin: 'com.android.model.application' 
apply plugin: 'checkstyle' 

task accessToken { 
    def tokenFile = new File("MapboxGLAndroidSDKTestApp/src/main/res/values/developer-config.xml") 
    if (!tokenFile.exists()) { 
     String tokenFileContents = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + 
       "<resources>\n" + 
       " <string name=\"mapbox_access_token\">" + "$System.env.MAPBOX_ACCESS_TOKEN" + "</string>\n" + 
       "</resources>" 

     if (tokenFileContents == null) { 
      throw new InvalidUserDataException("You must set the MAPBOX_ACCESS_TOKEN environment variable.") 
     } 
     tokenFile.write(tokenFileContents) 
    } 
} 

gradle.projectsEvaluated { 
    // preBuild.dependsOn('accessToken') 
} 

ext { 
    supportLibVersion = '23.4.0' 
} 

model { 
android { 
    compileSdkVersion 23 
    buildToolsVersion "23.0.3" 

    defaultConfig { 
     applicationId "com.mapbox.mapboxsdk.testapp" 
     minSdkVersion.apiLevel 15 
     targetSdkVersion.apiLevel 23 
     versionCode 9 
     versionName "4.1.0" 

     // Specify AndroidJUnitRunner as the default test instrumentation runner 
     testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" 
    } 

    compileOptions { 
     sourceCompatibility JavaVersion.VERSION_1_7 
     targetCompatibility JavaVersion.VERSION_1_7 
    } 

    packagingOptions { 
     exclude 'META-INF/LICENSE.txt' 
     exclude 'META-INF/NOTICE.txt' 
     exclude 'LICENSE.txt' 
    } 

    lintOptions { 
     checkAllWarnings true 
     warningsAsErrors true 
     disable 'IconDensities' 
     disable 'InvalidPackage' 
    } 

    testOptions { 
     unitTests.returnDefaultValues = true 
    } 

    buildTypes { 
     debug { 
      // run code coverage reports 
      testCoverageEnabled = true 
     } 
     release { 
      minifyEnabled false 
      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 
     } 
    } 
} 
} 

dependencies { 
    compile(project(':MapboxGLAndroidSDK')) { 
     transitive = true 
    } 

    // Support libraries 
    compile "com.android.support:support-annotations:${supportLibVersion}" 
    compile "com.android.support:support-v4:${supportLibVersion}" 
    compile "com.android.support:appcompat-v7:${supportLibVersion}" 
    compile "com.android.support:design:${supportLibVersion}" 
    compile "com.android.support:recyclerview-v7:${supportLibVersion}" 

    // Leak Canary 
    //debugCompile 'com.squareup.leakcanary:leakcanary-android:1.4-beta1' 
    //releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.4-beta1' 

    // Directions SDK 
    compile('com.mapbox.mapboxsdk:mapbox-android-directions:1.0.0@aar') { 
     transitive = true 
    } 

    // Geocoder SDK 
    compile('com.mapbox.mapboxsdk:mapbox-android-geocoder:1.0.0@aar') { 
     transitive = true 
    } 

    // Testing dependencies 
    testCompile 'junit:junit:4.12' 
    testCompile 'org.mockito:mockito-core:1.10.19' 
    androidTestCompile "com.android.support:support-annotations:${supportLibVersion}" 
    androidTestCompile 'com.android.support.test:runner:0.4.1' 
    androidTestCompile 'com.android.support.test:rules:0.4.1' 
    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.2.1' 
    androidTestCompile 'com.jayway.android.robotium:robotium-solo:5.5.4' 
} 

checkstyle { 
    configFile project.file('../checks.xml') 
    showViolations true 
} 

model { 
android.applicationVariants.all { variant -> 
    def name = variant.buildType.name 
    def checkstyle = project.tasks.create "checkstyle${name.capitalize()}", Checkstyle 
    checkstyle.dependsOn variant.javaCompile 
    checkstyle.source variant.javaCompile.source 
    checkstyle.classpath = project.fileTree(variant.javaCompile.destinationDir) 
    checkstyle.exclude('**/BuildConfig.java') 
    checkstyle.exclude('**/R.java') 
    project.tasks.getByName("check").dependsOn checkstyle 
} 
} 

Answer 1

귀하의 Gradle을 접근 방식은 본질적으로 Android SDK Makefile을 gradle로 다시 작성하거나 이식하는 것입니다. Linux에서 수행중인 작업을 해결하려면 기존 Makefile을 수정해야 할 수 있습니다.

이유는 Mapbox Android SDK build process이 make android을 사용하여 대상인 libmapbox-gl.so을 빌드하기 때문입니다. 보유하고있는 Gradle 프로젝트에는 일반적인 Java 코드와 함께 .so 파일이 포함되어 있습니다.

make android는 mapbox-gl-native/Makefile

에 전화를하게하고 또한 크리스 스트래튼 위의 댓글에서 언급으로 디버그 정보를 생성 수정하는 방법을 연구 할 수있는, mapbox-gl-native/build/android-arm-v7/Makefile를 생성합니다.

C++를 수정하려고 할 때 수정 된 .so를 Android 용으로 사용하려면 settings.gradle을 수정해야합니다.

include ':MapboxGLAndroidSDK' 
project(':MapboxGLAndroidSDK').projectDir = new File(rootProject.projectDir, '<relative-path-to>/../mapbox-gl-native/platform/android/MapboxGLAndroidSDK') 
include ':app' 

또 다른 고려 사항 - Linux 용 디버그 가능 버전을 구축 할 수 있습니까?

우리는 iOS 응용 프로그램을 빌드 할 때 Xcode 디버거를 사용하여 Mapbox SDK 용 C++를 성공적으로 디버깅했습니다. 저는 이것이 여러분의 정확한 요구에 맞지 않을 것이라는 것을 알고 있습니다 만, 연구소 나 조직의 다른 누구도 OS X에서 Xcode에 액세스 할 수 있고 make iproj을 사용하여 디버깅을 시작할 수 있다고 언급합니다.