前言

起因

今天开发遇到一个问题，就是在快速点击带点击事件的控件，如果控件里面写的是Dialog弹窗就有概率出现弹窗连续在界面上出现两次，也就是你关闭弹窗后发现还有一个一样的弹窗在界面，这样就会带来不好的体验。

结果

2月9日

在网上查了许多解决方法，就有提到将该Dialog变成类的成员变量，不用每次都new就可能避免这种情况出现，但我着实不清楚为什么以及具体怎么做，于是请教了组里的大哥，大哥和我说他之前也处理过这种问题，使用了弱引用，可我还是不知道具体的实现方式，于是便找到大哥的代码，并在网上了解了弱引用的具体作用。

2月10日

今天我请教了我们掘金开发群的Java大佬，他告诉我，我这个写法仍然避免不了弹两次Dialog的，并给出意见，可以使用共享状态，推荐我创建一个共享的ReentrantLock，不过我还没去实现，等有时间再看看。

下面就让我们看看弱引用到底是什么。

正篇

弱引用的概念

想知道弱引用，那就得知道几个名词：

• 强引用

• 软引用

• 弱引用

• 虚引用

首先我们来看看这些词的概念：

1. 强引用

强引用（StrongReference）：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj = new Object()”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。

1. 软引用

软引用（SoftReference）：在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存流出异常。

1. 弱引用

弱引用（WeakReference）：被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联的对象。

1. 虚引用

虚引用（PhantomReference）：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

以上定义都是参考自知乎回答 ：强引用、软引用、弱引用、虚引用有什么区别？具体使用场景是什么？ - 知乎 (zhihu.com)，从这我们可以了解到其实我们Java中new对象就是强引用，强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象，也就简而言之对象在引用时，不回收，上面说的文章中也举例说明了强引用的特点：

而我们本篇说的弱引用，则是发现即回收，它通常是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

但是，又因为垃圾回收器的线程通常优先级很低，所以，一般并不一定能很快地发现持有弱引用的对象，而在这种情况下，弱引用对象就可以存在较长的时间。

而如何使用弱引用，我们接着往下看：

使用方法

前言提到我们使用了弱引用在开发中大哥已经使用过，所以我就跟着后面仿写一下就好，而知乎的那篇文章也提到：

这就基本是弱引用的定义方法，因为之前前言说的Dialog问题弱引用并没有真正起效果，所以我们换一种方法去展示他在安卓上的使用，那就是在使用Bitmap时防止OOM，写法如下：

ImageView imageView = findViewById(R.id.vImage);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher_background);
Drawable drawable = new BitmapDrawable(getResources(), bitmap);
WeakReference<Drawable> weakDrawable = new WeakReference<>(drawable);
Drawable bgDrawable = weakDrawable.get();
if(bgDrawable != null) {
    imageView.setBackground(drawable);
}

我们再对比一下普通的强引用方法：

ImageView imageView = findViewById(R.id.vImage);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher_background);
Drawable drawable = new BitmapDrawable(getResources(), bitmap);
imageView.setBackground(drawable);

其实，就是对drawable对象从强引用转为弱引用，这样一旦出现内存不足，不会直接去使用drawable对象，让JVM自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。

总结

其实这块内容需要对GC机制很熟悉，我不是很熟，所以使用可能也出现不对，希望读者可以积极指正，谢谢观看！

作者：ObliviateOnline
来源：juejin.cn/post/7198519499867815997

接：Flutter Android多窗口方案落地（上）

1. 插件层封装。插件层就很简单了，创建好MethodCallHandler之后，直接持有单例的EngineManager就可以了。

class FlutterMultiWindowsPlugin : FlutterPlugin, MethodCallHandler {
  companion object {
      private const val TAG = "MultiWindowsPlugin"
  }


•   @SuppressLint("LongLogTag")
•   override fun onAttachedToEngine(@NonNull flutterPluginBinding: FlutterPlugin.FlutterPluginBinding) {
•       Log.i(TAG, "onMessage: onAttachedToEngine")
•       Log.i(TAG, "onAttachedToEngine: ${Thread.currentThread().name}")
•       MessageHandle.init(flutterPluginBinding.applicationContext)

•       MethodChannel(
•           flutterPluginBinding.binaryMessenger,
•           "flutter_multi_windows.messageChannel",
•       ).setMethodCallHandler(this)
•   }

•   override fun onDetachedFromEngine(@NonNull binding: FlutterPlugin.FlutterPluginBinding) {
•       Log.i(TAG, "onDetachedFromEngine: ${Thread.currentThread().name}")
•   }

•   override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
•       Log.i(TAG, "onMethodCall: thread : ${Thread.currentThread().name}")
•       MessageHandle.onMessage(call, result)
•   }
}

@SuppressLint("StaticFieldLeak")
internal object MessageHandle {
  private const val TAG = "MessageHandle"

•   private var context: Context? = null
•   private var manager: EngineManager? = null

•   fun init(context: Context) {
•       this.context = context
•       if (manager != null)
•           return
•       // 必须单例调用
•       manager = EngineManager.getInstance(this.context!!)
•   }

•   // 处理消息，所有管道通用。需要共享Flutter Activity
•   fun onMessage(
•       call: MethodCall, result: MethodChannel.Result
•   ) {
•       val params = call.arguments as Map<*, *>
•       when (call.method) {
•           "open" -> {
•               Log.i(TAG, "onMessage: open")
•               val map: HashMap<String, Any> = HashMap()
•               map["needShowWindow"] = true
•               map["name"] = params["name"] as String
•               map["entryPoint"] = params["entryPoint"] as String
•               map["width"] = (params["width"] as Double).toInt()
•               map["height"] = (params["height"] as Double).toInt()
•               map["gravityX"] = params["gravityX"] as Int
•               map["gravityY"] = params["gravityY"] as Int
•               map["paddingX"] = params["paddingX"] as Double
•               map["paddingY"] = params["paddingY"] as Double
•               map["draggable"] = params["draggable"] as Boolean
•               map["type"] = params["type"] as String

•               if (params["params"] != null) {
•                   map["params"] = params["params"] as ArrayList<String>
•               }
•               result.success(manager?.showWindow(map, object : EngineCallback {
•                   override fun onEngineDestroy(id: String) {
•                   }
•               }))
•           }
•           "close" -> {
•               val windowId = params["windowId"] as String
•               manager?.dismissWindow(windowId)
•           }
•           "executeTask" -> {
•               Log.i(TAG, "onMessage: executeTask")
•               val map: HashMap<String, Any> = HashMap()
•               map["name"] = params["name"] as String
•               map["entryPoint"] = params["entryPoint"] as String
•               map["type"] = params["type"] as String
•               result.success(manager?.executeTask(map))
•           }
•           "finishTask" -> {
•               manager?.finishTask(params["taskId"] as String)
•           }
•           "setPosition" -> {
•               val res = manager?.setPosition(
•                   params["windowId"] as String,
•                   params["x"] as Int,
•                   params["y"] as Int
•               )
•               result.success(res)
•           }
•           "setAlpha" -> {
•               val res = manager?.setAlpha(
•                   params["windowId"] as String,
•                   (params["alpha"] as Double).toFloat(),
•               )
•               result.success(res)
•           }
•           "resize" -> {
•               val res = manager?.resetWindowSize(
•                   params["windowId"] as String,
•                   params["width"] as Int,
•                   params["height"] as Int
•               )
•               result.success(res)
•           }
•           else -> {

•           }
•       }
•   }
}

同时需要清楚，Engine通过传入的entryPoint，就可以找到Flutter层中的方法入口点，在入口点中runApp即可。

实现过程中的坑

在实现过程中我们遇到的值得分享的坑，就是Flutter GestureDetector和Window滑动事件的冲突。 由于悬浮窗是需要可滑动的，因此在原生层需要监听对应的事件；而Flutter的事件,是Android层分发给FlutterView的，两者形成冲突，导致Flutter内部滑动的时候，原生层也会捕获到，最终造成冲突。
如何解决？
从需求上来看，悬浮窗是否需要滑动，应该交给调用方决定，也就是由Flutter层来决定是否Android是否要对Flutter的滑动事件进行监听，即flutterView.setOnTouchListener。这里我们使用一种更轻量级的操作，FlutterView的监听默认加上，然后在事件处理中，我们通过变量来做处理；而Flutter通过MethodChannel改变这个变量，加快了通信速度，避免了事件来回监听和销毁。

