DNS

DNS：Domain Name System 域名系统,应用层协议,是互联网的一项服务。它作为将域名和IP地址相互映射的一个分布式数据库，能够使人更方便地访问互联网,基于C/S架构，服务器端：53/udp, 53/tcp实际上，每一台 DNS 服务器都只负责管理一个有限范围（一个或几个域）内的主机域 名和 IP 地址的对应关系，这些特定的 DNS 域或 IP 地址段称为 zone（区域）。根据地址解 析的方向不同，DNS 区域相应地分为正向区域（包含域名到 IP 地址的解析记录）和反向区 域（包含 IP 地址到域名的解析记录）

根域: 全球根服务器节点只有13个,10个在美国，1个荷兰，1个瑞典，1个日本

• 一级域名：Top Level Domain: tld
• 三类：组织域、国家域(.cn, .ca, .hk, .tw)、反向域
• com, edu, mil, gov, net, org, int,arpa
• 二级域名：magedu.com
• 三级域名：study.magedu.com
• 最多可达到127级域名

ICANN（The Internet Corporation for Assigned Names and Numbers）互联网名称与数字地址分配机构，负责在全球范围内对互联网通用顶级域名（gTLD）以及国家和地区顶级域名（ccTLD）系统的管理、以及根服务器系统的管理

DNS服务器类型

• 缓存域名服务器：只提供域名解析结果的缓存功能，目的在于提高查询速度和效率， 但是没有自己控制的区域地址数据。构建缓存域名服务器时，必须设置根域或指定其他 DNS 服务器作为解析来源。
• 主域名服务器：管理和维护所负责解析的域内解析库的服务器
• 从域名服务器 从主服务器或从服务器"复制"（区域传输）解析库副本

序列号：解析库版本号，主服务器解析库变化时，其序列递增

刷新时间间隔：从服务器从主服务器请求同步解析的时间间隔

重试时间间隔：从服务器请求同步失败时，再次尝试时间间隔

过期时长：从服务器联系不到主服务器时，多久后停止服务

通知机制：主服务器解析库发生变化时，会主动通知从服务器

DNS查询类型及原理

查询方式

• 递归查询：一般客户机和本地DNS服务器之间属于递归查询，即当客户机向DNS服务器发出请求后,若DNS服务器本身不能解析，则会向另外的DNS服务器发出查询请求，得到最终的肯定或否定的结果后转交给客户机。此查询的源和目标保持不变,为了查询结果只需要发起一次查询。（不需要自己动手）

• 迭代查询：一般情况下(有例外)本地的DNS服务器向其它DNS服务器的查询属于迭代查询,如：若对方不能返回权威的结果，则它会向下一个DNS服务器(参考前一个DNS服务器返回的结果)再次发起进行查询，直到返回查询的结果为止。此查询的源不变,但查询的目标不断变化,为查询结果一般需要发起多次查询。(需要自己动手)

查询原理过程

正向解析查询过程：

1 先查本机的缓存记录

2 查询hosts文件

3 查询dns域名服务器，交给dns域名服务器处理 以上过程称为递归查询：我要一个答案你直接会给我结果

4 这个dns服务器可能是本地域名服务器，也有个缓存，如果有直接返回结果，如果没有则进行下一步

5 求助根域服务器，根域服务器返回可能会知道结果的一级域服务器，让他去找一级域服务器

6 求助一级域服务器，一级域服务器返回可能会知道结果的二级域服务器让他去找二级域服务器

7 求助二级域服务器，二级域服务器查询发现是我的主机，把查询到的ip地址返回给本地域名服务器

8 本地域名服务器将结果记录到缓存，然后把域名和ip的对应关系返回给客户端

DNS的分布式互联网解析库 

正向解析

各种资源记录

区域解析库：由众多资源记录RR(Resource Record)组成

记录类型：A, AAAA, PTR, SOA, NS, CNAME, MX

• SOA：Start Of Authority，起始授权记录；一个区域解析库有且仅能有一个SOA记录，必须位于解析库的第一条记录SOA，是起始授权机构记录，说明了在众多 NS 记录里哪一台才是主要的服务器。在任何DNS记录文件中，都是以SOA ( Startof Authority )记录开始。SOA资源记录表明此DNS名称服务器是该DNS域中数据信息的最佳来源。
• A（internet Address）：作用，域名解析成IP地址
• AAAA（FQDN）： --> IPV6
• PTR（PoinTeR）：反向解析，ip地址解析成域名
• NS（Name Server）：，专用于标明当前区域的DNS服务器，服务器类型为域名服务器
• CNAME ： Canonical Name，别名记录
• MX（Mail eXchanger）邮件交换器
• TXT：对域名进行标识和说明的一种方式，一般做验证记录时会使用此项，如：SPF（反垃圾邮件）记录，https验证等

安装配置实操

下载安装bind文件，关闭防火墙进行后续操作

cd到etc下的文件夹查询对应软件，编辑named.conf文件

wq保存退出，接下来修改named.rfc1912.zones文件

wq保存退出后cd到var/named的文件下，复制local的文件作为自定义网站的文件模板进行编辑

wq保存退出之后检查有效性，首先修改网卡DNS为当前主机地址然后重启

 接下来开启程序systemctl start named

反向解析

和正向相似，在named.rfc1912文件下添加一段命令之后重新创建一个zones文件，将类型A换成PTR

主从复制

首先需要两台服务器，以我自己的192.168.222.100和192.168.222.200为例

进入etc下的named.conf文件修改两个any

修改etc下的named.rfc1912文件

 复制一份named.localhost作为模板进行修改
 

对网卡配置进行修改，然后重启网卡和启动named程序 

 接下来对第二台从服务器进行修改
同上，对named.conf文件进行修改两个any

 接下来修改从服务器的rfc文件

此时自动在slave文件夹下生成主服务器的文件

 修改主服务器的配置，双方重启后从也会变更

我做开发多年，常常有人问我「软件开发难学吗？」「前端和后端哪个比较简单？」「培训后是否好找工作呢？」这些问题单拎出来比较棘手，三言两语说不清楚，需要你对开发有一个系统了解，问题才能迎刃而解。

所以，我想和你分享我的学习和工作经历，希望这对于正在准备成为一名程序员的你有所帮助。

我的经历可能会为新手提供一些有用的建议和思路。

01 萌芽之初，点燃编程学习的梦想

对于一些90后的朋友来说，网游填满了他们的高中时期，甚至是初中。

他们经常因为不走寻常路去打游戏，在回来时被门卫大爷逮个正着。尽管我没有沉迷于游戏，但我仍然被游戏所吸引。

在游戏中，我一直认为只有玩家和 NPC 的存在，但是，玩得越多，你会发现还有一些不寻常的角色，那就是“工作室”。部分“工作室”利用一些技术手段批量、自动地在游戏中完成任务以赚取游戏产出。

虽然这种行为不可取，但是他们使用的技术确实让我感兴趣。

这时候，代码的种子已经悄悄埋藏在我的内心深处，等待发芽。

高中毕业后，卸下学业负担，我开始利用暑期学习了一些脚本精灵、Tc 简单编程和易语言编程，这也是我第一次接触编程基础语法，如条件判断、循环、遍历和条件选择，再加上社区提供的一些识图插件，我就像一个蹩脚的裁缝，东拼西凑，左缝右补，费劲巴拉缝制成一件衣服，却不合身。

虽然实现了自动登录游戏的功能，但很不幸运的是，这样的小功能也还是过不去游戏的自检程序，万物皆有裨益，万事皆可为师，正是这一次编程体验促使了我后来的专业选择。

02 踏上编程学习之路，从安卓到前端，每一步都算数

英语是我成长路上的一块绊脚石，在选择专业时，我想躲开英语，于是选择了同为计算机系下的软件外包服务专业，结果发现，只要是技术，英语的要求都是一样的。

当然，我选择这个专业还有另外一个动机 -- 它开设了Android课程。毕竟，那时我刚拿到一款安卓手机，能在手机上开发自己的App是何等酷炫的体验啊！

那时，有一本厚重的《疯狂 Android 讲义》成了我的启蒙之书，我翻过无数遍，上课、参加编程比赛、实习工作、这本书我一直在用，为我第一份工作立下了汗马功劳。

临近毕业，是先就业还是先培训，许多软件相关专业的毕业生都面临着这样的选择。

