npm config set registry=https://registry.npm.taobao.org/

npm config set ELECTRON_MIRROR=http://npm.taobao.org/mirrors/electron/

/* main.js */
const { app, BrowserWindow } = require('electron')
const path = require('path')
const ipc = require('electron').ipcMain
const http = require('http');
const qs = require("qs")
const os = require('os');

// Keep a global reference of the window object, if you don't, the window will
// be closed automatically when the JavaScript object is garbage collected.
let mainWindow;
let server;

const initServer = () => {
    server = http.createServer(function (request, response) {
        // 定义了一个post变量，用于暂存请求体的信息
        let post = '';
        // 通过req的data事件监听函数，每当接受到请求体的数据，就累加到post变量中
        //当有数据请求时触发
        request.on('data', function (data) {
            post += data;
        });
        // 在end事件触发后，通过querystring.parse将post解析为真正的POST请求格式，然后向客户端返回。
        request.on('end', function () {
            //解析为post对象
            post = JSON.parse(post);
            //将对象转化为字符串
            response.writeHead(200, { 'Content-Type': 'text-plain' });
            response.end('{"status":200}\n');
            mainWindow.webContents.send("flightdata", post)
        });
    }).listen(8124);
}


const createWindow = () => {
    // Create the browser window.
    mainWindow = new BrowserWindow({
        fullscreen: false,
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false
        }
    });

    // and load the index.html of the app.
    mainWindow.loadFile("./build/index.html");

    // mainWindow.maximize()
    mainWindow.removeMenu()
    // mainWindow.webContents.openDevTools()
    mainWindow.webContents.openDevTools({mode:'right'});
    // Emitted when the window is closed.
    mainWindow.on('closed', () => {
        // Dereference the window object, usually you would store windows
        // in an array if your app supports multi windows, this is the time
        // when you should delete the corresponding element.
        mainWindow = null;
    });
};

const initApp = () => {
    createWindow();
    initServer();
}

// This method will be called when Electron has finished
// initialization and is ready to create browser windows.
// Some APIs can only be used after this event occurs.
app.on('ready', initApp);

// Quit when all windows are closed.
app.on('window-all-closed', () => {
    // On OS X it is common for applications and their menu bar
    // to stay active until the user quits explicitly with Cmd + Q
    if (process.platform !== 'darwin') {
        app.quit();
    }
});

app.on('activate', () => {
    // On OS X it's common to re-create a window in the app when the
    // dock icon is clicked and there are no other windows open.
    if (mainWindow === null) {
        createWindow();
    }
});

这里面大部分逻辑你不用考虑，我以后的文章会讲到，而你只需要知道一点就行。

那就是我在这个mian中指定了一个静态网页，巧了！位置就在我们打包文件夹build下🤭。

// and load the index.html of the app.
    mainWindow.loadFile("./build/index.html");

然后配置package.json

{
    ...
    "main": "main.js",
    "homepage": "./",
    ...
}

分析：

main：配置刚才我们创建的Electron的入口文件main.js homepage：如果不配置的话，就会。。，em~~~~就会。。算了贴代码吧

...
    const publicUrlOrPath = getPublicUrlOrPath(
    process.env.NODE_ENV === 'development',
    require(resolveApp('package.json')).homepage,
    process.env.PUBLIC_URL
    );
    ...

<HashRouter getUserConfirmation={this.getConfirmation}>
        ...
    </HashRouter>

/* package.json */
 "scripts": {
    ...
    "electron": "electron ."
    ...
  },

Web view 用于加载和显示丰富的网络内容。例如，嵌入 HTML 和网站。Mail app 使用 web view 显示邮件中的 HTML 内容。

iOS 8 和 macOS 10.10 中引入了WebKit framework，用以取代UIWebView和WebView。同时，在两个平台上提供同一API。与UIWebView相比，WebKit 有以下优势：使用了与 Safari 一样的 JavaScript engine，在运行脚本前，将脚本编译为机器代码，速度更快；支持多进程架构，Web 内容在单独的线程中运行，WKWebView崩溃不会影响 app运行；能够以60fps滑动。另外，在 iOS 12 和 macOS 10.14中，UIWebView和WebView已经被正式弃用。

WebKit framework 提供了多个类和协议，用于在窗口中显示网络内容，并实现类似浏览器功能。例如，点击链接时显示链接内容，维护前进、后退列表，维护最近访问列表。加载网页内容时，异步从 HTTP 服务器请求内容，其响应 (response) 可能以增量、随机顺序到达，也可能因网络原因部分到达，而 WebKit 极大简化了这些过程。WebKit 框架还简化了显示各种 MIME 类型内容过程，以及管理视图中各元素滚动条。

WebKit 框架中的方法、函数只能在主线程或主队列中调用。

1. WKWebView
WKWebView是 WebKit framework 的核心。在 app 内使用WKWebView插入网络内容步骤如下：

1、创建WKWebView对象。
2、将WKWebView设置为要显示的视图。
3、向WKWebView发送加载 Web 内容的请求。

使用initWithFrame:configuration:方法创建WKWebView，使用loadHTMLString:baseURL:加载本地HTML文件，或使用loadRequest:方法加载网络内容。如下：

// Local HTMLs
    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds configuration:self.webConfiguration];
    self.view = webView;
    NSURL *htmlURL = [[NSBundle mainBundle] URLForResource:@"WKWebView - NSHipster" withExtension:@"htm"];
    NSURL *baseURL = [htmlURL URLByDeletingLastPathComponent];
    NSString *htmlString = [NSString stringWithContentsOfURL:htmlURL
                                                    encoding:NSUTF8StringEncoding
                                                       error:NULL];
    [webView loadHTMLString:htmlString baseURL:baseURL];
    
    // Web Content
    WKWebView *webView = [[WKWebView alloc] initWithFrame:self.view.bounds configuration:self.webConfiguration];
    self.view = webView;
    NSURL *myURL = [NSURL URLWithString:@"https://github.com/pro648/tips/wiki"];
    NSURLRequest *request = [NSURLRequest requestWithURL:myURL
                                             cachePolicy:NSURLRequestUseProtocolCachePolicy
                                         timeoutInterval:30];
    [webView loadRequest:request];

本地HTML文件可以在demo源码中获取：https://github.com/pro648/BasicDemos-iOS/tree/master/WebKit

如图所示：

设置allowsBackForwardNavigationGestures属性可以开启、关闭横向滑动触发前进、后退导航功能：

self.webView.allowsBackForwardNavigationGestures = YES;

1.1 KVO

WKWebView中的title、URL、estimatedProgress、hasOnlySecureContent和loading

属性支持键值观察，可以通过添加观察者，获得当前网页标题、加载进度等。

根据文档serverTrust属性也支持KVO，但截至目前，在iOS 12.1 (16B91)中使用观察者观察该属性，运行时会抛出this class is not key value coding-compliant for the key serverTrust的异常。

将网页标题显示出来可以帮助用户了解当前所在位置，显示当前导航进度能够能够让用户感受到加载速度，另外，还可以观察hasOnlySecureContent查看当前网页所有资源是否均通过加密连接传输。在viewDidLoad中添加以下代码：

[self.webView addObserver:self forKeyPath:@"hasOnlySecureContent" options:NSKeyValueObservingOptionNew context:webViewContext];
    [self.webView addObserver:self forKeyPath:@"title" options:NSKeyValueObservingOptionNew context:webViewContext];
    [self.webView addObserver:self forKeyPath:@"estimatedProgress" options:NSKeyValueObservingOptionNew context:webViewContext];

