atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>A Mjn Blog</title>
  
  <link href="/atom.xml" rel="self"/>
  
  <link href="https://github.com/mjnhmd/"/>
  <updated>2016-04-21T02:21:22.641Z</updated>
  <id>https://github.com/mjnhmd/</id>
  
  <author>
    <name>MJN</name>
    
  </author>
  
  <generator uri="http://hexo.io/">Hexo</generator>
  
  <entry>
    <title>MarkDown简化贴图流程</title>
    <link href="https://github.com/mjnhmd/2016/04/14/MarkDown%E7%AE%80%E5%8C%96%E8%B4%B4%E5%9B%BE%E6%B5%81%E7%A8%8B/"/>
    <id>https://github.com/mjnhmd/2016/04/14/MarkDown简化贴图流程/</id>
    <published>2016-04-14T11:32:50.000Z</published>
    <updated>2016-04-21T02:21:22.641Z</updated>
    
    <content type="html">&lt;h2 id=&quot;动机&quot;&gt;&lt;a href=&quot;#动机&quot; class=&quot;headerlink&quot; title=&quot;动机&quot;&gt;&lt;/a&gt;动机&lt;/h2&gt;&lt;p&gt;这个原因还用说吗，完全是刚需啊！！！以前写个markdown想要贴个图简直让人崩溃啊！！！&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;你可能先要截个图&lt;/li&gt;
&lt;li&gt;然后打开浏览器&lt;/li&gt;
&lt;li&gt;打开你的图床网站&lt;/li&gt;
&lt;li&gt;点击上传图片&lt;/li&gt;
&lt;li&gt;等待上传完成&lt;/li&gt;
&lt;li&gt;复制外链&lt;/li&gt;
&lt;li&gt;返回markdown&lt;/li&gt;
&lt;li&gt;当然这是只是一个url，你还得写成markdown的格式，才算完成&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;执行完这些操作之后，思路早就跑到九霄云外了有木有，写文章的激情早就耗尽了！！！&lt;/p&gt;
&lt;p&gt;MarkDown作为一个逼格满满新潮写作方式，竟然还存在这种反人类的操作，实在是让人不能忍啊。&lt;/p&gt;
&lt;h2 id=&quot;尝试&quot;&gt;&lt;a href=&quot;#尝试&quot; class=&quot;headerlink&quot; title=&quot;尝试&quot;&gt;&lt;/a&gt;尝试&lt;/h2&gt;&lt;p&gt;于是就去google了一下，果然有很多人一样忍不了，并且找出了解决办法。搜到了三位大神的文章：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&quot;http://tianweishu.com/2015/10/16/simplify-the-img-upload-in-markdown/&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;简化markdown写作中的贴图流程&lt;/a&gt; 这个是写的很好，可是是mac的&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;http://mickir.xyz/blog/2015/12/simplify-the-img-upload-in-markdown.html&quot; target=&quot;_blank&quot; rel=&quot;external&quot;&gt;简化markdown中的贴图流程&lt;/a&gt; 这个是借鉴上问的windows版，作者是大神，写的比较简略。这里边的利用微信dll截图的功能非常值得借鉴&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://github.com/xzop/markdown-img-upload-windows/blob/master/ReadMe.md&quot;&gt;markdown-img-upload-windows&lt;/a&gt;这个是github项目，可能是dll版本不对，我这里不成功&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;需要的东西：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;python环境&lt;/li&gt;
&lt;li&gt;AutoHotKey&lt;/li&gt;
&lt;li&gt;windows系统&lt;/li&gt;
&lt;li&gt;七牛云存储账户&lt;/li&gt;
&lt;li&gt;没了&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;七牛肯定是有了，python也装过，所差的就是一个软件而已嘛，于是装了个破解版，按照操作做。果然，并不能成功。。&lt;/p&gt;
&lt;p&gt;照着做都不行，于是就只能自己修改了。&lt;/p&gt;
&lt;h2 id=&quot;修改&quot;&gt;&lt;a href=&quot;#修改&quot; class=&quot;headerlink&quot; title=&quot;修改&quot;&gt;&lt;/a&gt;修改&lt;/h2&gt;&lt;p&gt;相比起来第三篇比较完整，有源码有解释，只是某个功能需要修改。于是就尝试着对脚本进行修改。&lt;/p&gt;
&lt;p&gt;一共就两个脚本，一个是AutoHotKey自己的脚本，一个是Python脚本。很凑巧的是，对这两个都一窍不通。&lt;/p&gt;
&lt;p&gt;只能硬着头皮上，看了一下AutoHotKey自带的介绍，并不是很难，大概就是把某个快捷键绑定相应的功能，代码是这样的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;^!c::    #^代表ctrl，!代表alt，也就是说是让ctrl+alt+c执行相应的功能
send, ^c #首先执行Ctrl+c，也就是复制。也就是把选中的图片放到剪切板中
clipwait #然后做一个延迟，等待复制操作完成
Run %comspec%  /c &amp;quot;Python D:\qiniu\upload_qiniu.py&amp;quot; %Clipboard% /p 
        /#执行python脚本，并从剪贴板中获取值，这个值就是刚才执行的复制操作的值，也就是选中的图片
