देशी पुस्तकालय के लिए एंड्रॉइड एएआर पैकेज

Question

मैं एक मूल पुस्तकालय को एक एएआर पैकेज में पैकेज करने का एक तरीका ढूंढ रहा हूं, इसलिए इसे ग्रेडल स्क्रिप्ट में निर्भरता घोषणा के माध्यम से उपयोग करना संभव होगा।

मूल पुस्तकालय से मेरा मतलब है .cpp फ़ाइलों या संकलित स्थिर पुस्तकालय और शीर्षलेख फ़ाइलों का एक सेट। तो, मेरा मतलब है कि ऐप स्वयं पुस्तकालय को देशी कोड से कॉल करेगा, जावा से नहीं। दूसरे शब्दों में, लाइब्रेरी को ऐप के मूल कोड को संकलित करने की आवश्यकता है। ताकि देशी कोड की निर्भरता आसानी से प्रबंधित करना संभव हो।

क्या यह भी संभव है?

अब तक मुझे केवल इतना ही प्रश्न/उदाहरण मिल सकते हैं कि जेएनआई देशी पुस्तकालय के एएआर को .so फ़ाइल और उसके जावा इंटरफ़ेस के साथ कैसे बनाया जाए, इसलिए मूल कार्यान्वयन के साथ lib केवल जावा lib है, लेकिन यह नहीं है क्या चाहिए मुझे।

Answer 1

मिले समस्या के लिए निम्न hacky समाधान:

उपयोग एंड्रॉयड प्रायोगिक Gradle प्लगइन संस्करण 0.9.1 । विचार लाइब्रेरी हेडर और स्थैतिक पुस्तकालयों को .aar में रखना है। हेडर को ndkLibs/include पर रखा गया है और प्रत्येक आर्किटेक्चर के लिए ndkLibs/<arch> पर स्थैतिक libs डाल दिया गया है। फिर, ऐप में, या कोई अन्य lib जो इस पैक किए गए lib पर निर्भर करता है हम प्रोजेक्ट में निर्देशिका को AAR से build निर्देशिका में निकालें। नीचे उदाहरण gradle फ़ाइल देखें।

टिप्पणी के साथ पुस्तकालय के लिए build.gradle फ़ाइल:

apply plugin: "com.android.model.library" 

model { 
    android { 
     compileSdkVersion = 25 
     buildToolsVersion = '25.0.2' 

     defaultConfig { 
      minSdkVersion.apiLevel = 9 
      targetSdkVersion.apiLevel = 9 
      versionCode = 1 
      versionName = '1.0' 
     } 
     ndk { 
      platformVersion = 21 
      moduleName = "mylib" 
      toolchain = 'clang' 
      abiFilters.addAll(['armeabi', 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64', 'mips', 'mips64']) //this is default 
      ldLibs.addAll(['android', 'log']) 
      stl = 'c++_static' 
      cppFlags.add("-std=c++11") 
      cppFlags.add("-fexceptions") 
      cppFlags.add("-frtti") 

      //Add include path to be able to find headers from other AAR libraries 
      cppFlags.add("-I" + projectDir.getAbsolutePath() + "/build/ndkLibs/include") 
     } 

     //For each ABI add link-time library search path to be able to link against other AAR libraries 
     abis { 
      create("armeabi") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/armeabi") 
      } 
      create("armeabi-v7a") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/armeabi-v7a") 
      } 
      create("arm64-v8a") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/arm64-v8a") 
      } 
      create("x86") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/x86") 
      } 
      create("x86_64") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/x86_64") 
      } 
      create("mips") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/mips") 
      } 
      create("mips64") { 
       ldFlags.add("-L" + projectDir.getAbsolutePath() + "/build/ndkLibs/mips64") 
      } 
     } 
    } 

    //Configure this library source files 
    android.sources { 
     main { 
      jni { 
       //This does not affect AAR packaging 
       exportedHeaders { 
        srcDir "../../src/" 
       } 

       //This tells which source files to compile 
       source { 
        srcDirs '../../src' 
       } 
      } 
     } 
    } 
} 

//Custom Maven repository URLs to download AAR files from 
repositories { 
    maven { 
     url 'https://dl.bintray.com/igagis/android/' 
    } 
} 

//Our custom AAR dependencies, those in turn are also packed to AAR using the same approach 
dependencies { 
    compile fileTree(dir: 'libs', include: ['*.jar']) 
    compile 'io.github.igagis:libutki:+' 
    compile 'io.github.igagis:libsvgdom:+' 
    compile 'org.cairographics:cairo:+' 
} 