实现observerValueForKeyPath:ofObject:change:context:方法，在观察到值变化时进行对应操作：

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    if ([keyPath isEqualToString:@"hasOnlySecureContent"]) {
        BOOL onlySecureContent = [[change objectForKey:NSKeyValueChangeNewKey] boolValue];
        NSLog(@"onlySecureContent:%@",onlySecureContent ? @"YES" : @"NO");
    } else if ([keyPath isEqualToString:@"title"]) {
        self.navigationItem.title = change[NSKeyValueChangeNewKey];
    } else if ([keyPath isEqualToString:@"estimatedProgress"]) {
        self.progressView.hidden = [change[NSKeyValueChangeNewKey] isEqualToNumber:@1];
        
        CGFloat progress = [change[NSKeyValueChangeNewKey] floatValue];
        self.progressView.progress = progress;
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

如果你对键值观察、键值编码还不熟悉，可以查看我的另一篇文章：KVC和KVO学习笔记

运行demo，如下所示：

控制台会输出如下内容：

onlySecureContent:YES

WKWebView调用reload、stopLoading、goBack、goForward可以实现刷新、返回、前进等功能：

- (void)refreshButtonTapped:(id)sender {
    [self.webView reload];
}

- (void)stopLoadingButtonTapped:(id)sender {
    [self.webView stopLoading];
}

- (IBAction)backButtonTapped:(id)sender {
    [self.webView goBack];
}

- (IBAction)forwardButtonTapped:(id)sender {
    [self.webView goForward];
}

还可以通过观察loading属性，在视图加载完成时，更新后退、前进按钮状态：

- (void)viewDidLoad {
    ...
    
    [self.webView addObserver:self forKeyPath:@"loading" options:NSKeyValueObservingOptionNew context:webViewContext];
}
    
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey,id> *)change context:(void *)context {
    ...
    if (context == webViewContext && [keyPath isEqualToString:@"loading"]) {
        BOOL loading = [change[NSKeyValueChangeNewKey] boolValue];
        // 加载完成后，右侧为刷新按钮；加载过程中，右侧为暂停按钮。
        self.navigationItem.rightBarButtonItem = loading ? self.stopLoadingButton : self.refreshButton;
        
        self.backButton.enabled = self.webView.canGoBack;
        self.forwardButton.enabled = self.webView.canGoForward;
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

1.2 截取网页视图

在iOS 11和macOS High Sierra中，WebKit framework增加了takeSnapshotWithConfiguration:completionHandler: API用于截取网页视图。截取网页可见部分视图方法如下：

- (IBAction)takeSnapShot:(UIBarButtonItem *)sender {
    WKSnapshotConfiguration *shotConfiguration = [[WKSnapshotConfiguration alloc] init];
    shotConfiguration.rect = CGRectMake(0, 0, self.webView.bounds.size.width, self.webView.bounds.size.height);
    
    [self.webView takeSnapshotWithConfiguration:shotConfiguration
                              completionHandler:^(UIImage * _Nullable snapshotImage, NSError * _Nullable error) {
                                  // 保存截图至相册，需要在info.plist中添加NSPhotoLibraryAddUsageDescription key和描述。
                                  UIImageWriteToSavedPhotosAlbum(snapshotImage, NULL, NULL, NULL);
                              }];
}

此前，截取网页视图需要结合图层和graphics context。现在，只需要调用单一API。

1.3 执行JavaScript

可以使用evaluateJavaScript:completionHandler:方法触发web view JavaScript。下面方法触发输出web view userAgent:

[self.webView evaluateJavaScript:@"navigator.userAgent" completionHandler:^(id _Nullable userAgent, NSError * _Nullable error) {
        NSLog(@"%@",userAgent);
    }];

在iOS 12.1.2 (16C101) 中，输出如下：

Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/16C101

2. WKWebViewConfiguration

WKWebViewConfiguration是用于初始化Web视图属性的集合。通过WKWebViewConfiguration类，可以设置网页渲染速度，视频是否自动播放，HTML5 视频是否一帧一帧播放，如何与本地代码通信等。

WKWebViewConfiguration属性有偏好设置preference、线程池processPool和用户内容控制器userContentController等。

Web view 初始化时才需要WKWebViewConfiguration对象，WKWebView创建后无法修改其configuration。多个WKWebView可以使用同一个configuration。

例如，设置网页中最小字体为30，自动检测电话号码：

- (WKWebViewConfiguration *)webConfiguration {
    if (!_webConfiguration) {
        _webConfiguration = [[WKWebViewConfiguration alloc] init];
        
        // 偏好设置 设置最小字体
        WKPreferences *preferences = [[WKPreferences alloc] init];
        preferences.minimumFontSize = 30;
        _webConfiguration.preferences = preferences;
        
        // 识别网页中的电话号码
        _webConfiguration.dataDetectorTypes = WKDataDetectorTypePhoneNumber;
        
        // Web视图内容完全加载到内存之前，禁止呈现。
        _webConfiguration.suppressesIncrementalRendering = YES;
    }
    return _webConfiguration;
}

suppressesIncrementalRendering属性是布尔值，决定Web视图内容在完全加载到内存前是否显示，默认为NO，即边加载边显示。例如，Web视图中有文字和图片，会先显示文字后显示图片。

3. Scripts

用户脚本 (User Scripts) 是文档开始加载或加载完成后注入 Web 页面的 JS。User Scripts非常强大，其能够通过客户端设置网页，允许注入事件监听器，甚至可以注入脚本，这些脚本又可以回调 native app 。

3.1 WKUserScript

WKUserScript对象表示可以注入网页的脚本。initWithSource:injectionTime:forMainFrameOnly:方法返回可以添加到userContentController控制器的脚本。其中，source 参数为 script 源码；injectionTime为WKUserScriptInjectionTimeAtDocumentStart、WKUserScriptInjectionTimeAtDocumentEnd，

其参数如下：

source: script 源码。
injectionTime: user script注入网页时间，为WKUserScriptInjectionTime枚举常量。WKUserScriptInjectionTimeAtDocumentStart在创建文档元素之后，加载任何其他内容之前注入。WKUserScriptInjectionTimeAtDocumentEnd在加载文档后，但在加载其他子资源之前注入。
forMainFrameOnly: 布尔值，YES时只注入main frame，NO时注入所有 frame。
下面代码将隐藏 Wikipedia toc、mw-panel 脚本注入网页，同时使用 JS 提取网页 toc 表格内容：

// 隐藏wikipedia左边缘和contents表格
        NSURL *hideTableOfContentsScriptURL = [[NSBundle mainBundle] URLForResource:@"hide" withExtension:@"js"];
        NSString *hideTableOfContentsScriptString = [NSString stringWithContentsOfURL:hideTableOfContentsScriptURL
                                                                             encoding:NSUTF8StringEncoding error:NULL];
        WKUserScript *hideTableOfContentsScript = [[WKUserScript alloc] initWithSource:hideTableOfContentsScriptString
                                                                         injectionTime:WKUserScriptInjectionTimeAtDocumentStart
                                                                      forMainFrameOnly:YES];
        
        // 获取contents表格内容
        NSString *fetchTableOfContentsScriptString = [NSString stringWithContentsOfURL:[[NSBundle mainBundle] URLForResource:@"fetch" withExtension:@"js"] encoding:NSUTF8StringEncoding error:NULL];
        WKUserScript *fetchTableOfContentsScript = [[WKUserScript alloc] initWithSource:fetchTableOfContentsScriptString
                                                                          injectionTime:WKUserScriptInjectionTimeAtDocumentEnd
                                                                       forMainFrameOnly:YES];

本文中的 js 和 HTML 均可通过文章底部源码链接获取。要使用 JavaScript 提取内容的网页为：https://en.wikipedia.org/w/index.php?title=San_Francisco&mobileaction=toggle_view_desktop

3.2 WKUserContentController
WKUserContentController对象为 JavaScript 提供了发送消息至 native app，将 user scripts 注入 Web 视图方法。

将 user script 添加到userContentController才可以注入网页中：

WKUserContentController *userContentController = [[WKUserContentController alloc] init];
        [userContentController addUserScript:hideTableOfContentsScript];
        [userContentController addUserScript:fetchTableOfContentsScript];

要监听 JavaScript 消息，需要先注册要监听消息名称。添加监听事件方法为addScriptMessageHandler:name:，参数如下：

scriptMessageHandler: 处理监听消息，该类需要遵守WKMessageHandler协议。
name: 要监听消息名称。
使用该方法添加监听事件后，JavaScript 的 window.webkit.messageHandlers.name.postMessage(messageBody) 函数将被定义在使用了该userContentController网页视图的所有frame。

监听fetch.js中 didFetchTableOfContents 消息：

[userContentController addScriptMessageHandler:self name:@"didFetchTableOfContents"];
        
        // 最后，将userContentController添加到WKWebViewConfiguration
        _webConfiguration.userContentController = userContentController;

3.3 WKScriptMessageHandler

监听 script message 的类必须遵守WKMessageHandler协议，实现该协议唯一且必须实现的userContentController:didReceiveScriptMessage:方法。Webpage 接收到脚本消息时会调用该方法。

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message {
    if ([message.name isEqualToString:@"didFetchTableOfContents"]) {
        id body = message.body;
        if ([body isKindOfClass:NSArray.class]) {
            NSLog(@"messageBody:%@",body);
        }
    }
}

如下所示：

JavaScript 消息是WKScriptMessage对象，该对象属性如下：

body：消息内容，可以是NSNumber、NSString、NSDate、NSArray、NSDictionary、NSNull类型。
frameInfo：发送该消息的frame。
name：接收消息对象名称。
webView：发送该消息的网页视图。
最终，我们成功的将事件从 iOS 转发到 JavaScript，并将 JavaScript 转发回 iOS。

4. WKNavigationDelegate

用户点击链接，使用前进、后退手势，JavaScript 代码(例如，window.location = ' https://github.com/pro648 ')，使用代码调用loadRequest:等均会让网页加载内容，即action引起网页加载；随后，web view 会向服务器发送request，接收response，可能会是positive response，也可能请求失败；之后接收数据。我们的应用可以在action后、request前，或者response后、data前自定义网页加载，决定继续加载，或取消加载。

WKNavigationDelegate协议内方法可以自定义Web视图接收、加载和完成导航请求过程的行为。

首先，声明遵守WKNavigationDelegate协议：

@interface ViewController () <WKNavigationDelegate>

其次，指定遵守WKNavigationDelegate协议的类为 web view 代理：

self.webView.navigationDelegate = self;

最后，根据需要实现所需WKNavigationDelegate方法。

webView:decidePolicyForNavigationAction:decisionHandler:方法在action后响应，webView:decidePolicyForNavigationResponse:decisionHandler:方法在response后响应。

根据前面的配置，WKWebView会自动识别网页中电话号码。截至目前，电话号码只能被识别，无法点击。可以通过实现webView:decidePolicyForNavigationAction:decisionHandler:方法，调用系统Phone app拨打电话

- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler {
    if (navigationAction.navigationType == WKNavigationTypeLinkActivated && [navigationAction.request.URL.scheme isEqualToString:@"tel"]) {
        [UIApplication.sharedApplication openURL:navigationAction.request.URL options:@{} completionHandler:^(BOOL success) {
            NSLog(@"Successfully open url:%@",navigationAction.request.URL);
        }];
        decisionHandler(WKNavigationActionPolicyCancel);
    } else {
        decisionHandler(WKNavigationActionPolicyAllow);
    }
}

实现了该方法后，必须调用decisionHandler块。该块参数为WKNavigationAction枚举常量。WKNavigationActionPolicyCancel取消导航，WKNavigationActionPolicyAllow继续导航。

WKNavigationAction对象包含引起本次导航的信息，用于决定是否允许本次导航。其属性如下：

request：本次导航的request。
sourceFrame：WKFrameInfo类型，请求本次导航frame信息。
targetFrame：目标frame。如果导航至新窗口，则targetFrame为nil。
navigationType：WKNavigationType枚举类型，为以下常量：
WKNavigationTypeLinkActivated：用户点击href链接。
WKNavigationTypeFormSubmitted：提交表格。
WKNavigationTypeBackForward：请求前进、后退列表中item。
WKNavigationTypeReload：刷新网页。
WKNavigationTypeFormResubmitted：因后退、前进、刷新等重新提交表格。
WKNavigationTypeOther：其他原因。
WKFrameInfo对象包含了一个网页中的frame信息，其只是一个描述瞬时状态 (transient) 的纯数据 (data-only) 对象，不能在多次消息调用中唯一标志某个frame。

如果需要在response后操作导航，需要实现webView:decidePolicyForNavigationResponse:decisionHandler:方法。WKNavigationResponse对象包含navigation response信息，用于决定是否接收response。其属性如下：

canShowMIMEType：布尔类型值，指示WebKit是否显示MIME类型内容。
forMainFrame：布尔类型值，指示即将导航至的frame是否为main frame。
response：NSURLResponse类型。
实现了该方法后，必须调用decisionHandler块，否则会在运行时抛出异常。decisionHandler块参数为WKNavigationResponsePolicy枚举类型。WKNavigationResponseCancel取消导航，WKNavigationResponseAllow继续导航。

Navigation action 和 navigation response 既可以在处理完毕后立即调用decisionHandler，也可以异步调用。

5. WKUIDelegate

WKWebView与 Safari 类似，尽管前者在一个窗口显示内容。如果需要打开多个窗口、监控打开、关闭窗口，修改用户点击元素时显示哪些选项，需要使用WKUIDelegate协议。

首先，声明遵守WKUIDelegate协议：

@interface ViewController () <WKUIDelegate>

其次，指定遵守WKUIDelegate协议的类为 web view 代理：

self.webView.uiDelegate = self;

最后，根据需要实现WKUIDelegate协议内方法。

5.1 新窗口打开

如何响应 JavaScript 的打开新窗口函数、或target="_blank"标签？有以下三种方法：

创建新的WKWebView，并在新的页面打开。
在 Safari 浏览器打开。
捕捉 JS ，在同一个WKWebView加载。
当 URL 为 mail、tel、sms 和 iTunes链接时交由系统处理。此时，系统会交由对应 app 处理。其他情况在当前 web view 加载。

5.2 响应 JavaScript 弹窗
在响应 JavaScript 时，可以通过WKUIDelegate协议使用 native UI呈现，有以下三种方法：

1、webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板应只包含一个OK按钮。当 alert panel 消失后，调用completionHandler。
2、webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板包括两个按钮，一般为OK和Cancel。当 alert panel 消失后，调用completionHandler。如果用户点击的是OK按钮，为completionHandler传入YES；如果用户点击的是Cancel按钮，为completionHandler传入NO。
3、webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:completionHandler:：为了用户安全，在该方法的实现中需要需要标志出提供当前内容的网址，最为简便的方法便是frame.request.URL.host，响应面板包括两个按钮（一个OK按钮，一个Cancel按钮）和一个输入框。当面板消失时调用completionHandler，如果用户点击的是OK按钮，传入文本框文本；否则，传入nil。

例如，输入账号、密码前点击登陆按钮，大部分网页会弹出警告框。在 JavaScript 中，会弹出 alert 或 confirm box。

JavaScript alert 会堵塞当前进程，调用completionHandler后 JavaScript 才会继续执行。

6. WKURLSchemeHandler

UIWebView支持自定义NSURLProtocol协议。如果想要加载自定义 URL 内容，可以通过创建、注册NSURLProtocol子类实现。此后，任何调用自定义 scheme (例如，hello world://) 的方法，都会调用NSURLProtocol子类，在NSURLProtocol子类处理自定义 scheme ，这将非常实用。例如，在 book 中加载图片、视频等。

WKWebView不支持NSURLProtocol协议，因此不能加载自定义 URL Scheme。在 iOS 11 中，Apple 为 WebKit framework 增加了WKURLSchemeHandler协议，用于加载自定义 URL Scheme。

WebKit遇到无法识别的 URL时，会调用WKURLSchemeHandler协议。该协议包括以下两个必须实现的方法：

webView:startURLSchemeTask:：加载资源时调用。
webView:stopURLSchemeTask:：WebKit 调用该方法以终止 (stop) 任务。调用该方法后，不得调用WKURLSchemeTask协议的任何方法，否则会抛出异常。
使用WKURLSchemeHandler协议处理完毕任务后，调用WKURLSchemeTask协议内方法加载资源。WKURLSchemeTask协议包括request属性，该属性为NSURLRequest类型对象。还包含以下方法：

didReceiveResponse:：设置当前任务的 response。每个 task 至少调用一次该方法。如果尝试在任务终止或完成后调用该方法，则会抛出异常。
didReceiveData:：设置接收到的数据。当接收到任务最后的 response 后，使用该方法发送数据。每次调用该方法时，新数据会拼接到先前收到的数据中。如果尝试在发送 response 前，或任务完成、终止后调用该方法，则会引发异常。
didFinish：将任务标记为成功完成。如果尝试在发送 response 前，或将已完成、终止的任务标记为完成，则会引发异常。
didFailWithError:：将任务标记为失败。如果尝试将已完成、失败，终止的任务标记为失败，则会引发异常。
在WKURLSchemeHandler协议方法内，可以获取到请求的request。因此，可以提取 URL 中任何内容，并将数据转发给WKWebView进行加载。

下面的方法分别使用 url 、custom URL Scheme加载网络图片和相册图片：

- (void)webView:(WKWebView *)webView startURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
        NSURL *url = urlSchemeTask.request.URL;
        if ([url.absoluteString containsString:@"custom-scheme"]) {
            NSArray<NSURLQueryItem *> *queryItems = [NSURLComponents componentsWithURL:url resolvingAgainstBaseURL:YES].queryItems;
            for (NSURLQueryItem *item in queryItems) {
                
                // example: custom-scheme://path?type=remote&url=https://placehold.it/120x120&text=image1
                if ([item.name isEqualToString:@"type"] && [item.value isEqualToString:@"remote"]) {
                    for (NSURLQueryItem *queryParams in queryItems) {
                        if ([queryParams.name isEqualToString:@"url"]) {
                            NSString *path = queryParams.value;
                            path = [path stringByReplacingOccurrencesOfString:@"\\" withString:@""];
                            
                            // 获取图片
                            NSURLSession *session = [NSURLSession sharedSession];
                            NSURLSessionDataTask *task = [session dataTaskWithURL:[NSURL URLWithString:path] completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
                                [urlSchemeTask didReceiveResponse:response];
                                [urlSchemeTask didReceiveData:data];
                                [urlSchemeTask didFinish];
                            }];
                            [task resume];
                        }
                    }
                } else if ([item.name isEqualToString:@"type"] && [item.value isEqualToString:@"photos"]) { // example: custom-scheme://path?type=photos
                    dispatch_async(dispatch_get_main_queue(), ^{
                        self.imagePicker = [[ImagePicker alloc] init];
                        [self.imagePicker showGallery:^(BOOL flag, NSURLResponse * _Nonnull response, NSData * _Nonnull data) {
                            if (flag) {
                                [urlSchemeTask didReceiveResponse:response];
                                [urlSchemeTask didReceiveData:data];
                                [urlSchemeTask didFinish];
                            } else {
                                NSError *error = [NSError errorWithDomain:urlSchemeTask.request.URL.absoluteString code:0 userInfo:NULL];
                                [urlSchemeTask didFailWithError:error];
                            }
                        }];
                    });
                }
            }
        }
    });
}

- (void)webView:(WKWebView *)webView stopURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
    NSError *error = [NSError errorWithDomain:urlSchemeTask.request.URL.absoluteString code:0 userInfo:NULL];
    [urlSchemeTask didFailWithError:error];
}

实现上述方法的类必须遵守WKURLSchemeHandler协议。另外，必须在WKWebView的配置中注册所支持的 URL Scheme：

// 添加要自定义的url scheme
        [_webConfiguration setURLSchemeHandler:self forURLScheme:@"custom-scheme"];

运行如下：

总结

WebKit为 iOS 、macOS 开发人员提供了一套强大的开发工具，可以直接在 app 网页视图中操作 JavaScript，使用 user script 将 JavaScript 注入网页，使用WKScriptMessageHandler协议接收 JavaScript 消息。使用WKNavigationDelegate协议自定义网页导航，使用WKUIDelegate在网页上呈现 native UI，使用WKURLSchemeHandler加载自定义 URL Scheme 内容。

如果只是简单呈现网页视图，推荐使用 iOS 9 推出的SFSafariViewController，几行代码就可实现与 Safari 一样的体验。SFSafariViewController还提供了自动填充、欺诈网站监测等功能。

Demo名称：WebKit
源码地址：https://github.com/pro648/BasicDemos-iOS/tree/master/WebKit

链接：https://www.jianshu.com/p/65c66f924d56

pthread多线程(C语言) + Socket

pthread是使用使用C语言编写的多线程的API， 简称Pthreads ，是线程的POSIX标准，可以在Unix / Linux / Windows 等系统跨平台使用。在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthreads作为操作系统的线程。

GitHub项目FanSocket(纯C语言socket+线程队列)+其他demo客户端

1.线程创建

//子线程1
void test1(int *a){
    printf("线程test1");
    //修改自己的子线程系统释放，注释打开后，线程不能用pthread_join方法
    //pthread_detach(pthread_self());
}
//子线程2
void test2(int *a){
    printf("线程test2");
}

/*
int  pthread_create(pthread_t  *  thread, //新线程标识符
pthread_attr_t * attr, //新线程的运行属性
void * (*start_routine)(void *), //线程将会执行的函数
void * arg);//执行函数的传入参数，可以为结构体
*/