flutterView.setOnTouchListener { _, event ->
   when (event.action) {
       MotionEvent.ACTION_MOVE -> {
           if (dragging) {
               setPosition(
                   initialX + (event.rawX - startX).roundToInt(),
                   initialY + (event.rawY - startY).roundToInt()
              )
          }
      }
       MotionEvent.ACTION_UP -> {
           dragEnd()
      }
       MotionEvent.ACTION_DOWN -> {
           startX = event.rawX
           startY = event.rawY
           initialX = layoutParams.x
           initialY = layoutParams.y
           dragStart()
           windowManager.updateViewLayout(rootView, layoutParams)
      }
  }
   false
}

dragging则是通过Flutter层去驱动的：FlutterMultiWindowsPlugin().dragStart();

private fun dragStart() {
   dragging = true
}

private fun dragEnd() {
   dragging = false
}

使用方式

目前我们内部已在4个应用落地了这个方案。应用方式有两种：一种是Flutter通过插件调用，也可以直接通过后台Service打开。效果尚佳，目的都是为了让Flutter的UI跨端使用。
另外，Flutter的方法入口点必须声明@pragma('vm:entry-point')。

写在最后

目前来看这种方式可以完美支持Flutter在Android上开启多窗口，且能精准控制。但由于一个engine对应一个窗口，过多engine带来的内存隐患还是不可忽视的。我们希望Flutter官方能尽快的支持engine对应多个入口点，并且共享内存，只不过目前来看还是有点天方夜谭~~
这篇文章，需要有一定原生基础的同学才能看懂。只讲基础原理，代码不全，仅供参考！ 另外多窗口的需求，不知道大家需求量如何，热度可以的话我再出个windows的多窗口实现！

作者：Karl_wei
来源：juejin.cn/post/7198824926722949179

前言

Flutter在桌面端的多窗口需求，一直是个历史巨坑。随着Flutter的技术在我们windows、android桌面设备落地，我们发现多窗口需求必不可少，突破这个技术壁垒已经刻不容缓。

实现原理

1. 基本原理

对于Android移动设备来说，多窗口的应用大多是用于直播/音视频的悬浮弹窗，让用户离开应用后还能在小窗口中观看内容。实现原理是通过WindowManager创建和管理窗口，包括视图内容、拖拽、事件等操作。
我们都清楚Flutter只是一个可以做业务逻辑的UI框架，在Flutter中想要实现多窗口，也必须依赖Android的窗口管理机制。基于原生的Window，显示Flutter绘制的UI，从而实现跨平台的视图交互和业务逻辑。

2. 具体步骤

• Android端基于Window Manager创建Window，管理窗口的生命周期和拖拽逻辑；

• 使用FlutterEngineGroup来管理Flutter Engine，通过引擎吸附Flutter的UI，加入到原生的FlutterView；

• 把FlutterView通过addView的方式加入到Window上。

3. 原理图

插件实现

基于上述原理，可以在Android的窗口显示Flutter的UI。但要真正提供给Flutter层使用，还需要再封装一个插件层。

1. 通过单例管理多个窗口 由于是多窗口，可能项目中多个地方都会调用到，因此需要使用单例来统一管理所有窗口的生命周期，保证准确创建、及时销毁。

//引擎生命钩子回调，让调用方感知引擎状态
interface EngineCallback {
   fun onCreate(id:String)
   fun onEngineDestroy(id: String)
}

class EngineManager private constructor(context: Context) {

   // 单例对象
   companion object :
       SingletonHolder<EngineManager, Context>(::EngineManager)

   // 窗口类型；如果是单一类型，那么同名窗口将返回上一次的未销毁的实例。
   private val TYPE_SINGLE: String = "single"

   init {
       Log.d("EngineManager", "EngineManager init")
  }

   data class Entry(
       val engine: FlutterEngine,
       val window: AndroidWindow?
  )

   private var myContext: Context = context

   private var engineGroup: FlutterEngineGroup = FlutterEngineGroup(myContext)

   // 每个窗口对应一个引擎，基于引擎ID和名称存储多窗口的信息，以及查找
   private val engineMap = ConcurrentHashMap<String, Entry>() //搜索引擎，用作消息分发
   private val name2IdMap = ConcurrentHashMap<String, String>() //判断是否存在了任务
   private val id2NameMap = ConcurrentHashMap<String, String>() //根据任务获取name并清除
   private val engineCallback =
       ConcurrentHashMap<String, EngineCallback>() //通知调用方引擎状态 0-create 1-attach 2-destroy

   fun showWindow(
       params: HashMap<String, Any>,
       engineStatusCallback: EngineCallback
  ): String? {
       val entry: String?
       if (params.containsKey("entryPoint")) {
           entry = params["entryPoint"] as String
      } else {
           return null
      }

       val name: String?
       if (params.containsKey("name")) {
           name = params["name"] as String
      } else {
           return null
      }

       val type = params["type"]
       if (type == TYPE_SINGLE && name2IdMap[name] != null) {
           return name2IdMap[name]
      }

       val windowUid = UUID.randomUUID().toString()
       if (type == TYPE_SINGLE) {
           name2IdMap[name] = windowUid
           id2NameMap[windowUid] = name
           engineCallback[windowUid] = engineStatusCallback
      }
       val dartEntrypoint = DartExecutor.DartEntrypoint(findAppBundlePath(), entry)
       val args = mutableListOf(windowUid)

       var user: List<String>? = null
       if (params.containsKey("params")) {
           user = params["params"] as List<String>
      }

       if (user != null) {
           args.addAll(user)
      }
       // 把调用方传递的参数回调给Flutter
       val option =
           FlutterEngineGroup.Options(myContext).setDartEntrypoint(dartEntrypoint)
              .setDartEntrypointArgs(
                   args
              )
       val engine = engineGroup.createAndRunEngine(option)
       val draggable = params["draggable"] as Boolean? ?: true
       val width = params["width"] as Int? ?: 0
       val height = params["height"] as Int? ?: 0

       val config = GravityConfig()
       config.paddingX = params["paddingX"] as Double? ?: 0.0
       config.paddingY = params["paddingY"] as Double? ?: 0.0
       config.gravityX = GravityForX.values()[params["gravityX"] as Int? ?: 1]
       config.gravityY = GravityForY.values()[params["gravityY"] as Int? ?: 1]
       // 把创建好的引擎传给AndroidWindow，由其去创建窗口
       val androidWindow =
           AndroidWindow(myContext, draggable, width, height, config, engine)
       engineMap[windowUid] = Entry(engine, androidWindow)
       androidWindow.open()
       engine.platformViewsController.attach(
           myContext,
           engine.renderer,
           engine.dartExecutor
      )
       return windowUid
  }

   fun setPosition(id: String?, x: Int, y: Int): Boolean {
       id ?: return false
       val entry = engineMap[id]
       entry ?: return false
       entry.window?.setPosition(x, y)
       return true
  }
   
   fun setSize(id: String?, width: double, height: double): Boolean {
       // ......
  }
}

通过代码我们可以看到，每个窗口都对应一个engine，通过name和生成的UUID做唯一标识，然后把engine传给AndroidWindow，在那里加入WindowManger，以及Flutter UI的获取。

1. AndroidWindow的实现；通过context.getSystemService(Service.WINDOW_SERVICE) as WindowManager获取窗口管理器；同时创建FlutterView和LayoutInfalter，通过engine拿到视图吸附到FlutterView，把FlutterView加到Layout中，最后把Layout通过addView加到WindowManager中显示。