//=================================== 
//=== Extract NDK files from AARs === 
//This is to automatically extract ndkLibs directory from AAR to build directory before compiling any sources 
task extractNDKLibs { 
    doLast { 
     configurations.compile.each { 
      def file = it.absoluteFile 
      copy { 
       from zipTree(file) 
       into "build/" 
       include "ndkLibs/**/*" 
      } 
     } 
    } 
} 
build.dependsOn('extractNDKLibs') 
tasks.whenTaskAdded { task -> 
    if (task.name.startsWith('compile')) { 
     task.dependsOn('extractNDKLibs') 
    } 
} 



//================================= 
//=== pack library files to aar === 
//This stuff re-packs the release AAR file adding headers and static libs to there, but removing all shared (.so) libs, as we don't need them. The resulting AAR is put to the project root directory and can be uploaded to Maven along with POM file (you need to write one by hand). 

def aarName = name 

task copyNdkLibsToAAR(type: Zip) { 
    baseName = aarName 
    version = "\$(version)" 
    extension = 'aar.in' 
    destinationDir = file('..') //put resulting AAR file to upper level directory 

    from zipTree("build/outputs/aar/" + aarName + "-release.aar") 
    exclude('**/*.so') //do not include shared libraries into final AAR 
    from("../../src") { 
     exclude('makefile') 
     exclude('soname.txt') 
     exclude('**/*.cpp') 
     exclude('**/*.c') 
     into('ndkLibs/include') 
    } 
    from("build/intermediates/binaries/debug/lib"){ 
     include('**/*.a') 
     into('ndkLibs') 
    } 
} 

build.finalizedBy('copyNdkLibsToAAR') 

Answer 2

इस Link से, ऐसा लगता है कि यह संभव नहीं है। मैं सामग्री नीचे चिपकाने हूँ:

एक आर फ़ाइल

एक आर फ़ाइल के लिए फ़ाइल एक्सटेंशन .aar है, और Maven विरूपण साक्ष्य प्रकार की शारीरिक रचना के साथ-आर होना चाहिए।

• /AndroidManifest.xml
• /classes.jar
• /res/
• /R.txt

इसके अतिरिक्त: फ़ाइल स्वयं एक ज़िप निम्न अनिवार्य प्रविष्टियों फ़ाइल है जिसमें , एक एएआर फ़ाइल में निम्नलिखित में से एक या अधिक वैकल्पिक प्रविष्टियां शामिल हो सकती हैं:

• /आस्तियों/
• /libs/name.jar
• /jni/abi_name/name.so (जहां abi_name एंड्रॉयड में से एक है समर्थित Abis)
• /lint.jar
/proguard.txt

जैसा ऊपर बताया गया है, अनिवार्य प्रविष्टि में एक जार शामिल है। हालांकि आप एआर को अनजिप करके और फिर से ज़िप करके जार फ़ाइल को मैन्युअल रूप से हटाकर कोशिश कर सकते हैं। मुझे यकीन नहीं है कि यह काम करेगा या नहीं।

Answer 3

हालांकि मैं व्यक्तिगत रूप से करने के लिए प्रयास नहीं किया है, मैं कदम की here एक नंबर मिला:

शायद परोक्ष रूप से [एक बार थोड़ी देर पहले साझा लिब के साथ की कोशिश की], और मैं व्यक्तिगत रूप से नहीं लगता कि यह सार्थक है:

• अपने lib का निर्माण पहले एक स्थिर lib उत्पन्न करने के लिए, और एक आर [model.library टक नहीं करता * libs निर्देशिका यद्यपि में ए]
• अपने आर अनज़िप, और डाल * ए में libs
फ़ोल्डर
• अपने हेडर फ़ाइल के लिए एक जगह खोजें
• इसे अपने ऐप के अंदर एर पर वापस ज़िप करें, अपने आश्रित lib होने के लिए आरा बनाएं, इसलिए इसे विस्फोट-एआर फ़ोल्डर में निकाला जाएगा; तो रंगीन तस्वीर प्रकट होती है।
• इंटरमीडिएट विस्फोटित एआर निर्देशिका को पथ शामिल करने के लिए जोड़ें मुझे लगता है कि यह बहुत हैकी है और आपके ग्राहकों में उन्हें लागू करने का अच्छा विचार नहीं हो सकता है।

लिब और हेडर फ़ाइलों को वितरित करने का पारंपरिक तरीका सीधे ऊपर हैकिंग की तुलना में अभी भी बेहतर है। इमारत libs के लिए, cmake तरह से बेहतर है, गुरु-cmake शाखा में चेकआउट हैलो-libs, उम्मीद है कि इस मदद करता है