return   #返回
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这里这个脚本逻辑很清楚并且能够正常执行，是不需要修改的。&lt;/p&gt;
&lt;p&gt;再看一下python脚本，虽然不懂python语言，但是勉强还是能看懂一些大概逻辑：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# -*- coding: utf-8 -*-

import os
import sys
reload(sys)
sys.setdefaultencoding(&amp;apos;utf-8&amp;apos;)

from qiniu import Auth, put_file
import qiniu.config

from ctypes import *
import time

import ConfigParser
from datetime import datetime

#这部分显然是从config中获取到我们设置好的一些参数
cf = ConfigParser.ConfigParser()
cf.read(&amp;apos;config.ini&amp;apos;)
access_key = cf.get(&amp;apos;qiniu&amp;apos;, &amp;apos;ak&amp;apos;) # AK
secret_key = cf.get(&amp;apos;qiniu&amp;apos;, &amp;apos;sk&amp;apos;) # SK
bucket_name = cf.get(&amp;apos;qiniu&amp;apos;, &amp;apos;bucket&amp;apos;) # 七牛空间名
url = cf.get(&amp;apos;qiniu&amp;apos;, &amp;apos;url&amp;apos;) # url

q = Auth(access_key, secret_key)

mime_type = &amp;quot;image/jpeg&amp;quot;
params = {&amp;apos;x:a&amp;apos;: &amp;apos;a&amp;apos;}

prefix = datetime.now().strftime(&amp;apos;%Y_%m_%d&amp;apos;)

def upload_qiniu(path, prefix): #这是具体的上传图片方法，主要是调用七牛的sdk
&amp;apos;&amp;apos;&amp;apos; upload file to qiniu &amp;apos;&amp;apos;&amp;apos;
dirname, filename = os.path.split(path)
key = &amp;apos;%s_%s&amp;apos; % (prefix, filename) # upload to qiniu&amp;apos;s dir
key = key.decode(&amp;apos;gbk&amp;apos;).encode(&amp;apos;utf8&amp;apos;)

token = q.upload_token(bucket_name, key)
progress_handler = lambda progress, total: progress
ret, info = put_file(token, key, path, params, mime_type, progress_handler=progress_handler)
return ret != None and ret[&amp;apos;key&amp;apos;] == key

if __name__ == &amp;apos;__main__&amp;apos;:
path = sys.argv[1] #这里显然是获取图片的路径，也就是我们从剪切板里获取的
ret = upload_qiniu(path, prefix) 这是执行上面的上传方法
if ret:
    # upload success 如果成功则把url拼成markdown格式
    name = os.path.split(path)[1]
    alt = name.split(&amp;apos;.&amp;apos;, 1)
    markdown_url = &amp;quot;![%s](%s/%s_%s \&amp;quot;%s\&amp;quot;)&amp;quot; % (alt[0], url, prefix, name, alt[0])
    # make it to clipboard 然后调用ahk的dll库吧它放进剪贴板，这样我们直接复制就可以了。 我就是这里没有执行成功。
    ahk = cdll.AutoHotkey #load AutoHotkey
    ahk.ahktextdll(&amp;quot;&amp;quot;) #start script in persistent mode (wait for action)
    while not ahk.ahkReady(): #Wait for AutoHotkey.dll to start
        time.sleep(0.01)
    ahk.ahkExec(u&amp;quot;clipboard = %s&amp;quot; % markdown_url.decode(&amp;apos;gbk&amp;apos;))
else: print &amp;quot;upload_failed&amp;quot;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;整个脚本也简单，就一个主函数，一个上传函数，经过运行我发现上传没问题，能够成功上传，只是把它放入剪贴板中存在问题，为此我还安装了个pycharm，输出的log显示ahk.dll调用失败。&lt;/p&gt;
&lt;p&gt;但是把一个字符串放入剪贴板显然不只有这一种方法。于是我又查了一下直接用python自己能不能实现这个功能，果然没什么是强大的python做不到的。于是我把主函数改成了这样：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;def setText(aString):
w.OpenClipboard()
w.EmptyClipboard()
w.SetClipboardText(aString)
w.CloseClipboard()

if __name__ == &amp;apos;__main__&amp;apos;:
path = sys.argv[1]
ret = upload_qiniu(path, prefix)
if ret:
    # upload success
    name = os.path.split(path)[1]
    alt = name.split(&amp;apos;.&amp;apos;, 1)
    markdown_url = &amp;quot;![%s](%s/%s_%s \&amp;quot;%s\&amp;quot;)&amp;quot; % (alt[0], url, prefix, name, alt[0])
    # make it to clipboard
    setText(markdown_url)
else:
    print &amp;quot;upload_failed&amp;quot;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这里又加了个方法，简单的四行代码就可以实现剪切板的操作。这样，终于成功了。&lt;/p&gt;