class AndroidWindow(
   private val context: Context,
   private val draggable: Boolean,
   private val width: Int,
   private val height: Int,
   private val config: GravityConfig,
   private val engine: FlutterEngine
) {
   private var startX = 0f
   private var startY = 0f
   private var initialX = 0
   private var initialY = 0
   private var dragging = false
   private lateinit var flutterView: FlutterView
   private var windowManager = context.getSystemService(Service.WINDOW_SERVICE) as WindowManager
   private val inflater =
       context.getSystemService(Service.LAYOUT_INFLATER_SERVICE) as LayoutInflater
   private val metrics = DisplayMetrics()

   @SuppressLint("InflateParams")
   private var rootView = inflater.inflate(R.layout.floating, null, false) as ViewGroup
   private val layoutParams = WindowManager.LayoutParams(
       dip2px(context, width.toFloat()),
       dip2px(context, height.toFloat()),
       WindowManager.LayoutParams.TYPE_SYSTEM_ALERT, // 系统应用才可使用此类型
       WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
       PixelFormat.TRANSLUCENT
  )

   fun open() {
       @Suppress("Deprecation")
       windowManager.defaultDisplay.getMetrics(metrics)
       layoutParams.gravity = Gravity.START or Gravity.TOP
       selectMeasurementMode()

       // 设置位置
       val screenWidth = metrics.widthPixels
       val screenHeight = metrics.heightPixels
       when (config.gravityX) {
           GravityForX.Left -> layoutParams.x = config.paddingX!!.toInt()
           GravityForX.Center -> layoutParams.x =
              ((screenWidth - layoutParams.width) / 2 + config.paddingX!!).toInt()
           GravityForX.Right -> layoutParams.x =
              (screenWidth - layoutParams.width - config.paddingX!!).toInt()
           null -> {}
      }

       when (config.gravityY) {
           GravityForY.Top -> layoutParams.y = config.paddingY!!.toInt()
           GravityForY.Center -> layoutParams.y =
              ((screenHeight - layoutParams.height) / 2 + config.paddingY!!).toInt()
           GravityForY.Bottom -> layoutParams.y =
              (screenHeight - layoutParams.height - config.paddingY!!).toInt()
           null -> {}
      }

       windowManager.addView(rootView, layoutParams)
       flutterView = FlutterView(inflater.context, FlutterSurfaceView(inflater.context, true))
       flutterView.attachToFlutterEngine(engine)
       if (draggable) {
           @Suppress("ClickableViewAccessibility")
           flutterView.setOnTouchListener { _, event ->
               when (event.action) {
                   MotionEvent.ACTION_MOVE -> {
                       if (dragging) {
                           setPosition(
                               initialX + (event.rawX - startX).roundToInt(),
                               initialY + (event.rawY - startY).roundToInt()
                          )
                      }
                  }
                   MotionEvent.ACTION_UP -> {
                       dragEnd()
                  }
                   MotionEvent.ACTION_DOWN -> {
                       startX = event.rawX
                       startY = event.rawY
                       initialX = layoutParams.x
                       initialY = layoutParams.y
                       dragStart()
                       windowManager.updateViewLayout(rootView, layoutParams)
                  }
              }
               false
          }
      }
       @Suppress("ClickableViewAccessibility")
       rootView.setOnTouchListener { _, event ->
           when (event.action) {
               MotionEvent.ACTION_DOWN -> {
                   layoutParams.flags =
                       layoutParams.flags or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                   windowManager.updateViewLayout(rootView, layoutParams)
                   true
              }
               else -> false
          }
      }

       engine.lifecycleChannel.appIsResumed()

       rootView.findViewById<FrameLayout>(R.id.floating_window)
          .addView(
               flutterView,
               ViewGroup.LayoutParams(
                   ViewGroup.LayoutParams.MATCH_PARENT,
                   ViewGroup.LayoutParams.MATCH_PARENT
              )
          )
       windowManager.updateViewLayout(rootView, layoutParams)
  }
   // .....

续：Flutter Android多窗口方案落地（下）

作者：Karl_wei
来源：juejin.cn/post/7198824926722949179

一、前言

由于之前自己项目的账号系统不是非常完善，所以考虑接入QQ这个强大的第三方平台的接入，目前项目暂时使用QQ登录的接口进行前期的测试，这次从搭建到完善花了整整两天时间，不得不吐槽一下QQ互联的官方文档，从界面就可以看出了，好几年没维修了，示例代码也写的不是很清楚，翻了好多源代码和官方的demo，这个demo可以作为辅助参考，官方文档的api失效了可以从里面找相应的替代，但它的代码也太多了，一个demo 一万行代码，心累，当时把demo弄到可以运行就花了不少时间，很多api好像是失效了，笔者自己做了一些处理和完善，几乎把sdk功能列表的登录相关的api都尝试了一下，真的相当的坑，正文即将开始，希望这篇文章能够给后来者一些参考和帮助。

二、环境配置

1.获取应用ID

这个比较简单，直接到QQ互联官网申请一个即可，官网地址

https://connect.qq.com

申请应用的时候需要注意应用名字不能出现违规词汇，否则可能申请不通过

应用信息的填写需要当前应用的包名和签名，这个腾讯这边提供了一个获取包名和签名的app供我们开发者使用，下载地址

https://pub.idqqimg.com/pc/misc/files/20180928/c982037b921543bb937c1cea6e88894f.apk

未通过审核只能使用调试的QQ号进行登录，通过就可以面向全部用户了，以下为审核通过的图片

2.官网下载相关的sdk

下载地址

https://tangram-1251316161.file.myqcloud.com/qqconnect/OpenSDK_V3.5.10/opensdk_3510_lite_2022-01-11.zip

推荐直接下载最新版本的，不过着实没看懂最新版本的更新公告，说是修复了retrofit冲突的问题，然后当时新建的项目没有用，结果报错，最后还是加上了，才可以

3. jar的引入

将jar放入lib包下，然后在app 同级的 build.gradle添加以下代码即完成jar的引用

dependencies {
    ...
    implementation fileTree(dir: 'libs', include: '*.jar')
    ...
}

4.配置Manifest

在AndroidManifest.xml中的application结点下增加以下的activity和启动QQ应用的声明,这两个activity无需我们在另外创建文件，引入的jar已经处理好了

 <application
       ...    
        <!--这里的权限为开启网络访问权限和获取网络状态的权限，必须开启，不然无法登录-->
        <uses-permission android:name="android.permission.INTERNET" />
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
        <activity
            android:name="com.tencent.tauth.AuthActivity"
            android:exported="true"
            android:launchMode="singleTask"
            android:noHistory="true">
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />

                <data android:scheme="tencent你的appId" />
            </intent-filter>
        </activity>
        <activity
            android:name="com.tencent.connect.common.AssistActivity"
            android:configChanges="orientation|keyboardHidden"
            android:screenOrientation="behind"
            android:theme="@android:style/Theme.Translucent.NoTitleBar" />

        <provider
            android:name="androidx.core.content.FileProvider"
            android:authorities="com.tencent.login.fileprovider"
            android:exported="false"
            android:grantUriPermissions="true">
            <meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/file_paths" />
        </provider>
        ...
    </application>

上面的哪个代码的最后提供了一个provider用于访问 QQ 应用的，需要另外创建一个 xml 文件，其中的 authorities 是自定义的名字，确保唯一即可，这边最下面那个provider是翻demo找的，文档没有写，在res文件夹中新增一个包xml，里面添加文件名为file_paths的 xml ，其内容如下

<?xml version="1.0" encoding="utf-8"?>
<paths>
    <external-files-path name="opensdk_external" path="Images/tmp"/>
    <root-path name="opensdk_root" path=""/>
</paths>

三、初始化配置

1.初始化SDK

加入以下代码在创建登录的那个activtiy下，不然无法拉起QQ应用的登录界面，至于官方文档所说的需要用户选择是否授权设备的信息的说明，这里通用的做法是在应用内部声明一个第三方sdk的列表，然后在里面说明SDK用到的相关设备信息的权限

Tencent.setIsPermissionGranted(true, Build.MODEL)

2.创建实例

这部分建议放在全局配置，这样可以实现登录异常强制退出等功能

/**
 * 其中APP_ID是申请到的ID
 * context为全局context
 * Authorities为之前provider里面配置的值
 */
val mTencent = Tencent.createInstance(APP_ID, context, Authorities)

3.开启登录

在开启登录之前需要自己创建一个 UIListener 用来监听回调结果（文档没讲怎么创建的，找了好久的demo）这里的代码为基础的代码，比较容易实现，目前还没写回调相关的代码，主要是为了快速展示效果

open class BaseUiListener(private val mTencent: Tencent) : DefaultUiListener() {

    private val kv = MMKV.defaultMMKV()

    override fun onComplete(response: Any?) {

        if (response == null) {

            "返回为空,登录失败".showToast()

            return

        }

        val jsonResponse = response as JSONObject

        if (jsonResponse.length() == 0) {

            "返回为空,登录失败".showToast()

            return

        }

        "登录成功".showToast()

        doComplete(response)

    }



    private fun doComplete(values: JSONObject?) {



    }

    override fun onError(e: UiError) {

        Log.e("fund", "onError: ${e.errorDetail}")

    }



    override fun onCancel() {

        "取消登录".showToast()

    }

}

建立一个按钮用于监听，这里进行登录操作

button.setOnClickListener {

    

    if (!mTencent.isSessionValid) {

        //判断会话是否有效

        when (mTencent.login(this, "all",iu)) {

            

            //下面为login可能返回的值的情况

            0 -> "正常登录".showToast()

            1 -> "开始登录".showToast()

            -1 -> "异常".showToast()

            2 -> "使用H5登陆或显示下载页面".showToast()

            else -> "出错".showToast()

        }

    }

}

这边对mTencent.login(this, "all",iu)中login的参数做一下解释说明

mTencent.login(this, "all",iu)

//这里Tencent的实例mTencent的login函数的三个参数

//1.为当前的context，

//2.权限,可选项，一般选择all即可，即全部的权限，不过目前好像也只有一个开放的权限了

//3.为UIlistener的实例对象

还差最后一步，获取回调的结果的代码，activity的回调，这边显示方法已经废弃了，本来想改造一下的，后面发现要改造的话需要动sdk里面的源码，有点麻烦就没有改了，等更新

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

    super.onActivityResult(requestCode, resultCode, data)

    //腾讯QQ回调，这里的iu仍然是相关的UIlistener

    Tencent.onActivityResultData(requestCode, resultCode, data,iu)

    if (requestCode == Constants.REQUEST_API) {

        if (resultCode == Constants.REQUEST_LOGIN) {

            Tencent.handleResultData(data, iu)

        }

    }

}