//创建线程方法一    （手动释放线程）
int a=10;
pthread_t pid;
pthread_create(&pid, NULL, (void *)test1, (void *)&a);


//线程退出或返回时，才执行回调，可以释放线程占用的堆栈资源（有串行的作用）
if(pthread_join(pid, NULL)==0){
    //线程执行完成
    printf("线程执行完成：%d\n",threadIndex);
    if (message!=NULL) {
        printf("线程执行完成了\n");
    }
}


//创建线程方法二  （自动释放线程）
//设置线程属性
pthread_attr_t attr;
pthread_attr_init (&attr);
//线程默认是PTHREAD_CREATE_JOINABLE，需要pthread_join来释放线程的
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
//线程并发
int rc=pthread_create(&pid, &attr, (void *)test2, (void *)a);
pthread_attr_destroy (&attr);
if (rc!=0) {
    printf("创建线程失败\n");
    return;
}

2.线程退出和其他

pthread_exit (tes1) //退出当前线程
pthread_main_np () // 获取主线程

//主线程和子线程
if(pthread_main_np()){
    //main thread
}else{
    //others thread
}

int pthread_cancel(pthread_t thread)；//发送终止信号给thread线程,如果成功则返回0
int pthread_setcancelstate(int state, int *oldstate)；//设置本线程对Cancel信号的反应
int pthread_setcanceltype(int type, int *oldtype)；//设置本线程取消动作的执行时机
void pthread_testcancel(void)；//检查本线程是否处于Canceld状态，如果是，则进行取消动作，否则直接返回

3 线程互斥锁（量）与条件变量

3.1 互斥锁(量)

//静态创建
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
//动态创建
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
//注销互斥锁
int pthread_mutex_destroy(pthread_mutex_t *mutex);

//lock 和unlock要成对出现，不然会出现死锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
//判断是否可以加锁，如果可以加锁并返回0，否则返回非0
int pthread_mutex_trylock(pthread_mutex_t *mutex);

3.2 条件变量

1、条件变量是利用线程间共享的全局变量进行同步的一种机制，
2、一个线程等待”条件变量的条件成立”而挂起；
3、另一个线程使”条件成立”（给出条件成立信号）。
4、为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。

//静态创建
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
//动态创建
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
//注销条件变量
int pthread_cond_destroy(pthread_cond_t *cond);
//条件等待，和超时等待
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, 
                           const struct timespec *abstime);
//开启条件，启动所有等待线程
int pthread_cond_broadcast(pthread_cond_t *cond);
//开启一个等待信号量
int pthread_cond_signal(pthread_cond_t *cond);

4.线程同步：互斥锁（量）与条件变量(具体封装实现)

/*全局的队列互斥条件*/
extern pthread_cond_t fan_cond;
extern pthread_cond_t fan_cond_wait;
/*全局的队列互斥锁*/
extern pthread_mutex_t fan_mutex;
//extern pthread_mutex_t fan_mutex_wait;

extern int fan_thread_status;//0=等待 1=执行 -1=清空所有
extern int fan_thread_clean_status;//0=默认  1=清空所有

//开启线程等待  return=-2一定要处理
extern int fan_thread_start_wait(void);
//正常的超时后继续打开下一个信号量 return=-2一定要处理
int fan_thread_start_timedwait(int sec);
//启动线程，启动信号量
extern int fan_thread_start_signal(void);
//启动等待信号量
extern int fan_thread_start_signal_wait(void);
//暂停线程
extern int fan_thread_end_signal(void);
//初始化互斥锁
extern int fan_thread_queue_init(void);
//释放互斥锁信号量
extern int fan_thread_free(void);

//让队列里面全部执行完毕，而不是关闭线程；
extern int fan_thread_clean_queue(void);
//每次关闭清空后，等待1-2秒，要恢复状态，不然线程添加
extern int fan_thread_init_queue(void);
//设置线程的优先级，必须在子线程
extern int fan_thread_setpriority(int priority);

线程队列互斥，并且按入队顺序，一个一个按照外部条件，触发信号量，主要是等待队列，

/*全局的队列互斥条件*/
pthread_cond_t fan_cond=PTHREAD_COND_INITIALIZER;
pthread_cond_t fan_cond_wait=PTHREAD_COND_INITIALIZER;

/*全局的队列互斥锁*/
pthread_mutex_t fan_mutex = PTHREAD_MUTEX_INITIALIZER;
//pthread_mutex_t fan_mutex_wait = PTHREAD_MUTEX_INITIALIZER;
int fan_thread_status=1;//0=等待 1=执行
int fan_thread_clean_status;//0=默认  1=清空所有

//开启线程等待
int fan_thread_start_wait(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=0;
    while (fan_thread_status==0) {
        pthread_cond_wait(&fan_cond, &fan_mutex);
        if (fan_thread_clean_status==1) {
            break;
        }
    }
    if (fan_thread_clean_status==1) {
        pthread_mutex_unlock(&fan_mutex);
        return -2;
    }
    if (fan_thread_status==1) {
        fan_thread_status=0;
        pthread_mutex_unlock(&fan_mutex);
    }else{
        pthread_mutex_unlock(&fan_mutex);
    }
    return 0;
}
//正常的超时后继续打开下一个信号量
int fan_thread_start_timedwait(int sec){
    int rt=0;
    pthread_mutex_lock(&fan_mutex);
    struct timeval now;
    struct timespec outtime;
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + sec;
    outtime.tv_nsec = now.tv_usec * 1000;
    
    int result = pthread_cond_timedwait(&fan_cond_wait, &fan_mutex, &outtime);
    if (result!=0) {
        //线程等待超时
        rt=-1;
    }
    if (fan_thread_clean_status==1) {
        rt = -2;
    }
    pthread_mutex_unlock(&fan_mutex);
    return rt;
}
//启动线程，启动信号量
int fan_thread_start_signal(void){
    int rs=pthread_mutex_trylock(&fan_mutex);
    if(rs!=0){
        pthread_mutex_unlock(&fan_mutex);
    }
    fan_thread_status=1;
    pthread_cond_signal(&fan_cond);
//    pthread_cond_broadcast(&fan_cond);//全部线程
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//开启等待时间的互斥信号量
int fan_thread_start_signal_wait(void){
    int rs=pthread_mutex_trylock(&fan_mutex);
    if(rs!=0){
        pthread_mutex_unlock(&fan_mutex);
    }
//    fan_thread_status=1;
    pthread_cond_signal(&fan_cond_wait);
    //    pthread_cond_broadcast(&fan_cond);//全部线程
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//暂停下一个线程
int fan_thread_end_signal(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_status=0;
    pthread_cond_signal(&fan_cond);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//初始化互斥锁（动态创建）
int fan_thread_queue_init(void){
    pthread_mutex_init(&fan_mutex, NULL);
    pthread_cond_init(&fan_cond, NULL);
    return 0;
}
//释放互斥锁和信号量
int fan_thread_free(void)
{
    pthread_mutex_destroy(&fan_mutex);
    pthread_cond_destroy(&fan_cond);
    return 0;
}

//清空所有的队列
int fan_thread_clean_queue(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=1;
    pthread_cond_broadcast(&fan_cond);
    pthread_cond_broadcast(&fan_cond_wait);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//恢复队列
int fan_thread_init_queue(void){
    pthread_mutex_lock(&fan_mutex);
    fan_thread_clean_status=0;
    fan_thread_status=1;
    pthread_cond_signal(&fan_cond);
    pthread_mutex_unlock(&fan_mutex);
    return 0;
}
//设置线程的优先级，必须在子线程
int fan_thread_setpriority(int priority){
    struct sched_param sched;
    bzero((void*)&sched, sizeof(sched));
//    const int priority1 = (sched_get_priority_max(SCHED_RR) + sched_get_priority_min(SCHED_RR)) / 2;
    sched.sched_priority=priority;
    //SCHED_OTHER(正常,非实时)SCHED_FIFO(实时，先进先出)SCHED_RR(实时、轮转法)
    pthread_setschedparam(pthread_self(), SCHED_RR, &sched);
    return 0;
}

5 其他线程方法

//return=0:线程存活。ESRCH：线程不存在。EINVAL：信号不合法。
int kill_ret=pthread_kill(pid, 0);//测试线程是否存在
printf("线程状态：%d\n",kill_ret);
if(kill_ret==0){
    //关闭线程
    pthread_cancel(pid);
}


pthread_equal(pid, pid1);//比较两个线程ID是否相同


//函数执行一次
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once(&once, test1);

转自：https://www.jianshu.com/p/6fcd478635e2

据财经媒体报道：FIL将在6月底进行系统升级，FIL升级对矿工有哪些利好？那对与刚了解FIL挖矿的朋友们现在正是参与的好时机+slf81818，为什么呢？一起来了解下：

Filecoin’s v13 HyperDrive网络升级的重要意义在于：

一：人类宝贵信息的可验证存储容量将增长10—25倍。

二：GAS费大幅降低，无限期限接近于0。

三：质押费快速下降，新进场的投入成本明显降低，更有利于生态发展。

四：参与存储商激增，将实现更快的网络增长。

五：三大运营商之一（移动电信联通）智慧城市的数据将接入储存IPFS系统，进一步促进IPFS的应用落地，或将成为IPFS历史级重大标志性事件。

Filecoin V13版本的更新将是颠覆性的，也是突破共识的一次更新。其目的也不仅仅是降低Gas费，而是释放带宽，为Filecoin添加智能合约功能做准备。

目前FIL市场的具体情况具体分析，大多数人都在观望，主要还是带着想要一夜暴富的想法去炒币。这完全是两个概念，炒币没有哪个不伤筋动骨，这还是要轻的，可以考虑一下它的恐怖程度！为什么说矿工总是食物链的顶端？合理的投资方式是看其长期收益，不需要过多地去看目前的价格高低，手中的矿机每天都能产出 FIL，不用管它涨跌，相反，炒币就是你买了多少就有多少，性质不同。

例如，买一只鸡来给你每天生蛋，头七天价格比以前低，把鸡蛋存起来不卖，第八天它的价格达到了你想要的市场价就全部卖掉，与此相反，你直接买鸡蛋来倒买倒卖，风险成本是显而易见的。炒币看运气，屯币看心态，矿机相当于永动机。

现在币价低，加入挖矿成本也会很低，最重要的是其日产币并未降低，反而还在增加产量，这也大大缩短了回本周期，未来币价上涨，矿机也将随之涨价，人多挖矿效率肯定不如现在人少，回本周期更是大幅拉长，挖矿最大优势在于自身持币增多，有“粮”就能度过寒冬，躲过熊市就是迎来资产爆发的喜悦。感谢大家关注芳姐+slf81818，了解更多币圈最新资讯。

前言

很高兴遇见你~

今天准备和大家分享的是 LayoutInflater，我给它取名：布局打气筒，很形象，其实就是根据英文翻译过来的😂。我们知道气球打气筒可以给气球打气从而改变它的形状。而布局打气筒的作用就是给我们的 Xml 布局打气让它变成一个个 View 对象。在我们的日常工作中，经常会接触到他，因为只要你写了 Xml 布局，你就要使用 LayoutInflater，下面我们就来好好讲讲它。

注意：本文所展示的系统源码都是基于Android-30 ，并提取核心部分进行分析

一、基本使用

1、LayoutInflater 实例获取

1）、通过 LayoutInflater 的静态方法 from 获取

2）、通过系统服务 getSystemService 方法获取

3）、如果是在 Activity 或 Fragment 可直接获取到实例

//1、通过 LayoutInflater 的静态方法 from 获取

val layoutInflater: LayoutInflater = LayoutInflater.from(this)



//2、通过系统服务 getSystemService 方法获取

val layoutInflater: LayoutInflater = getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater



//3、如果是在 Activity 或 Fragment 可直接获取到实例

layoutInflater //相当于调用 getLayoutInflater()

 

实际上，1 是 2 的简单写法，只是 Android 给我们做了一下封装。拿到 LayoutInflater 实例后，我们就可以调用它的 inflate 系列方法了，这几个方法是本篇文章的一个重点，如下：

从 Xml 布局到创建 View 对象，这几个方法扮演着至关重要的作用，其中我们用的最多就是第一个和第三个重载方法，现在我们就来使用一下

二、例子

1、创建一个新项目，MainActivity 对应的布局如下：

<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout

    xmlns:android="http://schemas.android.com/apk/res/android"

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

    android:id="@+id/cons_main"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    tools:context=".MainActivity"/>

 

2、创建一个新的布局取名 item_main.xml，如下图：

3、修改 MainActivity 中的代码

class MainActivity : AppCompatActivity() {

  

    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)

        setContentView(R.layout.activity_main)

      

        val consMain = findViewById<ConstraintLayout>(R.id.cons_main)

        val itemMain = layoutInflater.inflate(R.layout.item_main, null)

        consMain.addView(itemMain)

    }

}

 

上述代码我们使用了两个参数的 inflate 重载方法，第二个参数 root 传了一个 null ，然后把当前布局添加到 Activity 中，运行看下效果：

啥情况？怎么和预想的不一样呢？我的背景颜色怎么不见了？把这个问题 1 先记着

接下来，我们修改一下 MainActivity 中的代码，如下：

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain)

//等同下面这行代码

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain,true)

 

实际上上面这句代码就相当于调用了三个参数的重载方法，且第三个参数为 true，我们看下它两个参数的源码：

public View inflate(@LayoutRes int resource, @Nullable ViewGroup root) {

    return inflate(resource, root, root != null);

}

 

现在在运行看下结果：

报错了，提示我们当前 child 已经有了一个父 View，你必须先调用父 View 的 removeView 方法移除当前 child 才行。是不是疑问更多了呢？把这个问题 2 也先记着

我们在修改一下 MainActivity 中的代码，如下：

val itemMain = layoutInflater.inflate(R.layout.item_main, consMain,false)

 

在运行看下结果：

嗯，现在达到了我们预期的效果

现在回到上面那两个问题，分析发现是 LayoutInflater inflate 方法传了不同的参数导致的，那这些参数到底有什么玄乎的地方呢？接下来跟着我的脚步分析下源码，或许你就豁然开朗了

三、LayoutInflater inflate 系列方法源码分析

在分析源码之前，我们需要明白一些基础知识：