&lt;h2 id=&quot;使用：&quot;&gt;&lt;a href=&quot;#使用：&quot; class=&quot;headerlink&quot; title=&quot;使用：&quot;&gt;&lt;/a&gt;使用：&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;p&gt;首先配置config.ini：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;[qiniu]&lt;/li&gt;
&lt;li&gt;ak     = # 填入你的AK&lt;/li&gt;
&lt;li&gt;sk     = # 填入你的SK&lt;/li&gt;
&lt;li&gt;url    = # 填入你的域名地址&lt;/li&gt;
&lt;li&gt;bucket = # 填入你的七牛空间名称&lt;/li&gt;
&lt;li&gt;注意！！！注释一定都要删掉， 写值时不要加引号。ak,sk不是用户名和密码，是在账户管理中的密钥管理那里找到。填完是这样婶儿的：&lt;br&gt;&lt;img src=&quot;http://7xry4c.com1.z0.glb.clouddn.com//2016_04_15_qiniuconfig.png&quot; alt=&quot;qiniuconfig&quot; title=&quot;qiniuconfig&quot;&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;然后是把config.ini和upload_qiniu.py放到同一个目录。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;然后修改upload_qiniu.ahk中的upload_qiniu.py路径&lt;/li&gt;
&lt;li&gt;然后双击upload_qiniu.ahk就可以了。&lt;/li&gt;
&lt;li&gt;用鼠标左键点击一张图片，然后点击ctrl+alt+c，然后窗口消失后再markdown里ctrl+v 神奇的事就发生了！&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;现在图片完全就是一键上传，一键贴到markdown了。&lt;/p&gt;
&lt;h3 id=&quot;源码在这&quot;&gt;&lt;a href=&quot;#源码在这&quot; class=&quot;headerlink&quot; title=&quot;源码在这&quot;&gt;&lt;/a&gt;&lt;a href=&quot;https://github.com/mjnhmd/markdown-upload-qiniu&quot;&gt;源码在这&lt;/a&gt;&lt;/h3&gt;</content>
    
    <summary type="html">
    
      &lt;h2 id=&quot;动机&quot;&gt;&lt;a href=&quot;#动机&quot; class=&quot;headerlink&quot; title=&quot;动机&quot;&gt;&lt;/a&gt;动机&lt;/h2&gt;&lt;p&gt;这个原因还用说吗，完全是刚需啊！！！以前写个markdown想要贴个图简直让人崩溃啊！！！&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;你可能先要截个图&lt;/l
    
    </summary>
    
      <category term="Hexo" scheme="https://github.com/mjnhmd/categories/Hexo/"/>
    
    
      <category term="Hexo" scheme="https://github.com/mjnhmd/tags/Hexo/"/>
    
      <category term="MarkDown" scheme="https://github.com/mjnhmd/tags/MarkDown/"/>
    
      <category term="python" scheme="https://github.com/mjnhmd/tags/python/"/>
    
  </entry>
  
  <entry>
    <title>鹿的消逝：对电影《犴达罕》的解读</title>
    <link href="https://github.com/mjnhmd/2016/04/13/%E9%B9%BF%E7%9A%84%E6%B6%88%E9%80%9D%EF%BC%9A%E5%AF%B9%E7%94%B5%E5%BD%B1%E3%80%8A%E7%8A%B4%E8%BE%BE%E7%BD%95%E3%80%8B%E7%9A%84%E8%A7%A3%E8%AF%BB/"/>
    <id>https://github.com/mjnhmd/2016/04/13/鹿的消逝：对电影《犴达罕》的解读/</id>
    <published>2016-04-13T09:45:11.000Z</published>
    <updated>2016-04-13T10:19:56.025Z</updated>
    
    <content type="html">&lt;p&gt;&amp;emsp;&amp;emsp;首先，这当然是一部以鄂温克人维加为主切入视角的记录片，但导演机敏地选择了“犴达罕”作为这部纪录片的名字，那么一切都变得比“民族志”式的叙述更为深刻。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;犴达罕是驼鹿在满语中的叫法，纪录片中出现过的只是驼鹿被偷猎者射杀后残留下的尸骨。这是一种世界上最大的鹿科动物，典型的亚寒带针叶林食草动物，喜欢单独或小群生活。它们和鄂温克族的关系其实并没有影片中出现的另一种鹿——驯鹿来的密切，但却是驼鹿而非驯鹿成为了这部纪录片的名称。通常而言，驯鹿是鄂温克族的民族标志物，因为驯鹿作为鄂温克族的交通工具的历史由来已久，早在新中国成立以前，居住在额尔古纳左旗的极少数鄂温克族人尚处于原始社会末期父系家族公社阶段，生活在原始森林中，住在简陋的帐幕—-撮罗子中，往往漂泊不定。因为他们饲养驯鹿，常被称为“使用驯鹿的鄂温克人”，驯鹿甚至就是鄂温克民族的吉祥物。从某种程度上，两种鹿在影片中的存在都具有一种映射性的象征意义，鄂温克族，这是一个鹿的民族，但残忍的事实却是他们不得不与鹿分离，并亲眼见证着鹿的消逝。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;纪录片中采取的一个确定性的线索是鄂温克民族在新时代的号召下被有组织地现代化，语言、服饰以及居住方式的改变是显而易见的，语言被汉化，服装的整洁化以及从山上的简陋的帷帐中搬到山下的鄂温克新村定居点，一个独立自足的民族的面貌发生了全然的改变。如果只从这些宏观的粗放镜头中表现鄂温克民族的生存现状，那么将与一部民族志式的纪实片没有分别，导演的眼光在于将他对于文明的思考穿插进一些微观的细节处。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;外在的东西是容易被塑造的，然而一些属于文化内部的坚硬的内容是无法轻易消除的。包括维加在内的鄂温克人都喜欢喝酒、打架、与鹿为伍。片中最先切入的镜头就是醉酒疯癫的维加，以及在后续无数次族人群聚饮酒的场面，这与汉族的所谓“文明”的文化是决然不同的，汉族饮酒讲究的是微醺，是酒醉后的适度美感，这一强一弱的喝酒文化的对立性其实暗含了对强势文化殖民弱势文化的可能性的反思，并进一步达成了对“文明”这一概念的讽刺，何为“文明”呢？难道“文明”就是要以牺牲少数文化和独特文化为代价吗？又或者是否真的存在一个可以称之为“文明”的概念，并赋予了人类用自以为高姿态的优秀文化去同化所谓的卑劣文化的权力？所以，尽管作为老一辈的维加们受到了文明政策的号召搬到了山下居住，但他们仍不能摒除用打架解决矛盾的“野蛮行为”。在这里，有一个与老维加们形成对比的新生鄂温克人形象，纪录片中的一个场面是年轻的鄂温克人已放下了手里的猎枪，离开了他们的好伙伴——驯鹿，转而在定居点进行着现代的足球游戏，而他们游戏的地点的背景则是一间鹿产品专卖店，这是一张极其接近现代城市生活方式的图景，导演似乎在用这个画面告诉我们，老维加们已经输了，传统鄂温克人的坚守、传统鄂温克文化中的坚硬最终在现代文明的攻势下一败涂地。而导演非常清楚地知道，鄂温克族的没落会伴随着很多东西的消失，但最为关键也是最能摧毁一个民族的点在于剥夺他们的“文明”，对于鄂温克族来说，狩猎文化就是他们最核心的“文明”。就像他们给自己的民族起名为“鄂温克”，寓意就是“住在大山林中的人们”，靠山吃山，靠水吃水，住在兴安岭常年积雪的大山林里的人们以驯鹿为交通工具，以驼鹿为捕猎对象，与鹿为伍，这就是他们的基本生活，也是他们的全部生活。影片中维加酒后的苦闷之言说，驯鹿发展不起来，政府缴收了他们的猎枪，他们无事可做，所以很多年轻人宁愿喝酒喝死。这是整部影片最具力量性的一句话，不成佛便成魔。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;更具讽刺的是，影片中透露出另外一种身份的存在——偷猎者。维加称其为偷猎者是因为这些人违背国家法律还是因为这些人违背狩猎原则呢？我想我更倾向于后者，传统的狩猎人打猎并不是为了获取商业利益，而是出于生存的需要，因此其与大自然与万物生灵间是一种和谐融洽的关系，他们不会肆意破坏生物规律地进行疯狂屠杀，并且会对猎物抱有神灵般的感恩与尊重，这些和偷猎者的暴力行径是截然不同的。那么，这里就存在一个强烈的讽刺手法，现代文明的优越感迫使处于劣势的少数民族文明被同化，这样的一个前提基础就是现代文明能更好地建设，然而，事实却好像是，现代文明总在建设的同时破坏着什么，并在破坏后再重新去建设。打破鄂温克人与鹿的和谐生活状态，将现代文明，商业文明带入深山树林，造成了鹿的消逝，然后再来发明一个法律保护鹿。这样的“文明”的循坏应该并不是一个陌生的话语吧。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;导演在记录鄂温克人与鹿的关系变化的进程中其实实现了对“文明”这一概念的解构，文明只应该作为一种中性的概念性词汇而存在于平等的各民族国家之间，而决不能被赋予任何的修饰性色彩用于不同地域间的比较之上，更不应该成为文化殖民的借口。：鄂温克族已与鹿渐行渐远，他们既不能为伴，也没有能力守护鹿不被偷猎者所屠杀。在见证着鹿的消逝的同时，他们何尝不是在见证着自己的陨灭，驼鹿，他们更习惯称其为“犴达罕”，这一独栖的孤独的大山的物种，终要在历史前往现代的路上被偷猎者终结了生命，它体型庞大，死得沉重而悲壮，却又在那不为人知的某一处丛林处静悄悄。正如昌耀的一首诗，《鹿的角枝》：&lt;/p&gt;
