精华内容
下载资源
问答
  • App拆包

    2019-04-02 17:36:03
    只能安装一个 我们在gradle里面配置一下即可 正在上传…重新上传取消 必须要把res---values—string里面的app_name 删除掉 app_name app的名字 app_scheme 区分正式还是测试 app_link_scheme 这个就是为了区分...

    博文地址:https://www.jianshu.com/p/b005ccddb29a

          很多时候我们为了配合测试需要打两个包  测试包 正式包   而且必须安装到同一个手机上面   我们知道每个apk都有一个对应的包名  包名一样是不能安装到同一个手机的  只能安装一个

     我们在gradle里面配置一下即可

    productFlavors {
        cloud {
            //云部署版本
            resValue "string","app_name", "MyLuban"
            resValue "string","app_scheme", "bv4phone"
            resValue "string","app_link_scheme", "cloud"
            manifestPlaceholders = [app_icon:"@drawable/ic_launcher"]
        }
        entp {
            //企业版本
            applicationIdSuffix ".entp"
            resValue "string","app_name", "MyLuban企业版"
            resValue "string","app_scheme", "bv4phoneentp"
            resValue "string","app_link_scheme", "entp"
            manifestPlaceholders = [app_icon:"@drawable/ic_launcher_entp"]
        }
    }

    必须要把res---values—string里面的app_name 删除掉     

    app_name    app的名字     

    app_scheme   区分正式还是测试 

    app_link_scheme    这个就是为了区分外部打开app  到底是打开测试版 还是正式版   类似在浏览器打开app  做隐式跳转用

    manifestPlaceholders = [app_icon:"@drawable/ic_launcher"]    icon

    在manifest中  icon一定要改成 “${app_icon}”

    这样可以安装两个不同的包 原理就是在包名后面加上后缀  但是包名是不能变的 是唯一的

    我们在代码里面可以根据BuildConfig.FLAVOR 获取clound entp  区分对比 做不同的操作 这里就可以动态改变url了

    展开全文
  • React native 拆包

    2020-01-02 11:35:45
    bundle文件过大: 一个Helloworld的App,如果使用0.53RN 官方命令react-native bundle打包出来的JSBundle文件大小大约为530KB,RN依赖模块本身占了99.9%。 页面加载慢: 如果使用热更新,从网络获取整个包的下载...

    拆包是React-Native项目不得不面临的一个重要技术门槛。

     

    图片来自网络

    为什么要拆包?

    bundle文件过大: 一个Helloworld的App,如果使用0.53RN 官方命令react-native bundle打包出来的JSBundle文件大小大约为530KB,RN依赖模块本身占了99.9%。

    页面加载慢: 如果使用热更新,从网络获取整个包的下载时间很长,每次进入RN页面都需要执行RN基础模块的定义。

    如果只是一个单独的新APP,纯RN的,或者只有一两个业务使用,这点大小算不了什么。
    但是对于很多业务的公司项目,如果每个业务的JSBundle都需要这么大的一个RN框架,那将是没必要的。

    Facebook官方有没有解决方案呢?
    Facebook的打包工具是metro, metro自带unbundle命令,不过,打包结果不符合预期;
    Android端是将每一个模块输出到单个文件并以模块ID命名;IOS端是将模块以流形式打到一个文件中;

    方案

    调研的方案可以分三类:

    1.手动拆分&合并后再加载

    使用RN打包工具打包,手动将文件分开分成基础包A.js, 业务包B.js;然后在APP加载该页面的时候将A,B两个文件合并再执行;
    优点:成本低,不需要改打包工具;
    缺点:性能没有提升,不能优化执行时间,反而会增加;

    2.动态更新

    可以从编译产物看到require(moduleID);这个方案的思路是:编写一个空的React容器组件,利用DeviceEventEmitter监听一个Native事件,在需要加载页面时,Native下载将模块保存下来,以对应模块ID命名,然后通过DeviceEventEmitter对应模块的id发给React来调用require(msg.id),比如:

    export default class App extends Component {
      constructor(){
        super();
        this.state = {
            dynamicModule : null
        }
      }
      componentDidMount(){
        DeviceEventEmitter.addListener('LoadBundle',(events) =>{ 
          let moduleId = parseInt(events.moduleID, 10))
          let dynamicModule = require(moduleId);
          self.setState({ dynamicModule:dynamicModule });
        });  
      }
      render() {
        const { dynamicModule } = this.state;
        if (dynamicModule) {
          return React.createElement(dynamicModule, this.props);
        } else {
          return (
            <View><Text>空空的容器</Text></View>
          );
        }
      }
    }
    

    但是在编译前使用require(moduleID)会报错,因为编译前根本就未生成模块Id,所以需要改动打包工具。
    优点:性能好,能优化执行时间, 加载时只是执行了React容器组件的render()方法;
    缺点:成本很大,需要修改Naive的RN源码来重写require方法,android在unbundle调用的是assets目录下,不能通过网络动态获取,而且需要改打包工具。

    3.动态执行

    将bundle分为两部分,在内存中先执行基础模块的定义,然后再需要打开页面时,执行该页面的业务模块文件;
    优点:性能好,能优化执行时间;
    缺点:成本大, 需要改Native加载方式,打包工具也许修改。

    Rabbit-bundler是按照此方案实现的打包工具。
    具体请参考:Rabbit-bundler介绍

    本文参考

     



    作者:乘着风
    链接:https://www.jianshu.com/p/ab94a94d58bb
    来源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    展开全文
  • RN拆包解析

    2020-01-14 17:40:28
    拆包动机 RN作为非常优秀的移动端跨平台开发框架,在近几年得到众多开发者的认可。国内各大厂采用在当前原生应用内集成RN的方式,使得App应用的灵活性得到了很大的提升。在原生应用内嵌入RN,就是需要在原生应用内...

    一. 拆包动机

    RN作为非常优秀的移动端跨平台开发框架,在近几年得到众多开发者的认可。国内各大厂采用在当前原生应用内集成RN的方式,使得App应用的灵活性得到了很大的提升。在原生应用内嵌入RN,就是需要在原生应用内加载RN模块(1个或多个JSBundle),并得以显示。JSBundle中包含了当前RN模块的js代码。如果存在多个RN模块需要被加载时,就需要分别打出多个JSBundle,并且多个JSBundle包含了很多重复的代码(例如:第三方依赖)。拆包的方式,就是将其中重复不变的代码打成基础包,动态变化的打成业务包。那么就做到了JSBundle的拆分。JSBundle的拆分,对降低内存的占用,减少加载时间,减少热更新时流量带宽等,在优化方面起到了非常大的作用。

    二.bundle简要分析

    1.bundle命令

    • entry-file:即入口文件,打包时以该文件作为入口,一步步进行模块分析处理。
    • platform:用于区分打包什么平台的 bundle
    • dev:用于区分 bundle 使用环境,非 dev 时,会对代码进行 minified
    • bundle-output:打包产物输出地址,即打包好的 bundle 存放地址
    • sourcemap-output:打包时生成对应的 sourcemap 文件存放地址,在跟踪查找错误或崩溃时,能帮助开发快速定位到代码
    • assets-dest:bundle 中使用的静态资源文件存放地址

    1.结构分析

    var 
    __DEV__ = false,
    __BUNDLE_START_TIME__ = this.nativePerformanceNow ? nativePerformanceNow() : Date.now(),
    process = this.process || {};
    process.env=process.env || {};
    process.env.NODE_ENV = "production";
     
    !(function(r) {
    	"use strict";
     
    	r.__r = o, 
     
    	r.__d = function(r,i,n) {
    		if(null != e[i]) 
    			return;
    		e[i] = {
    			dependencyMap:n,factory:r,hasError:!1,importedAll:t,importedDefault:t,isInitialized:!1,publicModule:{exports:{}}
    		}
    	},
     
    	r.__c = n;
     
       .... 代码省略
       
    })();
     
     
    __d(function(g,r,i,a,m,e,d){var n=r(d[0]),t=r(d[1]),o=n(r(d[2])),u=r(d[3]);t.AppRegistry.registerComponent(u.name,function(){return o.default})},0,[1,2,328,330]);
     
    ....省略其他 __d 代码
     
    __d(function(g,r,i,a,m,e,d){m.exports=function(t){if(t&&t.__esModule)return t;var o={};if(null!=t)for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)){var c=Object.defineProperty&&Object.getOwnPropertyDescriptor?Object.getOwnPropertyDescriptor(t,n):{};c.get||c.set?Object.defineProperty(o,n,c):o[n]=t[n]}return o.default=t,o}},329,[]);
     
    __d(function(e,s,t,a,n,N,d){n.exports={name:"RNTest",displayName:"RNTest"}},330,[]);
     
     
     
    __r(79);
    __r(0);
    

    以最基础的RN项目的 bundle 为例,可以看到 bundle 文件中大致定义了四个模块:

    (1)var 声明的变量,对当前运行环境的定义,bundle 的启动时间、Process进程环境相关信息

    (2)(function() { })() 闭包中定义的代码块,其中定义了对 define(__d)、  require(__r)、clear(__c) 的支持,以及 module(react-native及第三方dependences依赖的module) 的加载逻辑

    (3)__d 定义的代码块,包括RN框架源码 js 部分、自定义js代码部分、图片资源信息,供 require 引入使用

    (4)__r 定义的代码块,找到 __d 定义的代码块 并执行

    最终归纳出以下结构
    image

    polyfills : 预加载,最早执行的一些function,声明es语法新增的接口,定义模块声明方法等
    module difinitations : 模块声明,以__d开头,一般为每一个js文件或资源文件,将其封装成一个module对象,并进行标号
    require calls : bundle文件尾部指定入口文件,如如require(79),最后一行require(0);

    ps:79可以找到是InitializeCore,这个加载了js-c+±java三层的通信注册类,通信临听类等

    三.拆包方案

    其他方案对比

    1. moles-packer

    简介:携程大厂推出,稳定可靠,针对react native0.44时代的版本

    优点:重写了react native自带的打包工具,重写就是为了分包,为分包而生的项目,肯定可靠

    缺点:不持续维护更新,只适合rn老版本用户了,0.5以上的rn版本全部扑街

    1. 自己修改打包代码

    简介:现在很多教程都是让你去修改打包的源码,在里面判断分包,58的0.44版本就是这个方案

    优点:如果很懂打包源码,这个做法灵活,定制化强,100%没问题

    缺点:上手难,需要完全理解打包源码,网上的教程比较古老

    1. diff patch

    简介:大致的做法就是先打个正常的完整的jsbundle,然后再打个只包含了基础引用(react和第三方module)的基础包,比对一下patch,得出业务包,这样基础包和业务包都有了

    优点:简单暴力,如果只是想简单做下分包的可以尝试下

    缺点:1、不利于维护,由于module后面都是rn生成数字,依赖变了数字也变,导致基础包变了所有包都需要变2、图片没法分包,有的第三方库是有图片的,这个方法只处理jsbundle不处理图片

    Metro

    在执行 react-native bundle | unbundle 命令时,RN框架背后其实是依赖了 Metro-Bundler 来完成打包、加载任务。Metro 作为一个独立的打包工具,官方文档 对于它的定义如下:

    The JavaScript bundler for React Native. 
    Fast:Metro aims for sub-second reload cycles, fast startup and quick bundling speeds.
    快:Metro旨在实现亚秒级重载循环,快速启动和快速捆绑速度。
    Scalable:Works with thousands of modules in a single application.
    可扩展:在单个应用程序中使用数千个模块。
    Integrated:Supports every React Native project out of the box.
    集成:支持开箱即用的每个React Native项目。

    Metro 的高度可扩展性,为我们提供了自由配置的打包方式。我们可以根据实际的需要来控制打包过程中的一些需求。官方为我们提供了很多种可配置的方式,可以使用以下三种方式创建Metro配置(按优先级排序):

    metro.config.js
    metro.config.json
    package.json中的 metro 字段
    还可以通过在调用 CLI 时指定 --config <path / to / config> 来为配置提供自定义文件。

    Metro中的常见配置结构如下所示:

    module.exports = { 
    	resolver: { 
    		/* resolver options */
    	}, 
    	transformer: { 
    		/* transformer options */ 
    	}, 
    	serializer: { 
    		/* serializer options */ 
    	}, 
    	server: {
    	 	/* server options */
    	}
    	/* general options */ 
    };
    

    在打包过程中,Metro-Bundler 帮助我们完成了全部工作,解析加载的过程如下:
    image

    项目中,入口点文件(如 index.js)利用 import 依赖了其他组件。即组件间都是相互依赖的。

    Resolution 代表 解析 的过程,负责梳理关联js文件间的相互依赖关系。

    Transformation 代表 转换 的过程,负责将模块文件转换成平台可理解的格式。

    Serialization 代表 序列化 的过程,负责在完成转换过程并将模块转换为可访问的格式后,将其序列化。序列化程序将模块组合在一起以生成一个或多个包。捆绑包实际上是一组模块,组合成一个JavaScript文件。

    更多关于配置的详细信息可以查看(和谐翻墙):

    (1) Configuring Metro

    (2)Role of Metro Bundler in React native

    核心修改项

    拆包的核心思想就是将基础包和业务包拆分。那么我们只需要使用如下两个配置项即可:

    createModuleIdFactory
    用于生成 require 语句的模块ID,配置 createModuleIdFactory 让其每次打包的 module 使用固定的id(路径相关)。
    参数是要打包的 module 文件的绝对路径,返回的是打包后的 module 的 id

    processModuleFilter
    起到过滤功能,用于从输出中丢弃特定模块。配置 processModuleFilter 过滤基础包,打出对应业务包。
    参数是 Module 信息,返回值是 boolean 类型 ,如果是 false 就过滤掉不进行打包

    Metro Config 配置文件

    在打包过程中,我们需要依赖 createModuleIdFactory 、processModuleFilter 来帮助我们将JSBundle拆分为基础包和业务模块包。拆分的过程就需要我们通过配置 config 文件来完成。接下来我们来看看如何编写 config 配置文件。

    在编写 config 配置文件之前,先来想个问题,为什么要固定基础包中的模块ID( __r(id) )呢?

    在上面我们贴出的bundle文件中,可以看到最底部有两段代码:

    __r(79);
    __r(0);
    

    不同文件打出的 bundle,最底部都为__r(0); 而上面的会随着顺序依次增加,例如以 index.js 文件打出的 bundle id 为 79,以 CustomComponent.js 打出的为 80。

    基础包(common.bundle)
    在打基础包的时候,我们会把RN的基础文件以及第三方的依赖打进去。当我们在打业务包的时候,可能会做修改,例如导入组件的顺序发生变化,或者依赖版本做了更新等等。都有可能导致ID发生变化,造成基础包中不能找到对应的模块ID,导致基础包失效。所以需要将ID固定。一种简单的方式就是以模块名称作为 require 即可。所以配置 createModuleIdFactory 让其每次打包的 module 使用固定的模块名称即可。

    业务包 (bussiness.bundle)
    在打业务包时,需要结合 createModuleIdFactory、processModuleFilter 同时进行。createModuleIdFactory负责固定 module 的ID。processModuleFilter 负责过滤掉基础包的内容模块。

    createModuleIdFactory 源代码

    //node_modules/metro/src/lib/createModuleIdFactory.js 
    "use strict";
    
    function createModuleIdFactory() {
      const fileToIdMap = new Map();
      let nextId = 0;
      return path => {
        let id = fileToIdMap.get(path);
        if (typeof id !== "number") {
          id = nextId++;
          fileToIdMap.set(path, id);
        }
        return id;
      };
    }
    
    module.exports = createModuleIdFactory;
    

    我们知道,createModuleIdFactory 用于生成 require 语句的模块ID,从上述源码也可以看出,系统使用整数型的方式,从0开始遍历所有模块,并依次使 Id 增加 1。所以我们可以修改此处逻辑,以模块路径名称的方式作为Id即可。

    参考文档

    https://blog.csdn.net/u013718120/article/details/84571326

    展开全文
  • React Native 拆包思想

    2020-11-20 14:48:19
    在这里使用 Metro 的方式进行拆包拆包的目的是可以按业务需要进行按需加载,同时可以热更新和热修复。 分包思路为:基础包+业务包1+业务包2+…。 由上面可以看到,app有原来的一个bundle分拆为多个,在app启动的...

    在这里使用 Metro 的方式进行拆包,拆包的目的是可以按业务需要进行按需加载,同时可以热更新和热修复。

    分包思路为:基础包+业务包1+业务包2+…
    在这里插入图片描述
    由上面可以看到,app有原来的一个bundle分拆为多个,在app启动的时候,先加载公共部分bundle,启动之后按需加载业务bundle。每个bundle都对应一个容器,在android里面是Activity,而在iOS里面是ViewController。那么就可以理解为把之前单容器bundle的app,拆分为多个容器加载。

    规划代码拆分

    在进行bundle拆分之前,我们要制定好方案:

    首先我们的代码一般分为:主要代码+依赖+工具+资源

    举个例子,如下图:

    在这里插入图片描述
    红色框框里面的是工具代码,在打bundle的时候我们把他们排除,不打入bundle中。

    白色框框里面的是依赖代码,我们选择性打入。

    绿色框框里面的是主要代码,我们需要把他们打入到bundle中。

    资源比较特殊,下面在进行讨论

    在上面我们把bundle分为公共bundle业务bundle,在分包的时候也是把代码分成上面三个部分,然后装配到不同的bundle中的。如下图所示:
    在这里插入图片描述
    从上图可以看出,公共bundle与业务bundle唯一的区别就是多了依赖代码。这么分包的好处是:

    1. 公共bundle可以做成没有ui页面的组件,然后异步加载。在进入业务页面的时候会非常快。
    2. 抽离业务模块的依赖部分,打出来的bundle会非常小,单独更新bundle时候,冗余量非常小。

    但是也有一些缺点,你是需要知道的:

    1. 业务bundle也需要node_module依赖,在所有bundle中,如果 package.json 依赖版本不统一,有可能会引发白屏问题。

    分包方案这部分要具体问题具体分析,解决痛点才是重要的。

    演示

    为了演示demo,我们准备两个工程,一个主bundle,一个业务bundle。先来对比看一下这两个项目的目录结构。
    在这里插入图片描述
    为了方便,我把原生工程(iOS和Android)放到公共bundle下面,在实际情况中,一般都会新增仓库,由不同的项目组分管。

    在这里公共bundle仓库中,没有自有代码实现(没有src目录),因为demo的逻辑没有那么复杂,大家可以具体问题具体分析,放一些一些公共初始化的东西,如推送处理,后台服务等等。

    注意:react native在打包的过程中,如果一个依赖没有被使用到,即使你再package.json中声明了它,它也是不会被打包到bundle中的,所以为了把公共依赖都打到公共bundle中,我们需要在入口文件index.js中声明用到的依赖。

    import "react";
    import "react-native";
    import "react-native-gesture-handler";
    import "react-navigation";
    import "react-navigation-redux-helpers";
    import "react-redux";
    import "redux";
    import "redux-thunk";
    import "react-native-screens";
    

    小提示:如果在运行过成功发生白屏现象,检查依赖代码(node_modules)是否被打入到公共bundle中,如果没有,就要主动声明它们。

    打包

    现在假设你已经指定了自己的分包方案,那么看一下React Native 是如何生产bundle的,又是如何分包的。

    React Native 打包命令为:

    node ./node_modules/react-native/local-cli/cli.js bundle
    	--platform android 
    	--dev false
    	--entry-file index.js
    	--bundle-output ./bundles/base.android.bundle
    	--assets-dest ./bundles/res/android
    	--config ./package.config.js
    	--sourcemap-output  ./bundles/base.android.bundle.map
    	--reset-cache
    

    --platform android 指定运行平台,ios平台则指定为ios。

    --dev false 指定为release版本。

    --entry-file 指定入口文件,程序的主入口。

    --bundle-output --assets-dest --sourcemap-output 分别为bundle输出路径,资源输出路径,debug用到的映射文件输出路径,以上三个路径必须存在。

    --config 在这里传入分包方案用到的js文件。

    资源文件推荐直接输出到目的目录中,如果是android平台,输出到src/main/res/

    分包

    由上面可以知道,分包的重点就是 package.config.js 这个文件了。在这里可以把源码clone下来,打开base工程下的这个文件:

    module.exports = {
      serializer: {
        createModuleIdFactory: createModuleIdFactory,
        processModuleFilter: postProcessModulesFilter,
        /* serializer options */
      },
    }
    

    上面代码中,有两个很重要的方法createModuleIdFactorypostProcessModulesFiltercreateModuleIdFactory 是给每一个需要打包的文件去一个名字,避免多个bundle文件中代码冲突。而postProcessModulesFilter 就是用于标记哪些文件需要打入到bundle中的了。这个方法返回false表示不打入,true表示打入。

    // Base工程中 打包关键代码
      if (module["path"].indexOf(pathSep + "node_modules" + pathSep) > 0) {
        return true;
      }
      if (module["path"].indexOf("index") > 0) {
        return true;
      }
    

    在公共依赖base工程,我们只打入路径中包含node_modules入口文件。而在业务工程只打入主要代码入口文件。如下所示:

    // 业务工程中 打包关键代码
    // 提前过滤依赖
      if (module['path'].indexOf(pathSep + 'node_modules' + pathSep) > 0) {
        return false;
      }
      if (module['path'].indexOf(pathSep + 'src' + pathSep) > 0) {
        return true;
      }
      if (module['path'].indexOf('index') > 0) {
        return true;
      }
    

    至此,两个bundle和资源文件就生成了。

    后续

    这时候,分包的主要工作已经完成,把打包的产物放到远程工程里面已经可以正常运行。但是工作远远没有结束。首先这两个bundle没有任何版本信息,也无法判断时候被伪装。

    我们的bundle应该做到热替换,如果只在服务器上拉取最新的bundle,那么就无法保证分区域加载,或者灰度加载。所以我们还需要一个配置文件,用于记录这个bundle的日期、版本、灰度区域以及他的md5信息。

    这个配置文件为bundle打完包之后就要生成,同时可以被中台(原生工程读取)。为了方便,我们使用json作为文件结构格式。

    {
      "create_date":1595317939331,
      "version":"1.0.1",
      "update_desc":"新加了一个弹框",
      "md5":"0ca175b9c0f726a831d895e269332461"
    }
    

    首先create_date就代表这个config配置生成时间, version是当前bundle版本号,md5 为打包bundle的唯一标识。这个配置文件可以使用脚本生成。

    在 package.json 里面新增一个 postxxx ,其中xxx为你的打包命令。我使用的是make,那么就新增postmake,这样,在执行完成打包命令之后,他会自动执行。如下图

    "scripts": {
        "make": "node ./node_modules/react-native/local-cli/cli.js bundle --platform android --dev false --entry-file index.js --bundle-output ./bundles/base.android.bundle --assets-dest ./bundles/res/android --config ./package.config.js --sourcemap-output  ./bundles/base.android.bundle.map --reset-cache",
        "makeiOS": "node ./node_modules/react-native/local-cli/cli.js bundle --platform ios --dev false --entry-file index.js --bundle-output ./bundles/base.ios.bundle --assets-dest ./bundles/res/ios --config ./package.config.js --sourcemap-output  ./bundles/base.ios.bundle.map --reset-cache",
        "postmake":"node aftermake.js"
    },
    

    那么这里的aftermake.js ,主要工作就是生成配置文件了,并且把它打包成最终文件。

    var fs = require("fs");
    var crypto = require('crypto');
    var compressing = require('compressing');
    
    function generateMd5() {
        return new Promise((resolve,rejects) => {
            var stream = fs.createReadStream('bundles/base.android.bundle');
            var fsHash = crypto.createHash('md5');
            
            stream.on('data', function(d) {
                fsHash.update(d);
            });
            
            stream.on('end', function() {
                var md5 = fsHash.digest('hex');
                resolve(md5)
            });
        })
    }
    
    async function readPackageInfo()  {
        return new Promise((resolve,rejects) => {
            fs.readFile('package.json', function (err, data) {
                if (err) {
                    rejects(err)
                    return
                }
                var package = JSON.parse(data)
                resolve([package.version,package.update_desc])
             });
        })
    }
    
    async function writeToFile(info) {
        fs.writeFile('bundles/config.json', JSON.stringify(info),  function(err) {
            if (err) {
                return console.error(err);
            }
         });
    }
    
    async function main() {
        let info = await readPackageInfo()
        let md5 = await generateMd5()
        const config = {
            create_date: new Date().getTime(),
            version: info[0],
            update_desc: info[1],
            md5:md5
        }
        await writeToFile(config)
        await compressing.zip.compressDir('bundles', 'base.zip')
    }
    
    main();
    

    生成 base.zip 。这zip就可以放到应用分发平台,等待上线。

    源码地址:https://github.com/leconio/ReactNativeInPlatform

    展开全文
  • 1.在App所属的build.gradle里面 android { ...... defaultConfig { multiDexEnabled true ...... } } 2.在你自定义的Application(这个一般项目里面都有) MultiDex.install(this);//初始化 ok.这两...
  • react-native 业务拆包

    2017-11-07 00:25:16
    为什么要拆包 背景介绍 随着RN的包越来越大,第一次载入RN包的时长越来越长,用户需要等待的时间也就越长,体验较差。另外多个团队开发的话,互相之间的依赖也是个大问题,出现编译不过的话,就会出现水桶效应...
  • Android-用apktool工具进行拆包、重打包 ... 准备工作: 一、拆包。(Mac环境) 1.下载apktool,我用的是apktool_2.1.1.jar。...2.需要拆包的apk。...java -jar apktool_2.1.1.jar d app-test.apk 打包: java -...
  • APK逆向基础之拆包与合包的方法

    千次阅读 2020-03-14 16:05:07
    想着今后也许还有东西需要测试同事帮忙验证,我这里把拆包合包的东西整理出来好了。 如何拆包? https://ibotpeaches.github.io/Apktool/install/ apktool -r d app.apk 如何合包? apktool b app -o raw.apk ./...
  • Flask的配置2拆包处理

    2019-07-16 21:30:58
    项目的分组 manage.py文件 # conding:utf-8 from ihome import creat_app, db from flask_script import Manager # 导入脚本 from flask_migrate import Migrate, MigrateCommand #...app = creat_app("developme...
  • React_Native拆分bundle之patch拆包

    千次阅读 2017-04-06 16:28:48
    为什么要拆包背景介绍随着RN的包越来越大,第一次载入RN包的时长越来越长,用户需要等待的时间也就越长,体验较差。另外多个团队开发的话,互相之间的依赖也是个大问题,出现编译不过的话,就会出现水桶效应,所有的...
  • 作为iOS开发,我们经常会遇到业务告诉我们安装包过大了,我们需要怎么样让APP瘦身, 这里很多人就会想到,我们工程里面有很多的自己封装的静态库(.a文件)下手了,直接给静态库只放一个真机(.a文件<armv7+arm64&...
  • iOS拆包准备获取ipa包及资源文件

    千次阅读 2019-05-27 13:45:29
    要获得线上APP的ipa文件,现在有以下几种方案 1.通过PP助手下载安装到手机的应用 2.通过iTools助手下载安装到手机的应用 3.通过Apple Configurator 2(Mac商店)获取 前两种方案网上的教程很多,这里只介绍第三...
  • 对安卓的apk包进行多渠道动态打包,无需拆包和重新签名,因为不破坏apk包里面的结构,就无需重新打包和签名,废话不多说,上代码: 下面展示一些 内联代码片。 package com.ruoyi.common.utils.app; import ...
  • 减少业务包体积(app瘦身) 节省热更新流量 提升模块加载速度 点击查看结构 实现方式 打公用包,包括react-native框架、code-push框架、常用第三方框架、rnlib代码等 打全量bundle包 全量包基于公用包打出差异包...
  • 利用Android Killer拆包APP.首先更改AndroidManifest.xml里面的包名.全局更改com.xxx.xxxx类似的包名.全局更改smali类型代码的包名字符串Lcom/xxx/xxxx.全局更改所有com/xxx/xxxx文件夹的名称,因为java文件里面要求...
  •  目前各应用APP 包体积,日渐增大,各个公司都在提出精简包体积的要求。这个过程中,除了图片,so库,第三方library,混淆效率这些维度进行分析,统计,代码层面,统计的力度比较低,本博文重点从代码文件角度,分析...
  • Android 系统的rom最主要的就是3个文件:boot.img、system.img、userdata.img。其中boot.img 存放着内核以及Android系统的配置信息,比如android系统各文件夹...system.img中存放的是系统的各种库,系统预装的app等,u
  • app加固

    千次阅读 2018-09-03 18:59:30
    1、今天遇到一个坑,记录一下,详细的原理以后有时间补充  app加固时会进行拆包,合作方会向包中添加内容,破坏秘钥结构,所以加固之后需要重新添加秘钥。  ...
  • 在移动市场中有这么一个行业,零成本、高收入、低门槛。这就是那些做app二次打包这种灰色产业。这种行业几乎不需要投入...这些灰色行业的人,主要将目标定位在各大app商城中的热门应用,然后进行拆包,植入自己需要...
  • 因为平时拆包少,对某些好工具也了解不多,基本用了手工的方法来处理的。大家可以用什么APK改之理之类的工具。 apktool:这个大家都知道,反编译利器,我下的是apktool_2.0.0b9版本 dex2jar:不是必须,但看smali...
  • 拆包 首先把包拆了,加android:debuggable="true" 首次尝试: D:\桌面\apktool.jar d D:\桌面\crack.apk -o targetappFolder 换个搞法 java -jar apktool.jar d crack.apk -o targetappFolder 加进<...
  • 性能是每个前端工程师都应该关注的话题,通用的优化手段已有许多文章和实践,就不再赘述,本篇以百度App个人主页为例,聊聊针对业务特点进行的一些性能优化实践。 适用于:传统意义的优化手段能用的都用了:打包拆包...
  • <div><p>...可能是服务在拆包的过程中出错了 3、现在只在android模拟器下测试,发现这个问题,iOS还没看</p><p>该提问来源于开源项目:ctripcorp/CRN</p></div>
  • Android dex分包原理介绍QQ空间热修复方案基于Android dex分包基础之上,简单概述android dex分包的原理就是:就是把多个dex文件塞入到app的classloader之中,但是android dex拆包方案中的类是没有重复的,如果clas
  • 原料:app-debug.apk 拆包执行命令 apktool d app-debug.apk ...apktool b app-debug (app-debug是前面通过拆包生成的目录名,也可以改成其他的) 此时,生成的apk并不能安装,因为还没有给...
  • c8650 系统驱动包

    2013-01-25 12:32:28
    的系统驱动包。方便机油们自行拆包修改。无内置app。。
  • Heavy20MB.ttf

    2020-09-16 17:05:41
    思源宋体简体中文完整字形开源字体,官方只提供了OTF格式,MSOffice对OTF字体支持较差,WPS根本不支持...主要用于APP和小程序等移动应用拆包使用配合java拆包,亲测可用,网上很多办法我都试过不行,这个我自己摸索的

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

拆包app