我们一般都会使用 layout_width 和 layout_height 来设置 View 的大小，实际上是要满足一个条件，那就是这个 View 必须存在于一个容器或布局中，否则没有意义，之后如果将 layout_width 设置成 match_parent 表示让 View 的宽度填充满布局，如果设置成 wrap_content 表示让 View 的宽度刚好可以包含其内容，如果设置成具体的数值则 View 的宽度会变成相应的数值。这也是为什么这两个属性叫作 layout_width 和layout_height，而不是 width 和 height 。

明白了上面这些知识，我们继续往下看

实际上，我们调用 LayoutInflater inflate 系列方法，最终都会走到上述截图的第 4 个重载方法，看下它的源码，仅贴出关键代码：

public View inflate(XmlPullParser parser, @Nullable ViewGroup root, boolean attachToRoot) {

    synchronized (mConstructorArgs) {

       //...

       //获取布局 Xml 里面的属性集合

       AttributeSet attrs = Xml.asAttributeSet(parser);

       // 将传入的 root 赋值 给 result 

       View result = root;

     

       // 创建根 View 赋值给 temp

       final View temp = createViewFromTag(root, name, inflaterContext, attrs);

			

       ViewGroup.LayoutParams params = null;

			

       if (root != null) {

           //...

           //如果传入的 root 不为空，通过 root 和布局属性生成布局参数

           params = root.generateLayoutParams(attrs);

           if (!attachToRoot) {

             	// 如果传入的 attachToRoot 为 false 则给当前创建的根 View 设置布局参数

                temp.setLayoutParams(params);

           }

       }

                  

       //递归创建子 View 并添加到父布局中

       rInflateChildren(parser, temp, attrs, true);



       if (root != null && attachToRoot) {

           //如果 root 不为空且 attachToRoot 为 true，添加当前创建的根 View 到 root      

           root.addView(temp, params);

       }



       if (root == null || !attachToRoot) {

           //如果 root 为空或者 attachToRoot 为 false, 将当前创建的根 View 赋值给 result

           result = temp;

       }

      

       //...

       //返回当前 result

       return result;

   }

}

 

上述代码我们可以得到一些结论：

1、如果传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 设置布局参数

注意：Xml 布局生成的根 View 并没有被添加到任何其他 View 中，此时根 View 的布局属性不会生效，但是我们给它设置了布局参数，那么它就会生效，只是没有被添加到任何其他 View 中

2、如果传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中

注意：此时 Xml 布局生成的根 View 已经被添加到其他 View 中，注意避免重复添加而报错

3、如果传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

注意：此时 Xml 布局生成的根 View 既没有被添加到其他 View 中，也没有设置布局参数，那么它的布局参数将会失效

明白了上面这些知识点，我们在看下为啥为会出现之前那些问题

四、问题分析

1、问题 1

上述问题 1 实际上我们是调用了 LayoutInflater 两个参数的 inflate 重载方法：

inflate(@LayoutRes int resource, @Nullable ViewGroup root)

 

传入的实参： resouce 传入了一个 Xml 布局，root 传入了 null

根据我们上面源码得到的结论，当传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

那么此时这个布局根 View 不在任何 View 中，因此它的布局属性失效了，但是 TextView 在一个布局中，它的布局属性会生效，因此就出现了上述截图中的效果

2、问题 2

上述问题 2 我们调用的还是 LayoutInflater 两个参数的构造方法

传入的实参： resouce 传入了一个 Xml 布局，root 传入了 consMain

实际又会调用 LayoutInflater 三个参数的 inflate 重载方法：

inflate(@LayoutRes int resource, @Nullable ViewGroup root,boolean attachToRoot)

 

此时传入实参变为：resouce 传入了一个 Xml 布局，root 传入了 consMain，attachToRoot 传入了 true

根据我们上面源码得到的结论：当传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中

此时我们在 MainActivity 中又重复调用了 addView 方法，因此就报那个错了。如果想不报错，把 MainActivity 中的那行 addView 去掉就可以了

3、预期效果

上述预期效果，我们调用的是 LayoutInflater 三个参数的 inflate 重载方法

传入的实参：resouce 传入了一个 Xml 布局，root 传入了 consMain，attachToRoot 传入了 false

根据我们上面源码得到的结论：当传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 对象设置布局参数

此时根 View 的布局属性会生效，只不过没有被添加到任何 View 中，而又因为 MainActivity 中调用了 addView 方法，把当前根 View 添加了进去，所以达到了我们预期的效果

到这里，你是否明白了 LayoutInflater inflate 方法的应用了呢？

如果还有疑问，欢迎评论区给我提问，我们一起讨论

五、为啥 Activity 中布局根 View 的布局属性会生效？

看下面这张图：

注意：Android 版本号和应用主题会影响到 Activity 页面组成，这里以常见页面为例

我们的页面中有一个顶级 View 叫 DecorView，DecorView 中包含一个竖直方向的 LinearLayout，LinearLayout 由两部分组成，第一部分是标题栏，第二部分是内容栏，内容栏是一个FrameLayout，我们在 Activity 中调用 setContentView 就是将 View 添加到这个FrameLayout 中。

看到这里你应该也明白了：Activity 中布局根 View 的布局属性之所以能生效，是因为 Android 会自动在布局文件的最外层再嵌套一个FrameLayout

六、总结

本篇文章重点内容：

1、 LayoutInflater inflate 方法参数的应用，记住下面这个规律：

• 当传入的 root 不为 null 且 attachToRoot 为 false，此时会给 Xml 布局生成的根 View 设置布局参数
• 当传入的 root 不为 null 且 attachToRoot 为 true，此时会将 Xml 布局生成的根 View 通过 addView 方法携带布局参数添加到 root 中
• 当传入的 root 为 null ，此时会将 Xml 布局生成的根 View 对象直接返回

2、Activity 中布局根 View 的布局属性会生效是因为 Android 会自动在布局文件的最外层再嵌套一个 FrameLayout

前言

#ViewRootImpl

void scheduleTraversals() {

    if (!mTraversalScheduled) {

        mTraversalScheduled = true;

        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();

      	//重点关注这里：绘制的操作封装在mTraversalRunnable里，交给`Choreographer`类处理

        mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

       //...

    }

}

 

#Choreographer

public void postCallback(int callbackType, Runnable action, Object token) {

    postCallbackDelayed(callbackType, action, token, 0);

}

public void postCallbackDelayed(int callbackType,

        Runnable action, Object token, long delayMillis) {

    //...

    postCallbackDelayedInternal(callbackType, action, token, delayMillis);

}

 

#Choreographer

private void postCallbackDelayedInternal(int callbackType,

        Object action, Object token, long delayMillis) {

  synchronized (mLock) {

    //把当前的runnable加入到callback队列中

    mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

     //达到期限时间

    if (dueTime <= now) {

       scheduleFrameLocked(now);

    } else {

       Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action);

       msg.arg1 = callbackType;

       msg.setAsynchronous(true);

       mHandler.sendMessageAtTime(msg, dueTime);

    }

  }

}

 

#Choreographer

//默认使用VSync同步机制

private static final boolean USE_VSYNC = SystemProperties.getBoolean(

            "debug.choreographer.vsync", true);

private void scheduleFrameLocked(long now) {

    if (!mFrameScheduled) {

        mFrameScheduled = true;

        //是否使用VSync同步机制

        if (USE_VSYNC) {

            //是否在主线程

            if (isRunningOnLooperThreadLocked()) {

                scheduleVsyncLocked();

            } else {

                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC);

                msg.setAsynchronous(true);

                mHandler.sendMessageAtFrontOfQueue(msg);

            }

        } else {

            final long nextFrameTime = Math.max(

                    mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);

            if (DEBUG_FRAMES) {

                Log.d(TAG, "Scheduling next frame in " + (nextFrameTime - now) + " ms.");

            }

            Message msg = mHandler.obtainMessage(MSG_DO_FRAME);

            msg.setAsynchronous(true);

            mHandler.sendMessageAtTime(msg, nextFrameTime);

        }

    }

}

 

#Choreographer

private final FrameDisplayEventReceiver mDisplayEventReceiver;

private void scheduleVsyncLocked() {

  	//调用DisplayEventReceiver的scheduleVsync

    mDisplayEventReceiver.scheduleVsync();

}

 

#DisplayEventReceiver

public abstract class DisplayEventReceiver {

	public DisplayEventReceiver(Looper looper, int vsyncSource) {

    //初始化一个接收者

  	mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,

                vsyncSource);

	}



	public void scheduleVsync() {

    //初始化的接收者对象mReceiverPtr传进去

    nativeScheduleVsync(mReceiverPtr);

	}

}

 

#Choreographer.FrameDisplayEventReceiver

private final class FrameDisplayEventReceiver extends DisplayEventReceiver

        implements Runnable {

   public FrameDisplayEventReceiver(Looper looper, int vsyncSource) {

       super(looper, vsyncSource);

   }

          

   @Override

   public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {

     //...

     long now = System.nanoTime();

     mTimestampNanos = timestampNanos;

     mFrame = frame;

     Message msg = Message.obtain(mHandler, this);

     msg.setAsynchronous(true);

     //timestampNanos / TimeUtils.NANOS_PER_MS 时间后走run方法

     mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);

   }



   @Override

   public void run() {

     mHavePendingVsync = false;

     //接收到同步信号后执行

     doFrame(mTimestampNanos, mFrame);

   }

 }

 

void doFrame(long frameTimeNanos, int frame) {

    final long startNanos;

    synchronized (mLock) {

      if (!mFrameScheduled) {

          return; // no work to do

      }

      long intendedFrameTimeNanos = frameTimeNanos;

      startNanos = System.nanoTime();

      //抖动时间： 当前时间 - 同步信号通知的时间

      final long jitterNanos = startNanos - frameTimeNanos;

      //mFrameIntervalNanos = (long)(1000000000 / getRefreshRate()) 类似 1s/60hz = 16.6ms，不过这里是纳秒为单位

      //抖动时间超过了一帧刷新的时间，即发生了Jank

      if (jitterNanos >= mFrameIntervalNanos) {

          final long skippedFrames = jitterNanos / mFrameIntervalNanos;

          //计算调帧数，超过一定限制（默认30），就表示应用在主线程做了大量工作，影响了绘制，打印提示

          if (skippedFrames >= SKIPPED_FRAME_WARNING_LIMIT) {

              Log.i(TAG, "Skipped " + skippedFrames + " frames!  "

                      + "The application may be doing too much work on its main thread.");

          }

          final long lastFrameOffset = jitterNanos % mFrameIntervalNanos;

          frameTimeNanos = startNanos - lastFrameOffset;

      }

      //...

    }



    try {

        //按顺序执行任务（这里只留了核心代码）

        doCallbacks(Choreographer.CALLBACK_INPUT, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_ANIMATION, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_TRAVERSAL, frameTimeNanos);

        doCallbacks(Choreographer.CALLBACK_COMMIT, frameTimeNanos);

    } finally {}

}

 

 mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

 

void doCallbacks(int callbackType, long frameTimeNanos) {

    CallbackRecord callbacks;

    synchronized (mLock) {

        final long now = System.nanoTime();

        callbacks = mCallbackQueues[callbackType].extractDueCallbacksLocked(

                now / TimeUtils.NANOS_PER_MS);

        if (callbacks == null) {

            return;

        }

        mCallbacksRunning = true;

    try {

        for (CallbackRecord c = callbacks; c != null; c = c.next) {

          //注意这里：执行CallbackRecord的run方法

          c.run(frameTimeNanos);

        }

    } finally {

        synchronized (mLock) {

            mCallbacksRunning = false;

            do {

                final CallbackRecord next = callbacks.next;

              	//回收处理完的CallbackRecord

                recycleCallbackLocked(callbacks);

                callbacks = next;

            } while (callbacks != null);

        }

    }

}

 

private static final class CallbackRecord {

    public CallbackRecord next;

    public long dueTime;

    public Object action; // Runnable or FrameCallback

    public Object token;



    public void run(long frameTimeNanos) {

        if (token == FRAME_CALLBACK_TOKEN) {

            ((FrameCallback)action).doFrame(frameTimeNanos);

        } else {

           //执行我们最初post的Runnable

           ((Runnable)action).run();

        }

    }

}

 

 mChoreographer.postCallback(

                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

 

在音视频或 OpenGL 开发中，文字渲染是一个高频使用的功能，比如制作一些酷炫的字幕、为视频添加水印、设置特殊字体等等。

// 创建一个 bitmap 

Bitmap bitmap = Bitmap.createBitmap(width, hight, Bitmap.Config.ARGB_8888);

// 初始化画布绘制的图像到 bitmap 上

Canvas canvas = new Canvas(bitmap);

// 建立画笔

Paint paint = new Paint(); 

// 获取更清晰的图像采样，防抖动

paint.setDither(true); 

paint.setFilterBitmap(true);

// 绘制文字到 bitmap

canvas.drawText text, x, y,paint);

 

int[] textureIds = new int[1];

//创建纹理

GLES20.glGenTextures(1, textureIds, 0);

mTexId = textureIds[0];

//绑定纹理

GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexId);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_REPEAT);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_REPEAT);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);

GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);



ByteBuffer bitmapBuffer = ByteBuffer.allocate(bitmap.getHeight() * bitmap.getWidth() * 4);//RGBA

bitmap.copyPixelsToBuffer(bitmapBuffer);

bitmapBuffer.flip();



//设置内存大小绑定内存地址

GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, mWatermarkBitmap.getWidth(), mWatermarkBitmap.getHeight(),

        0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, bitmapBuffer);



//解绑纹理

GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);

 

https://www.freetype.org/

 

LOCAL_PATH:= $(call my-dir)



include $(CLEAR_VARS)





LOCAL_SRC_FILES := \

        ./src/autofit/autofit.c \

        ./src/base/ftbase.c \

        ./src/base/ftbbox.c \

        ./src/base/ftbdf.c \

        ./src/base/ftbitmap.c \

        ./src/base/ftcid.c \

        ./src/base/ftdebug.c \

        ./src/base/ftfstype.c \

        ./src/base/ftgasp.c \

        ./src/base/ftglyph.c \

        ./src/base/ftgxval.c \

        ./src/base/ftinit.c \

        ./src/base/ftlcdfil.c \

        ./src/base/ftmm.c \

        ./src/base/ftotval.c \

        ./src/base/ftpatent.c \

        ./src/base/ftpfr.c \

        ./src/base/ftstroke.c \

        ./src/base/ftsynth.c \

        ./src/base/ftsystem.c \

        ./src/base/fttype1.c \

        ./src/base/ftwinfnt.c \

        ./src/bdf/bdf.c \

        ./src/bzip2/ftbzip2.c \

        ./src/cache/ftcache.c \

        ./src/cff/cff.c \

        ./src/cid/type1cid.c \

        ./src/gzip/ftgzip.c \

        ./src/lzw/ftlzw.c \

        ./src/pcf/pcf.c \

        ./src/pfr/pfr.c \

        ./src/psaux/psaux.c \

        ./src/pshinter/pshinter.c \

        ./src/psnames/psmodule.c \

        ./src/raster/raster.c \

        ./src/sfnt/sfnt.c \

        ./src/smooth/smooth.c \

        ./src/tools/apinames.c \

        ./src/truetype/truetype.c \

        ./src/type1/type1.c \

        ./src/type42/type42.c \

        ./src/winfonts/winfnt.c







