android生成aar

❶ android Studio中编译aar release版本简便方法

在Android Studio中编译aar时，通常Build之后是Debug版本。
有网友提出添加了Release选项也无济于事：

其实，在控制台中输入gradlew assembleRelease指令即可生成，如下图所示，Mac上，AS的Terminal中生成aar Release包。

❷ android 怎样将mole打包成aar

1.aar包是Android studio下打包android工程中src、res、lib后生成的aar文件，aar包导入其他android studio 工程后，其他工程可以方便引用源码和资源文件
2.生成aar包步骤：
①.用android studio打开一个工程，然后新建一个Mole，新建Mole时候选择Android Library,后面按新建普通工程操作

②.新建Mole 类型为android Library 后如下图所示

③.在新建的Mole中编写完代码后，接下来编译整个工程后就会自动生成aar包，包的路径在新建的Mole ==》 build ===》outputs ==>aar目录下。 如图

3.其他androidstudio工程引用aar包
①.将aar包复制到lib目录下
②.配置build.gradle文件：
加入
repositories {
flatDir {
dirs 'libs'
}
compile(name:'camerascan-1.0', ext:'aar')

完整的配置文件：

[java] view plain
apply plugin: 'com.android.application'

android {
compileSdkVersion 22
buildToolsVersion "22.0.1"

defaultConfig {
applicationId "com.geenk.testcamerascanarr"
minSdkVersion 11
targetSdkVersion 22
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
repositories {
flatDir {
dirs 'libs'
}
}
}

dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile(name:'camerascan-1.0', ext:'aar')
compile 'com.android.support:appcompat-v7:22.2.0'
}

❸ 如何创建Android库以及Android aar文件详解

创建 Android 库

Android 库在结构上与 Android 应用模块相同。它可以提供构建应用所需的一切内容，包括源代码、资源文件和 Android 清单。不过，Android 库将编译到您可以用作 Android 应用模块依赖项的 Android 归档 (AAR：Android Archive Resource) 文件，而不是在设备上运行的 APK。与 JAR 文件不同，AAR 文件可以包含 Android 资源和一个清单文件，这样，除了 Java 类与方法外，您还可以捆绑布局和可绘制对象等共享资源。

库模块在以下情况下非常有用：

• 构建使用某些相同组件（例如 Activity、服务或 UI 布局）的多个应用。

• 构建存在多个 APK 变体（例如免费版本和付费版本）的应用并且需要在两种版本中使用相同的核心组件。
  在任何一种情况下，只需要将您希望重用的文件移动到库模块中，然后以依赖项的形式为每个应用模块添加库。本页面将说明如何执行这两个操作。

创建库模块

要在您的项目中创建一个新的库模块，请按以下步骤操作：
1、点击** File > New > New Mole。**
2、在出现的 Create New Mole 窗口中，依次点击** Android Library 和 Next。还存在一个用于创建 Java 库的选项，可以构建传统的 JAR 文件。尽管 JAR 文件在大多数项目中都非常实用（尤其在您希望与其他平台共享代码时），但这种文件不允许您包含 Android 资源或清单文件，而后者对于 Android 项目中的代码重用非常有用。**因此，本指南将侧重论述创建 Android 库。
3、为您的库命名，并为库中代码选择一个最低的 SDK 版本，然后点击 Finish。

在 Gradle 项目同步完成后，库模块将显示左侧的 Project 面板中。如果您未看到新模块文件夹，请确保将视图切换为 Android 视图。

将应用模块转换为库模块

如果您现有的应用模块包含您希望重用的所有代码，则可以按照以下步骤将其转换为库模块：

1、打开现有应用模块的 build.gradle 文件。您应在顶部看到以下内容：

• apply plugin: 'com.android.application'



2、按照下面所示更改插件分配：

• apply plugin: 'com.android.library'



3、点击 Sync Project with Gradle Files。

就这么简单。模块的整个结构仍然相同，但是现在它将作为 Android 库运行，构建也将创建一个 AAR 文件，而不是 APK。

生成aar

在Android Studio1.4中，New project，先默认新建一个Applicaton mole，接后File > New > New Mole，选择Androd Library > Next，指定Library Name和Mole Name。

新建的Library与正常的Application最大区别是mole build.gradle中是**apply plugin: ‘com.android.library’ **而不是 apply plugin: 'com.android.application'

Build > Make project，自动生成aar文件。



以依赖项形式添加您的库

要在另一个应用模块中使用您的 Android 库的代码，请按以下步骤操作：

1、通过两种方式之一将库添加到您的项目（如果您是在相同项目中创建的库模块，则该模块已经存在，您可以跳过此步骤）：

• 添加已编译的 AAR（或 JAR）文件：
  1、点击 File > New Mole。
  2、依次点击 Import .JAR/.AAR Package 和** Next**。
  3、输入 AAR 或 JAR 文件的位置，然后点击 Finish。

• 将库模块导入到您的项目中：
  1、点击** File > New > Import Mole。**
  2、输入库模块目录的位置，然后点击 Finish。
  库模块将复制到您的项目中，因此您可以尽管编辑库代码。如果您希望维护一个版本的库代码，则此方法可能不是您想要的，您应按照上文所述导入编译的 AAR 文件。

2、确保库列在您 settings.gradle 文件的顶部，如下面名为“my-library-mole”的库所示：

• include ':app', ':my-library-mole'



3、打开应用模块的 build.gradle 文件，并向 dependencies 块中添加一行新代码，如下面的片段所示：

• dependencies {


• compile project(":my-library-mole")


• }



4、点击 Sync Project with Gradle Files。
在上面的示例中，名为 my-library- mole 的 Android 库模块成为 build.gradle 文件所在模块的构建依赖项。
您的应用模块现在可以访问 Android 库中的任何代码和资源，库 AAR 文件在构建时已捆绑到您的 APK 中。
不过，如果希望单独共享 AAR 文件，则可以在 项目名称/模块名称/build/outputs/aar/ 中找到它，也可以通过点击 Build > Make Project 的方式重新生成此文件。

选择要设为公开的资源

库中的所有资源在默认情况下均处于公开状态。要将所有资源隐式设为私有，您必须至少将一个特定的属性定义为公开。资源包括您项目的 res/ 目录中的所有文件，例如图像。要阻止您的库用户访问仅供内部使用的资源，您应通过声明一个或多个公开资源的方式来使用这种自动私有标识机制。

要删除某个公开资源，请将一个声明添加到您的库的 public.xml文件中。如果您之前尚未添加公开资源，则需要在您的库的 res/values/目录中创建public.xml 文件。

下面的示例代码可以创建两个名称分别为 mylib_app_name和 mylib_public_string 的公开字符串资源：

• <resources>


• <public name="mylib_app_name" type="string"/>


• <public name="mylib_public_string" type="string"/>


• </resources>```


• 如果希望任何资源保持对使用您的库的开发者可见，您应当将其设为公开。例如，尽管 [v7 appcompat 库](https://developer.android.com/topic/libraries/support-library/features.html#v7-appcompat)中的大多数资源都是私有资源，但是为了支持[Material Design](https://developer.android.com/design/material/index.html)，控制工具栏小部件的属性应当公开。将属性隐式设为私有不仅可以阻止您的库用户从内部库资源获得代码自动完成建议，还让您能够在不中断您的库客户端的情况下重命名或移除私有资源。私有资源不在代码自动完成和 [Theme Editor](https://developer.android.com/studio/write/theme-editor.html) 的作用范围内，并且如果您尝试引用私有资源，[Lint](https://developer.android.com/studio/write/lint.html) 将显示警告。##开发注意事项在开发您的库模块和相关应用时，请注意以下行为和限制。


• 将库模块引用添加至您的 Android 应用模块后，您可以设置它们的相对优先级。构建时，库会按照一次一个的方式与应用合并，并按照从低到高的优先级顺序。


• * **资源合并冲突**


• 构建工具会将库模块中的资源与相关应用模块的资源合并。如果在两个模块中均定义了给定资源 ID，将使用应用中的资源。


• 如果多个 AAR 库之间发生冲突，将使用依赖项列表首先列出（位于 dependencies块顶部）的库中的资源。


• 为了避免常用资源 ID 的资源冲突，请使用在模块（或在所有项目模块）中具有唯一性的前缀或其他一致的命名方案。



• * **库模块可以包含 JAR 库**


• 您可以开发一个自身包含 JAR 库的库模块；不过，您需要手动编辑相关应用模块的构建路径，并添加 JAR 文件的路径。



• * **库模块可以依赖外部 JAR 库**


• 您可以开发一个依赖于外部库（例如 Maps 外部库）的库模块。在这种情况下，相关应用必须针对包含外部库（例如 Google API 插件）的目标构建。另外也要注意，库模块和相关应用都必须在其清单文件的 [<uses- library>


• ](https://developer.android.com/guide/topics/manifest/uses-library-element.html) 元素中声明外部库。* **库模块不得包含原始资源**


• 工具不支持在库模块中使用原始资源文件（保存在 assets/目录中）。应用使用的任何原始资源都必须存储在应用模块自身的 assets/目录中。



• * **应用模块的 minSdkVersion必须大于或等于库定义的版本**


• 库作为相关应用模块的一部分编译，因此，库模块中使用的 API 必须与应用模块支持的平台版本兼容。



• * **每个库模块都会创建自己的 R 类**


• 在您构建相关应用模块时，库模块将先编译到 AAR 文件中，然后再添加到应用模块中。因此，每个库都有其自己的 R 类，并根据库的软件包名称命名。从主模块和库模块生成的 R 类会在所需的所有软件包（包括主模块的软件包和库的软件包）中创建。



• * **库模块可能包含自己的 ProGuard 配置文件**


• 通过将 [ProGuard](https://developer.android.com/studio/build/shrink-code.html) 配置文件添加到包含其 ProGuard 指令的库，您可以在自己的库上启用代码压缩。构建工具会为库模块将此文件嵌入到生成的 AAR 文件中。在您将库添加到应用模块时，库的 ProGuard 文件将附加至应用模块的 ProGuard 配置文件 (proguard.txt)。通过将 ProGuard 文件嵌入到您的库模块中，您可以确保依赖于此库的应用模块不必手动更新其 ProGuard 文件即可使用库。当 ProGuard 在 Android 应用模块上运行时，它会同时使用来自应用模块和库的指令，因此您不应当只在库上运行 ProGuard。


• 要指定您的库的配置文件名称，请将其添加到 consumerProguardFiles方法中，此方法位于您的库的 build.gradle文件的 defaultConfig块内。例如，以下片段会将 lib-proguard-rules.txt设置为库的 ProGuard 配置文件：



android {
defaultConfig {
consumerProguardFiles 'lib-proguard-rules.txt'
}
...
}

• 默认情况下，应用模块会使用库的发布构建，即使在使用应用模块的调试构建类型时亦是如此。要使用库中不同的构建类型，您必须将依赖项添加到应用的 build.gradle文件的 dependencies块中，并在库的 build.gradle文件中将 publishNonDefault设置为 true。例如，您应用的 build.gradle文件中的以下代码段会使应用在应用模块于调试模式下构建时使用库的调试构建类型，以及在应用模块于发布模式下构建时使用库的发布构建类型：



dependencies {
debugCompile project(path: ':library', configuration: 'debug')
releaseCompile project(path: ':library', configuration: 'release')
}

• 您还必须在自己库的 build.gradle文件的 android 块内添加以下代码行，以便将此库的非发布配置展示给使用它的项目：



android {
...
publishNonDefault true
}```
不过请注意，设置 publishNonDefault会增加构建时间。
为了确保您的库的 ProGuard 规则不会将意外的压缩副作用施加到应用模块，请仅包含适当规则，停用不适用于此库的 ProGuard 功能。尝试协助开发者的规则可能会与应用模块或它的其他库中的现有代码冲突，因此不应包含这些规则。例如，您的库的 ProGuard 文件可以指定在应用模块的压缩期间需要保留的代码。

注：Jack 工具链仅支持 ProGuard 的部分压缩和模糊选项。

AAR 文件详解

AAR 文件的文件扩展名为 .aar，Maven 工件类型也应当是 aar。文件本身是一个包含以下强制性条目的 zip文件：

• /AndroidManifest.xml

• /classes.jar

• /res/

• /R.txt

此外，AAR 文件可能包含以下可选条目中的一个或多个：

• /assets/

• /libs/**名称 **.jar

• /jni/abi 名称 /名称.so（其中 abi 名称是 Android 支持的 ABI 之一）

• /proguard.txt

• /lint.jar

❹ uniapp安卓aar插件问题

Android插件在application中初始化了很多东西，如果生成aar包提供给前端，让前端进行云打包，那么Android在application中所初始化的东西将会失效，因为云打包，我们无法控制让他加载我们的application。Android插件依赖了很多第三方的aar包，如果把插件打成aar包，那么插件依赖的第三方aar包将无法和插件打包成一个aar文件，就会导致插件中很多类和文件找不到uniapp前端配置文件中可以依赖于maven仓库，但是uniapp的maven仅限于jcenter和aliyun名下的才能引用。

❺ android studio aar怎么用

一. 简介

aar是一个类似于jar的文件格式。但是他们之间是有区别的。
jar：仅仅包含class和清单文件，没有资源文件。
aar：包含了class文件和资源文件。说白了就是Android的专属“jar”

将代码打包成aar文件，可以在一定程度上加快AndroidStudio的速度。
尤其是将Mole打包成aar文件，提升的效果很显着。

二. 如何得到aar

1. Mole的aar文件

将一个AndroidStudio项目中的Mole打包成aar其实很简单。
在每一个Mole的目录下面都会有这样一个文件夹：build\outputs\aar。
这个文件夹下面就放着这个Mole对应的aar文件。
一般情况下会有两个aar文件，一个debug版本，一个release版本。
我们选择release的就ok。
注意：
新建的Mole是没有这个文件夹的。这时，你可以使用 两种方法 生成这个文件夹

将整个项目运行一遍，这个文件夹会自动生成
执行命令 ./gradlew assembleRelease 也可以生成这个文件夹
Mole中的libs目录文件会随着项目的编译被打包进aar文件中，但是build.gradle中的引用库不会打包进aar文件中，这个需要 特别留意。如果你忽略了这个Mole的build.gradle中的引用库，很可能引发ClassNotFoundException异常。
2. 远程仓库的aar

在项目里面经常会引用一下远程仓库的依赖库。
这时，我们也可以将它以aar的形式引入到项目中。
这个依赖库的aar其实也很好找。
当你配置好一个依赖库以后，点击 Sync Now 。
AndroidStudio会自动下载这个库到C盘（windows）。你找到这个文件就可以了。
这里我使用的是Everything进行搜索，很方便就找到这个库的下载文件夹。其他操作系统就自行搜索吧，总之找见这个项目的下载文件夹就ok。
这个下载文件夹中包含了这个项目所需要的所有东西：包括aar、jar等文件。

后面会以一个例子详细讲解这个过程

注：
Everything是一个搜索软件，可以瞬间搜索全盘。
是一个非常实用的软件。但是很可惜只有windows版本。
官网地址：<a href="<a href="https://www.voidtools.com/" target="_blank">https://www.voidtools.com/</a>" target="_blank"><a href="https://www.voidtools.com/" target="_blank">https://www.voidtools.com/</a></a>
三. 如何使用aar

想要使用aar文件，需要经过以下几步：

1. 在app的build.gradle中加入以下配置

repositories {
flatDir {
dirs 'libs' // aar目录
}
}
2. 将aar文件拷贝到app/libs目录下

3. 在dependencies中加入aar引用

compile(name: 'zbar-release', ext: 'aar')
四. LeakCanary项目示例

因为Mole的例子比较简单，所以选择远程代码库作为示例。
这里使用一个经常使用的内存检测项目LeakCanary来做一个示例。
我们通常使用依赖来使用这个库：

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.3'
releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.3'
当Sync Now完成后，我们可以在C盘（windows）找见这个项目文件夹。

这个文件夹下面就有我们需要的两个依赖库：leakcanary-android和leakcanary-android-no-op
点开leakcanary-android文件夹，目录结构如下（1.3是对应的版本号）：

leakcanary-android文件夹
打开最里层的文件夹，你会发现文件的类型主要有三种：

jar文件：有的项目是以jar文件形式提供
aar文件：有的项目是以aar文件形式提供
pom文件： （Project Object Model），实际上就是个xml，是对一些必要信息的说明。这里我们只关心一个节点信息：<dependencies>：声明依赖列表
我们用文本编辑器打开leakcanary-android文件夹下面的pom文件:
...
<dependencies>
<dependency>
<!--包组 id，通常是发布者拥有的域名的反向，以免跟别人的重复-->
<groupId>com.squareup.leakcanary</groupId>
<!--包 artifactId，其实就是组以下应该有一个更小的归类-->
<artifactId>leakcanary-analyzer</artifactId>
<!--版本号-->
<version>1.3</version>
<scope>compile</scope>
</dependency>
</dependencies>
..
当我们打开leakcanary-android的pom文件，
我们发现leakcanary-android依赖于leakcanary-analyzer的1.3版本。

同样的的我们打开leakcanary-analyzer 的pom文件,
发现leakcanary-analyzer依赖leakcanary-watcher和haha。

leakcanary-watcher和haha则没有依赖任何东西。

这样整个leakcanary-android导入本地的东西就是四个：

leakcanary-android
leakcanary-analyzer
leakcanary-watcher
haha
同样的方式去一层一层解析leakcanary-android-no-op，将所有需要的文件都导入到AndroidStudio中。这样整个LeakCanary就被我们真正实现本地化了。

debugCompile 'com.squareup.leakcanary:leakcanary-android:1.3'
releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.3'
debugCompile(name: 'leakcanary-android-1.3', ext: 'aar')
compile files('libs/leakcanary-analyzer-1.3.jar')
compile files('libs/leakcanary-watcher-1.3.jar')
compile files('libs/haha-1.1.jar')
releaseCompile(name: 'leakcanary-android-no-op-1.3', ext: 'aar')
这样就将整个LeakCanary项目完全转换成了本地的依赖。

❻ 如何将android studio整个工程编译成aar

要输出aar文件，必须将Mole配置为library，在gradle文件中如下：输出aar：applyplugin:'com.android.library'；输出apk：applyplugin:'com.android.application'。将Mole配置为library后，构建输出一个aar文件，根据渠道和BuildType的不同，在相应的目录下可以找到。比如对BuildType为debug的配置，输出为：[MoleName]/build/outputs/aar/[MoleName]-debug.aar。一份aar文件其实就是一份zip包，和jar不同的是，它将一些资源文件、第三方库文件、so文件等等都打包在内，而代码文件编译后压缩在在classes.jar中。比如：3、导入aar的方式引用这种方式比较简单，打开ProjectStructure，添加一个新Mole，然后选择Import*.JARor*.AARPackage的方式导入：导入后，在你的工程下面，会生成一个文件夹，里面是aar文件以及AndroidStudio的配置文件。接着可以在gradle中配置依赖了，其他Mole可以引用这个Mole了，依赖方式使用compileproject的方式即可。缺点：被依赖的aar无法F3跟进去，无法看到资源文件内容以及目录层级等等缺陷。4、使用配置依赖的方式引用gradle其实还有另一种依赖可以引用aar：compile(name:'xxx',ext:'aar')。首先需要将aar文件放入引用Mole的libs目录下，和一般的jar文件类似。然后在gradle配置文件中把libs目录加入依赖：?12345repositories{flatDir{dirs'libs'}}接着在gradle的依赖配置中加入compile(name:'xxx',ext:'aar')这一句，依赖即可关联完毕。构建一下工程，在Mole的build/intermediates/exploded-aar目录下，可以看到有一些临时文件生成：看起来完全是引用aar的解压版本。AndroidStudio安装反编译插件后，可以通过F3跟进到class文件里面，如果你有被依赖Mole的源代码的话，还可以AttachSource关联源代码查看。另外，可以很方便的查看aar中的资源文件。另外，这种依赖方式更新aar后，生成的临时文件也会随之变动，不用担心改动不同步的问题。

❼ Android Studio如何使用aar依赖包

ps:2013-12-25 号更新,升级到0.4以后 这种方法已经完美使用！

因为项目里面要用到actionbarsherlock，所以研究了一下如何导入到android studio中。
arr(Android Archive)：名字是谷歌到的，至于中文叫什么我也不知道。不过好像依赖都要使用这样的包了。
首先说明我使用的android studio 版本是3.1.因为现在android studio的bug还不较多，所以你的版本能不能正常使用我就不敢说了。
如果你只是单纯的想使用actionbarsherlock的话，引用是十分简单的

复制代码

代码如下:

dependencies {
// compile fileTree(dir: 'libs', include: '*.aar')
compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
compile 'com.android.support:support-v4:18.0.+'
}

然后重新编译一下项目就行了。(ps 这两天看见群里面都在讨论引用第三方jar包，请看我的第一行注释，你只要新建一个libs的文件夹，然后把想要jar包复制到文件夹下，接着把注释那句复制到build文件中，修改一下（*.aar -> *.jar）就可以了)

但是我们要是使用本地的aar文件，我谷歌了两天总算是勉强能用了，请看我的实现过程，如果你有更好的请转告小弟共同进步

第一步 ：生成aar文件

我的方法是通过maven-android-plugin来生成的，如果你使用过actionbarsherlock以前的版本的话，这个工具应该不陌生，如果你连maven 都不知道的话，建议好好学习一下maven，虽然现在gradle很火 ，但是我还是最喜欢maven。

关于具体生成步骤不久不详细说了，文章最后贴出几个网址供大家学习使用，放心我按顺序给你们，只要一步一步的来绝对能成功

1、把你的maven版本提升到3.1.1
2、去github上clone下来 maven-android-sdk-deployer 这个项目https://github.com/mosabua/maven-android-sdk-deployer，按照使用说明安装android的版本
3、通过maven-android-plugin生成一个android项目

复制代码

代码如下:

mvn archetype:generate /
-DarchetypeArtifactId=android-quickstart /
-DarchetypeGroupId=de.akquinet.android.archetypes /
-DarchetypeVersion=1.0.11 /
-DgroupId=your.company /
-DartifactId=my-android-application

4 修改pom

复制代码

代码如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.lee.study.android</groupId>
<artifactId>NiMa</artifactId>
<packaging>aar</packaging>
<name>NiMa</name></p><p> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<platform.version> 4.1.1.4
</platform.version>
<android.plugin.version>3.8.0</android.plugin.version>
</properties>
<dependencies>
<dependency>
<groupId>com.google.android</groupId>
<artifactId>android</artifactId>
<version>${platform.version}</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<pluginManagement>
<plugins>
<plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId>
<version>${android.plugin.version}</version>
<extensions>true</extensions>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId>
<configuration>
<sdk>
<platform>16</platform>
<path>E:/android_work/sdk/</path>
</sdk>
</configuration>
</plugin>
</plugins>
</build>
</project>

这是我的pom，打包类型改成aar，插件改成3.8版本，添加ANDROID_HOME到path。

5 执行 mvn install ,这样我们就得到了aar文件，和aar-class.jar文件，其实aar文件里面包含class.jar文件，但是我目前的版本必须手动导入到android studio中，这就是不完美之处。

第二步 导入到android studio中 创建libs文件夹，放入想要导入的文件

1 修改build.gradle ,依然是给出我的大家可以按照自己的项目对比修改

复制代码

代码如下:

buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:0.6.+'
}
}
apply plugin: 'android'</p><p>repositories {
mavenLocal()
mavenCentral()
flatDir {
dirs 'libs'
}
}
android {
compileSdkVersion 18
buildToolsVersion "18.1.1"</p><p> defaultConfig {
minSdkVersion 7
targetSdkVersion 18
}
}
dependencies {
// compile fileTree(dir: 'libs', include: '*.aar')
compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
compile 'com.jayway.maven.plugins.android.generation2.samples.libraryprojects:aar-lib1:1.0.0@aar'
//compile 'com.lee.study.android:NiMa:0.0.1@aar'
compile 'com.android.support:support-v4:18.0.+'
}
android {
compileOptions.encoding = "UTF-8"
}

repositories 添加了 flatDir ， dependencies 里面添加了 依赖的aar文件。
如果你做到这一步，重新编译一下依赖就添加好了，我目前的版本添加完了aar访问aar中的资源文件是不成问题的，但是不能访问到aar中的类文件。如果你和我一样不幸的话，请看下一步
2 手动的添加class.jar文件到android -studio，选中项目F4 ，手动添加依赖 jar到项目，看图片

如果这一步你也搞定了，恭喜你就能和我一样使用依赖了

Toast 显示的内容是依赖包中的一个静态方法返回的文本内容。

最后关于maven 如果搭建android项目的网址，按顺序看就可以

https://code.google.com/p/maven-android-plugin/
http://stand.spree.de/wiki_details_maven_archetypes
http://javacan.tistory.com/198

❽ 如何制作一个android studio的aar依赖包

首先说明咱使用的android studio
版本是0.4.因为现在android studio的bug还不较多，所以版本能不能正常使用就不敢说了。

如果只是单纯的想使用actionbarsherlock的话，引用是十分简单的dependencies {
// compile fileTree(dir: 'libs', include: '*.aar')
compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
compile 'com.android.support:support-v4:18.0.+'
}


不过官方也出了一个兼容包，也非常的不错。so 没必要非得要使用actionbarsherlock。

然后重新编译一下项目就行了。(ps
引用第三方jar包，请看第一行注释，只要新建一个libs的文件夹，然后把想要jar包复制到文件夹下，接着把注释那句复制到build文件中，修改一下（*.aar
-> *.jar）就可以了)。

但是要是使用本地的自定义的aar文件，请看实现过程
第一步 ：生成aar文件

方法是通过maven-android-plugin来生成的，如果使用过actionbarsherlock以前的版本的话，这个工具应该不陌生，如果连maven
都不知道的话，建议好好学习一下maven，虽然现在gradle很火 ，但是个人还是最喜欢maven。

关于具体生成步骤不久不详细说了，

1 把自己的maven版本提升到3.1.1
2 去github上clone下来
maven-android-sdk-deployer 这个项目
3 通过maven-android-plugin生成一个android项目



mvn archetype:generate \
-DarchetypeArtifactId=android-quickstart \
-DarchetypeGroupId=de.akquinet.android.archetypes \
-DarchetypeVersion=1.0.11 \
-DgroupId=your.company \
-DartifactId=my-android-application


如果不能够编译可能要修改一下pom



<?xml version="1.0" encoding="UTF-8"?>
<modelVersion>4.0.0</modelVersion>
<groupId>com.lee.study.android</groupId>
<artifactId>NiMa</artifactId>
<version>0.0.1</version>
<packaging>aar</packaging>
<name>NiMa</name>

<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<platform.version> 4.1.1.4
</platform.version>
<android.plugin.version>3.8.0</android.plugin.version>
</properties>

<dependencies>
<dependency>
<groupId>com.google.android</groupId>
<artifactId>android</artifactId>
<version>${platform.version}</version>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<finalName>${project.artifactId}</finalName>
<pluginManagement>
<plugins>
<plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId>
<version>${android.plugin.version}</version>
<extensions>true</extensions>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId>
<configuration>
<sdk>
<platform>16</platform>
<path>E:\android_work\sdk\</path>
</sdk>
</configuration>
</plugin>
</plugins>
</build>
</project>


上面都是个人pom，修改了打包类型和插件版本以及添加了sdk位置。

然后执行打包命令，就可以生成aar文件了，如果是已经有写好的类库的话，可以尝试这修改成maven形式的。

第二步
导入到android studio中 创建libs文件夹，放入想要导入的文件

1 修改build.gradle ,依然是给出可以按照自己的项目对比修改



buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:0.6.+'
}
}
apply plugin: 'android'

repositories {
mavenLocal()
mavenCentral()
flatDir {
dirs 'libs'
}
}

android {
compileSdkVersion 18
buildToolsVersion "18.1.1"

defaultConfig {
minSdkVersion 7
targetSdkVersion 18
}
}

dependencies {
// compile fileTree(dir: 'libs', include: '*.aar') compile 'com.actionbarsherlock:actionbarsherlock:4.4.0@aar'
compile 'com.jayway.maven.plugins.android.generation2.samples.libraryprojects:aar-lib1:1.0.0@aar'
//compile 'com.lee.study.android:NiMa:0.0.1@aar' compile 'com.android.support:support-v4:18.0.+'
}
android {
compileOptions.encoding = "UTF-8"
}

❾ Android发布AAR包

最近有需求要发布一套SDK，这套SDK有几个要求：

依照上面的要求我最先想到的就是AAR包了，因为以下几个原因：

打包aar其实很简单，只需要我们创建一个Library工程就可以了。

这个时候编译Library就会在outputs目录下生成一个aar文件夹，里面包含aar文件。

aar也是可以混淆的，方式和apk一样。

引用aar可以有两种方式，一种是本地引用，一种是远端库引用，目前我只用到了本地引用，远端的以后会补上。首先在bulid.gradle文件中定义一个本地库。

然后在依赖引用的地方添加依赖。

name：aar包的名字；ext：扩展名；

打包aar包的时候会自动将lib目录下的jar打包进aar包中。

因为分层的原因，有多个library工程，这样就会有多个aar，发布起来很麻烦，尝试google了半天，发现目前都是一个办法，android-fat-aar，一个gradle脚本，github地址是： https://github.com/adwiv/android-fat-aar 。不过我发现他支持gradle2.2.X之前的版本，新的3.X版本并不能执行。这块还在继续摸索，有知道办法的大神请指教一下~~~~

❿ Android：多aar打包

我使用的是网上这个 https://github.com/kezong/fat-aar-android
这个github库。

具体配置是再跟gradle中添加：
classpath 'com.kezong:fat-aar:1.2.7'

在需要打包的地方添加：
apply plugin: 'com.kezong.fat-aar'

然后添加需要合并的包，可以是远程包，本地aar，本地project。可以说很完整了。
例如：

怎么看远程依赖呢？下面这里就可以看

最后生成的aar包如下，jni和jar包都有了

反编译看看classes.jar看看，本地项目的类都在这里面了。

后面得看看是怎么打包起来的了，不然后续作者不维护了就蛋疼了。