精华内容
下载资源
问答
  • android 多module打包aar
    2021-05-26 17:49:32

    一、打包 aar

    1、单个模块打包

    打开 Gradle 工具窗口,找到 Android Library 模块. 在 build 任务中双击 assemble.

    执行成功后,在 mylibrary/build/outputs/aar 目录下找到 aar 包.

    默认 Debug 和 Release 的 AAR 包都会打出来,当然你也可以选择只打 Debug 的包,双击 assembleDebug 任务就可以了. 只打 Release 的包同理.

    2、多个模块打包

    当要打包的模块又依赖了其它几个模块时,常常需要把它们打包成一个 aar。多模块打包使用 fat-aar(https://github.com/adwiv/android-fat-aar),

    打包关键步骤如下:

    将下载好的 fat-aar.gradle 文件添加到对应的模块目录中,

    并在 build.gradle中引入 apply from: ‘fat-aar.gradle’。

    或直接引用

    1

    apply from: 'https://raw.githubusercontent.com/adwiv/android-fat-aar/master/fat-aar.gradle'

    添加要打包的工程,使用 embedded 关键字。示例代码如下:

    12345678

    apply from: 'fat-aar.gradle'

    dependencies {

    ...

    embedded project(':DynamicPageLibrary')

    embedded project(':VideoPlayerLib')

    embedded project(':AudioPlayLibrary')

    embedded project(':BaseCloudMusicResource')

    }

    1

    步骤同上《单个模块打包》一致。

    问题1:部分依赖没有打包进去

    升级到 Android Studio 2.3 后,Gradle Plugin 也升级到 2.3.0,对应推荐使用的 Gradle 版本是 3.3。

    这时候会发现项目目录下 {module name}/build/intermediates/exploded-aar/ 目录没了,经过一番查找,发现这并不是一个 Bug,是官方刻意为之,它会在 {user name}/.android/build-cache 下生成一部分缓存文件,来代替 exploded-aar ,如果需要生成它,可以配置项目目录下的 gradle.properties ,添加一行内容:

    1

    android.enableBuildCache=false

    然后重建项目即可在 {module name}/build/intermediates/ 看到 exploded-aar 目录了。

    想重新开启 BuildCache 功能,可以修改为 android.enableBuildCache=true 或者直接删除本行内容即可。

    https://blog.csdn.net/ys743276112/article/details/62235542

    问题2: The prefix “tools” for attribute “tools:overrideLibrary” associated with an element type “uses-sdk” is not bound.

    问题通常是由插件引起的。 从项目插件中findAndroidManifest.xml,打开它,然后在

    下添加

    12

    xmlns:tools="http://schemas.android.com/tools"

    问题3:编译运行之后就报异常NoClassDefFoundError: android.support.v7.recyclerview.R$styleable

    重新引入依赖

    提取RecyclerView的classes.jar,把这个jar包放到项目中的libs文件下即可。

    这个jar包就是RecyclerView要使用的,

    可以给它改个名字例如android-support-v7-recyclerview.jar

    https://blog.csdn.net/jtahz1_23/article/details/50569588

    二、引入 aar

    方法一、通过 libs 引入到 app 中

    把 aar 文件放在 libs 目录下

    在 app 的 build.gradle 中添加如下内容

    12345

    repositories {

    flatDir {

    dirs 'libs'

    }

    }

    之后通过如下方式引入

    123

    dependencies {

    compile(name:'test', ext:'aar')

    }

    Rebuild project

    如果发现引入后无法使用,重启 Android studio

    方法二、把 aar 作为一个库工程的方式引入

    当项目中库工程较多且依赖关系比较复杂时,最好采用这一种方式。

    如:某一个库工程也要引入这个 aar 时。

    12345

    菜单栏 -> File -> New -> New Module

    -> Import .Jar/.AAR Package

    -> Next

    -> 选择 File name 的文件 -> Subproject name 命名工程

    -> Finish

    创建完成后是一个工程,工程中包括 aar 文件和 build.gradle 文件。build.gradle文件内容如下:

    12

    configurations.create("default")

    artifacts.add("default", file('musiclibrary_20170622.aar'))

    更多相关内容
  • 因为项目不同,有些公用库而且还是c++的,还有一些带资源的,简单的复制遇到库升级又是一轮配置,编译成aar则解决这些麻烦。 但是默认andriod studio的make moudle只生成debug包,在3.0以上及时生成release的apk,...
  • 例如 App 引用了两个 aar(1.aar 和 2.aar),1.aar 和 2.aar 都依赖了第三方的 3.aar,如果1.aar 和 2.aar 都把 3.aar 打包进去的话,App 再引用 1.aar 和 2.aar 的时候就会因为都有 3.aar 发生引用冲突。...
  • 安卓开发多module打包aar

    千次阅读 2020-05-06 18:33:08
    在SDK开发过程中,我们可能遇到过需要将多个Module的代码打包成一个jar或者aar的情况,由于安卓打包的时候不会将module依赖的其他module打包aar中,所以通过AS打包出来的aar是不完整的。但是在组件化开发盛行的...

    需求背景

    在SDK开发过程中,我们可能遇到过需要将多个Module的代码打包成一个jar或者aar的情况,由于安卓打包的时候不会将module依赖的其他module打包进aar中,所以通过AS打包出来的aar是不完整的。但是在组件化开发盛行的当下,这种诉求却越发明显。

    解决方案

    当然,针对上述问题,也有很多解决方案,比如利用Python脚本来对代码进行重组、利用Gradle来进行打包流程干预,还有直接使用单模块开发的方式。首先,使用单模块开发的方式是不会面临上述问题的,也就不存在解决,但是它会抛弃掉组件化开发或者模块化开发的巨大优势;其次,使用Python对代码进行重组,这种方式的成本比较低,利用Python脚本语言的拷贝等语法对多个模块的代码进行组合,然后对组合后的代码进行打包操作,可以实现多个模块打包成一个目标文件的目的;当然,我们还可以利用AS原生嵌入的Gradle来完成这项工作,通过在打包流程中添加自定义的操作来完成多模块打包成一个目标文件。

    下面对比下这几种方式的优缺点:

    方式优点缺点
    单模块兼容性高,没有额外的流程不支持组件化开发,在项目较复杂时,开发维护成本偏高
    Python处理思路简单,实现容易需要额外的脚本语言支持,需要操作文件,通用性较弱
    Gradle没有额外流程,扩展性强,接近原生速度需要对原始流程进行干预,操作部分文件

    事实上,在笔者的项目中,最开始是用的Python脚本的方式,打包时,调用Python命令来完成。在此过程中,通过执行Python脚本命令来完成打包的方式在每次版本迭代时,可能都需要修改打包脚本,在我们的jenkins服务器上也需要安装Python环境,因此,我们修改了打包方式,通过原生的Gradle来实现,这种方式让我们的项目的打包更简洁,直接通过AS的任务来实现,而且具备很强的通用性。

    方案分析

    针对Gradle这种方式,我们主要是利用Gradle的一些特性和Android标准打包流程来实现的。

    Gradle生命周期

    涉及到到gradle的构建干预,我们必须了解gradle的一些基本规则。gradle的构建流程有三个步骤(或者说它的生命周期包含三个主要节点),分别是:初始化、配置、执行。

    官方给出的定义是:

    A Gradle build has three distinct phases.
    
    Initialization
    Gradle supports single and multi-project builds. During the initialization phase, Gradle determines which projects are going to take part in the build, and creates a Project instance for each of these projects.
    
    Configuration
    During this phase the project objects are configured. The build scripts of all projects which are part of the build are executed.
    
    Execution
    Gradle determines the subset of the tasks, created and configured during the configuration phase, to be executed. The subset is determined by the task name arguments passed to the gradle command and the current directory. Gradle then executes each of the selected tasks.
    
    

    事实上,每个build.gradle文件都会对应一个Project对象,在初始化完成之后,我们就可以获取到这个对象并进行一些操作。而配置阶段则是针对我们的build.gradle文件来进行一些配置操作,比如构建任务树等。在执行阶段,就会按照配置阶段确定的任务树来依次执行每个任务(不开启并发执行的情况下)。

    而我们的切入点就是在执行接阶段来对构建流程进行干预。事实上,我们既可以通过项目内的gradle脚本来实现,也可以通过gradle的插件plugin来实现我们的功能。相对脚本,插件具备更加强的通用性和简洁性。但是这里,我们仅仅针对脚本来阐述下我们的实现思路。

    生命周期监听器

    在我们的实现中,我们没有采用自定义任务以及任务依赖的方式,因为这样我们需要添加额外的任务,并且需要通过额外的任务来完成我们的构建,这是我们不想看到的,也是我们抛弃掉Python构建方式的原因之一。我们采用的是通过对构建流程中项目以及各个任务的执行状态和流程来进行切入的。这里,我们可以使用gradle api 提供的各种监听器来实现。Gradle本身提供了很多监听器,使之具备极强的扩展性。具体包含:

      /**
         * <li>{@link org.gradle.BuildListener}
         * <li>{@link org.gradle.api.execution.TaskExecutionGraphListener}
         * <li>{@link org.gradle.api.ProjectEvaluationListener}
         * <li>{@link org.gradle.api.execution.TaskExecutionListener}
         * <li>{@link org.gradle.api.execution.TaskActionListener}
         * <li>{@link org.gradle.api.logging.StandardOutputListener}
         * <li>{@link org.gradle.api.tasks.testing.TestListener}
         * <li>{@link org.gradle.api.tasks.testing.TestOutputListener}
         * <li>{@link org.gradle.api.artifacts.DependencyResolutionListener}
         */
         
    

    其中有比较重要的几个监听器接口是我们在实现多模块打包中可以使用的。

    全局构建监听器:可以获取项目构建的一些关键性节点步骤,从而可以初始化一些全局变量。

    public interface BuildListener {
        /**
         * <p>Called when the build is started.</p>
         *
         * @param gradle The build which is being started. Never null.
         */
        void buildStarted(Gradle gradle);
    
        /**
         * <p>Called when the build settings have been loaded and evaluated. The settings object is fully configured and is
         * ready to use to load the build projects.</p>
         *
         * @param settings The settings. Never null.
         */
        void settingsEvaluated(Settings settings);
    
        /**
         * <p>Called when the projects for the build have been created from the settings. None of the projects have been
         * evaluated.</p>
         *
         * @param gradle The build which has been loaded. Never null.
         */
        void projectsLoaded(Gradle gradle);
    
        /**
         * <p>Called when all projects for the build have been evaluated. The project objects are fully configured and are
         * ready to use to populate the task graph.</p>
         *
         * @param gradle The build which has been evaluated. Never null.
         */
        void projectsEvaluated(Gradle gradle);
    
        /**
         * <p>Called when the build is completed. All selected tasks have been executed.</p>
         *
         * @param result The result of the build. Never null.
         */
        void buildFinished(BuildResult result);
    }
    
    

    任务状态监听器:可以获取每个任务的执行入口和出口,实现对指定任务的输入输出进行干预

    public interface TaskExecutionListener {
        /**
         * This method is called immediately before a task is executed.
         *
         * @param task The task about to be executed. Never null.
         */
        void beforeExecute(Task task);
    
        /**
         * This method is call immediately after a task has been executed. It is always called, regardless of whether the
         * task completed successfully, or failed with an exception.
         *
         * @param task The task which was executed. Never null.
         * @param state The task state. If the task failed with an exception, the exception is available in this
         * state. Never null.
         */
        void afterExecute(Task task, TaskState state);
    }
    
    

    任务树结果监听器:可以获知整个构建流程中的所有任务,实现对某些任务的移除,缩减构建时间等优化措施

    public interface TaskExecutionGraphListener {
        /**
         * <p>This method is called when the {@link TaskExecutionGraph} has been populated, and before any tasks are
         * executed.
         *
         * @param graph The graph. Never null.
         */
        void graphPopulated(TaskExecutionGraph graph);
    }
    

    Project对象

    上文提到过,每个build.gradle都对应一个Project对象,而且,需要指出的是,apply语法会将当前build.gradle的对象传递给引入的插件或者gradle对象。因此,我们可以通过需要构建的build.gradle对象,获取一些重要的信息。比如,配置列表、模块名称,模块属性等。同时还可以给当前的Project对象添加各种监听器。完成这些操作,我们只需要两行代码即可。。

    引入构建的gradle(插件)

    apply from: '../shell.gradle'
    

    获取Project对象

    /**以下语法是在shell.gradle文件中任意位置可用**/
    project.gradle
    

    其中project的gradle成员是非常核心的一个对象,它记录了构建流程的很多内容,并且通过它可以添加任务、行为(Action)、配置信息、监听器等。比如,我们添加监听器的方式为:

    project.gradle.addListener(new TaskListener())
    
    

    通过对这些基础信息的获取以及监听器的添加,我们就可以实现对构建流程的干预了。

    流程干预

    对构建流程的干预,我们主要是通过对构建任务的入口和出口进行干预的。我们通过
    beforeExecute来修改任务的输入(Task.inputs),通过afterExecute来管理任务的输出(Task.outputs),从而实现对参与打包的文件的管理和打包结果的控制。当然,我们可以通过一些简单的配置来确定我们需要处理的模块。类似:

       /**
       * 是否merge内容:BuildConfig等
       */
      private boolean merge;
    
       /**
       * 主模块名
       */
      private String host = "mainModule";
    
       /**
       * 参与构建的子模块名集合
       */
      private Set<String> subs = new HashSet<>();
    
      public TaskListener() {
        subs.add("module1")
        subs.add("module2")
        subs.add("module3")
        subs.add("module4")
      }
    
    
    

    其目的是确定参与构建的子模块、主模块以及某些任务的区分。当然,如果是插件的话,配置则更灵活。在这里,我们主要关心这几个任务:

      private final static String JAVA_WITH_JAVAC = "JavaWithJavac";
      private final static String BUILD_CONFIG = "BuildConfig";
      private final static String TRANSFORM = "transformClasses";
      private final static String AAR = "Aar";
      
    

    Javac:将java文件编译成字节码文件

    generateBuildConfig:确定是否抛弃,或者合并各个模块的构建配置类

    transformClasses:正常情况下,字节码文件处理的最后步骤

    bundleAar:将所有的构建产物压缩成aar的步骤,也是生成aar的最后步骤。

    所以我们只需要通过任务名称来对任务输入和输出进行控制,就可以达到我们的目的。简单的逻辑是:

    1. 记录各个子模块的javac输出
    2. 确定子模块的BuildConfig的处理规则:禁用或者删除
    3. 收集各个模块的资源文件
    4. 合并各个模块的R文件
    5. 将收集到的数据作为输入,传递给主模块的transform或者bundle任务

    举个例子:

    记录所有的字节码文件是通过监听javac任务的输出来实现的

          // 收集子模块字节码文件
          if (task.name.contains(JAVA_WITH_JAVAC)) {
            Iterator<File> it = task.outputs.getFiles().iterator()
            while (it.hasNext()) {
              toMoveFilePaths.addAll(listF(it.next()))
            }
          }
    

    确定子模块的BuildConfig处理规则是通过监听generateBuildConfig来实现的

            // 阻止子模块生成BuildConfig.java
            if (task.name.contains(BUILD_CONFIG)) {
              task.enabled(false)
            }
          }
    
    

    后续任务分别是通过generateResourcesgenerateRFilebundleAar来实现的。在打包aar之前,我们先合并一些文件,比如字节码文件的合并,将子模块的字节码文件拷贝到主模块的字节码文件中间目录中:

            // move lib classes to main lib
            if (task.name.contains(TRANSFORM) && !isTransformed) {
              String[] path = task.inputs.files.head().absolutePath.split("classes/")
              String libDir = path[0] + "classes/"
              for (int i = 0; i < toMoveFilePaths.size(); i++) {
                File file = toMoveFilePaths.get(i)
                String[] classPaths = file.absolutePath.split("classes/")
                String classPath = classPaths[classPaths.length - 1]
                File dest = new File(libDir, classPath);
                CopyFile(file, dest)
              }
              isTransformed = true;
            }
            
    

    这样,我们基本就完成了所有文件的处理,只需要bundleAar自身来合并就可以。

    思路扩展

    上述方案是通过自定义gradle监听来实现的,事实上利用Gradle自定义插件可以达到同样的效果,并且适用性和扩展性更强,参数的处理更灵活。以上方案主要是提供一种多模块打包AAR的解决思路,通过这种构建流程的监听和干预,我们可以在原生的构建体检下完成一些非常奇妙的操作。

    展开全文
  • 1.首先什么是aar格式 2. 怎么把一个模块编译成一个aar 首先把鼠标放到要编译的模块上 然后再点击:Build ->Build Module ‘xxx’ 刚刚鼠标选的模块 最后生成的aar包在这里 3. 怎么引用aar包 例如我把我刚刚编译的...
  • 添加 AAR 包文件到项目依赖(对应 Android Library,包含资源文件、manifest等);通过 Maven 仓库形式添加远程依赖 (远程依赖库文件,并且可以传递依赖关系);Android Studio 创建 module 时可以选择类型,当我们选择...

    通常来说,我们在项目中引入第三方 SDK 通常有下面几种方式:

    添加 JAR 包文件到项目依赖(对应 Java Library);

    添加 AAR 包文件到项目依赖(对应 Android Library,包含资源文件、manifest等);

    通过 Maven 仓库形式添加远程依赖 (远程依赖库文件,并且可以传递依赖关系);

    Android Studio 创建 module 时可以选择类型,当我们选择 Android Library 的形式构建模块,可以打包得到一个 AAR 包。通常开发一个复杂业务流程的 SDK 项目跟一般应用项目一样,会按照业务拆分成多个 module 进行构建,与开发应用的区别在于,SDK 项目在开发阶段处于可随时编译运行状态,打包时要合并多个 module 产出 AAR 形式的 SDK 包。因为每个 module 都会生成对应的 aar 文件,但是一般来说我们不可能针对每个 module 进行单独打包让开发者接入,那么这时候问题就来了,可不可以把多 Module 合并打包成一个 AAR 文件?

    首先明确一点的是 Android 没有帮我们实现这一点,如果你针对单个模块打包 AAR 是不会把它依赖 module 一起打进去的。所以也延伸出下面几种尝试解决的方式:

    最简单方案:把所有 module 合并成一个 module,变成单独 module 打包的形式,全部交给 Android Studio 帮我们完成,但这又走回了原先代码未拆分前的老路,最不该优先考虑的方案。

    使用 maven 管理 aar 依赖方案:使用 maven 仓库进行远程依赖时,可在其 POM 文件中看到依赖关系,添加依赖时会自动导入其依赖的其他库。对于这种多个 module 的情况,我们可以把每个 module 都上传到 maven 库,因为上传时会 POM 文件中会保留 module 之间的依赖关系,最终用户添加某一库时也能正确引入其他依赖的库。缺点是使用这种方式通常需要 gradle 构建,在兼容一些旧版本的 Unity Editor 或其他场景下最好是能直接提供库文件,可作为保留方案考虑。

    使用 fat-aar 方案: 开源项目一开始 fat-aar.gradle 实现脚本你就知道,这是针对特地版本下的构建环境,把 module 构建 aar 时依赖的其他模块进行 copy 以及合并进来打包,这部分对开发者来说是透明的,所以整个流程足够简单又够用。但是因为项目输出结构跟构建环境有关,所以兼容性是个很大的问题,当然如果你也可以自己去兼容新版的 gradle 构建环境。

    有兴趣的还可以看看这篇文章,里面提到了一些手动修改文件的失败方案: Android 多module合并打包笔记 ,通常这种非常规的方案在万不得已的情况下最好别考虑,因为就算能用但操作也会相当麻烦而且容易出错,还是那句话能自动完成的工作就不要手动操作。

    使用 fat-aar 方案:

    把 fat-aar.gradle 文件复制到你的打包模块根目录,再修改 module 的 build.gradle 文件:

    apply from: 'fat-aar.gradle'

    或者直接从 URL 中获取

    apply from: 'https://raw.githubusercontent.com/adwiv/android-fat-aar/master/fat-aar.gradle'

    第二步:确定模块嵌套的依赖关系

    这里可以使用 compile 和 embedded 两个字段来确定嵌套依赖关系,使用 embedded 添加依赖,表示这是要打包嵌套依赖的库。比如你的打包模块 moduleA 需要把其依赖 moduleB 和 moduleC 一起打包进去,而 support 包不需要一起打包进去,那么 moduleA 的 build.gradle 文件就该是 :

    dependencies {

    compile fileTree(dir: 'libs', include: ['*.jar'])

    embedded project(':moduleB')

    embedded project(':moduleC')

    compile 'com.android.support:appcompat-v7:22.2.0'

    }

    使用 fat-aar 注意点:

    兼容性:目前项目最新支持的 gradle 版本是 2.3.3 版本,新版本的 gradle 编译输出结果目录因为有变动,需要有针对性地重新适配才行。所以一定要注意项目使用的 gradle 版本:

    buildscript {

    repositories {

    google()

    jcenter()

    }

    dependencies {

    // warning: current fat-aar only support gradle 2.3.3!

    //noinspection GradleDependency

    classpath 'com.android.tools.build:gradle:2.3.3'

    }

    }

    R 文件合并问题:如果打包模块和依赖的模块中都存在资源文件,也就是存在 R 文件的引用,这是需要注意 R 文件合并的问题。因为一个 ARR 包只会存在一个 R 文件,使用 fat-aar 打包时会把依赖模块中的 R 文件进行合并,但是因为原先模块中导入的 R 文件包名还是之前的模块的,所以会存在找不到 R 文件的错误。这里看到有其他人说通过修改脚本文件替换 R 文件 import 导包或者把全部资源文件放到打包模块,不过我觉得这样做都不太合理,于是我自己尝试了下面这种方案:

    我们知道 R 文件是根据 AndroidManifest.xml 文件的 package 字段内容来生成的对应包名的,比如 module 中 AndroidManifest.xml 的 package 指定为 com.xx.xxx 时,那么该 module 内的 R 文件导包就是:import com.xx.xxx.R 了。我们可以利用这一点,把所有需要打包的 module 的 package name 改成统一的名称,这样的话,所有 R 文件导包就变成一致的了,就算合并后的 AAR 中只存在一个 R 文件也不会存在找不到的问题。

    为了避免相同模块使用相同包名导致的编译失败的问题,我们可以使用 enforceUniquePackageName = false 配置各个 module 的 build.gradle 文件,这样可以不强制各 module 使用唯一包名。

    BuildConfig 合并问题:因为每个模块也会对应生成 BuildConfig.class 文件,为了在开发阶段可以正常运行,我们还需要处理相同包名时各模块的 BuildConfig.class 合并的问题,这里我们可以选择设置 packageBuildConfig(false) 这样可以让依赖的子模块不把 BuildConfig.class 打包进去,而打包模块可以保留,所以 build.gradle 文件配置如下:

    android {

    enforceUniquePackageName = false

    packageBuildConfig(false)

    lintOptions {

    abortOnError false

    }

    }

    展开全文
  • 个人笔记:android studio,多moudle打包AAR上传到gitHub,自定义远程依赖仓库 个人笔记:android studio,多moudle打包AAR上传到gitHub,自定义远程依赖仓库 个人笔记:android studio,多moudle打包AAR上传到...
  • Android-打包AAR步骤以及注意事项

    千次阅读 2021-07-15 00:29:14
    点击上方蓝字关注????????简介最近因为项目的要求,需要把开发的模块打包aar,供其他项目调用,在搞了一段时间后,发现这里还是有很多需要注意的地方,所以记录一下,帮助大家不要走弯路...

    点击上方蓝字关注 ????????

    简介

    最近因为项目的要求,需要把开发的模块打包成aar,供其他项目调用,在搞了一段时间后,发现这里还是有很多需要注意的地方,所以记录一下,帮助大家不要走弯路。

    首先何为aar包?

    jar与aar的简单区别:

    • *.jar:只包含了class文件与清单文件 ,不包含资源文件,如图片等所有res中的文件。

    • *.aar:包含所有资源 ,class 以及 res 资源文件全部包含

    新工程(无依赖)打包AAR的步骤

    1.新建Library


    然后一路next+finish就新建成功了

    将要打包的文件都按照文件夹的位置放入你的Module中,然后直接点击build-->Make Moudle app

    打包成功后会在对应的路径下生成aar

    当然了,这些应该应该都不是我们需要的, 因为开发项目中一定会有所依赖的。
    而且也肯定不是空的项目。

    成型的项目(有依赖)如何快速打包AAR

    我们可以直接在项目中New一个Moudle 然后把项目复制到Moudle中,或者重新复制出来一个当前项目,然后在复制的项目中直接把此项目修改成AAR。

    我就说一下第二种把,也就是把复制项目直接修改成AAR,我们需要做如下改动:
    1. 修改app下的bulid gradle文件:
    把apply plugin: 'com.android.application'修改成apply plugin: 'com.android.library'

    2. 注释调defaultConfig下的applicationId

    3. AndroidManifest.xml文件,修改application

    并且注释调首先启动的Activity启动的action

    <intent-filter>
                    <action android:name="android.intent.action.MAIN" />
    
                    <category android:name="android.intent.category.LAUNCHER" />
                </intent-filter>

    4.如果你自己自定义了Application,需要去掉,因为AAR中是没有Application的,那问题来了,我们原来在Application中的初始化代码怎么办?这个简单,我们可以单独写一个Options类,提供给调用者,让他传递过来application,这样我们就可以在这个类中做一些初始化操作了。

    调用者在他的application中传入application:

    然后直接build-->Make Moudle app 就可以生成aar了!

    注意事项

    1. 主项目需要依赖AAR中所依赖的远程库,否则会出现ClassNotFound异常
    这里也许某个依赖库你们的版本会发生冲突,这就需要你们协调了

    2. 资源命名最好统统加上你的项目名字前缀,比如图片资源、string、color、dimens、layout等等,反正res目录下所有文件最好都使用统一的加前缀命名,防止跟宿主app下的资源重复,因为aar引用跟源码引用起到的效果一样一样的,所有很容易出现资源重复引用的问题,所以加上前缀非常有必要。

    3. 如果该aar包里面有微信支付,分享等第三方库,你要在主工程中使用,要记得在gradle里面替换applicationId,或者用你主工程的包名和key去获取第三方操作的key和id  
    以分享为例,如果你清单文件中的分享KEY与主项目中的build gradle文件中的分享KEY不同的话,就会包清单文件异常的。

    4. butterknife需要统一用8.4.0以上的版本,不然报错 ;依我的建议,最好不用,否则有你好受的哈!
    5. 如果在aar的MyAppliction里面使用了类的管理器,那么在打包成aar的时候需要将代码抽出来做个独立的类管理器,记住一点,打包成aar之后所有和application有关的东西都要检查替换,避免出现空指针异常。
    6. AAR模块用butterknife需要把资源R改为R2(批量替换)
    7. 布局文件不要重名,否则会报找不到Id的异常

    今天就分析到这里,下次继续新内容!

    - END -
    【IT搬砖圈】各种黑科技,IT技术博文!
    (更多精彩值得期待……)推荐我的微信号
    
    
    
    加微信送Android,Java,Python资料,交流学习我的视频号,已经录制了几十期,有工具推荐,有教育知识、副业赚钱但都是原创用心输出。
    
    让我知道你在看
    
    展开全文
  • 最近工作要求实现一个应用统一门户平台,现尝试了两条方案,一种使用了腾讯的shadow,一种是打包aar并上传maven引用的方式。打包aar并上传maven,我分别使用了maven和maven-publish两条插件,这里主要是记录一下插件...
  • 打包aar 分为原项目打包成aar 和新建module 打包成aar 1 原项目打包成aar 文件 需要把项目先变成库 把apply plugin: 'com.android.application' 改为apply plugin: 'com.android.library' 然后把 applicationId ...
  • 开发中有时候需要我们自己处理一些sdk,以jar包或者aar包的形式提供给其它人员来使用。如果你没接触过,在第一次使用时一定要查阅不少资料,从我个人来说,这个过程耗费了很多时间,你得查找,得判断资料的可靠性等...
  • android打包aar包含三方库和三方aar

    千次阅读 2021-07-14 15:49:56
    前段时间做安卓SDK开发,其中我们的SDK里集成了支付宝的人脸认证SDK,现在说一说怎样解决将三方SDK和三方引入库一起打包进SDK。 1.修改app下的bulid gradle文件: 把apply plugin: 'com.android.application'修改成...
  • 打包aar时把依赖的jar打包进aar中

    千次阅读 2020-12-20 07:31:54
    在调用方引用我们aar的时候,同时还需要引用我们aar中所用到的jar,不然就会报ClassNotFound之类的问题 C方法是直接将依赖的jar,打包aar中,调用方使用我们aar的时候,不需要重复引用我们使用的jar,直接就可以...
  • 最新的opencv 4.5.0 版本 已经打包aar 直接导入android studio 中使用即可 无须再重复下载 opencv sdk 包
  • android 打包aar,和引入aar

    千次阅读 2022-04-19 15:35:48
    一:先把项目修改为 “library” ... 2.删除AndroidManifest.xml中application的name和icon防止冲突 ...Make Module,编译完后,在\app\build\outputs\aar下就可以找到打的aar包 二:引入aar 复制打好的a.
  • 但是,在组件化工程中,却面临着一个非常尴尬的问题,组件化的作用是将功能解耦,打包的时候可以选择需要的组件进行,在apk项目中这是一个非常大的优势。但是对于开发SDK来说,这引起了另外一个问题:SDK本身就是一...
  • 1、打包aar的工程①AndroidManifest.xml中不能有 ,如果有这个的话,在别的项目引用这个aar包之后,手机上会有两个图标②build.gradle中不能有apply plugin: 'com.android.application',需要改为apply plugin: '...
  • 项目打包AAR碰到的问题

    千次阅读 2021-12-15 16:17:39
    1、下面的异常就是包重复依赖了,这就要对aar中的依赖和当前项目的依赖进行筛除 AGPBI: {"kind":"error","text":"Program type already present: io.reactivex.android.schedulers.HandlerScheduler$...
  • GO 交叉编译打包AAR并将Android应用变成web服务 最近在用go写高并发web接口,发现其强大的交叉编译功能可以编译成Android AAR,用go来做native层的工作简直不要太香,告别繁琐的JNI调用,效率瞬间提升上来。下面简单...
  • 因为将mylibrary打包aar的时候,并不会把它所引用的aar一起打包进去。 mylibrary2执行一个日志打印。 mylibrary执行一个日志打印后,调用mylibrary2中Test.class中show()方法。 mylibrary中,build.gradle中...
  • Flutter 打包aar并集成到Android项目

    千次阅读 2019-08-19 21:17:53
    前言 flutter项目作为组件集成到原Android...这种依赖方式需要团队每个人都要安装flutter 环境,下载sdk等,否则无法编译项目,所以可以依赖jar/aar的方式来集成,也就是下面第二种方式集成。 第二种是把flutter项...
  • image.png image.png image.png 而相应的aar文件则会同时生成:在下图目录中 image.png aar文件和jar的内容区别:aar文件包含了res目录下的资源文件,一般的jar下不包含,经过特殊的配置之后也可以包含res资源 当然...
  • 在写基础库的时候需要打包一个arr提供给业务app的时候有两种方式,一种是将打包aar直接发给业务开发人员通过本地依赖的方式引入或者将打包好的aar上传到maven私服上面业务app通过远程依赖的方式接入。但是有时候...
  • android studio 打包aar

    千次阅读 2019-07-19 10:59:54
    本文摘抄网址:Android Studio 打包 aar artifactory下载网址:https://jfrog.com/open-source/ android中自动上传aar的代码设置:Artifactory的搭建与使用简介 推荐查看maven的一些属性设置:maven3常用POM属性...
  • 当Flutter作为模块 (Flutter Module) 使用的时候,我们可以将Flutter Module 打包aar的方式,依赖到Android原生项目中,这样原生项目无需进行任何的Flutter配置,耦合最小。 我们可以使用maven仓库对aar包进行管理...
  • 前言jar与aar差异*.jar:只包含了class文件与清单文件 ,不包含资源文件,如图片等所有res中的文件。*.aar:包含所有资源 ,class 以及 res 资源文件全部包含1、将app-build.gradle的apply plugin: ...
  • 简介最近因为项目的要求,需要把开发的模块打包成aar,供其他项目调用,在搞了一段时间后,发现这里还是有很多需要注意的...*.aar:包含所有资源 ,class 以及 res 资源文件全部包含新工程(无依赖)打包AAR的步骤1.新...
  • Flutter模块打包aar上传maven

    千次阅读 2021-03-19 18:10:14
    settingsDir.parentFile, 'flutter_module/.android/include_flutter.groovy' )) 打包aar依赖,本地文件/maven 依赖 简单分析下两个方法的优劣: 重定向方式:需要Android开发者配置flutter环境,且会增加构建时间...
  • Flutter项目打包AAR供Android使用 一、打成本地AAR步骤详解 1、用Android Studio 工具打开已有或者新建 Flutter项目 输入 flutter doctor命令 检测环境是否正常, 如上图所示,带x的是未安装的环境,根据提示安装...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,625
精华内容 3,850
关键字:

打包aar