所以，你要想明白，你到底需要的是什么？

我选择参加培训是出于两个原因：第一是为了将平时自学的知识整合起来，第二是希望能够认识更多的小伙伴，以便进行技术交流。编程最忌讳的就是闭门造车，不进行沟通交流。

然而，选择参加培训并不是每个人的选择。

如果你有能力自己阅读技术书籍，并且知道如何获取最新的技术信息，那么参加培训完全没有必要。

只有当你需要别人的指点和帮助来梳理技能，或者需要更好的机会来进行技术交流时，参加培训才是一个好的选择。

但是，如果你仅仅因为听说培训完就能很赚钱而选择花钱加入，那么你就要好好思考一下了，周围打水漂的人确实不在少数。

培训结束后，2015 年 12 月 7 号，我入职了第一家公司，担任 Android 开发工程师。

人生有时候做一个决策，一个行动，当时只道是寻常，当它的价值在未来某一刻兑现时，你会感谢当时努力的自己。

如果没有大学时翻过无数遍的《疯狂 Android 讲义》，我不可能找到这份工作。

03 学前端到底在学什么

工作后，我第一次真正进入团队开发模式（我是不会告诉你我当初使用百度云盘定时同步代码的，炸过一次硬盘），由于业务需要一定的前端支持（合同模板），所以在一次小组会议上，组长建议我们要着手学习前端技术（Angular1.x）。

到了17年左右，公司的业务开始由原 Pad 端转移到手机端。我和其他几个新入职的小伙伴经过一上午的 Vuejs2.x 培训后，就开始上手开发了。

也是在这次前端项目开发中，我第一次接触到了闭包导致循环失灵的问题，第一次把一个页面写到 3 千多行（烂，不懂拆分）。

由于这次前端项目开发的经验不足，导致迭代两年后，项目能编译出 200MB 的内容。我只能通过各种查找和大量的 webpack 参数调试，将产物压缩回了20MB 左右。对于我来说，这也是一次很大的成长。

我非常推荐各位小伙伴在工作中多承担，因为开发经验绝非是你熟背八股题得到的，开发经验只能是来自大量的项目实战。

多做练习，多遇困难，多做总结，得到的才是自己的。开发经验决定了你的下一个项目能否走得更顺利。

选择成为前端程序员是一件比较苦的事情，因为这个领域的技术更新非常频繁，如果你不持续学习，那么你就会落后，这也是“前端很累”的一个根本原因。

实际上，现在还有一些人对前端存在偏见，因为他们认为不就一个 JavaScript，能有多难？

但是事实上，很多前端构建技术的底层实现并不是用 JavaScript 语言编写的，而是基于了其它编程语言如 Golang（代：ESBuild）和Rust（代表：SWC）“包装”起来的，利用这些语言的特点来弥补 JavaScript 的不足。

前端学习的基础是 JavaScript，但不仅仅是 JavaScript，如果你认为学习 JavaScript 就是学习前端，那么你可能会走进死胡同。

04 正确的学习编程方式一定是这样的

在学校里，老师一定告诉过你两个正确的学习方式，其中一个是要做笔记，另一个是要能够向同学清晰地讲解。

繁多的技术是不可能靠记忆实现的，因此做笔记和写博客是记录学习过程和分享学习成果的捷径。

现在，我也发现很多在校的同学积极在各大技术社区分享自己的学习经验，这也印证了这条成长途径的正确，同时也激励我们这些已经做了多年程序员的伙伴要更加努力。

不论你是学习新的编程语言还是新的框架，都需要为其配置对应环境，但有很多框架的环境配置其实对于第一次接触的小伙伴来说并不友好，就比如我最初在从Android转前端的时候就因为安装NodeJs、Npm这些东西而烦恼，因为当时莫名其妙就提示你Python2的模块找不到了，要不就是安装依赖超时了，在环境搭建问题上花费太长时间真的不划算。

为了避免环境搭建影响学习进度，我们可以使用一些在线的 IDE 环境，例如 CodePen、CodeSandBox、Stackblitz、JSRun 等。

但是，它们在依赖安装、操作习惯和响应速度上仍然有一些上手难度。

我最近一段时间一直在使用 1024Code  社区提供的在线 IDE，它提供了很多热门语言和框架的代码空间模板，免配置环境，即开即用随时学习新技术。

它支持多人开发和在线分享，无论是和朋友一起开发项目还是找大佬请教问题，都非常轻松。

05 学习编程，高效沉淀需要技巧

我发现之前写博客时做的案例很难沉淀下来。往往只是写完一遍，很少再打开运行。

但是在 1024Code 中，可以以卡片的形式记录每一个案例，也可以将一系列案例放到一个集合中归类。

此外，1024Code 还支持在个人主页中渲染 Markdown，为小伙伴打造炫酷的个人主页提供了便利。

最令人赞叹的是，1024Code 紧跟最近比较火的 ChatGPT，将其接入到了 IDE 中，让你在编码的同时可以更快速地查找解决方案。下面我给大家简单地展示一下：

在社区主页中，案例以卡片的形式展示。你可以点击你感兴趣的案例，一键运行。边浏览源码，边跟着作者提供的 README 进行学习。

如果你想在此基础上练习或二次开发，还可以 fork 一份到自己的工作空间。如果你发现作者的代码有不合理的地方，还可以在评论区大胆地给他留言，大家可以共同成长。

1024Code 提供了众多空间模板，涵盖了多种编程语言和框架，例如针对数据统计和 AI 模型训练的 Python，以及让许多程序员感到头疼的 C++。

此外，它还支持其它主流的热门编程语言和框架。

Markdown 是编程小伙伴们最常用的笔记格式之一，因此无需专门学习其语法。只需要多看几遍，就可以自然而然地掌握。

此外，你还可以参考社区中其他小伙伴的主页，来打造自己独特的个人主页。

接下来，我要展示一段时间以来我制作的合集。

最初，这个合集是为了帮助那些不熟悉滴滴 LF 框架如何使用 Vue3+TS 编写的小伙伴们而制作的。

我还将合集地址提交到了 LF 仓库，希望能够帮助那些正在转向 Vue3+TS 的小伙伴们。

最重磅的就是 ChatGPT 了。

在使用 1024Code 的 IDE 进行开发过程中，如果遇到问题，你可以快速打开 ChatGPT 来协助你查找答案，而不需要离开当前页面。

ChatGPT 支持上下文连续问答模式，虽然它不能解决你所有的问题，甚至会给出错误的答案，但对于一些常规类编程问题或正在做毕业设计的小伙伴们，它还是能够显著提升效率的。

总结

最后，我再为你做一些总结、建议和对未来的期待：

• 我建议你要有很强的动力来学习编程，因为坚持并不是易事；

• 我建议你坚守自己慎重选择的专业，因为不忘初心方得始终；

• 我建议你在面对技术培训时要清醒认知，因为明确目标的选择才适合自己；

• 我建议你在工作中抓住一切学习的机会，因为努力的人很多，只有不断学习才能跟上技术的发展；

• 我建议你在编程学习时要善用工具、做好笔记、写博客，不断沉淀自己的知识和经验；

最后的最后，愿我们所有付出都将是沉淀，所有美好终会如期而至。

我想，关于秋招，大家是真的焦虑的。

作为一个刚起了两个月的公众号，平时写写技术相关的内容，阅读量少则几十，多则也不超过500。结果一聊到秋招这个话题，阅读量直接干到27000去了，让我硬生生地过了一把大V的瘾。（手动狗头）

现代版的“国家不幸诗家幸，赋到沧桑句便工”有没有？

所以，我决定再聊十块钱的“秋招焦虑”这个话题，以一个过来人的身份，开导开导同学们。如果同学们真的干了这碗鸡汤后，觉得暖心暖胃，精神上舒服一些，那也不枉我敲这么多字了。

首先说下，产生焦虑的原因是什么？

参照了知乎上的众多答案，我觉得最精辟的一个答案是：担心某件不好的事情，在未来的某个时间点将会发生，但主观上又拒绝接纳。

而往往焦虑的人的认知特点是：

• 高估不好的事情的发生概率；
• 高估不好的事情所带来的后果；
• 低估自己应对挫折的能力；

我们把这种认知特点带入到秋招中，同学们的想法大概是这样：