至此，已经可以正常登录了，但还有一件我们开发者最关心的事情没有做，获取的用户的数据在哪呢？可以获取QQ号吗？下面将为大家解答这方面的疑惑。

四、接入流程以及相关代码

首先回答一下上面提出的问题，可以获得两段比较关键的json数据，一个是 login 的时候获取的，主要是token相关的数据，还有一段就是用户的个人信息的 json 数据，这些都在 UIListener 中进行处理和获取。第二个问题能不能获取QQ号，答案是不能，我们只能获取与一个与QQ号一样具有唯一标志的id即open_id,显然这是出于用户的隐私安全考虑的，接下来简述一下具体的登录流程

1.登录之前检查是否有token缓存

• 有，直接启动主activity

• 无，进入登录界面

判断是否具有登录数据的缓存

//这里采用微信的MMKV进行储存键值数据

MMKV.initialize(this)

val kv = MMKV.defaultMMKV()

kv.decodeString("qq_login")?.let{

    val gson = Gson()

    val qqLogin = gson.fromJson(it, QQLogin::class.java)

    QQLoginTestApplication.mTencent.setAccessToken(qqLogin.access_token,qqLogin.expires_in.toString())

    QQLoginTestApplication.mTencent.openId = qqLogin.openid

}

检查token和open_id是否有效和token是否过期，这里采取不同于官方的推荐的用法，主要是api失效了或者是自己没用对方法，总之官方提供的api进行缓存还不如MMKV键值存login json来的实在，也很方便，这里建议多多使用日志，方便排查错误

//这里对于uiListener进行了重写，object的作用有点像java里面的匿名类

//用到了checkLogin的方法

mTencent.checkLogin(object : DefaultUiListener() {

    override fun onComplete(response: Any) {

        val jsonResp = response as JSONObject



        if (jsonResp.optInt("ret", -1) == 0) {

            val jsonObject: String? = kv.decodeString("qq_login")

            if (jsonObject == null) {

                "登录失败".showToast()



            } else {

                //启动主activity



            }

        } else {

            "登录已过期，请重新登录".showToast()

            //启动登录activity



        }

    }



    override fun onError(e: UiError) {

        "登录已过期，请重新登录".showToast()

        //启动登录activity



    }



    override fun onCancel() {

        "取消登录".showToast()

    }

})

2.进入登录界面

在判断session有效的情况下，进入登录界面，对login登录可能出现的返回码做一下解释说明

Login.setOnClickListener {

    if (!QQLoginTestApplication.mTencent.isSessionValid) {

        when (QQLoginTestApplication.mTencent.login(this, "all",iu)) {

            0 -> "正常登录".showToast()

            1 -> "开始登录".showToast()

            -1 -> {

                "异常".showToast()

                QQLoginTestApplication.mTencent.logout(QQLoginTestApplication.context)

            }

            2 -> "使用H5登陆或显示下载页面".showToast()

            else -> "出错".showToast()

        }

    }

}

• 1：正常登录

  这个就无需做处理了，直接在回调那里做相关的登录处理即可

• 0：开始登录

  同正常登录

• -1：异常登录

  这个需要做一点处理，当时第一次遇到这个情况就是主activity异常消耗退回登录的activity，此时在此点击登录界面的按钮导致了异常情况的出现，不过这个处理起来还是比较容易的，执行强制下线操作即可

  "异常".showToast()
  
  mTencent.logout(QQLoginTestApplication.context)

• 2：使用H5登陆或显示下载页面

  通常情况下是未安装QQ等软件导致的，这种情况无需处理，SDK自动封装好了，这种情况会自动跳转QQ下载界面

同样的有出现UIListener就需要调用回调进行数据的传输

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {

    super.onActivityResult(requestCode, resultCode, data)

    //腾讯QQ回调

    Tencent.onActivityResultData(requestCode, resultCode, data,iu)

    if (requestCode == Constants.REQUEST_API) {

        if (resultCode == Constants.REQUEST_LOGIN) {

            Tencent.handleResultData(data, iu)

        }

    }

}

3.进入主activity

这里需要放置一个按钮执行下线操作，方便调试，同时这里需要将之前的token移除重新获取token等数据的缓存

button.setOnClickListener {

    mTencent.logout(this)

    val  kv = MMKV.defaultMMKV()

    kv.remove("qq_login")

    //返回登录界面的相关操作

    "退出登录成功".showToast()

}

至此，其实还有一个很重要的东西没有说明，那就是token数据的缓存和个人信息数据的获取，这部分我写的登录的那个UIlistener里面了，登录成功的同时，获取login的response的json数据和个人信息的json数据

4.获取两段重要的json数据

• login 的json数据

  这个比较容易，当我们登录成功的时候，oncomplete里面的response即我们想要的数据

  override fun onComplete(response: Any?) {
  
      if (response == null) {
  
          "返回为空,登录失败".showToast()
  
          return
  
      }
  
      val jsonResponse = response as JSONObject
  
      if (jsonResponse.length() == 0) {
  
          "返回为空,登录失败".showToast()
  
          return
  
      }
  
      //这个即利用MMKV进行缓存json数据
  
      kv.encode("qq_login",response.toString())
  
      "登录成功".showToast()
  
  }

• 个人信息的数据

  这个需要在login有效的前提下才能返回正常的数据

  //首先需要用上一步获取的json数据对mTencent进行赋值，这部分放在doComplete方法中执行
  
  private fun doComplete(values: JSONObject?) {
  
      //利用Gson进行格式化成对象
  
      val gson = Gson()
  
      val qqLogin = gson.fromJson(values.toString(), QQLogin::class.java)
  
      mTencent.setAccessToken(qqLogin.access_token, qqLogin.expires_in.toString())
  
      mTencent.openId = qqLogin.openid
  
      Log.e("fund",values.toString())
  
  }

  创建一个get_info方法进行获取，注意这里需要对mTencent设置相关的属性才能获取正常获取数据

  private fun getQQInfo(){
      val qqToken = mTencent.qqToken
      //这里的UserInfo是sdk自带的类，传入上下文和token即可
      val info = UserInfo(context,qqToken)
      info.getUserInfo(object :BaseUiListener(mTencent){
          override fun onComplete(response: Any?){
              //这里对数据进行缓存
              kv.encode("qq_info",response.toString())           
          }
      })
  }

5.踩坑系列

这里主要吐槽一下关于腾讯的自带的session缓存机制，当时是抱着不用自己实现缓存直接用现成的机制去看的，很遗憾这波偷懒失败，这部分session的设置不知道具体的缓存机制，只知道大概是用share preference实现的，里面有saveSession，initSession，loadSession这三个方法，看上去很容易的样子，然后抱着这种心态去尝试了一波，果然不出意外空指针异常，尝试修改了一波回调的顺序仍然空指针异常，折腾了大概三个多小时，放弃了，心态给搞崩了，最终释然了，为什么要用腾讯提供的方法，这个缓存自己实现也是相当的容易，这时想到了MMKV，两行代码完成读取，最后只修改了少数的代码完成了登录的token的缓存机制，翻看demo里面的实现，里面好像是用这三种方法进行实现的，可能是某个实现机制没有弄明白，其实也不想明白，自己的思路比再去看demo容易多了，只是多了一个json的转对象的过程，其他的没有差别。所以建议后来者直接自己实现缓存，不用管sdk提供的那些方法，真的有点难用。