&lt;center&gt;在雄鹿的颅骨，&lt;br&gt;&lt;br&gt;有两株&lt;br&gt;被精血所滋养的小树。&lt;br&gt;&lt;br&gt;雾光里&lt;br&gt;&lt;br&gt;这些挺拔的枝状体&lt;br&gt;&lt;br&gt;明丽而珍重，&lt;br&gt;&lt;br&gt;遁越于危崖、沼泽，&lt;br&gt;&lt;br&gt;与猎人相周旋。&lt;br&gt;&lt;br&gt;&lt;br&gt;若干个世纪以后。&lt;br&gt;&lt;br&gt;在我的书架，&lt;br&gt;&lt;br&gt;在我新得收藏品之上，&lt;br&gt;&lt;br&gt;我才听到来自高原腹地的那一声&lt;br&gt;&lt;br&gt;火枪。——&lt;br&gt;&lt;br&gt;那样的夕阳&lt;br&gt;&lt;br&gt;倾照着那样呼唤的荒野，&lt;br&gt;&lt;br&gt;从高岩。飞动的鹿角&lt;br&gt;&lt;br&gt;猝然倒仆……&lt;br&gt;&lt;br&gt;&lt;br&gt;……是悲壮的。&lt;/center&gt;
</content>
    
    <summary type="html">
    
      &lt;p&gt;&amp;emsp;&amp;emsp;首先，这当然是一部以鄂温克人维加为主切入视角的记录片，但导演机敏地选择了“犴达罕”作为这部纪录片的名字，那么一切都变得比“民族志”式的叙述更为深刻。&lt;/p&gt;