LOCAL_C_INCLUDES += $(LOCAL_PATH)/include



LOCAL_CFLAGS += -W -Wall

LOCAL_CFLAGS += -fPIC -DPIC

LOCAL_CFLAGS += "-DDARWIN_NO_CARBON"

LOCAL_CFLAGS += "-DFT2_BUILD_LIBRARY"



LOCAL_CFLAGS += -O2



LOCAL_MODULE:= freetype



include $(BUILD_STATIC_LIBRARY)

#https://android.googlesource.com/platform/external/freetype/+/android-6.0.1_r28/Android.mk

 

APP_OPTIM := release

APP_CPPFLAGS := -std=c++14 -frtti

NDK_TOOLCHAIN_VERSION := clang

APP_PLATFORM := android-28

APP_STL := c++_static

APP_ABI := arm64-v8a,armeabi-v7a



 

https://github.com/githubhaohao/NDK_OpenGLES_3_0

 

#include "ft2build.h"

#include 

 

FT_Library ft;



if (FT_Init_FreeType(&ft))

	LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Could not init FreeType Library");





FT_Face face;

if (FT_New_Face(ft, "/sdcard/fonts/Antonio-Regular.ttf", 0, &face))

	LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Failed to load font");





FT_Set_Pixel_Sizes(face, 0, 96);

 

if (FT_Load_Char(face, 'A', FT_LOAD_RENDER))

    std::cout << "ERROR::FREETYTPE: Failed to load Glyph" << std::endl;  

 

FT_Done_Face(face);

FT_Done_FreeType(ft);

 

struct Character {

	GLuint textureID;   // ID handle of the glyph texture

	glm::ivec2 size;    // Size of glyph

	glm::ivec2 bearing;  // Offset from baseline to left/top of glyph

	GLuint advance;    // Horizontal offset to advance to next glyph

};



std::map m_Characters;

 

void TextRenderSample::LoadFacesByASCII() {

	// FreeType

	FT_Library ft;

	// All functions return a value different than 0 whenever an error occurred

	if (FT_Init_FreeType(&ft))

		LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Could not init FreeType Library");



	// Load font as face

	FT_Face face;

	if (FT_New_Face(ft, "/sdcard/fonts/Antonio-Regular.ttf", 0, &face))

		LOGCATE("TextRenderSample::LoadFacesByASCII FREETYPE: Failed to load font");



	// Set size to load glyphs as

	FT_Set_Pixel_Sizes(face, 0, 96);



	// Disable byte-alignment restriction

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);



	// Load first 128 characters of ASCII set

	for (unsigned char c = 0; c < 128; c++)

	{

		// Load character glyph

		if (FT_Load_Char(face, c, FT_LOAD_RENDER))

		{

		LOGCATE("TextRenderSample::LoadFacesByASCII FREETYTPE: Failed to load Glyph");

			continue;

		}

		// Generate texture

		GLuint texture;

		glGenTextures(1, &texture);

		glBindTexture(GL_TEXTURE_2D, texture);

		glTexImage2D(

				GL_TEXTURE_2D,

				0,

				GL_LUMINANCE,

				face->glyph->bitmap.width,

				face->glyph->bitmap.rows,

				0,

				GL_LUMINANCE,

				GL_UNSIGNED_BYTE,

				face->glyph->bitmap.buffer

		);



		// Set texture options

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		// Now store character for later use

		Character character = {

				texture,

				glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows),

				glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top),

				static_cast(face->glyph->advance.x)

		};

		m_Characters.insert(std::pair(c, character));

	}

	glBindTexture(GL_TEXTURE_2D, 0);

	// Destroy FreeType once we're finished

	FT_Done_Face(face);

	FT_Done_FreeType(ft);



}



 

//vertex shader

#version 300 es

layout(location = 0) in vec4 a_position;// 

uniform mat4 u_MVPMatrix;

out vec2 v_texCoord;

void main()

{

    gl_Position = u_MVPMatrix * vec4(a_position.xy, 0.0, 1.0);;

    v_texCoord = a_position.zw;

}



//fragment shader

#version 300 es

precision mediump float;

in vec2 v_texCoord;

layout(location = 0) out vec4 outColor;

uniform sampler2D s_textTexture;

uniform vec3 u_textColor;



void main()

{

    vec4 color = vec4(1.0, 1.0, 1.0, texture(s_textTexture, v_texCoord).r);

    outColor = vec4(u_textColor, 1.0) * color;

}

 

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  

 

glGenVertexArrays(1, &m_VaoId);

glGenBuffers(1, &m_VboId);



glBindVertexArray(m_VaoId);

glBindBuffer(GL_ARRAY_BUFFER, m_VboId);

glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 4, nullptr, GL_DYNAMIC_DRAW);

glEnableVertexAttribArray(0);

glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), 0);

glBindBuffer(GL_ARRAY_BUFFER, GL_NONE);

glBindVertexArray(GL_NONE);

 

void TextRenderSample::RenderText(std::string text, GLfloat x, GLfloat y, GLfloat scale,

                                  glm::vec3 color, glm::vec2 viewport) {

	// 激活合适的渲染状态

	glUseProgram(m_ProgramObj);

	glUniform3f(glGetUniformLocation(m_ProgramObj, "u_textColor"), color.x, color.y, color.z);

	glBindVertexArray(m_VaoId);

	GO_CHECK_GL_ERROR();

	// 对文本中的所有字符迭代

	std::string::const_iterator c;

	x *= viewport.x;

	y *= viewport.y;

	for (c = text.begin(); c != text.end(); c++)

	{

		Character ch = m_Characters[*c];



		GLfloat xpos = x + ch.bearing.x * scale;

		GLfloat ypos = y - (ch.size.y - ch.bearing.y) * scale;



		xpos /= viewport.x;

		ypos /= viewport.y;



		GLfloat w = ch.size.x * scale;

		GLfloat h = ch.size.y * scale;



		w /= viewport.x;

		h /= viewport.y;



		LOGCATE("TextRenderSample::RenderText [xpos,ypos,w,h]=[%f, %f, %f, %f]", xpos, ypos, w, h);



		// 当前字符的VBO

		GLfloat vertices[6][4] = {

				{ xpos,     ypos + h,   0.0, 0.0 },

				{ xpos,     ypos,       0.0, 1.0 },

				{ xpos + w, ypos,       1.0, 1.0 },



				{ xpos,     ypos + h,   0.0, 0.0 },

				{ xpos + w, ypos,       1.0, 1.0 },

				{ xpos + w, ypos + h,   1.0, 0.0 }

		};



		// 在方块上绘制字形纹理

		glActiveTexture(GL_TEXTURE0);

		glBindTexture(GL_TEXTURE_2D, ch.textureID);

		glUniform1i(m_SamplerLoc, 0);

		GO_CHECK_GL_ERROR();

		// 更新当前字符的VBO

		glBindBuffer(GL_ARRAY_BUFFER, m_VboId);

		glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);

        GO_CHECK_GL_ERROR();

		glBindBuffer(GL_ARRAY_BUFFER, 0);

		// 绘制方块

		glDrawArrays(GL_TRIANGLES, 0, 6);

		GO_CHECK_GL_ERROR();

		// 更新位置到下一个字形的原点，注意单位是1/64像素

		x += (ch.advance >> 6) * scale; //(2^6 = 64)

	}

	glBindVertexArray(0);

	glBindTexture(GL_TEXTURE_2D, 0);

}



 

	// (x,y)为屏幕坐标系的位置，即原点位于屏幕中心，x(-1.0,1.0), y(-1.0,1.0)

RenderText("My WeChat ID is Byte-Flow.", -0.9f, 0.2f, 1.0f, glm::vec3(0.8, 0.1f, 0.1f), viewport);

RenderText("Welcome to add my WeChat.", -0.9f, 0.0f, 2.0f, glm::vec3(0.2, 0.4f, 0.7f), viewport);

 

Android 自定义CoolImageView实现QQ首页背景图片动画效果

一.第三方RoundedImageView

1.在Android Studio中，可进入模块设置中添加库依赖。 进入Module结构设置添加库依赖 ，输入RoundedImageView然后搜索添加

2.在Moudle的build.gradle中添加如下代码，添加完之后在Build中进行下Make Module操作（编译下Module），使自己添加的依赖生效

repositories {


    mavenCentral()


}


dependencies {


    compile 'com.makeramen:roundedimageview:2.2.1'

}

3.添加相关属性：

控件属性： 


riv_border_width： 边框宽度 


riv_border_color： 边框颜色 


riv_oval： 是否圆形 


riv_corner_radius： 圆角弧度 


riv_corner_radius_top_left：左上角弧度 


riv_corner_radius_top_right： 右上角弧度 


riv_corner_radius_bottom_left：左下角弧度 


riv_corner_radius_bottom_right：右下角弧度

4.示例布局：

 <com.makeramen.roundedimageview.RoundedImageView


          android:layout_width="wrap_content"


          android:layout_height="wrap_content"


          android:src="@mipmap/avatar"


          app:riv_border_color="#333333"


          app:riv_border_width="2dp"


          app:riv_oval="true" />


    <com.makeramen.roundedimageview.RoundedImageView


          xmlns:app="http://schemas.android.com/apk/res-auto"


          android:layout_width="wrap_content"


          android:layout_height="wrap_content"


          android:scaleType="fitCenter"


          android:src="@mipmap/avatar"


          app:riv_border_color="#333333"


          app:riv_border_width="2dp"


          app:riv_corner_radius="10dp"


          app:riv_mutate_background="true"


          app:riv_oval="false"


          app:riv_tile_mode="repeat" />


    <com.makeramen.roundedimageview.RoundedImageView


          android:layout_width="wrap_content"


          android:layout_height="wrap_content"


          android:scaleType="fitCenter"


          android:src="@mipmap/avatar"


          app:riv_border_color="#333333"


          app:riv_border_width="2dp"


          app:riv_corner_radius_top_left="25dp"


          app:riv_corner_radius_bottom_right="25dp"


          app:riv_mutate_background="true"


          app:riv_oval="false"


          app:riv_tile_mode="repeat" />


   <com.makeramen.roundedimageview.RoundedImageView


          android:layout_width="wrap_content"


          android:layout_height="wrap_content"


          android:scaleType="fitCenter"


          android:src="@mipmap/avatar"


          app:riv_border_color="#333333"


          app:riv_border_width="2dp"


          app:riv_corner_radius_top_right="25dp"


          app:riv_corner_radius_bottom_left="25dp"


          app:riv_mutate_background="true"


          app:riv_oval="false"


          app:riv_tile_mode="repeat" />


   <com.makeramen.roundedimageview.RoundedImageView


          android:layout_width="96dp"


          android:layout_height="72dp"


          android:scaleType="center"


          android:src="@mipmap/avatar"


          app:riv_border_color="#333333"


          app:riv_border_width="2dp"


          app:riv_corner_radius="25dp"


          app:riv_mutate_background="true"


          app:riv_oval="true"


          app:riv_tile_mode="repeat" />

 <com.makeramen.roundedimageview.RoundedImageView


            android:id="@+id/imCompanyHeadItem"


            android:layout_width="50dp"


            android:layout_marginTop="10dp"


            android:layout_marginRight="6.5dp"


            android:layout_marginLeft="6.5dp"


            android:src="@drawable/head_home"


            android:layout_gravity="center"


            android:layout_height="50dp"


            app:riv_border_color="@color/_c7ced8"


            app:riv_border_width="1dp"


            app:riv_corner_radius_top_left="5dp"


            app:riv_corner_radius_bottom_right="5dp"


            app:riv_corner_radius_bottom_left="5dp"


            app:riv_corner_radius_top_right="5dp"


            app:riv_mutate_background="true"


            app:riv_oval="false"


            app:riv_tile_mode="repeat"/>

二.自定义RoundImageView

1.布局：

 <com.iruiyou.pet.utils.RoundImageView


                        android:id="@+id/headIv"


                        android:layout_width="125dp"


                        android:layout_height="125dp"


                        android:layout_marginTop="92dp"


                        android:src="@drawable/head_home"


                        loonggg:border_incolor="#000fff"


                        loonggg:border_outcolor="#fff000"


                        loonggg:border_width="10dp"


                        app:layout_constraintLeft_toLeftOf="parent"


                        app:layout_constraintRight_toRightOf="parent"


                        app:layout_constraintTop_toTopOf="parent"/>

2.自定义类：

import android.content.Context;


import android.content.res.TypedArray;


import android.graphics.Bitmap;


import android.graphics.Canvas;


import android.graphics.Paint;


import android.graphics.PorterDuff;


import android.graphics.PorterDuffXfermode;


import android.graphics.Rect;


import android.graphics.drawable.BitmapDrawable;


import android.graphics.drawable.Drawable;


import android.graphics.drawable.NinePatchDrawable;


import android.util.AttributeSet;


import android.widget.ImageView;


import com.iruiyou.pet.R;





/**


 *


 * @author sgf


 * 自定义圆形头像


 *


 */


public class RoundImageView extends ImageView {


    private int mBorderThickness = 0;


    private Context mContext;


    private int defaultColor = 0xFFFFFFFF;


    // 外圆边框颜色


    private int mBorderOutsideColor = 0;


    // 内圆边框颜色


    private int mBorderInsideColor = 0;


    // RoundImageView控件默认的长、宽


    private int defaultWidth = 0;


    private int defaultHeight = 0;





    public RoundImageView(Context context) {


        super(context);


        mContext = context;


    }





    public RoundImageView(Context context, AttributeSet attrs) {


        super(context, attrs);


        mContext = context;


        // 设置RoundImageView的属性值，比如颜色，宽度等


        setRoundImageViewAttributes(attrs);


    }





    public RoundImageView(Context context, AttributeSet attrs, int defStyle) {


        super(context, attrs, defStyle);


        mContext = context;


        setRoundImageViewAttributes(attrs);


    }