五、总结

总之这次完成QQ接入踩了许多的坑，不过幸好最终还是实现了，希望腾讯互联这个sdk能够上传github让更多的人参与和提供反馈，不然这个文档说是最差sdk体验也不为过。下面附上这次实现QQ登录的demo的github地址以及相关的demo apk供大家进行参考，大概总共就400行代码左右比官方的demo好很多，有问题欢迎留言

https://github.com/xyh-fu/QQLoginTest.git

作者：wresource
来源：juejin.cn/post/7072878774261383176

前言

我们平时玩游戏多多少少会碰到一些视频广告，看完后是能领取游戏奖励的，然后你会发现有时候看完点击那个关闭按钮，结果是跳下载，你理所当然的认为是点击到了外边，事实真的是这样的吗？有些东西不好那啥，你们懂的，所以以下内容纯属我个人猜测，纯属虚构

1. 整个广告流程的各个角色

要想对广告这东西有个大概的了解，你得先知道你看广告的过程中都有哪些角色参与了进来。

简单来说，是有三方参与了进来：
（1）广告提供商：顾名思义负责提供广告，比如你看的广告是一款游戏的广告，那这个游戏的公司就是广告的提供商。
（2）当前应用：就是播放这个广告的应用。
（3）平台：播放广告这个操作就是平台负责的，它负责连接上面两方，从广告提供商中拿到广告，然后让当前应用接入。

平台有很多，比如字节、腾讯都有相对应的广告平台，或者一些小公司自己做广告平台。他们之间的py交易是这样的：所有广告的功能是由平台去开发，然后他会提供一套sdk或者什么的让应用接入，应用你接入之后每播放1次广告，平台就给你多少钱，但是播放的是什么广告，这个就是平台自己去下发。然后广告提供商就找到平台，和他谈商业合作，你帮我展示我家的产品的广告多少次，我给你多少钱。 简单来说他们之间的交易就是这样。

简单来说，就是广告提供商想要影响力，其它两方要钱，他们都希望广告能更多的展示。

2. 广告提供商的操作

广告提供商是花钱让平台推广广告的，那我肯定是希望尽量每次广告的展示都有用户去点击然后下载我们家的应用。

所以广告提供商想出了一个很坏的办法，相信大家都遇到过，就是我播放视频，我在视频的最后几帧里面的图片的右上角放一个关闭图片，误导用户这个关闭图片是点了之后能关闭的，其实它是视频的一部分，所以你点了就相当于点了视频，那就触发跳转下载应用这些操作。

破解的方法也很简单，你等到计算结束后的几秒再点关闭按钮，不要一看到关闭按钮的图片出来马上点。

3. 应用的操作

应用是很难在广告播放的时候去做手脚，因为这部分的代码不是他们写的，他们只是去调用平台写的代码。

那他们想让广告尽可能多的展示，唯一能做的就是把展示广告的地方增加，尽可能多的让更多场景能展示广告。当然这也有副作用，你要是这个应用点哪里都是广告，这不得把用户给搞吐了，砸了自己的口碑，如果只有一些地方有，用户还是能理解的，毕竟赚钱嘛，不寒参。

4. 平台的操作

平台的操作那就丰富了，代码是我写的，兄弟，我想怎么玩就怎么玩，我能有一百种方法算计你。

猜测的，注意，是猜测的[狗头]

有的人说，故意把关闭按钮设置小，让我们误触关闭按钮以外的区域。我只能说，你让我来做，我都不屑于把关闭按钮设置小。

我们都知道平时开发时，我们觉得点击按钮不灵，所以我们想扩大图标的点击区域，但是又不想改变图标的大小，所以我们用padding来实现。同样的，我也能做到不改变图标的大小，然后缩小点击的范围

我写一个自定义view（假设就是关闭图标）

public class TestV extends View {

    public TestV(Context context) {
        super(context);
    }

    public TestV(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public TestV(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            int w = getMeasuredWidth();
            int h = getMeasuredHeight();
            Log.d("mmp", "============ view点击");
            if (event.getX() < w / 4 || event.getX() > 3 * w / 4 || event.getY() < h / 4 || event.getY() > 3 * h / 4) {
                return super.dispatchTouchEvent(event);
            } else {
                Log.d("mmp", "============ view点击触发-》关闭");
                return true;
            }
        }
        return super.dispatchTouchEvent(event);
    }
}

代码很简单就不过多讲解，能看出我很简单就实现让点击范围缩小1/4。所以当你点到边缘的时候，其实就相当于点到了广告。

除了缩小范围之外，我还能设置2秒前后点击是不同的效果，你有没有一种感觉，第一次点关闭按钮就是跳到下载应用，然后返回再点击就是关闭，所以你觉得是你第一次点击的时候是误触了外边。

public class TestV extends View {

    private boolean canClose = true;

    public TestV(Context context) {
        super(context);
    }

    public TestV(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public TestV(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    public void setVisibility(int visibility) {
        super.setVisibility(visibility);
        if (visibility == View.VISIBLE) {
            canClose = false;
        }
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            int w = getMeasuredWidth();
            int h = getMeasuredHeight();
            Log.d("mmp", "============ view点击");
            if (!canClose) {
                return super.dispatchTouchEvent(event);
            } else {
                Log.d("mmp", "============ view点击触发-》关闭");
                return true;
            }
        }
        return super.dispatchTouchEvent(event);
    }

    // 播放完成
    public void playFinish() {
        setVisibility(VISIBLE);
        Handler handler = new Handler(Looper.getMainLooper());
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                canClose = true;
            }
        }, 2000);
    }

}

播放完成之后调用playFinish方法，然后会把canClose这个状态设置为false，2秒后再设为true。这样你在2秒前点击按钮，其实就是点击外部的效果，也就会跳去下载。

而且你注意，这些限制，我可以不写死在代码里面，可以用后台返回，比如这个2000,我可以后台返回。我就能做到比如第一天我返回0,你觉得没什么问题，能正常点关闭，我判断你是第二天，我直接返2000给你,然后你一想，之前都是正常的，那这次不正常，肯定是我点错。

你以为的意外只不过是我想让你以为是意外罢了。那这个如何去破解呢？我只能说无解，他能有100种方法让你点中跳出去下载，那还能有是什么解法?

作者：流浪汉kylin
来源：juejin.cn/post/7197611189244592186

1. Android App Bundle 是什么？

从 2021 年 8 月起，新应用需要使用 Android App Bundle 才能在 Google Play 中发布。

Android App Bundle是一种发布格式，打包出来的格式为aab，而之前我们打包出来的格式为apk。编写完代码之后，将其打包成aab格式（里面包含了所有经过编译的代码和资源），然后上传到Google Play。用户最后安装的还是apk，只不过不是一个，而是多个apk，这些apk是Google Play根据App Bundle生成的。

既然已经有了apk，那要App Bundle有啥用？咱之前打一个apk，会把各种架构、各种语言、各种分辨率的图片等全部放入一个apk中，但具体到某个用户的设备上，这个设备只需要一种so库架构、一种语言、一种分辨率的图片，那其他的东西都在apk里面，这就有点浪费了，不仅下载需要更多的流量，而且还占用用户设备更多的存储空间。当然，也可以通过在打包的时候打多个apk，分别支持各种密度、架构、语言的设备，但这太麻烦了。

于是，Google Play出手了。

App Bundle是经过签名的二进制文件，可将应用的代码和资源组织到不同的模块中。比如，当某个用户的设备是xxhdpi+arm64-v8a+values-zh环境，那Google Play后台会利用App Bundle中的对应的模块(xxhdpi+arm64-v8a+values-zh)组装起来，组成一个base apk和多个配置apk供该用户下载并安装，而不会去把其他的像armeabi-v7a、x86之类的与当前设备无关的东西组装进apk，这样用户下载的apk体积就会小很多。体积越小，转化率越高，也更环保。

有了Android App Bundle之后，Google Play还提供了2个东西：Play Feature Delivery 和 Play Asset Delivery。Play Feature Delivery可以按某种条件分发或按需下载应用的某些功能，从而进一步减小包体积。Play Asset Delivery是Google Play用于分发大体积应用的解决方案，为开发者提供了灵活的分发方式和极高的性能。

2. Android App Bundle打包

打Android App Bundle非常简单，直接通过Android Studio就能很方便地打包，当然命令行也可以的。