&lt;p&gt;&amp;emsp;&amp;emsp;犴达罕是驼鹿在满语中的叫法，纪录片中出现过的只是驼鹿被偷猎者射
    
    </summary>
    
      <category term="影评" scheme="https://github.com/mjnhmd/categories/%E5%BD%B1%E8%AF%84/"/>
    
    
      <category term="影评" scheme="https://github.com/mjnhmd/tags/%E5%BD%B1%E8%AF%84/"/>
    
  </entry>
  
  <entry>
    <title>CoordinatorLayout调用原理源码解析</title>
    <link href="https://github.com/mjnhmd/2016/04/05/CoordinatorLayout%E8%B0%83%E7%94%A8%E5%8E%9F%E7%90%86%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/"/>
    <id>https://github.com/mjnhmd/2016/04/05/CoordinatorLayout调用原理源码解析/</id>
    <published>2016-04-05T10:15:54.000Z</published>
    <updated>2016-04-13T11:00:53.887Z</updated>
    
    <content type="html">&lt;h2 id=&quot;获取Behavior&quot;&gt;&lt;a href=&quot;#获取Behavior&quot; class=&quot;headerlink&quot; title=&quot;获取Behavior&quot;&gt;&lt;/a&gt;获取Behavior&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;CoordinatorLayout中子view关联的动作主要由Behavior实现。&lt;br&gt;系统控件中往往把behavior作为内部类，自己实现，比如AppbarLayout。&lt;br&gt;当然我们也可以自己实现自定义的Behavior来完成我们需要的动作。&lt;br&gt;自定义Behavior时，我们需要在xml代码中实现相应属性，例如：&lt;/p&gt;