卧槽，今年校招这么卷，完全就是一片哀鸿遍野的景象，那我肯定找不到工作了。一旦形成毕业即失业的情况，那我前面二十多年爬冰卧雪、寒窗苦读就完全看不到价值了。试问读书的意义是什么呢？完了，生不逢时啊，我这辈子基本上也就交待了。

而在这种焦虑的情绪下，最常见的应激反应就是回避行为。即：有条件的打算润到国外，没条件的誓死考公。

下面，开始灌鸡汤，各位同学听好。

超过80%的人，你不必焦虑

其实各行各业都一样，你只要能超过行业内80%的人，基本上就没什么好担心的，降低一些预期，找到一份差不多的工作肯定没问题。

逻辑是这样的，如果一个行业的top 20%都凉凉了，那证明这个行业不仅仅是不景气，而是被这个时代所淘汰了。如果真的到了这个地步，那最焦虑的肯定不是作为个体的你了。

按照top 20%这个人物画像进行圈选的话，很多专业能力不错，有实习经历的211 985同学，其实是都在其内的。

你如果还在焦虑的话，那就是世上本无事，庸人自扰之了。

当然，再说一句，如果你不在这20%的池子里面，那你还轮不到焦虑，你最先做好的的是四个字：反求诸己。

反求诸己，很多事情上都是这么一个道理，就是苦练基本功。

正常周期变化，你无须焦虑

一般情况下，经济和行业周期大概在8到10年左右。任何人漫长的职业生涯中，都会经历几个起起伏伏的过程，有时候早经历一次，未必是坏事。

郭德纲的原话是这样说的：

吃亏要趁早，一帆风顺不是什么好事。从小大伙娇生惯养，没有人跟他说过什么话，65岁走在街上谁瞪他眼就会猝死。从出生开始一天打八个嘴巴，这样的到25岁就是铁罗汉、活金刚一样什么都不在乎，吃亏要趁早。

其实话糙理不糙，当你经历了萧条的经济周期，再遇到经济转好，行业内一片欣欣向荣的时候，你会怀着更加感恩的心态，拥有更成熟的理性思考，再也不会把风口机遇和平台资源当做个人能力。

说得粗鄙一点儿就是，变得更加有逼数儿了，不好高骛远，不过度消费，这样反而让你以后的路走得更平稳一些。

不就是一次秋招吗，你焦虑个毛

有的同学性格过于敏感脆弱，总是会把一件不好的事情的后果，弄得跟世界末日一样。

其推理过程大概这样：

少了一枚铁钉，掉了一只马掌。掉了一只马掌，失去一匹战马。失去一匹战马，失去一场战役。败了一场战役，毁了一个王朝。

等于“千里之堤，毁于蚁穴”的道理，让他给用到这里了。

其实真的不用这么想，就算秋招不太理想，还有春招，春招就算也不理想，直接走社招投简历不就完了。退一万步说，大不了转行，只要你不懒不傻不笨，照样能在别的行业混得风生水起。

真的真的没必要，认为秋招GG了，整个人生都黯淡了。人这一辈子很长，有很多翻盘的机会，也有很多盛极而衰的事例，没必要计较一时之成败。

像男人一样，扛过焦虑期

永远不要低估人类应对挫折和低谷的能力。

想想我们的父母辈，正好赶上了国企的下岗潮，捧了半辈子的铁饭碗丢了。就像刘欢的那首《重头再来》所唱到的那样，”辛辛苦苦已度过半生，今夜重又走进风雨“。

但是，基本上没看到下岗的哪家哪户断粮饿死，最不济的也是出去打工或者做点儿小生意，还有的因此而混出一些名堂出来呢。

就像曾国藩的那句名言所说的一样：生平长进，全在受挫受辱之时，需咬牙立志，受不得穷，立不得品，受不得屈，必做不得事。

我们再来看看褚时健老爷子，以前是云南红塔集团的董事长，后来由于贪污受贿被判处无期徒刑，和妻子双双入狱，女儿自杀，他的低谷堪称绝望之谷。

2002年，74岁出狱二次创业，开始做褚橙。到了2014年，”褚橙“销售额达到了一亿多元，纯利润7000多万。因此，人们又称它为”励志橙“。

难怪见过大世面的王石都这样感慨道：

橙子挂果要6年，他那时已经75岁高龄了。试想一下，一个75岁的老人，戴一个大墨镜，穿着颇圆领衫，兴致勃勃地跟我谈论橙子挂果是什么场景。我当时就想，如果我遇到他那样的挫折，到了他那个年纪，我会想什么？我知道，我一定不会像他那样勇敢。

所以，像个男人一样，顶住压力，行动起来吧。扛过这段焦虑期吧，阴霾只是暂时的，未来终将是美好的。

一、简介

在iOS系统中，定位权限获取是一个涉及进程间同步通信的方法，如果频繁访问可能会导致卡顿或者卡死。在一些打车或者地图类的APP中，定位权限的卡顿报错可能是大头，亟需解决！
下面是系统类提供的访问定位权限的方法：

// CLLocationManager是系统的定位服务管理类

open class CLLocationManager : NSObject {

    // 1.下面方法是访问系统设置中定位是否打开

    @available(iOS 4.0, *)

    open class func locationServicesEnabled() -> Bool



    // 2.1 iOS 14.0之后，访问定位的授权状态

    @available(iOS 14.0, *)

    open var authorizationStatus: CLAuthorizationStatus { get }



    // 2.2 iOS 14.0之后，访问定位的授权状态

    @available(iOS, introduced: 4.2, deprecated: 14.0)

    open class func authorizationStatus() -> CLAuthorizationStatus

}

二、从卡顿堆栈例子中分析问题

为了解决这个卡顿，首先要分析卡顿报错堆栈。接下来举一个定位权限频繁获取导致的卡顿的堆栈：

0 libsystem_kernel.dylib _mach_msg2_trap + 8

1 libsystem_kernel.dylib _mach_msg2_internal + 80

2 libsystem_kernel.dylib _mach_msg_overwrite + 388

3 libsystem_kernel.dylib _mach_msg + 24

4 libdispatch.dylib __dispatch_mach_send_and_wait_for_reply + 540

5 libdispatch.dylib _dispatch_mach_send_with_result_and_wait_for_reply + 60

6 libxpc.dylib _xpc_connection_send_message_with_reply_sync + 240

7 Foundation ___NSXPCCONNECTION_IS_WAITING_FOR_A_SYNCHRONOUS_REPLY__ + 16

8 Foundation -[NSXPCConnection _sendInvocation:orArguments:count:methodSignature:selector:withProxy:] + 2236

9 Foundation -[NSXPCConnection _sendSelector:withProxy:arg1:arg2:arg3:] + 136

10 Foundation __NSXPCDistantObjectSimpleMessageSend3 + 76

11 CoreLocation _CLCopyTechnologiesInUse + 30852

12 CoreLocation _CLCopyTechnologiesInUse + 25724

13 CoreLocation _CLClientStopVehicleHeadingUpdates + 104440

14 MyAPPName +[ZLLocationRecorder locationAuthorised] + 40

15 ... // 以下略

• 首先从第14行找到是ZLLocationRecorder类的locationAuthorised方法调用后，执行到了系统库函数，最终导致了卡死、卡顿。

• 对堆栈中第0-13行中的方法做一番了解，初步发现xpc_connection_send_message_with_reply_sync函数涉及进程间同步通信，可能会阻塞当前线程点击查看官方方法说明。

该函数说明：Sends a message over the connection and blocks the caller until it receives a reply.

• 接下来添加符号断点xpc_connection_send_message_with_reply_sync, 注意如果是系统库中的带下划线的函数，我们添加符号断点的时候一般需要少一个下划线_. 执行后，从Xcode的方法调用栈视图中查看，可以发现ZLLocationRecorder类的locationAuthorised方法内部中调用CLLocationManager类的locationServicesEnabled和authorizationStatus方法都会来到这个符号断点.所以确定了是这两个方法导致的卡顿。（调试时并未发现卡顿，只是线上用户的使用环境更加复杂，卡顿时间长一点就被监控到了，我们目前卡顿监控是3秒，卡死监控是10s+）。

• 然后通过CLLocationManager类的authorizationStatus方法说明，发现也是说在权限发生改变后，系统会保证调用代理方法locationManagerDidChangeAuthorization(_:)，所以就产生了我们的解决方案，最终上线后也是直接解决了这个卡顿，并且APP启动耗时监控数据也因此变好了一些。