• Android Studio打包：Build -> Generate Signed Bundle / APK -> 选中Android App Bundle -> 选中签名和输入密码 -> 选中debug或者release包 -> finish开始打包

• gradle命令行打包：./gradlew bundleDebug 或者 ./gradlew bundleRelease

打出来之后是一个类似app-debug.aab的文件，可以将aab文件直接拖入Android Studio进行分析和查看其内部结构，很方便。

3. 如何测试Android App Bundle？

Android App Bundle包倒是打出来了，那怎么进行测试呢？我们设备上仅允许安装apk文件，aab是不能直接进行安装的。这里官方提供了3种方式可供选择：Android Studio 、Google Play 和 bundletool，下面我们一一来介绍。

3.1 Android Studio

利用Android Studio，在我们平时开发时就可以直接将项目打包成debug的aab并且运行到设备上，只需要点一下运行按钮即可（当然，这之前需要一些简单的配置才行）。Android Studio和Google Play使用相同的工具从aab中提取apk并将其安装在设备上，因此这种本地测试策略也是可行的。这种方式可以验证以下几点：

• 该项目是否可以构建为app bundle

• Android Studio是否能够从app bundle中提取目标设备配置的apk

• 功能模块的功能与应用的基本模块是否兼容

• 该项目是否可以在目标设备上按预期运行

默认情况下，设备连接上Android Studio之后，运行时打的包是apk。所以我们需要配置一下，改成运行时先打app bundle，然后再从app bundle中提取出该设备需要的配置apk，再组装成一个新的apk并签名，随后安装到设备上。具体配置步骤如下：

1. 从菜单栏中依次选择 Run -> Edit Configurations。

2. 从左侧窗格中选择一项运行/调试配置。

3. 在右侧窗格中，选择 General 标签页。

4. 从 Deploy 旁边的下拉菜单中选择 APK from app bundle。

5. 如果你的应用包含要测试的免安装应用体验，请选中 Deploy as an instant app 旁边的复选框。

6. 如果你的应用包含功能模块，你可以通过选中每个模块旁边的复选框来选择要部署的模块。默认情况下，Android Studio 会部署所有功能模块，并且始终都会部署基本应用模块。

7. 点击 Apply 或 OK。

好了，现在已经配置好了，现在点击运行按钮，Android Studio会构建app bundle，并使用它来仅部署连接的设备及你选择的功能模块所需要的apk。

3.2 bundletool

bundletool 是一种命令行工具，谷歌开源的，Android Studio、Android Gradle 插件和 Google Play 使用这一工具将应用的经过编译的代码和资源转换为 App Bundle，并根据这些 Bundle 生成可部署的 APK。

前面使用Android Studio来测试app bundle比较方便，但是，官方推荐使用bundletool 从 app bundle 将应用部署到连接的设备。因为bundletool提供了专门为了帮助你测试app bundle并模拟通过Google Play分发而设计的命令，这样的话我们就不必上传到Google Play管理中心去测试了。

下面我们就来实验一把。

1. 首先是下载bundletool，到GitHub上去下载bundletool，地址：github.com/google/bund…

2. 然后通过Android Studio或者Gradle将项目打包成Android App Bundle，然后通过bundletool将Android App Bundle生成一个apk容器（官方称之为split APKs），这个容器以.apks作为文件扩展名，这个容器里面包含了该应用支持的所有设备配置的一组apk。这么说可能不太好懂，我们实操一下：

//使用debug签名生成apk容器
java -jar bundletool-all-1.14.0.jar build-apks --bundle=app-release.aab --output=my_app.apks

//使用自己的签名生成apk容器
java -jar bundletool-all-1.14.0.jar build-apks --bundle=app-release.aab --output=my_app.apks
--ks=keystore.jks
--ks-pass=file:keystore.pwd
--ks-key-alias=MyKeyAlias
--key-pass=file:key.pwd

ps: build-apks命令是用来打apks容器的，它有很多可选参数，比如这里的--bundle=path表示：指定你的 app bundle 的路径，--output=path表示：指定输出 .apks 文件的名称，该文件中包含了应用的所有 APK 零部件。它的其他参数大家感兴趣可以到bundletool查阅。

执行完命令之后，会生成一个my_app.apks的文件，我们可以把这个apks文件解压出来，看看里面有什么。

│ toc.pb
│
└─splits
        base-af.apk
        base-am.apk
        base-ar.apk
        base-as.apk
        base-az.apk
        base-be.apk
        base-bg.apk
        base-bn.apk
        base-bs.apk
        base-ca.apk
        base-cs.apk
        base-da.apk
        base-de.apk
        base-el.apk
        base-en.apk
        base-es.apk
        base-et.apk
        base-eu.apk
        base-fa.apk
        base-fi.apk
        base-fr.apk
        base-gl.apk
        base-gu.apk
        base-hdpi.apk
        base-hi.apk
        base-hr.apk
        base-hu.apk
        base-hy.apk
        base-in.apk
        base-is.apk
        base-it.apk
        base-iw.apk
        base-ja.apk
        base-ka.apk
        base-kk.apk
        base-km.apk
        base-kn.apk
        base-ko.apk
        base-ky.apk
        base-ldpi.apk
        base-lo.apk
        base-lt.apk
        base-lv.apk
        base-master.apk
        base-mdpi.apk
        base-mk.apk
        base-ml.apk
        base-mn.apk
        base-mr.apk
        base-ms.apk
        base-my.apk
        base-nb.apk
        base-ne.apk
        base-nl.apk
        base-or.apk
        base-pa.apk
        base-pl.apk
        base-pt.apk
        base-ro.apk
        base-ru.apk
        base-si.apk
        base-sk.apk
        base-sl.apk
        base-sq.apk
        base-sr.apk
        base-sv.apk
        base-sw.apk
        base-ta.apk
        base-te.apk
        base-th.apk
        base-tl.apk
        base-tr.apk
        base-tvdpi.apk
        base-uk.apk
        base-ur.apk
        base-uz.apk
        base-vi.apk
        base-xhdpi.apk
        base-xxhdpi.apk
        base-xxxhdpi.apk
        base-zh.apk
        base-zu.apk

里面有一个toc.pb文件和一个splits文件夹（splits顾名思义，就是拆分出来的所有apk文件），splits里面有很多apk，base-开头的apk是主module的相关apk，其中base-master.apk是基本功能apk，base-xxhdpi.apk则是对资源分辨率进行了拆分，base-zh.apk则是对语言资源进行拆分。

我们可以将这些apk拖入Android Studio看一下里面有什么，比如base-xxhdpi.apk：

│  AndroidManifest.xml
|  
|  resources.arsc
│
├─META-INF
│      BNDLTOOL.RSA
│      BNDLTOOL.SF
│      MANIFEST.MF
│
└─res
    ├─drawable-ldrtl-xxhdpi-v17
    │      abc_ic_menu_copy_mtrl_am_alpha.png
    │      abc_ic_menu_cut_mtrl_alpha.png
    │      abc_spinner_mtrl_am_alpha.9.png
    │
    ├─drawable-xhdpi-v4
    │      notification_bg_low_normal.9.png
    │      notification_bg_low_pressed.9.png
    │      notification_bg_normal.9.png
    │      notification_bg_normal_pressed.9.png
    │      notify_panel_notification_icon_bg.png
    │
    └─drawable-xxhdpi-v4
            abc_textfield_default_mtrl_alpha.9.png
            abc_textfield_search_activated_mtrl_alpha.9.png
            abc_textfield_search_default_mtrl_alpha.9.png
            abc_text_select_handle_left_mtrl_dark.png
            abc_text_select_handle_left_mtrl_light.png
            abc_text_select_handle_middle_mtrl_dark.png
            abc_text_select_handle_middle_mtrl_light.png
            abc_text_select_handle_right_mtrl_dark.png
            abc_text_select_handle_right_mtrl_light.png

首先，这个apk有自己的AndroidManifest.xml，其次是resources.arsc，还有META-INF签名信息，最后是与自己名称对应的xxhdpi的资源。

再来看一个base-zh.apk:

│  AndroidManifest.xml
│  resources.arsc
│
└─META-INF
        BNDLTOOL.RSA
        BNDLTOOL.SF
        MANIFEST.MF

也是有自己的AndroidManifest.xml、resources.arsc、签名信息，其中resources.arsc里面包含了字符串资源（可以直接在Android Studio中查看）。