&lt;/blockquote&gt;
&lt;pre&gt;&lt;code&gt;app:layout_behavior=&amp;quot;com.wuba.views.CustomAppbarBehavior&amp;quot;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这个就是我们首页动画实现的自定义的behavior。&lt;br&gt;在xml中实现之后，必然会在代码中获取这个behavior:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public static class LayoutParams extends MarginLayoutParams {
    CoordinatorLayout.Behavior mBehavior;

    LayoutParams(Context context, AttributeSet attrs) {
    super(context, attrs);
    TypedArray a = context.obtainStyledAttributes(attrs, styleable.CoordinatorLayout_LayoutParams);
    this.mBehaviorResolved = a.hasValue(styleable.CoordinatorLayout_LayoutParams_layout_behavior);
    if(this.mBehaviorResolved) {
        this.mBehavior = CoordinatorLayout.parseBehavior(context, attrs, a.getString(styleable.CoordinatorLayout_LayoutParams_layout_behavior));//这个方法获取到behavior的实例
    }
    a.recycle();
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到，获取behavior的方式和很多自定义view的方式是一样的,通过自定义属性来获取。我们具体看一下parseBehavior()方法是怎么实现的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;static CoordinatorLayout.Behavior parseBehavior(Context context, AttributeSet attrs, String name) {
    if(TextUtils.isEmpty(name)) {
        return null;
    } else {
    String fullName;
    if(name.startsWith(&amp;quot;.&amp;quot;)) {//如果以.开始，就拼接上包名
        fullName = context.getPackageName() + name;
    } else if(name.indexOf(46) &amp;gt;= 0) {//这里我猜46是类名的最大长度，大于46由没有以.开始，说明它本身就是完整包名
        fullName = name;
    } else {
        fullName = WIDGET_PACKAGE_NAME + &amp;apos;.&amp;apos; + name;//否则就是包名.类名
    }

    try {
        Object e = (Map)sConstructors.get();
        if(e == null) {
            e = new HashMap();
            sConstructors.set(e);
        }

        Constructor c = (Constructor)((Map)e).get(fullName);
        if(c == null) {
            Class clazz = Class.forName(fullName, true, context.getClassLoader());//用反射获取类
            c = clazz.getConstructor(CONSTRUCTOR_PARAMS);//通过构造方法获取实例
           ((Map)e).put(fullName, c);
        }

        return (CoordinatorLayout.Behavior)c.newInstance(new Object[]{context, attrs});
    } catch (Exception var7) {
        throw new RuntimeException(&amp;quot;Could not inflate Behavior subclass &amp;quot; + fullName, var7);
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到这个方法，通过拼接路径，然后用反射的方式获取到了behavior的实例。这样View就成功获取到了behavior。&lt;/p&gt;
&lt;h2 id=&quot;通用动作的实现&quot;&gt;&lt;a href=&quot;#通用动作的实现&quot; class=&quot;headerlink&quot; title=&quot;通用动作的实现&quot;&gt;&lt;/a&gt;通用动作的实现&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;Behavior中有很多可以实现的接口。在我看来关于动作的方法大概可以分成两类。先说第一类；&lt;/p&gt;
&lt;/blockquote&gt;
&lt;pre&gt;&lt;code&gt;public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency) 
public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) 
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这两个方法主要实现通用的的关联动作，各种view的改变都可以使用。&lt;br&gt;下面看一下他们的作用以及调用关系。&lt;br&gt;前两个方法和主要是在dispatchOnDependentViewChanged方法中调用，我们先看看在哪里调用了这个方法。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class OnPreDrawListener implements android.view.ViewTreeObserver.OnPreDrawListener {
    OnPreDrawListener() {
    }

    public boolean onPreDraw() {
        CoordinatorLayout.this.dispatchOnDependentViewChanged(false);
        return true;
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;主要是在这个listener中，再看一下哪里注册了这个监听：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public void onAttachedToWindow() {
    super.onAttachedToWindow();
    this.resetTouchBehaviors();
    if(this.mNeedsPreDrawListener) {
        if(this.mOnPreDrawListener == null) {
            this.mOnPreDrawListener = new CoordinatorLayout.OnPreDrawListener();
    }

    ViewTreeObserver vto = this.getViewTreeObserver();
    vto.addOnPreDrawListener(this.mOnPreDrawListener);
    }

    this.mIsAttachedToWindow = true;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;主要是在onAttachedToWindow里。也就是说在coordinatorlayout绑定到窗口是，就会直接注册这个监听，每次要绘制view之前都会i调用dispatchOnDependentViewChanged方法。现在再来看一下刚才提到的dispatchOnDependentViewChanged的具体实现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;void dispatchOnDependentViewChanged(boolean fromNestedScroll) {
    int layoutDirection = ViewCompat.getLayoutDirection(this);
    int childCount = this.mDependencySortedChildren.size();

    for(int i = 0; i &amp;lt; childCount; ++i) {
        View child = (View)this.mDependencySortedChildren.get(i);
        CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams)child.getLayoutParams();

        for(int oldRect = 0; oldRect &amp;lt; i; ++oldRect) {
        View newRect = (View)this.mDependencySortedChildren.get(oldRect);
        if(lp.mAnchorDirectChild == newRect) {
            this.offsetChildToAnchor(child, layoutDirection);
            }
        }

        Rect var14 = this.mTempRect1;
        Rect var15 = this.mTempRect2;
        this.getLastChildRect(child, var14);
        this.getChildRect(child, true, var15);
        if(!var14.equals(var15)) {
            this.recordLastChildRect(child, var15);

            for(int j = i + 1; j &amp;lt; childCount; ++j) {
                View checkChild = (View)this.mDependencySortedChildren.get(j);
                CoordinatorLayout.LayoutParams checkLp = (CoordinatorLayout.LayoutParams)checkChild.getLayoutParams();
                CoordinatorLayout.Behavior b = checkLp.getBehavior();
                if(b != null &amp;amp;&amp;amp; b.layoutDependsOn(this, checkChild, child)) {
                    if(!fromNestedScroll &amp;amp;&amp;amp; checkLp.getChangedAfterNestedScroll()) {
                        checkLp.resetChangedAfterNestedScroll();
                    } else {
                        boolean handled = b.onDependentViewChanged(this, checkChild, child);
                        if(fromNestedScroll) {
                        checkLp.setChangedAfterNestedScroll(handled);
                        }
                    }
                }
            }
        }
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;只看我们关心的部分，也就是最下边的for循环，可以看出coordinatorlayout会循环获取每个子view的behavior。然后在if中看到了b.layoutDependsOn，if里面有b.onDependentViewChanged。&lt;br&gt;也就是说，当view改变时，如果通过符合我们自己实现的某些条件（这个条件在layoutDependsOn中定义），就会调用onDependentViewChanged方法，实现我们需要的动作。&lt;/p&gt;
&lt;h2 id=&quot;滚动动作的实现&quot;&gt;&lt;a href=&quot;#滚动动作的实现&quot; class=&quot;headerlink&quot; title=&quot;滚动动作的实现&quot;&gt;&lt;/a&gt;滚动动作的实现&lt;/h2&gt;&lt;p&gt;下面就是第二类，专门针对滚动动作的接口&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout, V child, View directTargetChild, View target, int nestedScrollAxes) 
public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout, V child, View directTargetChild, View target, int nestedScrollAxes) 
public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target) 
public void onNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed)
public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dx, int dy, int[] consumed)
public boolean onNestedFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY, boolean consumed) 
public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY) 
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到有很多方法，针对各种不同的滚动以及不同的阶段。&lt;br&gt;这个单在coordinatorlayout中很难看清楚如何调用，因为它涉及到了，接口，以及其他的view。就从事件的源头看，也就是NestedScrollView。&lt;br&gt;首先看NestedScrollView，它实现了NestedScrollingChild接口，这个接口有很多方法，我们就找startNestedScroll这个方法，这个从名称来看，应该跟上边的onStartNestedScroll方法对应。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@Override
public boolean startNestedScroll(int axes) {
    return mChildHelper.startNestedScroll(axes);
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;先看看哪里调用了这个方法，果然是touch事件触发的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {   
    final int action = ev.getAction();
    switch (action &amp;amp; MotionEventCompat.ACTION_MASK) {
        case MotionEvent.ACTION_DOWN: {
            startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
            break;
        }
    }
    return mIsBeingDragged;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;再跟进这个方法，可以看到是在NestedScrollingChildHelper中实现的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public boolean startNestedScroll(int axes) {
    if (hasNestedScrollingParent()) {
        // Already in progress
        return true;
    }
    if (isNestedScrollingEnabled()) {
        ViewParent p = mView.getParent();
        View child = mView;
        while (p != null) {
            if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {
                mNestedScrollingParent = p;
                ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
                return true;
            }
            if (p instanceof View) {
                child = (View) p;
            }
            p = p.getParent();
        }
    }
    return false;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这个方法主要是循环网上找parent，直到符合条件，条件就是ViewParentCompat.onStartNestedScroll(p, child, mView, axes)，具体看一下这个方法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
    int nestedScrollAxes) {
    return IMPL.onStartNestedScroll(parent, child, target, nestedScrollAxes);
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;再往下点：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;static final ViewParentCompatImpl IMPL;
static {
    final int version = Build.VERSION.SDK_INT;
    if (version &amp;gt;= 21) {
        IMPL = new ViewParentCompatLollipopImpl();
    } else if (version &amp;gt;= 19) {
        IMPL = new ViewParentCompatKitKatImpl();
    } else if (version &amp;gt;= 14) {
        IMPL = new ViewParentCompatICSImpl();
    } else {
        IMPL = new ViewParentCompatStubImpl();
    }
}    
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这里是一个版本判断。我们app支持的最小版本是16，所以肯定看第三个：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@Override
public boolean onStartNestedScroll(ViewParent parent, View child, View target,int nestedScrollAxes) {
    if (parent instanceof NestedScrollingParent) {
        return ((NestedScrollingParent) parent).onStartNestedScroll(child, target,nestedScrollAxes);
    }
    return false;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;所这里可以看到，如果想要实现滚动的关联，要求父view必须实现NestedScrollingParent接口，然后调用这个接口的onStartNestedScroll方法。&lt;br&gt;好了，现在再返回头来看：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public class CoordinatorLayout extends ViewGroup implements NestedScrollingParent 
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;CoordinatorLayout 刚好实现了这个接口，所以如果它的子view如果实现了NestedScrollingChild接口就可以实现滚动动作的联动了&lt;br&gt;再来看下这个方法的具体实现：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
    boolean handled = false;
    int childCount = this.getChildCount();

    for(int i = 0; i &amp;lt; childCount; ++i) {
        View view = this.getChildAt(i);
        CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams)view.getLayoutParams();
        CoordinatorLayout.Behavior viewBehavior = lp.getBehavior();
        if(viewBehavior != null) {
            boolean accepted = viewBehavior.onStartNestedScroll(this, view, child, target, nestedScrollAxes);
            handled |= accepted;
            lp.acceptNestedScroll(accepted);
        } else {
            lp.acceptNestedScroll(false);
        }
    }

    return handled;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到，最终还是通过调用其behavior中的onStartNestedScroll实现了具体的动作。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;h2 id=&quot;获取Behavior&quot;&gt;&lt;a href=&quot;#获取Behavior&quot; class=&quot;headerlink&quot; title=&quot;获取Behavior&quot;&gt;&lt;/a&gt;获取Behavior&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;CoordinatorLayout中子view关联
    
    </summary>
    
      <category term="Android" scheme="https://github.com/mjnhmd/categories/Android/"/>
    
    
      <category term="Material Designed" scheme="https://github.com/mjnhmd/tags/Material-Designed/"/>
    
      <category term="behavior" scheme="https://github.com/mjnhmd/tags/behavior/"/>
    
  </entry>
  
  <entry>
    <title>Handler实现原理</title>
    <link href="https://github.com/mjnhmd/2016/03/23/Handler%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86/"/>
    <id>https://github.com/mjnhmd/2016/03/23/Handler实现原理/</id>
    <published>2016-03-23T12:52:31.000Z</published>
    <updated>2016-04-13T11:01:26.848Z</updated>
    
    <content type="html">&lt;p&gt;今天在尝试把百度定位sdk的初始化转移到子线程时，遇到了一个问题：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;java.lang.RuntimeException: Can&amp;apos;t create handler inside thread that has not called Looper.prepare()
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这个问题并不少见，网上一搜有很多。&lt;br&gt;解决方法就是在创建handler时传入Looper.getMainLooper()。&lt;/p&gt;
&lt;p&gt;但是我发现我在子线程执行的代码里并没有创建handler，只是创建了一个百度sdk的定位类。&lt;br&gt;显然是在这个类里边创建了handler，导致了这个问题。显然这个方法解决不了我的问题，由于handler并不是我创建的，我并没有办法给它传进去一个looper。&lt;/p&gt;
&lt;p&gt;只能看一下后台的实现原理，决定怎么解&lt;/p&gt;
&lt;p&gt;首先看下源码，在哪里报的错：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public Handler(Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class&amp;lt;? extends Handler&amp;gt; klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &amp;amp;&amp;amp;
                (klass.getModifiers() &amp;amp; Modifier.STATIC) == 0) {
            Log.w(TAG, &amp;quot;The following Handler class should be static or leaks might occur: &amp;quot; +
                klass.getCanonicalName());
        }
    }

    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            &amp;quot;Can&amp;apos;t create handler inside thread that has not called Looper.prepare()&amp;quot;);
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到是在handler的构造函数中抛出的异常,从代码和错误内容都不难看出是获取looper失败。那么我们再看一下这个Looper.myLooper()方法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public static Looper myLooper() {
    return sThreadLocal.get();
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;它只是返回了一个线程里的looper，显然是这个线程里没有looper造成的。线程里的looper是在哪里设置的呢?我们通过错误的内容“has not called Looper.prepare()”可以推断出应该就是prepare()方法了：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public static void prepare() {
    prepare(true);
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException(&amp;quot;Only one Looper may be created per thread&amp;quot;);
    }
    sThreadLocal.set(new Looper(quitAllowed));
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这里可以看到一个线程里只能有一个looper。&lt;/p&gt;
&lt;p&gt;那么Looper到底是干嘛的呢？&lt;br&gt;首先我们都知道收到消息都是在handleMessage()方法处理的。我们就从最熟悉的地方找起，handleMessage方法是在哪调的呢：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;可以看到是在dispatchMessage(Message msg)里调用的。这里先判断有没有callback，也就是Runnable，如果自己写了runnable，那么就交由runnable处理&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;private static void handleCallback(Message message) {
    message.callback.run();
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;如果没有，则调用handleMessage()方法。&lt;/p&gt;
&lt;p&gt;继续往上找， dispatchMessage(Message msg)是在这里调用的：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException(&amp;quot;No Looper; Looper.prepare() wasn&amp;apos;t called on this thread.&amp;quot;);
    }
    final MessageQueue queue = me.mQueue;

    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        msg.target.dispatchMessage(msg);
        msg.recycleUnchecked();
    }
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这里有很多代码，我们只捡关心的看，首先他拿到了当前的looper，然后从中获取了一个队列，也就是消息队列。可以知道一个looper里会有一个消息队列。然后是一个死循环，循环获取队列中的message，然后调用之前的dispatchMessage(msg)。这样就把整个过程连起来了：&lt;/p&gt;
&lt;p&gt;Looper维持一个消息队列，然后不断的从队列里边拿出消息，然后交给handelr处理。还差一点，就是队列里的消息是从哪来的呢。这个相信用过的人都知道，自然就是sendMessage：&lt;br&gt;     public final boolean sendMessage(Message msg)&lt;br&gt;    {&lt;br&gt;        return sendMessageDelayed(msg, 0);&lt;br&gt;    }&lt;br&gt;可以看到这是一个包装，经过一系列的调用链，最终调用到了&lt;br&gt;    queue.enqueueMessage(msg, uptimeMillis)&lt;br&gt;这个queue就是从looper里获取到的那个消息队列，这个方法里就是一个典型的队列链表操作：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt; boolean enqueueMessage(Message msg, long when) {
    synchronized (this) {
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;
        boolean needWake;
        if (p == null || when == 0 || when &amp;lt; p.when) {
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            needWake = mBlocked &amp;amp;&amp;amp; p.target == null &amp;amp;&amp;amp; msg.isAsynchronous();
            Message prev;
            for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when &amp;lt; p.when) {
                    break;
                }
                if (needWake &amp;amp;&amp;amp; p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }
    }
    return true;
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;好了现在就全明白了，handler拿着一个looper，不断地往looper手里的消息队列里放消息，looper拿着这个消息队列又不断地往出取，让handler来处理消息。&lt;/p&gt;
&lt;p&gt;至于最开始的问题，已经很简单了。只需要在线程中调用Looper.prepare()在线程中放一个looper,然后在最后执行Looper.loop()，让它不断的往出取消息就可以了。即使不直接往handler里传入looper，handler也会在构建时自动从线程中拿到looper。&lt;/p&gt;
</content>
    
    <summary type="html">
    
      &lt;p&gt;今天在尝试把百度定位sdk的初始化转移到子线程时，遇到了一个问题：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;java.lang.RuntimeException: Can&amp;apos;t create handler inside thread that has not called 
    
    </summary>
    
      <category term="Android" scheme="https://github.com/mjnhmd/categories/Android/"/>
    
    
      <category term="java" scheme="https://github.com/mjnhmd/tags/java/"/>
    
  </entry>
  
</feed>