三、具体的解决方案

 注意点：设置代理必须在有runloop的线程，如果业务量不多的话，就在主线程设置就可以。

四、Demo类，可以直接用

import CoreLocation



public class XLLocationAuthMonitor: NSObject, CLLocationManagerDelegate {

    // 单例类

    @objc public static let shared = XLLocationAuthMonitor()

    

    /// 定位服务是否可用， 这里设置成变量避免过于频繁调用系统方法时产生卡顿，系统方法涉及进程间通信

    @objc public private(set) var serviceEnabled: Bool {

        set {

            threadSafe { _serviceEnabled = newValue }

        }

        

        get {

            threadSafe { _serviceEnabled ?? CLLocationManager.locationServicesEnabled() }

        }

    }

    

    /// 定位服务授权状态

    @objc public private(set) var authStatus: CLAuthorizationStatus {

        set {

            threadSafe { _authStatus = newValue }

        }

        

        get {

            threadSafe {

                if let auth = _authStatus {

                    return auth

                }

                if #available(iOS 14.0, *) {

                    return locationManager.authorizationStatus

                } else {

                    return CLLocationManager.authorizationStatus()

                }

            }

        }

    }

    

    /// 计算属性，这里返回当前定位是否可用

    @objc public var isLocationEnable: Bool {

        guard serviceEnabled else {

            return false

        }

        

        switch authStatus {

        case .authorizedAlways, .authorizedWhenInUse:

            return true

        case .denied, .notDetermined, .restricted:

            return false

        default: return false

        }

    }

    

    // MARK: - 内部使用的私有属性

    private lazy var locationManager: CLLocationManager = CLLocationManager()

    private let _lock = NSLock()

    private var _serviceEnabled: Bool?

    private var _authStatus: CLAuthorizationStatus?

    

    private override init() {

        super.init()

        // 如果是主线程则直接设置，不是则在mainQueue中设置

        DispatchQueue.main.safeAsync {

            self.locationManager.delegate = self

        }

    }

    

    private func threadSafe<T>(task: () -> T) -> T {

        _lock.lock()

        defer { _lock.unlock() }

        return task()

    }

    

    // MARK: - CLLocationManagerDelegate

    /// iOS 14以上调用

    public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {

        if #available(iOS 14.0, *) {

            authStatus = locationManager.authorizationStatus

            serviceEnabled = CLLocationManager.locationServicesEnabled()

        }

    }

    

    /// iOS 14以下调用

    public func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {

        authStatus = status

        serviceEnabled = CLLocationManager.locationServicesEnabled()

    }

}

hi 大家好，我是 DHL。公众号：ByteCode ，专注有用、有趣的硬核原创内容，Kotlin、Jetpack、性能优化、系统源码、算法及数据结构、大厂面经。

随着防疫政策的放开，小阳人越来越多了，身边很多小伙伴都在朋友圈晒自己阳了之后的各种状态，基本上都处于一边发烧，一边坚持工作的状态，症状严重的小伙伴忍着疼痛还要处理公司的任务，把自己奉献给公司，然后收到了却是公司无情的裁员的消息。

年末将至，知乎和小米也登上了热搜。

裁员

我之前在小米的同事陆陆续续收到了通知，阳着还在工作，然后收到了裁员的消息。国内公司裁员的吃相都不怎么好看，基本上在发年终奖前会进行大比例的裁员。

2021 年的时候小米有 32000 名员工，据传 2022 年底小米要裁 6000 名员工，裁员幅度接近 20%，无论消息是否真实，但是这次裁员规模影响范围应该不小。

小米为什么要裁员

小米连续 3 个季度开始下滑，前 3 个季度，每个季度利润 20 亿，相比于去年同期的 50 亿下跌了很多，那为什么利润下跌这么多呢，主要有以下原因：

1. 公司不赚钱，意味着主营业务开始萎缩，小米的主营业务，手机前 3 个季度卖了 4020 万部，销售额大概 425 亿，平均每部手机 1000 元，原本指望华为被制裁之后，小米能拿下这部分用户，但是最后也放弃了，这部分用户基本上都归苹果了
2. 据调查中国的手机市场已经处于饱和状态，每年换手机的发烧友越来越少了
3. 小米赌上全部身价大踏步地进入汽车领域，汽车是个周期长、投资大的业务，没有上百个亿，基本上不可能会有结果的
4. 小米的股价也跌了很多，投资人很失望，我也买了很多小米的股票，基本上都是血亏

所以不得不开始降本增效，在老板的眼里，业务上升期的时候，开始疯狂砸钱招人，到达了瓶颈，业务不再增长的时候，老板就会冷静下来盘算，到底需不需要这么多人，然后开始降本增效，而裁员就是最有效的控制成本的手段。

曾经有小伙伴问过，小米的年终奖能拿多少

我在这里也只是顺口一说，大家当做饭后余兴看看就好了，小米的年终奖是 2 个月，而个人绩效是跟部门和所在事业部挂钩的，如果部门的绩效好的话，大部分人都能拿满，但是如果部门绩效不好的话，只有少数人能拿满，平均下来一个部门能拿满 2 个月的人数非常少，如果你非常的优秀，拿 3~4 个月也是有的，但是这个比例极其少，如果你和领导关系好的话，那么就另当别论了。

小米这次裁员赔偿虽然给了 N+2，但是这次裁员的吃相也比较难看，引来了小米员工的吐槽。以下图片来自网络。

而每次裁员，应届生都是最惨的，在大裁员的环境下，能不能找到工作是最大的问题，应届生和有工作经验的社招生是不一样的，无论是赔偿还是找工作的机会，相比于应届生更愿意招社招生，当然特别优秀的除外。

我之前很多在小米的同事，赔偿都给了 N + 2，但是年底被裁员时间点非常的不好，短时间内，想找到工作是非常困难的，但是先不要着急，如果你的身体还没恢复，建议先等身体恢复，在恢复期间，整理一下你的工作项目，网上搜索一下面试题，整理和回顾这些面试题，记住一定要多花时间刷算法题。

等到年后找工作会容易些，面试的成功的率也会很高，你的溢价空间也会很大，在选择公司的时候，这个阶段还是以稳为主，避开那些风险高的公司和部门。

文章的最后

遍地小阳人的冬天比以往更冷，在公司非常艰难，业务不再增长的时候，都会断臂求生，我们都要去面对被裁的风险。

站在打工者的角度，当一个人在某个环境待久了，会被表象的舒适所蒙蔽，时间久了会变得很迷茫，所以我们要想办法跳出舒适圈，保持学习的热情。

上一篇文章是8.4号写的，一个多月没有写东西了，按照现在的情况估计，年底要写到40篇有点悬，虽然有很多要写的，但现在事情太多了也太累了。今天写点随笔，写到哪算哪吧。

工作

这次参与的新项目，前景还是不错的，不过活也是真多。这段日子，很多时候十一二点才下班，有的时候搞到两点，周末再加一天班。

业务快速发展，不断地有新同学加入，架构也在不断迭代，其实感觉还是蛮不错的，有点像当初刚工作负责电商的时候了，始终创业啊。

雷总曾经说过，要顺势而为，其实是对的，选对方向往往事半功倍，但选对方向需要极强的能力。新的变革已经到来了。

文化

这里的文化是指公司文化，扩展一下也指家庭文化。为什么突然聊文化？

最近感觉无论是家庭还是公司，让大家聚集在一起努力的，相同的文化或者三观是重要的一环。文化认同不一致，很难长久的在一起，这个没有对错，每个人都有选择的权利，没必要强求，很多时候祝福就好。

还是想夸一下字节的文化，虽然看过很多公司的文化宣言，感觉字节的带着哲思在里面，这种文化不是只对公司有利，而是说在自己的生活中，用这种文化来要求自己也是好的。认同这种文化的人在一起，办事效率、质量要高很多，很多时候，损失来自于内耗。

1.1追求极致

不断提高要求，延迟满足感

在更大范围里找最优解

不放过问题，思考本质

持续学习和成长

1.2务实敢为

直接体验，深入事实

不自嗨，注重效果

能突破有担当，打破定式

尝试多种可能，快速迭代

1.3开放谦逊

内心阳光，信任伙伴

乐于助人和求助，合作成大事

格局大，上个台阶想问题

对外敏锐谦虚，ego（自我） 小，听得进意见

1.4坦诚清晰