分析到这里大家对apks文件就有一定的了解了，它是一个压缩文件，里面包含了各种最终需要组成apk的各种零部件，这些零部件可以根据设备来按需组成一个完整的app。 比如我有一个设备是只支持中文、xxhdpi分辨率的设备，那么这个设备其实只需要下载部分apk就行了，也就是base-master.apk(基本功能的apk)、base-zh.apk（中文语言资源）和base-xxhdpi.apk（图片资源）给组合起来。到Google Play上下载apk，也是这个流程（如果这个项目的后台上传的是app bundle的话），Google Play会根据设备的特性（CPU架构、语言、分辨率等），首先下载基本功能apk，然后下载与之配置的CPU架构的apk、语言apk、分辨率apk等，这样下载的apk是最小的。

1. 生成好了apks之后，现在我们可以把安卓测试设备插上电脑，然后利用bundletool将apks中适合设备的零部件apk挑选出来，并部署到已连接的测试设备。具体操作命令：java -jar bundletool-all-1.14.0.jar install-apks --apks=my_app.apks，执行完该命令之后设备上就安装好app了，可以对app进行测试了。bundletool会去识别这个测试设备的语言、分辨率、CPU架构等，然后挑选合适的apk安装到设备上，base-master.apk是首先需要安装的，其次是语言、分辨率、CPU架构之类的apk，利用Android 5.0以上的split apks，这些apk安装之后可以共享一套代码和资源。

3.3 Google Play

如果我最终就是要将Android App Bundle发布到Google Play，那可以先上传到Google Play Console的测试渠道，再通过测试渠道进行分发，然后到Google Play下载这个测试的App，这样肯定是最贴近于用户的使用环境的，比较推荐这种方式进行最后的测试。

4. 拆解Android App Bundle格式

首先，放上官方的格式拆解图（下图包含：一个基本模块、两个功能模块、两个资源包）：

app bundle是经过签名的二进制文件，可将应用的代码和资源装进不同的模块中，这些模块中的代码和资源的组织方式和apk中相似，它们都可以作为单独的apk生成。Google Play会使用app bundle生成向用户提供的各种apk，如base apk、feature apk、configuration apks、multi-APKs。图中蓝色标识的目录（drawable、values、lib）表示Google Play用来为每个模块创建configuration apks的代码和资源。

• base、feature1、feature2：每个顶级目录都表示一个不同的应用模块，基本模块是包含在app bundle的base目录中。

• asset_pack_1和asset_pack_2：游戏或者大型应用如果需要大量图片，则可以将asset模块化处理成资源包。资源包可以根据自己的需要，在合适的时机去请求到本地来。

• BUNDLE-METADATA/：包含元数据文件，其中包含对工具或应用商店有用的信息。

• 模块协议缓冲区(*pb)文件：元数据文件，向应用商店说明每个模块的内容。如：BundleConfig.pb 提供了有关 bundle 本身的信息（如用于构建 app bundle 的构建工具版本），native.pb 和 resources.pb 说明了每个模块中的代码和资源，这在 Google Play 针对不同的设备配置优化 APK 时非常有用。

• manifest/：与 APK 不同，app bundle 将每个模块的 AndroidManifest.xml 文件存储在这个单独的目录中。

• dex/：与 APK 不同，app bundle 将每个模块的 DEX 文件存储在这个单独的目录中。

• res/、lib/ 和 assets/：这些目录与典型 APK 中的目录完全相同。

• root/：此目录存储的文件之后会重新定位到包含此目录所在模块的任意 APK 的根目录。

5. Split APKs

Android 5.0 及以上支持Split APKs机制，Split APKs与常规的apk相差不大，都是包含经过编译的dex字节码、资源和清单文件等。区别是：Android可以将安装的多个Split APKs视为一个应用，也就是虽然我安装了多个apk，但Android系统认为它们是同一个app，用户也只会在设置里面看到一个app被安装上了；而平时我们安装的普通apk，一个apk就对应着一个app。Android上，我们可以安装多个Split APK，它们是共用代码和资源的。

Split APKs的好处是可以将单体式app做拆分，比如将ABI、屏幕密度、语言等形式拆分成多个独立的apk，按需下载和安装，这样可以让用户更快的下载并安装好apk，并且占用更小的空间。

Android App Bundle最终也就是利用这种方式来进行安装的，比如我上面在执行完java -jar bundletool-all-1.14.0.jar install-apks --apks=my_app.apks命令之后，那么最后安装到手机上的apk文件如下：

ps：5.0以下不支持Split APKs，那咋办？没事，Google Play会为这些设备的用户安装一个全量的apk，里面什么都有，问题不大。

6. 国内商店支持Android App Bundle吗？

Android App Bundle不是Google Play的专有格式，它是开源的，任何商店想支持都可以的。

上面扯那么大一堆有的没的，这玩意儿这么好用，那国内商店的支持情况如何。我查了下，发现就华为可以支持，手动狗头。

华为 Android App Bundle developer.huawei.com/consumer/cn…

7. 小结

现在上架Google Play必须上传Android App Bundle才行了，所以有必要简单了解下。简单来说就是Android App Bundle是一种新的发布格式，上传到商店之后，商店会利用这个Android App Bundle生成一堆Split APKs，当用户要去安装某个app时，只需要按需下载Split APKs中的部分apk（base apk + 各种配置apk），进行安装即可，总下载量大大减少。

参考资料

• splits——安卓gradle blog.csdn.net/weixin_3762…

• Android App Bundle探索 juejin.cn/post/684490…

• Android App Bundle 简介 developer.android.google.cn/guide/app-b…

• 配置基本模块 developer.android.google.cn/guide/app-b…

• 测试 Android App Bundle developer.android.google.cn/guide/app-b…

• app bundle 的代码透明性机制 developer.android.google.cn/guide/app-b…

• Android App Bundle 格式 developer.android.google.cn/guide/app-b…

• Android App Bundle 常见问题解答 developer.android.google.cn/guide/app-b…

• 视频资料 App Bundles - MAD Skills ：http://www.youtube.com/playlist?li…

• Android App Bundle解析 zhuanlan.zhihu.com/p/86995941

• bundletool developer.android.google.cn/studio/comm…

• 从命令行构建应用 developer.android.google.cn/studio/buil…

作者：潇风寒月
来源：juejin.cn/post/7197246543207022629

你有因为手速不够快抢不到红包而沮丧？ 你有因为错过红包而懊恼吗？ 没错，它来了。。。

一、目标

使用AccessibilityService的方式，实现微信自动抢红包（吐槽一下，网上找了许多文档，由于各种原因，无法实现对应效果，所以先给自己整理下），关于AccessibilityService的文章，网上有很多（没错，多的都懒得贴链接那种多），可自行查找。

二、实现流程

1、流程分析（这里只分析在桌面的情况）

我们把一个抢红包发的过程拆分来看，可以分为几个步骤：

收到通知 -> 点击通知栏 -> 点击红包 -> 点击开红包 -> 退出红包详情页

以上是一个抢红包的基本流程。

2、实现步骤

1、收到通知 以及 点击通知栏

接收通知栏的消息，介绍两种方式

Ⅰ、AccessibilityService

即通过AccessibilityService的AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED事件来获取到Notification

private fun handleNotification(event: AccessibilityEvent) {
   val texts = event.text
   if (!texts.isEmpty()) {
           for (text in texts) {
               val content = text.toString()
               //如果微信红包的提示信息,则模拟点击进入相应的聊天窗口
               if (content.contains("[微信红包]")) {
                   if (event.parcelableData != null && event.parcelableData is Notification) {
                       val notification: Notification? = event.parcelableData as Notification?
                       val pendingIntent: PendingIntent = notification!!.contentIntent
                       try {
                           pendingIntent.send()
                      } catch (e: CanceledException) {
                           e.printStackTrace()
                      }
                  }
              }
          }
      }

}

Ⅱ、NotificationListenerService

这是监听通知栏的另一种方式，记得要获取权限哦

class MyNotificationListenerService : NotificationListenerService() {

   override fun onNotificationPosted(sbn: StatusBarNotification?) {
       super.onNotificationPosted(sbn)

       val extras = sbn?.notification?.extras
       // 获取接收消息APP的包名
       val notificationPkg = sbn?.packageName
       // 获取接收消息的抬头
       val notificationTitle = extras?.getString(Notification.EXTRA_TITLE)
       // 获取接收消息的内容
       val notificationText = extras?.getString(Notification.EXTRA_TEXT)
       if (notificationPkg != null) {
           Log.d("收到的消息内容包名：", notificationPkg)
           if (notificationPkg == "com.tencent.mm"){
               if (notificationText?.contains("[微信红包]") == true){
                   //收到微信红包了
                   val intent = sbn.notification.contentIntent
                   intent.send()
              }
          }
      }
       Log.d("收到的消息内容", "Notification posted $notificationTitle & $notificationText")
  }