    // 从attr.xml文件中获取属性值，并给RoundImageView设置


    private void setRoundImageViewAttributes(AttributeSet attrs) {


        TypedArray a = mContext.obtainStyledAttributes(attrs,


                R.styleable.round_image_view);


        mBorderThickness = a.getDimensionPixelSize(


                R.styleable.round_image_view_border_width, 0);


        mBorderOutsideColor = a.getColor(


                R.styleable.round_image_view_border_outcolor, defaultColor);


        mBorderInsideColor = a.getColor(


                R.styleable.round_image_view_border_incolor, defaultColor);


        a.recycle();


    }





    // 具体解释：比如我自定义一个控件，怎么实现呢，以RoundImageView为例，首先是继承ImageView,然后实现其构造函数，在构造函数中，获取attr中的属性值（再次解释：这里获取的具体的这个属性的值是怎么来的呢？比如颜色和宽度，这个在attr.xml中定义了相关的名字，而在使用RoundImageView的xml布局文件中，我们会设置其值，这里需要用的值，就是从那里设置的），并设置在本控件中，然后继承onDraw方法，画出自己想要的图形或者形状即可


    /**


     * 这个是继承的父类的onDraw方法


     *


     * onDraw和下面的方法不用管，基本和学习自定义没关系，就是实现怎么画圆的，你可以改变下面代码试着画三角形头像，哈哈


     */


    @Override


    protected void onDraw(Canvas canvas) {


        Drawable drawable = getDrawable();


        if (drawable == null) {


            return;


        }


        if (getWidth() == 0 || getHeight() == 0) {


            return;


        }


        this.measure(0, 0);


        if (drawable.getClass() == NinePatchDrawable.class)


            return;


        Bitmap b = ((BitmapDrawable) drawable).getBitmap();


        Bitmap bitmap = b.copy(Bitmap.Config.ARGB_8888, true);


        if (defaultWidth == 0) {


            defaultWidth = getWidth();


        }


        if (defaultHeight == 0) {


            defaultHeight = getHeight();


        }


        int radius = 0;


        // 这里的判断是如果内圆和外圆设置的颜色值不为空且不是默认颜色，就定义画两个圆框，分别为内圆和外圆边框


        if (mBorderInsideColor != defaultColor


                && mBorderOutsideColor != defaultColor) {


            radius = (defaultWidth < defaultHeight ? defaultWidth


                    : defaultHeight) / 2 - 2 * mBorderThickness;


            // 画内圆


            drawCircleBorder(canvas, radius + mBorderThickness / 2,


                    mBorderInsideColor);


            // 画外圆


            drawCircleBorder(canvas, radius + mBorderThickness


                    + mBorderThickness / 2, mBorderOutsideColor);


        } else if (mBorderInsideColor != defaultColor


                && mBorderOutsideColor == defaultColor) {// 这里的是如果内圆边框不为空且颜色值不是默认值，就画一个内圆的边框


            radius = (defaultWidth < defaultHeight ? defaultWidth


                    : defaultHeight) / 2 - mBorderThickness;


            drawCircleBorder(canvas, radius + mBorderThickness / 2,


                    mBorderInsideColor);


        } else if (mBorderInsideColor == defaultColor


                && mBorderOutsideColor != defaultColor) {// 这里的是如果外圆边框不为空且颜色值不是默认值，就画一个外圆的边框


            radius = (defaultWidth < defaultHeight ? defaultWidth


                    : defaultHeight) / 2 - mBorderThickness;


            drawCircleBorder(canvas, radius + mBorderThickness / 2,


                    mBorderOutsideColor);


        } else {// 这种情况是没有设置属性颜色的情况下，即没有边框的情况


            radius = (defaultWidth < defaultHeight ? defaultWidth


                    : defaultHeight) / 2;


        }


        Bitmap roundBitmap = getCroppedRoundBitmap(bitmap, radius);


        canvas.drawBitmap(roundBitmap, defaultWidth / 2 - radius, defaultHeight


                / 2 - radius, null);


    }





    /**


     * 获取裁剪后的圆形图片


     *


     * @param bmp


     * @param radius


     *            半径


     * @return


     */


    public Bitmap getCroppedRoundBitmap(Bitmap bmp, int radius) {


        Bitmap scaledSrcBmp;


        int diameter = radius * 2;


        // 为了防止宽高不相等，造成圆形图片变形，因此截取长方形中处于中间位置最大的正方形图片


        int bmpWidth = bmp.getWidth();


        int bmpHeight = bmp.getHeight();


        int squareWidth = 0, squareHeight = 0;


        int x = 0, y = 0;


        Bitmap squareBitmap;


        if (bmpHeight > bmpWidth) {// 高大于宽


            squareWidth = squareHeight = bmpWidth;


            x = 0;


            y = (bmpHeight - bmpWidth) / 2;


            // 截取正方形图片


            squareBitmap = Bitmap.createBitmap(bmp, x, y, squareWidth,


                    squareHeight);


        } else if (bmpHeight < bmpWidth) {// 宽大于高


            squareWidth = squareHeight = bmpHeight;


            x = (bmpWidth - bmpHeight) / 2;


            y = 0;


            squareBitmap = Bitmap.createBitmap(bmp, x, y, squareWidth,


                    squareHeight);


        } else {


            squareBitmap = bmp;


        }


        if (squareBitmap.getWidth() != diameter


                || squareBitmap.getHeight() != diameter) {


            scaledSrcBmp = Bitmap.createScaledBitmap(squareBitmap, diameter,


                    diameter, true);


        } else {


            scaledSrcBmp = squareBitmap;


        }


        Bitmap output = Bitmap.createBitmap(scaledSrcBmp.getWidth(),


                scaledSrcBmp.getHeight(), Bitmap.Config.ARGB_8888);


        Canvas canvas = new Canvas(output);





        Paint paint = new Paint();


        Rect rect = new Rect(0, 0, scaledSrcBmp.getWidth(),


                scaledSrcBmp.getHeight());





        paint.setAntiAlias(true);


        paint.setFilterBitmap(true);


        paint.setDither(true);


        canvas.drawARGB(0, 0, 0, 0);


        canvas.drawCircle(scaledSrcBmp.getWidth() / 2,


                scaledSrcBmp.getHeight() / 2, scaledSrcBmp.getWidth() / 2,


                paint);


        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));


        canvas.drawBitmap(scaledSrcBmp, rect, rect, paint);


        bmp = null;


        squareBitmap = null;


        scaledSrcBmp = null;


        return output;


    }





    /**


     * 画边缘的圆，即内圆或者外圆


     */


    private void drawCircleBorder(Canvas canvas, int radius, int color) {


        Paint paint = new Paint();


        /* 去锯齿 */


        paint.setAntiAlias(true);


        paint.setFilterBitmap(true);


        paint.setDither(true);


        paint.setColor(color);


        /* 设置paint的　style　为STROKE：空心 */


        paint.setStyle(Paint.Style.STROKE);


        /* 设置paint的外框宽度 */


        paint.setStrokeWidth(mBorderThickness);


        canvas.drawCircle(defaultWidth / 2, defaultHeight / 2, radius, paint);


    }


}

3.res--values--attrs.xml文件

<?xml version="1.0" encoding="utf-8"?>


<resources>





    <declare-styleable name="round_image_view">


        <attr name="border_width" format="dimension" />


        <attr name="border_incolor" format="color" />


        <attr name="border_outcolor" format="color"></attr>


    </declare-styleable>





</resources>

三.第三方NiceImageView

1.效果图如下：

 2.特点：

基于AppCompatImageView扩展

支持圆角、圆形显示

可绘制边框，圆形时可绘制内外两层边框

支持边框不覆盖图片

可绘制遮罩

3.基本用法：

 1. 添加JitPack仓库 在项目根目录下的 build.gradle 中添加仓库:

allprojects {


    repositories {


        ...


        maven { url "https://jitpack.io" }


    }


}

2. 添加项目依赖

dependencies {


    implementation 'com.github.SheHuan:NiceImageView:1.0.5'


}

3. 在布局文件中添加CornerLabelView

<com.shehuan.niv.NiceImageView


    android:layout_width="200dp"


    android:layout_height="200dp"


    android:layout_marginTop="10dp"


    android:src="@drawable/cat"


    app:border_color="#FF7F24"


    app:border_width="4dp"


    app:is_circle="true" />

4.支持的属性、方法

可参考：https://github.com/SheHuan/NiceImageView

 5.其它：

如果你需要实现类似钉钉的圆形组合头像，例如：

可以先生成对应的Bitmap，并用圆形的 NiceImageView 显示即可。如何生成组合Bitmap可以参考这里：CombineBitmap

四.如果你的项目中只有圆形的图片而不需要设置圆角图片的话，可以试试下面的第三方：

https://github.com/hdodenhof/CircleImageView

https://github.com/open-android/RoundedImageView

通常我们使用富文本编辑器都是在H5端实现，但是如果你遇到在移动端发表文章的功能，那么richeditor-android这套框架可以轻松为你实现，不需要再使用大量的控件进行拼凑！

• 功能表如下图所示：

• 引入richeditor-android

 richeditor-android需要的jar：



 implementation 'jp.wasabeef:richeditor-android:1.2.2'





 这是一个Dialog框架，demo中不想自己去写，所以就使用了第三方

 implementation 'com.afollestad.material-dialogs:core:0.9.6.0'

• 引入控件RichEditor

   <jp.wasabeef.richeditor.RichEditor

        android:id="@+id/editor"

        android:layout_width="match_parent"

        android:layout_height="wrap_content" />

• 使用到的权限

如果拍照需要相机权限，选择图片需要SD卡权限，插入网络图片需要网络权限

 <uses-permission android:name="android.permission.CAMERA" />

    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <uses-permission android:name="android.permission.INTERNET" />

• 初始化RichEditor

       mEditor = (RichEditor) findViewById(R.id.editor);



        //初始化编辑高度

        mEditor.setEditorHeight(200);

        //初始化字体大小

        mEditor.setEditorFontSize(22);

        //初始化字体颜色

        mEditor.setEditorFontColor(Color.BLACK);

        //mEditor.setEditorBackgroundColor(Color.BLUE);



        //初始化内边距

        mEditor.setPadding(10, 10, 10, 10);

        //设置编辑框背景，可以是网络图片

        // mEditor.setBackground("https://raw.githubusercontent.com/wasabeef/art/master/chip.jpg");

        // mEditor.setBackgroundColor(Color.BLUE);

        mEditor.setBackgroundResource(R.drawable.bg);

        //设置默认显示语句

        mEditor.setPlaceholder("Insert text here...");

        //设置编辑器是否可用

        mEditor.setInputEnabled(true);

• 实时监听Editor输入内容

   mPreview = (TextView) findViewById(R.id.preview);

        mEditor.setOnTextChangeListener(new RichEditor.OnTextChangeListener() {

            @Override

            public void onTextChange(String text) {

                mPreview.setText(text);

            }

        });

• 功能方法

        /**

         * 撤销当前标签状态下所有内容

         */

        findViewById(R.id.action_undo).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.undo();

            }

        });

        /**

         * 恢复撤销的内容

         */

        findViewById(R.id.action_redo).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.redo();

            }

        });

        /**

         * 加粗

         */

        findViewById(R.id.action_bold).setOnClickListener(new View.OnClickListener() {



            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setBold();

            }

        });

        /**

         * 斜体

         */

        findViewById(R.id.action_italic).setOnClickListener(new View.OnClickListener() {



            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setItalic();

            }

        });

        /**

         * 下角表

         */

        findViewById(R.id.action_subscript).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                if (mEditor.getHtml() == null) {

                    return;

                }

                mEditor.setSubscript();

            }

        });

        /**

         * 上角标

         */

        findViewById(R.id.action_superscript).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                if (mEditor.getHtml() == null) {

                    return;

                }

                mEditor.setSuperscript();

            }

        });



        /**

         * 删除线

         */

        findViewById(R.id.action_strikethrough).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setStrikeThrough();

            }

        });

        /**

         *下划线

         */

        findViewById(R.id.action_underline).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setUnderline();

            }

        });

        /**

         * 设置标题（1到6）

         */

        findViewById(R.id.action_heading1).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(1);

            }

        });



        findViewById(R.id.action_heading2).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(2);

            }

        });



        findViewById(R.id.action_heading3).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(3);

            }

        });



        findViewById(R.id.action_heading4).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(4);

            }

        });



        findViewById(R.id.action_heading5).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(5);

            }

        });



        findViewById(R.id.action_heading6).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setHeading(6);

            }

        });

        /**

         * 设置字体颜色

         */

        findViewById(R.id.action_txt_color).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                new MaterialDialog.Builder(MainActivity.this)

                        .title("选择字体颜色")

                        .items(R.array.color_items)

                        .itemsCallbackSingleChoice(-1, new MaterialDialog.ListCallbackSingleChoice() {

                            @Override

                            public boolean onSelection(MaterialDialog dialog, View itemView, int which, CharSequence text) {



                                dialog.dismiss();

                                switch (which) {

                                    case 0://红

                                        mEditor.setTextColor(Color.RED);

                                        break;

                                    case 1://黄

                                        mEditor.setTextColor(Color.YELLOW);

                                        break;

                                    case 2://蓝

                                        mEditor.setTextColor(Color.GREEN);

                                        break;

                                    case 3://绿

                                        mEditor.setTextColor(Color.BLUE);

                                        break;

                                    case 4://黑

                                        mEditor.setTextColor(Color.BLACK);

                                        break;

                                }

                                return false;

                            }

                        }).show();

            }

        });



        findViewById(R.id.action_bg_color).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                new MaterialDialog.Builder(MainActivity.this)

                        .title("选择字体背景颜色")

                        .items(R.array.text_back_color_items)

                        .itemsCallbackSingleChoice(-1, new MaterialDialog.ListCallbackSingleChoice() {

                            @Override

                            public boolean onSelection(MaterialDialog dialog, View itemView, int which, CharSequence text) {



                                dialog.dismiss();

                                switch (which) {

                                    case 0://红

                                        mEditor.setTextBackgroundColor(Color.RED);

                                        break;

                                    case 1://黄

                                        mEditor.setTextBackgroundColor(Color.YELLOW);

                                        break;

                                    case 2://蓝

                                        mEditor.setTextBackgroundColor(Color.GREEN);

                                        break;

                                    case 3://绿

                                        mEditor.setTextBackgroundColor(Color.BLUE);

                                        break;

                                    case 4://黑

                                        mEditor.setTextBackgroundColor(Color.BLACK);

                                        break;

                                    case 5://透明

                                        mEditor.setTextBackgroundColor(R.color.transparent);

                                        break;

                                }

                                return false;

                            }

                        }).show();



            }

        });

        /**

         * 向右缩进

         */

        findViewById(R.id.action_indent).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setIndent();

            }

        });

        /**

         * 向左缩进

         */

        findViewById(R.id.action_outdent).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setOutdent();

            }

        });

        /**

         *文章左对齐

         */

        findViewById(R.id.action_align_left).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.setAlignLeft();

            }

        });

        /**

         * 文章居中对齐

         */

        findViewById(R.id.action_align_center).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setAlignCenter();

            }

        });

        /**

         * 文章右对齐

         */

        findViewById(R.id.action_align_right).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setAlignRight();

            }

        });

        /**

         * 无序排列

         */

        findViewById(R.id.action_insert_bullets).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setBullets();

            }

        });

        /**

         * 有序排列

         */

        findViewById(R.id.action_insert_numbers).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setNumbers();

            }

        });

        /**

         * 引用

         */

        findViewById(R.id.action_blockquote).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.setBlockquote();

            }

        });



        /**

         * 插入图片

         */

        findViewById(R.id.action_insert_image).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                ActivityCompat.requestPermissions(MainActivity.this, mPermissionList, 100);

            }

        });

        /**

         * 插入连接

         */

        findViewById(R.id.action_insert_link).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                new MaterialDialog.Builder(MainActivity.this)

                        .title("将输入连接地址")

                        .items("http://blog.csdn.net/huangxiaoguo1")

                        .itemsCallbackSingleChoice(-1, new MaterialDialog.ListCallbackSingleChoice() {

                            @Override

                            public boolean onSelection(MaterialDialog dialog, View itemView, int which, CharSequence text) {

                                dialog.dismiss();

                                mEditor.focusEditor();

                                mEditor.insertLink("http://blog.csdn.net/huangxiaoguo1",

                                        "http://blog.csdn.net/huangxiaoguo1");

                                return false;

                            }

                        }).show();

            }

        });

        /**

         * 选择框

         */

        findViewById(R.id.action_insert_checkbox).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                mEditor.focusEditor();

                mEditor.insertTodo();

            }

        });



        /**

         * 获取并显示Html

         */

        findViewById(R.id.tv_showhtml).setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Intent intent = new Intent(v.getContext(), WebViewActivity.class);

                intent.putExtra("contextURL", mEditor.getHtml());

                startActivity(intent);

            }

        });