敢当面表达真实想法

能承认错误，不装不爱面子

实事求是，暴露问题，反对“向上管理”

准确、简洁、直接，有条理有重点

1.5始终创业

自驱，不设边界，不怕麻烦

有韧性，直面现实并改变它

拥抱变化，对不确定性保持乐观

始终像公司创业第一天那样思考

1.6多元兼容

理解并重视差异和多元，建立火星视角

打造多元化的团队，欢迎不同背景的人才，激发潜力

鼓励人人参与，集思广益，主动用不同的想法来挑战自己

创造海纳百川，兼容友好的工作环境

教育

最近在想，怎么教育好下一代？或者话题小一点，如何在知道A选项不好的情况下，让子女听自己的？

以前看过一篇文章，说是孩子们总归不会听你的，但他们也终会在跌跌撞撞中长大，然后他们的子女再来一次循环。

但我觉得，还是有可能教育好的，不过要付出很多，这是一个细雨润无声，充斥在点点滴滴生活中的事情，它永远不是一个一次性任务，或者说几次道理就能达成的。

拿选择来说，需要做到

1. 父母本身就对每种选择的结果比较知晓

2. 父母很了解子女的性格和能力

3. 子女相对相信父母

4. 或者 子女已经培养的很好了，有了自己的主见和三观，知道自己的性格和能力

如果能培养到第四点，那真是轻松很多。不过呀，最重要的还是得立志，论语里说：“不愤不启，不悱不发，举一隅不以三隅反，则不复也。”也是这个道理。立志能给人以动力，自己主观上想干了，才能干好。

家庭

最近媳妇工作上的事情也比较多，我感觉很神奇，好像每次事情都会像商量好似得一起来，这时候考验的就是毅力和耐力，不松气，努力干，总能顶过这一波。

或许真像媳妇说的，人生就像一场游戏，努力就完事了，别想太多。

前些日子和媳妇都阳了，好在不太严重，也不知道什么时候是个头。看到满满的小药箱，比起去年12月的时候，还是感觉安全一些的。

哦，对了，前些日子公司冷藏柜漏水，导致我摔了一跤，电脑都飞出去了。怎么说呢，幸亏电脑没事，就人伤着一点，哈哈哈。本来想投诉一下，但负责人一直在会议室门口等我们会议结束，又道歉又拿药，加了联系方式方便后面有问题及时联系；同时讲了原因和后续的改进措施。做的挺不错的。

以前对摔倒的影响概念不深，现在倒蛮有体会的了，有时候在想，如果六七十岁的人，以这个力道被摔，真的很危险。大家还是要多多注意。

在开发过程中经常会遇到设计给出的button尺寸偏小的情况.这种UIButton在使用中会非常难点击,极大降低了用户体验

解决方案一：重写UIButton的- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent*)event方法

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent*)event



{



   //获取当前button的实际大小

    CGRect bounds = self.bounds;



    //若原热区小于44x44，则放大热区，否则保持原大小不变



    CGFloat widthDelta = MAX(44.0 - bounds.size.width, 0);



    CGFloat heightDelta = MAX(44.0 - bounds.size.height, 0);

    //扩大bounds



    bounds = CGRectInset(bounds, -0.5 * widthDelta, -0.5 * heightDelta);



    //如果点击的点 在 新的bounds里，就返回YES



    return CGRectContainsPoint(bounds, point);



}

系统默认写法是：

- (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event

{

    return CGRectContainsPoint(self.bounds, point); 

}

其实是在判断的时候对响应区域的bounds进行了修改.CGRectInset(view, 10, 20)方法表示对rect大小进行修改

解决方案二 runtime关联对象来改变范围，- (UIView) hitTest:(CGPoint) point withEvent:(UIEvent) event里用新设定的 Rect 来当着点击范围。

#import "UIButton+EnlargeTouchArea.h"

#import <objc/runtime.h>



@implementation UIButton (EnlargeTouchArea)



static char topNameKey;

static char rightNameKey;

static char bottomNameKey;

static char leftNameKey;



- (void)setEnlargeEdgeWithTop:(CGFloat)top right:(CGFloat)right bottom:(CGFloat)bottom left:(CGFloat)left

{

    objc_setAssociatedObject(self, &topNameKey, [NSNumber numberWithFloat:top], OBJC_ASSOCIATION_COPY_NONATOMIC);

    objc_setAssociatedObject(self, &rightNameKey, [NSNumber numberWithFloat:right], OBJC_ASSOCIATION_COPY_NONATOMIC);

    objc_setAssociatedObject(self, &bottomNameKey, [NSNumber numberWithFloat:bottom], OBJC_ASSOCIATION_COPY_NONATOMIC);

    objc_setAssociatedObject(self, &leftNameKey, [NSNumber numberWithFloat:left], OBJC_ASSOCIATION_COPY_NONATOMIC);

}



- (void)setTouchAreaToSize:(CGSize)size

{

    CGFloat top = 0, right = 0, bottom = 0, left = 0;

    

    if (size.width > self.frame.size.width) {

        left = right = (size.width - self.frame.size.width) / 2;

    }

    

    if (size.height > self.frame.size.height) {

        top = bottom = (size.height - self.frame.size.height) / 2;

    }

    

    [self setEnlargeEdgeWithTop:top right:right bottom:bottom left:left];

}



- (CGRect)enlargedRect

{

    NSNumber *topEdge = objc_getAssociatedObject(self, &topNameKey);

    NSNumber *rightEdge = objc_getAssociatedObject(self, &rightNameKey);

    NSNumber *bottomEdge = objc_getAssociatedObject(self, &bottomNameKey);

    NSNumber *leftEdge = objc_getAssociatedObject(self, &leftNameKey);

    if (topEdge && rightEdge && bottomEdge && leftEdge)

    {

        return CGRectMake(self.bounds.origin.x - leftEdge.floatValue,

                          self.bounds.origin.y - topEdge.floatValue,

                          self.bounds.size.width + leftEdge.floatValue + rightEdge.floatValue,

                          self.bounds.size.height + topEdge.floatValue + bottomEdge.floatValue);

    }

    else

    {

        return self.bounds;

    }

}



- (UIView *)hitTest:(CGPoint)point withEvent:(UIEvent *)event

{

    CGRect rect = [self enlargedRect];

    if (CGRectEqualToRect(rect, self.bounds) || self.hidden)

    {

        return [super hitTest:point withEvent:event];

    }

    return CGRectContainsPoint(rect, point) ? self : nil;

}



@end

解决方案三：使用runtime swizzle交换IMP

+ (void)load {

    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{

        NSError *error = nil;

        [self hg_swizzleMethod:@selector(pointInside:withEvent:) withMethod:@selector(hitTest_pointInside:withEvent:) error:&error];

        NSAssert(!error, @"UIView+HitTest.h swizzling failed: error = %@", error);

    });

}



- (BOOL)hitTest_pointInside:(CGPoint)point withEvent:(UIEvent *)event {

    if (UIEdgeInsetsEqualToEdgeInsets(self.hitTestEdgeInsets, UIEdgeInsetsZero)) {

        return [self hitTest_pointInside:point withEvent:event];

    }

    CGRect relativeFrame = self.bounds;

    CGRect hitFrame = UIEdgeInsetsInsetRect(relativeFrame, self.hitTestEdgeInsets);

    return CGRectContainsPoint(hitFrame, point);

}

category的诞生只是为了让开发者更加方便的去拓展一个类，它的初衷并不是让你去改变一个类。

技术点总结

关联对象，也就是绑定对象，可以绑定任何东西

//关联对象

 objc_setAssociatedObject(self, &topNameKey, [NSNumber numberWithFloat:top], OBJC_ASSOCIATION_COPY_NONATOMIC);

// self 关联的类，

 //key：要保证全局唯一，key与关联的对象是一一对应关系。必须全局唯一

//value：要关联类的对象。

//policy：关联策略。有五种关联策略。

//OBJC_ASSOCIATION_ASSIGN 等价于 @property(assign)。

//OBJC_ASSOCIATION_RETAIN_NONATOMIC等价于 @property(strong, //nonatomic)。

//OBJC_ASSOCIATION_COPY_NONATOMIC等价于@property(copy, nonatomic)。

//OBJC_ASSOCIATION_RETAIN等价于@property(strong,atomic)。