   override fun onNotificationRemoved(sbn: StatusBarNotification?) {
       super.onNotificationRemoved(sbn)
  }
}

2、点击红包

通过上述的跳转，可以进入聊天详情页面，到达详情页之后，接下来就是点击对应的红包卡片，那么问题来了，怎么点？肯定不是手动点。。。

我们来分析一下，一个聊天列表中，我们怎样才能识别到红包卡片，我看网上有通过findAccessibilityNodeInfosByViewId来获取对应的View，这个也可以，只是我们获取id的方式需要借助工具，可以用Android Device Monitor,但是这玩意早就废废弃了，虽然在sdk的目录下存在monitor，奈何本人太菜，点击就是打不开

我本地的jdk是11，我怀疑是不兼容，毕竟Android Device Monitor太老了。换新的layout Inspector，也就看看本地的debug应用，无法查看微信的呀。要么就反编译，这个就先不考虑了，或者在配置文件中设置android:accessibilityFlags="flagReportViewIds",然后暴力遍历Node树，打印相应的viewId和className,找到目标id即可。当然也可以换findAccessibilityNodeInfosByText这个方法试试。

这个方法从字面意思能看出来，是通过text来匹配的，我们可以知道红包卡片上面是有“微信红包”的固定字样的，是不是可以通股票这个来匹配呢，这还有个其他问题，并不是所有的红包都需要点，比如已过期，已领取的是不是要过滤下，咋一看挺好过滤的，一个循环就好，仔细想，这是棵树，不太好剔除，所以换了个思路。

最终方案就是递归一棵树，往一个列表里面塞值，“已过期”和“已领取”的塞一个字符串“#”，匹配到“微信红包”的塞一个AccessibilityNodeInfo，这样如果这个红包不能抢，那肯定一前一后分别是一个字符串和一个AccessibilityNodeInfo，因此，我们读到一个AccessibilityNodeInfo，并且前一个值不是字符串，就可以执行点击事件，代码如下

private fun getPacket() {
   val rootNode = rootInActiveWindow
   val caches:ArrayList<Any> = ArrayList()
   recycle(rootNode,caches)
   if(caches.isNotEmpty()){
       for(index in 0 until caches.size){
           if(caches[index] is AccessibilityNodeInfo && (index == 0 || caches[index-1] !is String )){
               val node = caches[index] as AccessibilityNodeInfo
               var parent = node.parent
               while (parent != null) {
                   if (parent.isClickable) {
                       parent.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                       break
                  }
                   parent = parent.parent
              }
               break
          }
      }
  }

}

private fun recycle(node: AccessibilityNodeInfo,caches:ArrayList<Any>) {
       if (node.childCount == 0) {
           if (node.text != null) {
               if ("已过期" == node.text.toString() || "已被领完" == node.text.toString() || "已领取" == node.text.toString()) {
                   caches.add("#")
              }

               if ("微信红包" == node.text.toString()) {
                   caches.add(node)
              }
          }
      } else {
           for (i in 0 until node.childCount) {
               if (node.getChild(i) != null) {
                   recycle(node.getChild(i),caches)
              }
          }
      }
  }

以上只点击了第一个能点击的红包卡片，想点击所有的可另行处理。

3、点击开红包

这里思路跟上面类似，开红包页面比较简单，但是奈何开红包是个按钮，在不知道id的前提下，我们也不知道则呢么获取它，所以采用迂回套路，找固定的东西，我这里发现每个开红包的页面都有个“xxx的红包”文案，然后这个页面比较简单，只有个关闭，和开红包，我们通过获取“xxx的红包”对应的View来获取父View,然后递归子View，判断可点击的，执行点击事件不就可以了吗

private fun openPacket() {
   val nodeInfo = rootInActiveWindow
   if (nodeInfo != null) {
       val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")
       for ( i in 0 until list.size) {
           val parent = list[i].parent
           if (parent != null) {
               for ( j in 0 until  parent.childCount) {
                   val child = parent.getChild (j)
                   if (child != null && child.isClickable) {
                       child.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                  }
              }

          }

      }
  }

}

4、退出红包详情页

这里回退也是个按钮，我们也不知道id，所以可以跟点开红包一样，迂回套路，获取其他的View，来获取父布局，然后递归子布局，依次执行点击事件，当然关闭事件是在前面的，也就是说关闭会优先执行到

private fun close() {
   val nodeInfo = rootInActiveWindow
   if (nodeInfo != null) {
       val list = nodeInfo.findAccessibilityNodeInfosByText ("的红包")
       if (list.isNotEmpty()) {
           val parent = list[0].parent.parent.parent
           if (parent != null) {
               for ( j in 0 until  parent.childCount) {
                   val child = parent.getChild (j)
                   if (child != null && child.isClickable) {
                       child.performAction(AccessibilityNodeInfo.ACTION_CLICK)
                  }
              }

          }

      }
  }
}

三、遇到问题

1、AccessibilityService收不到AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED事件

android碎片问题很正常，我这边是使用NotificationListenerService来替代的。

2、需要点击View的定位

简单是就是到页面应该点哪个View，找到相应的规则，来过滤出对应的View，这个规则是随着微信的改变而变化的，findAccessibilityNodeInfosByViewId最直接，但是奈何工具问题，有点麻烦，遍历打印可以获取，但是id每个版本可能会变。还有就是通过文案来获取，即findAccessibilityNodeInfosByText，获取一些固定文案的View，这个相对而言在不改版，可能不会变，相对稳定些，如果这个文案的View本身没点击事件，可获取它的parent，尝试点击，或者遍历parent树，根据isClickable来判断是否可以点击。

划重点：

这里还有一种就是钉钉的开红包按钮，折腾了半天，始终拿不到，各种递归遍历，一直没有找到，最后换了个方式，通过AccessibilityService的模拟点击来做，也就是通过坐标来模拟点击，当然要在配置中开启android:canPerformGestures="true"， 然后通过 accessibilityService.dispatchGesture() 来处理，具体坐标可以拿一个其他的View,然后通过比例来确定大概得位置，或者,看看能不能拿到外层的Layout也是一样的

object AccessibilityClick {
   fun click(accessibilityService: AccessibilityService, x: Float, y: Float) {
       val builder = GestureDescription.Builder()
       val path = Path()
       path.moveTo(x, y)
       path.lineTo(x, y)
       builder.addStroke(GestureDescription.StrokeDescription(path, 0, 10))
       accessibilityService.dispatchGesture(builder.build(), object : AccessibilityService.GestureResultCallback() {
           override fun onCancelled(gestureDescription: GestureDescription) {
               super.onCancelled(gestureDescription)
          }

           override fun onCompleted(gestureDescription: GestureDescription) {
               super.onCompleted(gestureDescription)
          }
      }, null)
  }
}

续：android 微信抢红包工具 AccessibilityService（下）

作者：我有一头小毛驴你有吗
来源：juejin.cn/post/7196949524061339703

接：android 微信抢红包工具 AccessibilityService（上）

四、完整代码

MyNotificationListenerService

class MyNotificationListenerService : NotificationListenerService() {

   override fun onNotificationPosted(sbn: StatusBarNotification?) {
       super.onNotificationPosted(sbn)

       val extras = sbn?.notification?.extras
       // 获取接收消息APP的包名
       val notificationPkg = sbn?.packageName
       // 获取接收消息的抬头
       val notificationTitle = extras?.getString(Notification.EXTRA_TITLE)
       // 获取接收消息的内容
       val notificationText = extras?.getString(Notification.EXTRA_TEXT)
       if (notificationPkg != null) {
           Log.d("收到的消息内容包名：", notificationPkg)
           if (notificationPkg == "com.tencent.mm"){
               if (notificationText?.contains("[微信红包]") == true){
                   //收到微信红包了
                   val intent = sbn.notification.contentIntent
                   intent.send()
              }
          }
      } Log.d("收到的消息内容", "Notification posted $notificationTitle & $notificationText")
  }

   override fun onNotificationRemoved(sbn: StatusBarNotification?) {
       super.onNotificationRemoved(sbn)
  }
}