• 插入图片并使用屏幕宽度

权限，我这里只是选着图片，关于拍照的自己可以去实现



  String[] mPermissionList = new String[]{

            Manifest.permission.WRITE_EXTERNAL_STORAGE,

            Manifest.permission.READ_EXTERNAL_STORAGE};

    @Override

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {

        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        switch (requestCode) {

            case 100:

                boolean writeExternalStorage = grantResults[0] == PackageManager.PERMISSION_GRANTED;

                boolean readExternalStorage = grantResults[1] == PackageManager.PERMISSION_GRANTED;

                if (grantResults.length > 0 && writeExternalStorage && readExternalStorage) {

                    getImage();

                } else {

                    Toast.makeText(this, "请设置必要权限", Toast.LENGTH_SHORT).show();

                }



                break;

        }

    }



    private void getImage() {

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {

            startActivityForResult(new Intent(Intent.ACTION_GET_CONTENT).setType("image/*"),

                    REQUEST_PICK_IMAGE);

        } else {

            Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);

            intent.addCategory(Intent.CATEGORY_OPENABLE);

            intent.setType("image/*");

            startActivityForResult(intent, REQUEST_PICK_IMAGE);

        }

    }



    @Override

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {

        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == Activity.RESULT_OK) {

            switch (requestCode) {

                case REQUEST_PICK_IMAGE:

                    if (data != null) {

                        String realPathFromUri = RealPathFromUriUtils.getRealPathFromUri(this, data.getData());

                        mEditor.insertImage("https://unsplash.it/2000/2000?random&58",

                                "huangxiaoguo\" style=\"max-width:100%");

                        mEditor.insertImage(realPathFromUri, realPathFromUri + "\" style=\"max-width:100%");

//                        mEditor.insertImage(realPathFromUri, realPathFromUri + "\" style=\"max-width:100%;max-height:100%");



                    } else {

                        Toast.makeText(this, "图片损坏，请重新选择", Toast.LENGTH_SHORT).show();

                    }



                    break;

            }

        }

    }

注意这里 “\” style=\”max-width:100%”是让我们从手机选择的图片和网络加载的图片适配屏幕宽高，解决图片太大显示不全问题！

关于如何获得手机图片真正地址（realPathFromUri ）请看http://blog.csdn.net/huangxiaoguo1/article/details/78983582

richeditor-android github地址：https://github.com/wasabeef/richeditor-android

demo地址：http://download.csdn.net/download/huangxiaoguo1/10205773

本文介绍如何将android-gif-drawable集成到项目中，并且如何使用android-gif-drawable加载离线和网络Gif动图。

android-gif-drawable的集成

在线集成

Github上相关教程，也比较简单，将依赖添加到项目的build.gradle文件即可：

dependencies {

    compile 'pl.droidsonroids.gif:android-gif-drawable:1.2.11'

}

离线集成

Android Studio 3.0中有效

1. 进入Github上的realease页面-realease点我




2. 下载其中的android-gif-drawable-1.2.11.aar




3. 将android-gif-drawable-1.2.11.aar添加到项目的libs目录中




4. 在项目的build.gradle中添加该arr文件

compile(name:'android-gif-drawable-1.2.11', ext:'aar')

1. 集成完毕，可以进行测试。

android-gif-drawable的使用

android-gif-drawable有四种控件：GifImageView、GifImageButton、GifTextView、GifTextureView。这里以ImageView为例进行介绍。

加载本地图片

1. 直接在布局中选定资源文件

<pl.droidsonroids.gif.GifImageView

    android:id="@+id/fragment_gif_local"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:src="@drawable/dog"/>

1. 通过代码进行动态添加gif动图

//1. 构建GifDrawable

GifDrawable gifFromResDrawable = new GifDrawable( getResources(), R.drawable.dog );

//2. 设置给GifImageView控件

gifImageView.setImageDrawable(gifFromResDrawable);

GifDrawable

GifDrawable是用于该开源库的Drawable类。构造方法大致有9种：

//1. asset file

GifDrawable gifFromAssets = new GifDrawable( getAssets(), "anim.gif" );



//2. resource (drawable or raw)

GifDrawable gifFromResource = new GifDrawable( getResources(), R.drawable.anim );



//3. byte array

byte[] rawGifBytes = ...

GifDrawable gifFromBytes = new GifDrawable( rawGifBytes );



//4. FileDescriptor

FileDescriptor fd = new RandomAccessFile( "/path/anim.gif", "r" ).getFD();

GifDrawable gifFromFd = new GifDrawable( fd );



//5. file path

GifDrawable gifFromPath = new GifDrawable( "/path/anim.gif" );



//6. file

File gifFile = new File(getFilesDir(),"anim.gif");

GifDrawable gifFromFile = new GifDrawable(gifFile);



//7. AssetFileDescriptor

AssetFileDescriptor afd = getAssets().openFd( "anim.gif" );

GifDrawable gifFromAfd = new GifDrawable( afd );



//8. InputStream (it must support marking)

InputStream sourceIs = ...

BufferedInputStream bis = new BufferedInputStream( sourceIs, GIF_LENGTH );

GifDrawable gifFromStream = new GifDrawable( bis );



//9. direct ByteBuffer

ByteBuffer rawGifBytes = ...

GifDrawable gifFromBytes = new GifDrawable( rawGifBytes );

加载网络Gif

我们解决的办法是将Gif图片下载到缓存目录中，然后从磁盘缓存中获取该Gif动图进行显示。

1、下载工具DownloadUtils.java

public class DownloadUtils {

    private final int DOWN_START = 1; // Handler消息类型(开始下载)

    private final int DOWN_POSITION = 2; // Handler消息类型(下载位置)

    private final int DOWN_COMPLETE = 3; // Handler消息类型(下载完成)

    private final int DOWN_ERROR = 4; // Handler消息类型(下载失败)

    private OnDownloadListener onDownloadListener;



    public void setOnDownloadListener(OnDownloadListener onDownloadListener) {

        this.onDownloadListener = onDownloadListener;

    }



    /**

     * 下载文件

     *

     * @param url      文件路径

     * @param filepath 保存地址

     */

    public void download(String url, String filepath) {

        MyRunnable mr = new MyRunnable();

        mr.url = url;

        mr.filepath = filepath;

        new Thread(mr).start();

    }



    @SuppressWarnings("unused")

    private void sendMsg(int what) {

        sendMsg(what, null);

    }



    private void sendMsg(int what, Object mess) {

        Message m = myHandler.obtainMessage();

        m.what = what;

        m.obj = mess;

        m.sendToTarget();

    }



    Handler myHandler = new Handler() {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case DOWN_START: // 开始下载

                    int filesize = (Integer) msg.obj;

                    onDownloadListener.onDownloadConnect(filesize);

                    break;

                case DOWN_POSITION: // 下载位置

                    int pos = (Integer) msg.obj;

                    onDownloadListener.onDownloadUpdate(pos);

                    break;

                case DOWN_COMPLETE: // 下载完成

                    String url = (String) msg.obj;

                    onDownloadListener.onDownloadComplete(url);

                    break;

                case DOWN_ERROR: // 下载失败

                    Exception e = (Exception) msg.obj;

                    e.printStackTrace();

                    onDownloadListener.onDownloadError(e);

                    break;

            }

            super.handleMessage(msg);

        }

    };



    class MyRunnable implements Runnable {

        private String url = "";

        private String filepath = "";



        @Override

        public void run() {

            try {

                doDownloadTheFile(url, filepath);

            } catch (Exception e) {

                sendMsg(DOWN_ERROR, e);

            }

        }

    }



    /**

     * 下载文件

     *

     * @param url      下载路劲

     * @param filepath 保存路径

     * @throws Exception

     */

    private void doDownloadTheFile(String url, String filepath) throws Exception {

        if (!URLUtil.isNetworkUrl(url)) {

            sendMsg(DOWN_ERROR, new Exception("不是有效的下载地址：" + url));

            return;

        }

        URL myUrl = new URL(url);

        URLConnection conn = myUrl.openConnection();

        conn.connect();

        InputStream is = null;

        int filesize = 0;

        try {

            is = conn.getInputStream();

            filesize = conn.getContentLength();// 根据响应获取文件大小

            sendMsg(DOWN_START, filesize);

        } catch (Exception e) {

            sendMsg(DOWN_ERROR, new Exception(new Exception("无法获取文件")));

            return;

        }

        FileOutputStream fos = new FileOutputStream(filepath); // 创建写入文件内存流，

        // 通过此流向目标写文件

        byte buf[] = new byte[1024];

        int numread = 0;

        int temp = 0;

        while ((numread = is.read(buf)) != -1) {

            fos.write(buf, 0, numread);

            fos.flush();

            temp += numread;

            sendMsg(DOWN_POSITION, temp);

        }

        is.close();

        fos.close();

        sendMsg(DOWN_COMPLETE, filepath);

    }



    interface OnDownloadListener{

        public void onDownloadUpdate(int percent);



        public void onDownloadError(Exception e);



        public void onDownloadConnect(int filesize);



        public void onDownloadComplete(Object result);

    }

}

2、调用DonwloadUtils进行下载，下载完成后加载本地图片

//1. 下载gif图片(文件名自定义可以通过Hash值作为key)

DownloadUtils downloadUtils = new DownloadUtils();

downloadUtils.download(gifUrlArray[0],

                getDiskCacheDir(getContext())+"/0.gif");

//2. 下载完毕后通过“GifDrawable”进行显示

downloadUtils.setOnDownloadListener(new DownloadUtils.OnDownloadListener() {

            @Override

            public void onDownloadUpdate(int percent) {

            }

            @Override

            public void onDownloadError(Exception e) {

            }

            @Override

            public void onDownloadConnect(int filesize) {

            }

            //下载完毕后进行显示

            @Override

            public void onDownloadComplete(Object result) {

                try {

                    GifDrawable gifDrawable = new GifDrawable(getDiskCacheDir(getContext())+"/0.gif");

                    mGifOnlineImageView.setImageDrawable(gifDrawable);

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        });

//获取缓存的路径

public String getDiskCacheDir(Context context) {

    String cachePath = null;

    if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())

            || !Environment.isExternalStorageRemovable()) {

        // 路径：/storage/emulated/0/Android/data/<application package>/cache

        cachePath = context.getExternalCacheDir().getPath();

    } else {

        // 路径：/data/data/<application package>/cache

        cachePath = context.getCacheDir().getPath();

    }

    return cachePath;

}

github地址：https://github.com/koral--/android-gif-drawable

转载请注明链接：http://blog.csdn.net/feather_wch/article/details/79558240

四，ObjectWatcher 保留对象检查分析

我们转到 ObjectWatcher 的 expectWeaklyReachable 方法看看

@Synchronized override fun expectWeaklyReachable(

  watchedObject: Any,

  description: String

) {

   //是否启用 , AppWatcher 持有的ObjectWatcher 默认是启用的

  if (!isEnabled()) {

    return

  }

  ///移除之前已经被回收的监听对象

  removeWeaklyReachableObjects()

  val key = UUID.randomUUID()

    .toString()

  val watchUptimeMillis = clock.uptimeMillis()

   //(1) 创建弱引用

  val reference =

    KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue)

  SharkLog.d {

    "Watching " +

      (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") +

      (if (description.isNotEmpty()) " ($description)" else "") +

      " with key $key"

  }



  watchedObjects[key] = reference

  checkRetainedExecutor.execute {

    //(2)

    moveToRetained(key)

  }

}

 

继续分析源码中标注的地方。

(1) 创建弱引用

标注(1.2.4)处的代码是初始化的主要代码，创建要观察对象的弱引用，传入queue 作为gc 后的对象信息存储队列，WeakReference 中，当持有对象呗gc的时候，会将其包装对象压入队列中。可以在后续对该队列进行观察。

(2) moveToRetained(key)，检查对应key对象的保留

作为Executor的runner 执行，在AppWatcher中，默认延迟五秒后执行该方法 查看源码分析