//OBJC_ASSOCIATION_COPY等价于@property(copy, atomic)。



 NSNumber *topEdge = objc_getAssociatedObject(self, &topNameKey);

// 方法说明

objc_setAssociatedObject 相当于 setValue:forKey 进行关联value对象



objc_getAssociatedObject 用来读取对象



objc_AssociationPolicy  属性 是设定该value在object内的属性，即 assgin, (retain,nonatomic)...等



 objc_removeAssociatedObjects 函数来移除一个关联对象，或者使用objc_setAssociatedObject函数将key指定的关联对象设置为nil。

方法交换 Method Swizzling 注意点

对于已经存在的类，我们通常会在+load方法，或者无法获取到类文件，我们创建一个分类，也通过其+load方法进行加载swizzling

• Swizzling应该总在+load中执行
• Swizzling应该总是在dispatch_once中执行
• Swizzling在+load中执行时，不要调用[super load]。如果多次调用了[super load]，可能会出现“Swizzle无效”的假象。

交换实例方法

以class为类

void class_swizzleInstanceMethod(Class class, SEL originalSEL, SEL replacementSEL)

{

    //class_getInstanceMethod()，如果子类没有实现相应的方法，则会返回父类的方法。

    Method originMethod = class_getInstanceMethod(class, originalSEL);

    Method replaceMethod = class_getInstanceMethod(class, replacementSEL);

    

    //class_addMethod() 判断originalSEL是否在子类中实现，如果只是继承了父类的方法，没有重写，那么直接调用method_exchangeImplementations，则会交换父类中的方法和当前的实现方法。此时如果用父类调用originalSEL，因为方法已经与子类中调换，所以父类中找不到相应的实现，会抛出异常unrecognized selector.

    //当class_addMethod() 返回YES时，说明子类未实现此方法(根据SEL判断)，此时class_addMethod会添加（名字为originalSEL，实现为replaceMethod）的方法。此时在将replacementSEL的实现替换为originMethod的实现即可。

    //当class_addMethod() 返回NO时，说明子类中有该实现方法，此时直接调用method_exchangeImplementations交换两个方法的实现即可。

    //注：如果在子类中实现此方法了，即使只是单纯的调用super，一样算重写了父类的方法，所以class_addMethod() 会返回NO。

    

    //可用BaseClass实验

    if(class_addMethod(class, originalSEL, method_getImplementation(replaceMethod),method_getTypeEncoding(replaceMethod)))

    {

        class_replaceMethod(class,replacementSEL, method_getImplementation(originMethod), method_getTypeEncoding(originMethod));

    }else {

        method_exchangeImplementations(originMethod, replaceMethod);

    }

}

这里存在的问题是继承时子类没有实现父类方法的问题：
基类A类 有方法 -(void)test
子类B类继承自基类A，但没有重写test方法，即其类[B class]中没有test这个实例方法
当我们交换子类B中的方法test，交换为testRelease方法(这必然会在子类B中写testRelease的实现)，子类B中有没有test方法的实现时，就会将基类A的test方法与testRelease替换，当仅仅使用子类B时，不会有问题。
但当我们使用基类A的test方法时，由于test指向的IMP是原testRelease的IMP,而基类A中没有这个实现，因为我们是写在子类B中的。所以就出现了unrecognized selector

交换类方法

由于类方法存储在元类中，以实例方法存在，所以实质就是交换元类的实例方法
上面交换实例方法基础上，传入cls为元类即可。
获取的元类可以这样objc_getMetaClass("ClassName")或者object_getclass([NSObject class])

事件响应者链

如图所示，不再赘述

 两个重要的方法

- (nullable UIView*)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event；称为方法A



- (BOOL)pointInside:(CGPoint)point withEvent:(nullable UIEvent *)event；称为方法B

对view进行重写这两个方法后，点击屏幕后，首先响应的是方法A；

• 如果方法A中，我们没有调用父类（[super hitTest:point withEvent:event];）的这个方法，那就根据这个方法A的返回view，作为响应事件的view。（当然返回nil，就是这个view不响应）

• 如果方法A中，我们调用了父类的方法（[super hitTest:point withEvent:event];）那这个时候系统就要调用方法B；通过这个方法的返回值，来判断当前这个view能不能响应消息

• 如果方法B返回的是no，那就不用再去遍历它的子视图。方法A返回的view就是可以响应事件的view。

• 如果方法B返回的是YES，那就去遍历它的子视图。（就是上图我们描述的那样，找到合适的view返回，如果找不到，那就由方法A返回的view去响应这个事件。）

总结

返回一个view来响应事件 （如果不想影响系统的事件传递链，在这个方法内，最好调用父类的这个方法）

- (nullable UIView*)hitTest:(CGPoint)point withEvent:(nullable UIEvent *)event{

    return [super hitTest:point withEvent:event]; 

}

返回的值可以用来判断是否继续遍历子视图（返回的根据是触摸的point是否在view的frame范围内）

- (BOOL)pointInside:(CGPoint)point withEvent:(nullableUIEvent *)event；      

点此链接查看：手把手教你集成环信ReactNative离线推送（上）

三、从原生将device_token 传到RN 并且绑定

1、原生调用方法

reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)

        .emit("deviceToken",jsonObject.toString());

通过PushModule 类进行传递，PushModule 代码如下：

package com.awesomeproject;

import com.facebook.react.bridge.ReactApplicationContext;

import com.facebook.react.bridge.ReactContextBaseJavaModule;

import com.facebook.react.bridge.ReactMethod;

import com.facebook.react.modules.core.DeviceEventManagerModule;

import com.xiaomi.mipush.sdk.MiPushClient;

import org.json.JSONException;

import org.json.JSONObject;



public class PushModule extends ReactContextBaseJavaModule {

    private ReactApplicationContext reactContext;

    public PushModule(ReactApplicationContext reactContext) {

        super(reactContext);

        this.reactContext = reactContext;

    }



    @Override

    public String getName() {

        return "PushModule";

    }

    /**

     从RN界面里面调用该方法

     **/

    @ReactMethod

    public void getDeviceToken(){

        MainApplication.getReactPackage().mModule.sendDataToJS( MiPushClient.getRegId(MainApplication.getContext()));





    }



    public void sendDataToJS(String deviceToken){

        JSONObject jsonObject = new JSONObject();

        try {

            jsonObject.put("deviceToken",deviceToken);

            jsonObject.put("deviceName","2882303761517520571");



        } catch (JSONException e) {

            throw new RuntimeException(e);

        }



        this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)

                .emit("deviceToken",jsonObject.toString());

    }







}

2、RN 层进行获取数据