@Synchronized private fun moveToRetained(key: String) {

///移除已经被回收的观察对象

  removeWeaklyReachableObjects()

  val retainedRef = watchedObjects[key]

  if (retainedRef != null) {

  //记录泄漏时间

    retainedRef.retainedUptimeMillis = clock.uptimeMillis()

    //回调泄漏监听

    onObjectRetainedListeners.forEach { it.onObjectRetained() }

  }

}

 

从上述代码可知，ObjectWatcher 监测内存泄漏总共有以下几步

1. 清除已经被内存回收的监听对象
2. 创建弱引用，传入 ReferenceQueue 作为gc 信息保存队列
3. 在延迟指定的时间后，再次检查针对的对象是否被回收（通过检查ReferenceQueue队列内有无该WeakReference实例）
4. 检测到对象没有被回收后,回调 onObjectRetainedListeners 们的 onObjectRetained

五，dumpHeap，怎么个DumpHeap流程

（1.1）objectWatcher 添加 OnObjectRetainedListeners 监听

回到最初AppWatcher的 manualInstall 方法。 可以看到其中执行了loadLeakCanary 方法。 代码如下:

///(2)

  LeakCanaryDelegate.loadLeakCanary(application)

 //反射获取InternalLeakCanary实例

  val loadLeakCanary by lazy {

  try {

    val leakCanaryListener = Class.forName("leakcanary.internal.InternalLeakCanary")

    leakCanaryListener.getDeclaredField("INSTANCE")

      .get(null) as (Application) -> Unit

  } catch (ignored: Throwable) {

    NoLeakCanary

  }

}

 

该方法通过反射获取了 InternalLeakCanary 的静态实例。 并且调用了他的 invoke(application: Application)方法，所以我们接下来看InternalLeakCanary的该方法：

override fun invoke(application: Application) {

  _application = application



  checkRunningInDebuggableBuild()

  //（1.2）添加 addOnObjectRetainedListener

  AppWatcher.objectWatcher.addOnObjectRetainedListener(this)



  val heapDumper = AndroidHeapDumper(application, createLeakDirectoryProvider(application))

    //Gc触发器

  val gcTrigger = GcTrigger.Default



  val configProvider = { LeakCanary.config }



  val handlerThread = HandlerThread(LEAK_CANARY_THREAD_NAME)

  handlerThread.start()

  val backgroundHandler = Handler(handlerThread.looper)

///（1.3）

  heapDumpTrigger = HeapDumpTrigger(

    application, backgroundHandler, AppWatcher.objectWatcher, gcTrigger, heapDumper,

    configProvider

  )

  ///（1.4） 添加application前后台变化监听

  application.registerVisibilityListener { applicationVisible ->

    this.applicationVisible = applicationVisible

    heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)

  }

  //（1.5）

  registerResumedActivityListener(application)

  //（1.6）

  addDynamicShortcut(application)



   // 6 判断是否应该DumpHeap 

  // We post so that the log happens after Application.onCreate()

  mainHandler.post {

    // https://github.com/square/leakcanary/issues/1981

    // We post to a background handler because HeapDumpControl.iCanHasHeap() checks a shared pref

    // which blocks until loaded and that creates a StrictMode violation.

    backgroundHandler.post {

      SharkLog.d {

        when (val iCanHasHeap = HeapDumpControl.iCanHasHeap()) {

          is Yup -> application.getString(R.string.leak_canary_heap_dump_enabled_text)

          is Nope -> application.getString(

            R.string.leak_canary_heap_dump_disabled_text, iCanHasHeap.reason()

          )

        }

      }

    }

  }

}

 

我们看到初始化的时候做了这么6步

• （1.2） 将自己加入到ObjectWatcher 的对象异常持有监听器中
• （1.3）创建内存快照转储触发器 HeapDumpTrigger
• （1.4）监听application 前后台变动，并且记录来到后台时间，便于LeakCanary 针对刚刚切入后台的一些destroy操作做泄漏监测
• （1.5）注册activity生命周期回调，获取当前resumed的activity实例
• （1.6）添加动态的桌面快捷入口
• （1.7）在异步线程中，判断是否处于可dumpHeap的状态，如果处于触发一次内存泄漏检查 其中最重要的是 1.2，我们重点分析作为ObjectRetainedListener 他在回调中做了哪些工作。

（1.2）添加对象异常持有监听

可以看到代码(1.2)，在objectWatcher将自己加入到泄漏监测回调中。 当ObjectWatcher监测到对象依然被异常持有的时候，会回调 onObjectRetained 方法。 从源码中可知，其中调用了 heapDumpTrigger的 scheduleRetainedObjectCheck方法， 代码如下。

fun scheduleRetainedObjectCheck() {

  if (this::heapDumpTrigger.isInitialized) {

    heapDumpTrigger.scheduleRetainedObjectCheck()

  }

}

 

HeapDumpTrigger 顾名思义，就是内存快照转储的触发器。在回调中最终调用了HeapDumpTrigger 的 checkRetainedObjects方法来检查内存泄漏。

（1.3）检查内存泄漏checkRetainedObjects

private fun checkRetainedObjects() {

  val iCanHasHeap = HeapDumpControl.iCanHasHeap()



  val config = configProvider()

 //省略一些代码，主要是判断 iCanHasHeap。

 //如果当前处于不dump内存快照的状态，就先不处理。如果有新的异常持有对象被发现则发送通知提示

 //%d retained objects, tap to dump heap

  /** ...*/



  var retainedReferenceCount = objectWatcher.retainedObjectCount



   //主动触发gc

  if (retainedReferenceCount > 0) {

    gcTrigger.runGc()

    //重新获取异常持有对象

    retainedReferenceCount = objectWatcher.retainedObjectCount

  }

  //如果泄漏数量小于阈值，且app在前台，或者刚转入后台，就展示泄漏通知，并先返回

  if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return



//如果泄漏数量到达dumpHeap要求，继续往下

   ///转储内存快照在  WAIT_BETWEEN_HEAP_DUMPS_MILLIS （默认60秒）只会触发一次，如果之前刚触发过，就先不生成内存快照，直接发送通知了事。

//省略转储快照时机判断,不满足的话会提示 Last heap dump was less than a minute ago

/**...*/



  dismissRetainedCountNotification()

  val visibility = if (applicationVisible) "visible" else "not visible"

  ///转储内存快照

  dumpHeap(

    retainedReferenceCount = retainedReferenceCount,

    retry = true,

    reason = "$retainedReferenceCount retained objects, app is $visibility"

  )

}

 

这一块也可以看出检测是否需要dumpHeap分为4步。

1. 如果没有检测到异常持有的对象，返回
2. 如果有异常对象，主动触发gc
3. 如果还有异常对象，就是内存泄漏了。
4. 判断泄漏数量是否到达需要dump的地步
5. 判断一分钟内是否叫进行过dump了
6. dumpHeap 前面都是判断代码，关键重点在于dumpHeap方法

（1.4）dumpHeap 转储内存快照

private fun dumpHeap(

  retainedReferenceCount: Int,

  retry: Boolean,

  reason: String

) {

  saveResourceIdNamesToMemory()

  val heapDumpUptimeMillis = SystemClock.uptimeMillis()

  KeyedWeakReference.heapDumpUptimeMillis = heapDumpUptimeMillis

  when (val heapDumpResult = heapDumper.dumpHeap()) {

    is NoHeapDump -> {

     //省略 dump失败，等待重试代码和发送失败通知代码

    }

    is HeapDump -> {

      lastDisplayedRetainedObjectCount = 0

      lastHeapDumpUptimeMillis = SystemClock.uptimeMillis()

      ///清除 objectWatcher 中，在heapDumpUptimeMillis之前持有的对象，也就是已经dump的对象

      objectWatcher.clearObjectsWatchedBefore(heapDumpUptimeMillis)

       // 发送文件到HeapAnalyzerService解析

      HeapAnalyzerService.runAnalysis(

        context = application,

        heapDumpFile = heapDumpResult.file,

        heapDumpDurationMillis = heapDumpResult.durationMillis,

        heapDumpReason = reason

      )

    }

  }

}

 

HeapDumpTrigger#dumpHeap中调用到了 AndroidHeapDumper#dumpHeap方法。 并且在dump后马上调用 HeapAnalyzerService.runAnalysis 进行内存分析工作，该方法在下一节分析。先看AndroidHeapDumper#dumHeap源码

override fun dumpHeap(): DumpHeapResult {

//创建新的hprof 文件

  val heapDumpFile = leakDirectoryProvider.newHeapDumpFile() ?: return NoHeapDump



  val waitingForToast = FutureResult<Toast?>()

  ///展示dump吐司

  showToast(waitingForToast)



  ///如果展示吐司时间超过五秒，就不dump了

  if (!waitingForToast.wait(5, SECONDS)) {

    SharkLog.d { "Did not dump heap, too much time waiting for Toast." }

    return NoHeapDump

  }



  //省略dumpHeap通知栏提示消息代码

  val toast = waitingForToast.get()



  return try {

    val durationMillis = measureDurationMillis {

    //调用DumpHprofData

      Debug.dumpHprofData(heapDumpFile.absolutePath)

    }

    if (heapDumpFile.length() == 0L) {

      SharkLog.d { "Dumped heap file is 0 byte length" }

      NoHeapDump

    } else {

      HeapDump(file = heapDumpFile, durationMillis = durationMillis)

    }

  } catch (e: Exception) {

    SharkLog.d(e) { "Could not dump heap" }

    // Abort heap dump

    NoHeapDump

  } finally {

    cancelToast(toast)

    notificationManager.cancel(R.id.leak_canary_notification_dumping_heap)

  }

}

 

在该方法内，最终调用 Debug.dumpHprofData 方法 完成hprof 快照的生成。

六，分析内存 HeapAnalyzerService

上面代码分析中可以看到，在dumpHeap后紧跟着就是启动内存分析服务的方法。 现在我们跳转到HeapAnalyzerService的源码处。

override fun onHandleIntentInForeground(intent: Intent?) {

     //省略参数获取代码

  val config = LeakCanary.config

  val heapAnalysis = if (heapDumpFile.exists()) {

    analyzeHeap(heapDumpFile, config)

  } else {

    missingFileFailure(heapDumpFile)

  }

   //省略完善分析结果属性的代码

  onAnalysisProgress(REPORTING_HEAP_ANALYSIS)

  config.onHeapAnalyzedListener.onHeapAnalyzed(fullHeapAnalysis)

}

 

可以看到重点在于 analyzeHeap，其中调用了 HeapAnalyzer#analyze HeapAnalyzer 类位于shark模块中。

（1）HeapAnalyzer#analyze

内存分析方法代码如下：

fun analyze(

  heapDumpFile: File,

  leakingObjectFinder: LeakingObjectFinder,

  referenceMatchers: List<ReferenceMatcher> = emptyList(),

  computeRetainedHeapSize: Boolean = false,

  objectInspectors: List<ObjectInspector> = emptyList(),

  metadataExtractor: MetadataExtractor = MetadataExtractor.NO_OP,

  proguardMapping: ProguardMapping? = null

): HeapAnalysis {

  

 //省略内存快照文件不存在的处理代码



  return try {

    listener.onAnalysisProgress(PARSING_HEAP_DUMP)

   ///io读取 内存快照

    val sourceProvider = ConstantMemoryMetricsDualSourceProvider(FileSourceProvider(heapDumpFile))

    sourceProvider.openHeapGraph(proguardMapping).use { graph ->

      val helpers =

        FindLeakInput(graph, referenceMatchers, computeRetainedHeapSize, objectInspectors)

     //关键代码：在此处找到泄漏的结果以及其对应调用栈

      val result = helpers.analyzeGraph(

        metadataExtractor, leakingObjectFinder, heapDumpFile, analysisStartNanoTime

      )

      val lruCacheStats = (graph as HprofHeapGraph).lruCacheStats()

      ///io读取状态

      val randomAccessStats =

        "RandomAccess[" +

          "bytes=${sourceProvider.randomAccessByteReads}," +

          "reads=${sourceProvider.randomAccessReadCount}," +

          "travel=${sourceProvider.randomAccessByteTravel}," +

          "range=${sourceProvider.byteTravelRange}," +

          "size=${heapDumpFile.length()}" +

          "]"

      val stats = "$lruCacheStats $randomAccessStats"

      result.copy(metadata = result.metadata + ("Stats" to stats))

    }

  } catch (exception: Throwable) {

  //省略异常处理

  }

}

 

通过分析代码可知：分析内存快照分为以下5步：

1. 读取hprof内存快照文件
2. 找到LeakCanary 标记的泄漏对象们的数量和弱引用包装 ids，class name 为com.squareup.leakcanary.KeyedWeakReference

代码在 KeyedWeakReferenceFinder#findLeakingObjectIds

1. 找到泄漏对象的gcRoot开始的路径

代码在PathFinder#findPathsFromGcRoots

1. 返回分析结果，走结果回调
2. 回调内 展示内存分析成功或者失败的通知栏消息，并将泄漏列表存储到数据库中

详情代码看 DefaultOnHeapAnalyzedListener#onHeapAnalyzed 以及 LeaksDbHelper

1. 点开通知栏跳转到LeaksActivity 展示内存泄漏信息。

七，总结

终于从头到尾，总算是梳理了一波LeakCanary 源码

过程中学习到了这么多—>

• 主动调用Gc的方式 GcTrigger.Default.runGc()

Runtime.getRuntime().gc()

 

• seald class 密封类来表达状态，比如以下几个（关键好处在于使用when可以直接覆盖所有情况，而不必使用else）。

sealed class ICanHazHeap {

  object Yup : ICanHazHeap()

  abstract class Nope(val reason: () -> String) : ICanHazHeap()

  class SilentNope(reason: () -> String) : Nope(reason)

  class NotifyingNope(reason: () -> String) : Nope(reason)

}

sealed class Result {

  data class Done(

    val analysis: HeapAnalysis,

    val stripHeapDumpDurationMillis: Long? = null

    ) : Result()

  data class Canceled(val cancelReason: String) : Result()

}

 

• 了解了系统创建内存快照的api

 Debug.dumpHprofData(heapDumpFile.absolutePath)

 

• 知道了通过 ReferenceQueue 检测内存对象是否被gc，之前WeakReference都很少用。
• 学习了leakCanary的分模块思想。作为sdk,很多功能模块引入自动开启。比如 leakcanary-android-process 自动开启对应进程等。
• 学习了通过反射hook代码，替换实例达成添加钩子的操作。比如在Service泄漏监听代码中，替换Handler和activityManager的操作。