NativeModules.PushModule.getDeviceToken();

  DeviceEventEmitter.addListener('deviceToken',(res)=>{

    const goosid = JSON.parse(res);

    deviceToken = goosid.deviceToken;

    manufacturer = goosid.deviceName;

    console.log('React Native界面,收到数据：',goosid);

3、获取到数据后调用环信RN sdk 方法进行绑定

ChatClient.getInstance().updatePushConfig(push);

js 代码如下

// 导入依赖库

import React, { useEffect } from 'react';

import {

  DeviceEventEmitter,

  NativeModules,

  SafeAreaView,

  ScrollView,

  StyleSheet,

  Text,

  TextInput,

  View,

} from 'react-native';

import {

  ChatClient,

  ChatMessage,

  ChatMessageChatType,

  ChatOptions,

  ChatPushConfig,

} from 'react-native-chat-sdk';

// 创建 app

const App = () => {

  // 进行 app 设置

  const title = 'ChatQuickstart';

  var deviceToken='';

  var manufacturer='';

  NativeModules.PushModule.getDeviceToken();

  DeviceEventEmitter.addListener('deviceToken',(res)=>{

    const goosid = JSON.parse(res);

    deviceToken = goosid.deviceToken;

    manufacturer = goosid.deviceName;

    console.log('React Native界面,收到数据：',goosid);



})

  const [appKey, setAppKey] = React.useState('1137220225110285#demo');

  const [username, setUsername] = React.useState('p9');

  const [password, setPassword] = React.useState('1');

  const [userId, setUserId] = React.useState('');

  const [content, setContent] = React.useState('');

  const [logText, setWarnText] = React.useState('Show log area');



  // 输出 console log 文件

  useEffect(() => {

    logText.split('\n').forEach((value, index, array) => {

      if (index === 0) {

        console.log(value);

      }

    });

  }, [logText]);



  // 输出 UI log 文件

  const rollLog = text => {

    setWarnText(preLogText => {

      let newLogText = text;

      preLogText

        .split('\n')

        .filter((value, index, array) => {

          if (index > 8) {

            return false;

          }

          return true;

        })

        .forEach((value, index, array) => {

          newLogText += '\n' + value;

        });

      return newLogText;

    });

  };



  // 设置消息监听器。

  const setMessageListener = () => {

    let msgListener = {

      onMessagesReceived(messages) {

        for (let index = 0; index < messages.length; index++) {

          rollLog('received msgId: ' + messages[index].msgId);

        }

      },

      onCmdMessagesReceived: messages => {},

      onMessagesRead: messages => {},

      onGroupMessageRead: groupMessageAcks => {},

      onMessagesDelivered: messages => {},

      onMessagesRecalled: messages => {},

      onConversationsUpdate: () => {},

      onConversationRead: (from, to) => {},

    };



    ChatClient.getInstance().chatManager.removeAllMessageListener();

    ChatClient.getInstance().chatManager.addMessageListener(msgListener);

  };



  // SDK 初始化。

  // 调用任何接口之前，请先进行初始化。

  const init = () => {

   

    let option = new ChatOptions({

      autoLogin: false,

      appKey: appKey

    });

    ChatClient.getInstance().removeAllConnectionListener();

    ChatClient.getInstance()

      .init(option)

      .then(() => {

        rollLog('init success');

        this.isInitialized = true;

        let listener = {

          onTokenWillExpire() {

            rollLog('token expire.');

          },

          onTokenDidExpire() {

            rollLog('token did expire');

          },

          onConnected() {

            rollLog('login success.');

            setMessageListener();

          },

          onDisconnected(errorCode) {

            rollLog('login fail: ' + errorCode);

          },

        };

        ChatClient.getInstance().addConnectionListener(listener);

      })

      .catch(error => {

        rollLog(

          'init fail: ' +

            (error instanceof Object ? JSON.stringify(error) : error),

        );

      });

  };



  // 注册账号。

  const registerAccount = () => {

    if (this.isInitialized === false || this.isInitialized === undefined) {

      rollLog('Perform initialization first.');

      return;

    }

    rollLog('start register account ...');

    ChatClient.getInstance()

      .createAccount(username, password)

      .then(response => {

        rollLog(`register success: userName = ${username}, password = ******`);

      })

      .catch(error => {

        rollLog('register fail: ' + JSON.stringify(error));

      });

  };



  // 用环信即时通讯 IM 账号和密码登录。

  const loginWithPassword = () => {

    if (this.isInitialized === false || this.isInitialized === undefined) {

      rollLog('Perform initialization first.');

      return;

    }

    rollLog('start login ...');

    ChatClient.getInstance()

      .login(username, password)

      .then(() => {

        rollLog('login operation success.');

        let push = new ChatPushConfig({

          deviceId:manufacturer,

          deviceToken:deviceToken,

          

        });

        console.log("--------------------------------------------");

        console.log(manufacturer);

        console.log(deviceToken);

        console.log("--------------------------------------------");

        ChatClient.getInstance().updatePushConfig(push);

      })

      .catch(reason => {

        rollLog('login fail: ' + JSON.stringify(reason));

      });

  };



  // 登出。

  const logout = () => {

    if (this.isInitialized === false || this.isInitialized === undefined) {

      rollLog('Perform initialization first.');

      return;

    }

    rollLog('start logout ...');

    ChatClient.getInstance()

      .logout()

      .then(() => {

        rollLog('logout success.');

      })

      .catch(reason => {

        rollLog('logout fail:' + JSON.stringify(reason));

      });

  };



  // 发送一条文本消息。

  const sendmsg = () => {

    if (this.isInitialized === false || this.isInitialized === undefined) {

      rollLog('Perform initialization first.');

      return;

    }

    let msg = ChatMessage.createTextMessage(

      userId,

      content,

      ChatMessageChatType.PeerChat,

    );

    const callback = new (class {

      onProgress(locaMsgId, progress) {

        rollLog(`send message process: ${locaMsgId}, ${progress}`);

      }

      onError(locaMsgId, error) {

        rollLog(`send message fail: ${locaMsgId}, ${JSON.stringify(error)}`);

      }

      onSuccess(message) {

        rollLog('send message success: ' + message.localMsgId);

      }

    })();

    rollLog('start send message ...');

    ChatClient.getInstance()

      .chatManager.sendMessage(msg, callback)

      .then(() => {

        rollLog('send message: ' + msg.localMsgId);

      })

      .catch(reason => {

        rollLog('send fail: ' + JSON.stringify(reason));

      });

  };



  // UI 组件渲染。

  return (

    <SafeAreaView>

      <View style={styles.titleContainer}>

        <Text style={styles.title}>{title}</Text>

      </View>

      <ScrollView>

        <View style={styles.inputCon}>

          <TextInput

            multiline

            style={styles.inputBox}

            placeholder="Enter appkey"

            onChangeText={text => setAppKey(text)}

            value={appKey}

          />

        </View>

        <View style={styles.buttonCon}>

          <Text style={styles.btn2} onPress={init}>

            INIT SDK

          </Text>

        </View>

        <View style={styles.inputCon}>

          <TextInput

            multiline

            style={styles.inputBox}

            placeholder="Enter username"

            onChangeText={text => setUsername(text)}

            value={username}

          />

        </View>

        <View style={styles.inputCon}>

          <TextInput

            multiline

            style={styles.inputBox}

            placeholder="Enter password"

            onChangeText={text => setPassword(text)}

            value={password}

          />

        </View>

        <View style={styles.buttonCon}>

          <Text style={styles.eachBtn} onPress={registerAccount}>

            SIGN UP

          </Text>

          <Text style={styles.eachBtn} onPress={loginWithPassword}>

            SIGN IN

          </Text>

          <Text style={styles.eachBtn} onPress={logout}>

            SIGN OUT

          </Text>

        </View>

        <View style={styles.inputCon}>

          <TextInput

            multiline

            style={styles.inputBox}

            placeholder="Enter the username you want to send"

            onChangeText={text => setUserId(text)}

            value={userId}

          />

        </View>

        <View style={styles.inputCon}>

          <TextInput

            multiline

            style={styles.inputBox}

            placeholder="Enter content"

            onChangeText={text => setContent(text)}

            value={content}

          />

        </View>

        <View style={styles.buttonCon}>

          <Text style={styles.btn2} onPress={sendmsg}>

            SEND TEXT

          </Text>

        </View>

        <View>

          <Text style={styles.logText} multiline={true}>

            {logText}

          </Text>

        </View>

        <View>

          <Text style={styles.logText}>{}</Text>

        </View>

        <View>

          <Text style={styles.logText}>{}</Text>

        </View>

      </ScrollView>

    </SafeAreaView>

  );

};



// 设置 UI。

const styles = StyleSheet.create({

  titleContainer: {

    height: 60,

    backgroundColor: '#6200ED',

  },

  title: {

    lineHeight: 60,

    paddingLeft: 15,

    color: '#fff',

    fontSize: 20,

    fontWeight: '700',

  },

  inputCon: {

    marginLeft: '5%',

    width: '90%',

    height: 60,

    paddingBottom: 6,

    borderBottomWidth: 1,

    borderBottomColor: '#ccc',

  },

  inputBox: {

    marginTop: 15,

    width: '100%',

    fontSize: 14,

    fontWeight: 'bold',

  },

  buttonCon: {

    marginLeft: '2%',

    width: '96%',

    flexDirection: 'row',

    marginTop: 20,

    height: 26,

    justifyContent: 'space-around',

    alignItems: 'center',

  },

  eachBtn: {

    height: 40,

    width: '28%',

    lineHeight: 40,

    textAlign: 'center',

    color: '#fff',

    fontSize: 16,

    backgroundColor: '#6200ED',

    borderRadius: 5,

  },

  btn2: {

    height: 40,

    width: '45%',

    lineHeight: 40,

    textAlign: 'center',

    color: '#fff',

    fontSize: 16,

    backgroundColor: '#6200ED',

    borderRadius: 5,

  },

  logText: {

    padding: 10,

    marginTop: 10,

    color: '#ccc',

    fontSize: 14,

    lineHeight: 20,

  },

});



export default App;

注：需要再登录成功以后进行绑定

四、推送测试

1、push测试
如何查看绑定的证书信息：
登录环信console—>即时推送—>找到对应的用户id—>点击查看用户绑定推送证书（如下图）

如何测试推送
登录环信console—> 即时推送—>填写相关的内容—>发送预览—>确认推送

收到推送

2、离线消息测试
登录环信console—> 即时通讯—>用户管理—>找到对应的用户id—>发送rest 消息

至此，ReactNative 推送集成完成。

前言：在集成ReactNative推送之前，需要了解ReactNative与Android原生交互

一、RN与Android原生交互

RN给原生传递参数

步骤：

1.用Android Studio打开一个已经存在的RN项目，即用AS打开 项目文件夹/android,如下图所示

2.在Android原生这边创建一个类继承ReactContextBaseJavaModule，这个类里边放我们需要被RN调用的方法，将其封装成一个原生模块。

MyNativeModule.java代码如下：

package com.awesomeproject;

import com.facebook.react.bridge.ReactApplicationContext;

import com.facebook.react.bridge.ReactContextBaseJavaModule;

import com.facebook.react.bridge.ReactMethod;

import com.facebook.react.modules.core.DeviceEventManagerModule;

import com.xiaomi.mipush.sdk.MiPushClient;

import org.json.JSONException;

import org.json.JSONObject;



public class PushModule extends ReactContextBaseJavaModule {

    private ReactApplicationContext reactContext;

    public PushModule(ReactApplicationContext reactContext) {

        super(reactContext);

        this.reactContext = reactContext;

    }



    @Override

    public String getName() {

        return "PushModule";

    }

    /**

     从RN界面里面调用该方法

     **/

    @ReactMethod

    public void getDeviceToken(){

        MainApplication.getReactPackage().mModule.sendDataToJS( MiPushClient.getRegId(MainApplication.getContext()));





    }

    

    public void sendDataToJS(String deviceToken){

        JSONObject jsonObject = new JSONObject();

        try {

            jsonObject.put("deviceToken",deviceToken);

            jsonObject.put("deviceName","");



        } catch (JSONException e) {

            throw new RuntimeException(e);

        }



        this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)

                .emit("deviceToken",jsonObject.toString());

    }







}

本类中存放我们要复用的原生方法，继承了ReactContextBaseJavaModule类，并且实现了其getName（）方法，构造方法也是必须的。按着Alt+Enter程序会自动提示。接着定义了一个方法，该方法必须使用注解@ReactMethod标明，说明是RN要调用的方法。

3.在Android原生这边创建一个类实现接口ReactPackage包管理器，并把第二步创建的类加到原生模块（NativeModule）列表里。

PushPackage.java代码如下：

package com.awesomeproject;

import com.facebook.react.ReactPackage;

import com.facebook.react.bridge.NativeModule;

import com.facebook.react.bridge.ReactApplicationContext;

import com.facebook.react.uimanager.ViewManager;



import java.util.ArrayList;

import java.util.Collections;

import java.util.List;



public class PushPackage implements ReactPackage {

    public PushModule mModule;

    @Override

    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {

        List<NativeModule> list = new ArrayList<>();

        mModule = new PushModule(reactContext);

        list.add(mModule);

        return list;

    }



    @Override

    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {

        return Collections.emptyList();

    }

}

4.将第三步创建的包管理器添加到ReactPackage列表里（getPackage方法里）

MainApplication.java代码如下：

package com.awesomeproject;



import android.app.Application;

import android.content.Context;

import android.util.Log;



import com.facebook.react.PackageList;

import com.facebook.react.ReactApplication;

import com.facebook.react.ReactInstanceManager;

import com.facebook.react.ReactNativeHost;

import com.facebook.react.ReactPackage;

import com.facebook.react.config.ReactFeatureFlags;

import com.facebook.soloader.SoLoader;

import com.awesomeproject.newarchitecture.MainApplicationReactNativeHost;

import com.vivo.push.IPushActionListener;

import com.vivo.push.PushClient;

import com.vivo.push.PushConfig;

import com.vivo.push.util.VivoPushException;

import com.xiaomi.channel.commonutils.logger.LoggerInterface;

import com.xiaomi.mipush.sdk.Logger;

import com.xiaomi.mipush.sdk.MiPushClient;



import java.lang.reflect.InvocationTargetException;

import java.util.List;



public class MainApplication extends Application implements ReactApplication {



  private final ReactNativeHost mReactNativeHost =

      new ReactNativeHost(this) {

        @Override

        public boolean getUseDeveloperSupport() {

          return BuildConfig.DEBUG;

        }



        @Override

        protected List<ReactPackage> getPackages() {

          @SuppressWarnings("UnnecessaryLocalVariable")

          List<ReactPackage> packages = new PackageList(this).getPackages();

          packages.add(mCommPackage);

          // Packages that cannot be autolinked yet can be added manually here, for example:

          // packages.add(new MyReactNativePackage());

          return packages;

        }



        @Override

        protected String getJSMainModuleName() {

          return "index";

        }

      };



  private final ReactNativeHost mNewArchitectureNativeHost =

      new MainApplicationReactNativeHost(this);



  @Override

  public ReactNativeHost getReactNativeHost() {

    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {

      return mNewArchitectureNativeHost;

    } else {

      return mReactNativeHost;

    }

  }





    static Context context;



    public static Context getContext() {

        return context;

    }

    private static final PushPackage mCommPackage = new PushPackage();

    public static PushPackage getReactPackage() {

        return mCommPackage;

    }







    @Override

  public void onCreate() {

    super.onCreate();

        context = this;

    // If you opted-in for the New Architecture, we enable the TurboModule system

    ReactFeatureFlags.useTurboModules = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;

    SoLoader.init(this, /* native exopackage */ false);

    initializeFlipper(this, getReactNativeHost().getReactInstanceManager());







        //初始化push



        try {

//PushConfig.agreePrivacyStatement属性及含义说明请参考接口文档

//使用方法

            PushConfig config = new PushConfig.Builder()

                    .agreePrivacyStatement(true)

                    .build();

            PushClient.getInstance(MainApplication.this).initialize(config);

        } catch (VivoPushException e) {

            Log.d("VivoPushException","-------------"+e.toString());

//此处异常说明是有必须的vpush配置未配置所致，需要仔细检查集成指南的各项配置。

            e.printStackTrace();

        }







// 打开push开关, 关闭为turnOffPush，详见api接入文档

        PushClient.getInstance(this).turnOnPush(new IPushActionListener() {

            @Override

            public void onStateChanged(int state) {

                // TODO: 开关状态处理， 0代表成功，获取regid建议在state=0后获取；

                Log.d("vivo初始化------","开关状态处理， 0代表成功，获取regid建议在state=0后获取----"+state);

            }

        });





        //小米初始化push推送服务



        MiPushClient.registerPush(this, "2882303761517520571", "5841752092571");



        //打开Log

        LoggerInterface newLogger = new LoggerInterface() {



            @Override

            public void setTag(String tag) {

                Log.d("MainApplication-------",tag);

                // ignore

            }



            @Override

            public void log(String content, Throwable t) {

                Log.d("MainApplication-------",content+"-----"+t.toString());



            }



            @Override

            public void log(String content) {

                Log.d("MainApplication-------",content);

            }

        };

        Logger.setLogger(this, newLogger);

  }



  /**

   * Loads Flipper in React Native templates. Call this in the onCreate method with something like

   * initializeFlipper(this, getReactNativeHost().getReactInstanceManager());

   *

   * @param context

   * @param reactInstanceManager

   */

  private static void initializeFlipper(

      Context context, ReactInstanceManager reactInstanceManager) {

    if (BuildConfig.DEBUG) {

      try {

        /*

         We use reflection here to pick up the class that initializes Flipper,

        since Flipper library is not available in release mode

        */

        Class<?> aClass = Class.forName("com.awesomeproject.ReactNativeFlipper");

        aClass

            .getMethod("initializeFlipper", Context.class, ReactInstanceManager.class)

            .invoke(null, context, reactInstanceManager);

      } catch (ClassNotFoundException e) {

        e.printStackTrace();

      } catch (NoSuchMethodException e) {

        e.printStackTrace();

      } catch (IllegalAccessException e) {

        e.printStackTrace();

      } catch (InvocationTargetException e) {

        e.printStackTrace();

      }

    }

  }



}