# 最后一个数为支点，从小到大排序
def partition_two(array, lo, hi):
    i = lo
    j = hi
    while i < j:
        while i < j and array[i] <= array[hi]:
            i += 1
        while i < j and array[j] >= array[hi]: # =保证支点不变，可以后续比较。
            j -= 1
        array[i], array[j] = array[j], array[i]
    array[i], array[hi] = array[hi], array[i]
    return i

# 快速排序
def quick_sort(array, lo, hi):
    #参数合法性
    if array is None or lo >= hi:
        return
    mid = partition_two(array, lo, hi)
    quick_sort(array, lo, mid - 1)
    quick_sort(array, mid + 1, hi)

#对数组来说，以下标index为根节点的左右子树的下标为 index * 2 + 1， index * 2 +  2
# 将length个元素，i为节点的数组堆化(i的子节点也都是堆)
def big_heap_array(array, i, length):
    # 左叶子节点
    temp_value = array[i]
    node_index = (i << 1) + 1
    while node_index < length:
        #左右叶子节点的较大值
        if node_index + 1 < length and array[node_index + 1] > array[node_index]:
            node_index = node_index + 1
        # 如果根节点大于叶子节点，说明已经是堆，退出循环。
        if array[node_index] < temp_value:
            break
        array[i] = array[node_index]
        # 调整交换过元素的子节点
        i = node_index
        node_index = (i << 1) + 1
    array[i] = temp_value

#n长度的数组，最后一个根节点的下标为： n / 2 - 1
#构建最大堆，从小到大排序
def heap_sort_one(array):
    # 最后一个跟节点
    last_node_index = (len(array) >> 1) - 1
    for node_index in range(last_node_index, 0 - 1, -1):  #[llast_node_index .. 0] 的列表
        big_heap_array(array, node_index, len(array))
    # 堆顶最大值和最后一个数互换， 然后堆化数组
    for index in range(len(array) - 1, 0, -1):
        array[0], array[index] = array[index], array[0]
        big_heap_array(array, 0, index)

react-native init FirstReact
cd FisrtReact
npm install 
react-native run-adnroid

{
  "presets": ["react-native"],
  "plugins": [
    "syntax-decorators",
    "transform-decorators-legacy"  ]
}

import {action, observable, useStrict} from "mobx";
import {extendObservable} from "mobx";

class AppState {
    @observable
    timer = 101;
    
    addTimers() {
        this.timer += 1
    }
    resetTimer() {
        this.timer = 0;
    }
}
export default new AppState()

@observer
class App extends React.Component {
    render() {
        return (
            <View>
                <Text>当前的数是：{AppState.timer}</Text>
                <Button
                    onPress={() =>
                        AppState.addTimers()}
                    title='add'
                />
                <Button
                    onPress={() =>
                        AppState.resetTimer()
                    }
                    title='reset'
                />
            </View>
        );
    }
}
export default App;

import { AppRegistry } from 'react-native';
import App from './mobx/MobxDemo';
AppRegistry.registerComponent('FirstReact', () => App);

import {action, observable, useStrict} from "mobx";
import {extendObservable} from "mobx";
class AppState {
    constructor() {
        let that = this;
        extendObservable(this, {
            timer: 11,
            get tenTimer() {
              return that.timer * 2
            },
            addTimers: action(function () {
                this.timer += 1
            }),
            resetTimer: action( () => {
                that.timer = 0
            })
        })
    }
}
export default new AppState()

import React from "react";
import {observer} from "mobx-react";
import {View, Text, Button} from "react-native";
import AppState from './AppState'
const App = observer( class MobxDemo extends React.Component {
    render() {
        return (
            <View>
                <Text>当前的数是：{AppState.tenTimer}</Text>
                <Button
                    onPress={() =>
                        AppState.addTimers()}
                    title='add'
                />
                <Button
                    onPress={() =>
                        AppState.resetTimer()
                    }
                    title='reset'
                />
            </View>
        );
    }
})
export default App;

fun TextView.countDown() {
    val frameLayout = FrameLayout(context)
    val rootView = LayoutInflater.from(context).inflate(R.layout.view_count_down, null)
    val mobileView = rootView.find<EditText>(R.id.vcd_et_mobile)
    val codeView = rootView.find<EditText>(R.id.vcd_et_code)
    val sendCode = rootView.find<TextView>(R.id.vcd_tv_send_code)
    sendCode.setOnClickListener {
        Timber.d("发送验证码")
    }

    val lp = FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
            FrameLayout.LayoutParams.WRAP_CONTENT)
    lp.topMargin = dp2px(20f)
    lp.bottomMargin = dp2px(20f)
    lp.leftMargin = dp2px(24f)
    lp.rightMargin = dp2px(24f)
    rootView.layoutParams = lp
    frameLayout.addView(rootView)

    AlertDialog.Builder(context).setTitle("手机号码")
            .setNegativeButton("取消", { _, _ ->
                showToast("取消")
            })
            .setPositiveButton("确认", { _, _ ->
                showToast("确认")
            })
            .setView(frameLayout)
            .show()
}

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:background="@color/white">

    <EditText
        android:id="@+id/vcd_et_mobile"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="@color/white"
        android:padding="10dp"
        android:hint="请输入手机"
        android:text=""
        android:textSize="16sp"
        />

    <EditText
        android:id="@+id/vcd_et_code"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:hint="请输入验证码"
        app:layout_constraintTop_toBottomOf="@id/vcd_et_mobile"
        app:layout_constraintRight_toLeftOf="@id/vcd_tv_send_code"
        android:background="@color/white"
        app:layout_constraintLeft_toLeftOf="parent"
        android:layout_marginTop="10dp"
        android:layout_marginRight="10dp"
        android:padding="10dp"
        android:textSize="16sp"
        />
    <TextView
        android:id="@+id/vcd_tv_send_code"
        android:layout_width="wrap_content"
        android:layout_height="0dp"
        app:layout_constraintTop_toTopOf="@id/vcd_et_code"
        app:layout_constraintBottom_toBottomOf="@id/vcd_et_code"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintLeft_toRightOf="@id/vcd_et_code"
        android:text="获取验证码"
        android:background="@color/white"
        android:textColor="@color/colorTextMain"
        android:textSize="16sp"
        android:gravity="center"
        />

</android.support.constraint.ConstraintLayout>

    var disposable: Disposable? = null
    val countTimesObservable = Observable.interval(1, TimeUnit.SECONDS)
            .take(10)
            .doOnDispose {
                Logger.d(TAG, "取消订阅")
            }
            .doOnSubscribe {
                Logger.d(TAG, "开始计时")
                disposable = it
            }.doOnComplete {
                Logger.d(TAG, "结束计时")
                sendCode.text = context.getString(R.string.login_get_code)
                disposable?.let {
                    if (it.isDisposed) {
                        it.dispose()
                    }
                }
            }
            .observeOn(AndroidSchedulers.mainThread())

    sendCode.setOnClickListener {
        countTimesObservable.subscribe {
            val second = 9 - it
            sendCode.text = "已发送($second)"
            Timber.d(second.toString())
        }
    }

04-14 14:50:57.915 28606-28606/com.swensun.swdesign D/ViewExtensionKt$countDown$countTimesObservable: 开始计时
04-14 14:50:58.922  D/ViewExtensionKt$countDown: 9
04-14 14:50:59.921  D/ViewExtensionKt$countDown: 8
04-14 14:51:00.921  D/ViewExtensionKt$countDown: 7
04-14 14:51:01.921  D/ViewExtensionKt$countDown: 6
04-14 14:51:02.919  D/ViewExtensionKt$countDown: 5
04-14 14:51:03.923  D/ViewExtensionKt$countDown: 4
04-14 14:51:04.922  D/ViewExtensionKt$countDown: 3
04-14 14:51:05.921  D/ViewExtensionKt$countDown: 2
04-14 14:51:06.922  D/ViewExtensionKt$countDown: 1
04-14 14:51:07.922  D/ViewExtensionKt$countDown$countTimesObservable: 结束计时
04-14 14:51:07.923  D/ViewExtensionKt$countDown: 0
04-14 14:51:07.924  D/ViewExtensionKt$countDown$countTimesObservable: 取消订阅

    AlertDialog.Builder(context).setTitle("手机号码")
            .setNegativeButton("取消", { _, _ ->
                showToast("取消")
                disposable?.dispose()
            })
            .setPositiveButton("确认", { _, _ ->
                showToast("确认")
                disposable?.dispose()
            })
            .setView(frameLayout)
            .show()

04-14 14:57:04.190 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown$countTimesObservable: 开始计时
04-14 14:57:05.198 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown: 9
04-14 14:57:06.198 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown: 8
04-14 14:57:07.197 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown: 7
04-14 14:57:08.197 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown: 6
04-14 14:57:09.116 28980-28980/com.swensun.swdesign D/ViewExtensionKt$countDown$countTimesObservable: 取消订阅

fun add1(a: Int, b: Int): Int {
    return a + b
}

fun calculate(a: Int, b: Int, f: (Int, Int) -> Int) : Int {
    return f(a, b)
}

codeBtn.setOnClickListener {
                when (position) {
                    0 -> {
                        codeBtn.countDown()
                    }
                    1 -> {
                        val result = calculate(2, 3, ::add1)
                        Timber.d("计算结果为: $result")
                    }
                }
            }

 D/CodeExampleActivity$ItemViewHolder$bindData: 计算结果为: 5

val add3 = {a: Int, b: Int -> a + b}
Timber.d(add3(3, 5).toString())
val result = calculate(2, 3, add3)
Timber.d("计算结果为: $result")

 D/CodeExampleActivity$ItemViewHolder$bindData: 函数对象计算结果：8
 D/CodeExampleActivity$ItemViewHolder$bindData: 计算结果为: 5

fun add4(): (Int, Int) -> Int {
    return ::add2
}

fun add5() = {
    add3
}

val add6 = add3

                        val addF = add4()

                        val addFF = add5()
                        Timber.d("函数add4(): ${add4()}")
                        Timber.d("函数对象addF: $addF")

                        Timber.d("函数add5(): ${add5()}")

                        Timber.d("函数对象addF计算结果：${addF(1, 2)}")
                        Timber.d("函数add4()计算结果: ${add4()(3, 4)}")


                        Timber.d("函数addFF计算结果: ${addFF()(4, 5)}")
                        Timber.d("函数add5()计算结果: ${add5()()(6, 7)}")

 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add4(): fun add2(kotlin.Int, kotlin.Int): kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数对象addF: fun add2(kotlin.Int, kotlin.Int): kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add5(): () -> (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数对象addF计算结果：3
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add4()计算结果: 7
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数addFF计算结果: 9
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add5()计算结果: 13

fun add7(): (Int, Int) -> Int {
    return fun(a: Int, b: Int): Int {
        return a + b
    }
}

fun add8(): (Int, Int) -> Int {
    return {a: Int, b: Int -> a + b}
}

val add9 = {a: Int, b: Int -> a + b}

                        val addF = add7()

                        val addFF = add8()
                        Timber.d("函数add7(): ${add7()}")
                        Timber.d("函数对象addF: $addF")

                        Timber.d("函数add8(): ${add8()}")
                        Timber.d("函数addFF: $addFF")

                        Timber.d("函数add6(): $add9")

                        Timber.d("函数对象addF计算结果：${addF(1, 2)}")
                        Timber.d("函数add7()计算结果: ${add7()(3, 4)}")


                        Timber.d("函数addFF计算结果: ${addFF(4, 5)}")
                        Timber.d("函数add8()计算结果: ${add8()(6, 7)}")

 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add7(): (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数对象addF: (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add8(): (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数addFF: (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add9: (kotlin.Int, kotlin.Int) -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数对象addF计算结果：3
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add7()计算结果: 7
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数addFF计算结果: 9
 D/CodeExampleActivity$ItemViewHolder$bindData: 函数add8()计算结果: 13

val add5_1 = { 10 }

val add5_2 = 10

fun add5_1() = {
    10
}

fun add5_2(): Int {
    return 10
}

                        val addF = add5_1
                        val addFF = add5_2
                        val addFFF = add5_1()
                        val addFFFF = add5_2()
                        Timber.d("$addF")
                        Timber.d("${addF()}")
                        Timber.d("$addFF")
                        Timber.d("$addFFF")
                        Timber.d("$addFFFF")

 D/CodeExampleActivity$ItemViewHolder$bindData: () -> kotlin.Int
 D/CodeExampleActivity$ItemViewHolder$bindData: 17
 D/CodeExampleActivity$ItemViewHolder$bindData: 10 D/CodeExampleActivity$ItemViewHolder$bindData: () -> kotlin.Int D/CodeExampleActivity$ItemViewHolder$bindData: 10

val add5_3_1 = {
    val temp = 10
    {a: Int -> a + temp}
}


fun add5_3_2() = {
    val temp = 10
    {a: Int -> a + temp}
}

                        Timber.d("${add5_3_1()(15)}")
                        Timber.d("${add5_3_2()()(15)}")

// docker-compose.yml
// command：启动是的命令行参数，添加认证auth
version: '2'
services:
  mongodb:
    image: mongo
    ports:
        - 27017:27017
    volumes:
        - "./data/configdb:/data/configdb"
        - "./data/db:/data/db"
    command: mongod --auth
    tty: true

docker exec -it 4 /bin/bash
mongo

use admin
db.createUser({ user: 'root', pwd: 'root', roles: [ { role: "userAdminAnyDatabase", db: "admin" } ] })

//拥有对数据库app的读写权限。
use app
db.createUser(
  {
    user: "swen",
    pwd: "swen",
    roles: [ { role: "readWrite", db: "app" }
             ]
  }
)

//判断2的幂次方
if (（n & -n） == n) // ture

FLAG_ACTIVITY_NEW_TASK
FLAG_ACTIVITY_CLEAR_TOP
FLAG_ACTIVITY_SINGLE_TOP

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)
    list.forEach { println(it) }
    // 1， 4， 7
}

public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)
    list.forEach { print1(it) }
    list.forEach { print2(it) }
    list.forEach({ print1(it) })
    list.forEach(print2)
    list.forEach(print3)
}

fun print1(a: Int) {
    print(a)
}

val print2 = { a: Int ->
    print(a)
}

val print3 = ::print1

    val list = arrayListOf(1, 4, 7)
    list.filter { it != 1 }.forEach { println(it) }  // 4, 7

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (predicate(element)) destination.add(element)
    return destination
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)
    list.add2().forEach { println(it) } // 3, 6, 9

}

fun Iterable<Int>.add2(): List<Int> {
    val tempList = arrayListOf<Int>()
    for (e in this) {
        tempList.add(e + 2)
    }
    return tempList
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)
    list.add2(3).forEach { println(it) }

}

fun Iterable<Int>.add2(a: Int): List<Int> {
    val tempList = arrayListOf<Int>()
    for (e in this) {
        tempList.add(e + a)
    }
    return tempList
}

inline fun Iterable<Int>.calculate(f: (Int) -> Int): List<Int> {
    val tempList = arrayListOf<Int>()
    for (e in this) {
        tempList.add(f(e))
    }
    return tempList
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)
    list.calculate { add2(it) }.forEach { println(it) }
    list.calculate { add3(it) }.forEach { println(it) }

    list.calculate(::add2).forEach { println(it) }
    list.calculate(add3).forEach { println(it) }

    list.calculate { it + 2 }.forEach { println(it) }
}

fun add2(a: Int): Int {
    return a + 2
}

val add3 = {a: Int -> a + 2}

inline fun Iterable<Int>.calculate(f: (Int) -> Int): List<Int> {
    val tempList = arrayListOf<Int>()
    for (e in this) {
        tempList.add(f(e))
    }
    return tempList
}

fun Iterable<Int>.add2(): List<Int> {
    val tempList = arrayListOf<Int>()
    for (e in this) {
        tempList.add(e + 2)
    }
    return tempList
}

fun Iterable<Int>.add2(): List<Int> {
    val tempList = this.map { it + 2 }
    return tempList
}

fun Iterable<Int>.add2(): List<Int> {
    return map { it + 2 }
}

fun main(args: Array<String>) {
    val list = arrayListOf(1, 4, 7)

    list.add2().forEach { println(it) }
    list.map { it + 2 }.forEach { println(it) }
    list.map(::add2).forEach { println(it) }
}

fun add2(a :Int): Int {
    return a + 2
}

fun <T> T?.println() = kotlin.io.println(this)

fun main(args: Array<String>) {
    add(1, 2).println()
}

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main(args: Array<String>) {
    add(1, 2).println()
    add1(1)(2).println()
    add2(1)(2).println()

    add3(1)(2).println()

}

fun add(a: Int, b: Int): Int {
    return a + b
}
fun add1(a: Int): (Int) -> Int {
    return {b: Int -> a + b}
}
fun add2(a: Int) = {b: Int -> a + b}

val add3 = {a: Int -> {b: Int -> a + b}}

    val addOne = add1(1)
    addOne(2).println()
    addOne(4).println()

fun main(args: Array<String>) {

    add(1, 2, 3).println()
    add1(1)(2)(3).println()
}

fun add(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

fun add1(a: Int): (Int) -> (Int) -> Int {
    return fun(b: Int): (Int) -> Int {
        return {c: Int -> a + b + c}
    }
}

fun main(args: Array<String>) {
    ::add.curried()(1)(2)(3).println()   // 6
}

fun <P1, P2, P3, R> Function3<P1, P2, P3, R>.curried()
        = fun(p1: P1) = fun(p2: P2) = fun(p3: P3) = this(p1, p2, p3)

fun <P1, P2, R> Function2<P1, P2, R>.curried()
        = fun(p1: P1) = fun(p2: P2) = this(p1, p2)

fun add(a: Int, b: Int, c: Int): Int {
    return a + b + c
}

/**
 * A functional interface (callback) that computes a value based on multiple input values.
 * @param <T1> the first value type
 * @param <T2> the second value type
 * @param <T3> the third value type
 * @param <R> the result type
 */
public interface Function3<T1, T2, T3, R> {
    /**
     * Calculate a value based on the input values.
     * @param t1 the first value
     * @param t2 the second value
     * @param t3 the third value
     * @return the result value
     * @throws Exception on error
     */
    @NonNull
    R apply(@NonNull T1 t1, @NonNull T2 t2, @NonNull T3 t3) throws Exception;
}

 fun <P1, P2, R> Function2<P1, P2, R>.partial1(p1: P1) = fun(p2: P2) = this(p1, p2) 
 fun <P1, P2, R> Function2<P1, P2, R>.partial2(p2: P2) = fun(p1: P1) = this(p1, p2)

fun main(args: Array<String>) {
    val addOne = add.partial1(1)
    val addTwo = add.partial2("2")
    addOne("2").println()
    addTwo(3).println()
}

val add = {a:Int, b: String -> "$a$b"}

if __name__ == '__main__':
   url = 'https://www.zhihu.com/collection/146079773'
   res = requests.get(url, verify=False)
   resSoup = BeautifulSoup(res.content, 'lxml')
   items = resSoup.select("div > h2 > a")
   print(len(items))

if __name__ == '__main__':
    url = 'https://www.zhihu.com/collection/146079773'
    # res = requests.get(url, verify=False)
    driver = webdriver.Chrome()
    driver.get(url)
    driver.implicitly_wait(2)
    res = driver.page_source
    resSoup = BeautifulSoup(res, 'lxml')
    items = resSoup.select("div > h2 > a")
    print(len(items))

if __name__ == '__main__':

    ssl._create_default_https_context = ssl._create_unverified_context
    # url = 'https://www.zhihu.com/collection/146079773'
    url = "https://www.zhihu.com/signin"
    # res = requests.get(url, verify=False)
    driver = webdriver.Chrome()
    driver.implicitly_wait(5)
    driver.get(url)
    time.sleep(40)
    cookies = driver.get_cookies()
    pickle.dump(cookies, open("cookies.pkl", "wb"))
    print("save suc")

if __name__ == '__main__':
    cookies = pickle.load(open("cookies.pkl", "rb"))
    url = 'https://www.zhihu.com/collection/146079773'
    driver = webdriver.Chrome()
    driver.get("https://www.zhihu.com/signin")
    for cookie in cookies:
        print(cookie)
        driver.add_cookie(cookie)
    driver.get(url)
    driver.implicitly_wait(2)
    res = driver.page_source
    resSoup = BeautifulSoup(res, 'lxml')
    items = resSoup.select("div > h2 > a")
    print(len(items))

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    # 'zhihu.middlewares.PhantomJSMiddleware': 100,
}

# Configure maximum concurrent requests performed by Scrapy (default: 16)
# CONCURRENT_REQUESTS = 32

# Configure a delay for requests for the same website (default: 0)
# See http://scrapy.readthedocs.org/en/latest/topics/settings.html#download-delay
# See also autothrottle settings and docs
DOWNLOAD_DELAY = 2
# The download delay setting will honor only one of:
# CONCURRENT_REQUESTS_PER_DOMAIN = 16
# CONCURRENT_REQUESTS_PER_IP = 16

class Zhihu(scrapy.Spider):
    name = "zhihu"
    cookeis = pickle.load(open("cookies.pkl", "rb"))
    urls = []
    questions_url = set()
    for i in range(1, 11):
        temp_url = "https://www.zhihu.com/collection/146079773?page=" + str(i)
        urls.append(temp_url)

    def start_requests(self):
        for url in self.urls:
            request = scrapy.Request(url=url, callback=self.parse, cookies=self.cookeis)
            yield request

    def parse(self, response):
        print(response.url)
        resSoup = BeautifulSoup(response.body, 'lxml')
        items = resSoup.select("div > h2 > a")
        print(len(items))
        for item in items:
            print(item['href'])
            self.questions_url.add(item['href'] + "\n")

    @classmethod
    # 信号的使用
    def from_crawler(cls, crawler, *args, **kwargs):
        print("from_crawler")
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_closed)
        return s

    def spider_opened(self, spider):
        print("spider close, save urls")
        with open("urls.txt", "w") as f:
            for url in self.questions_url:
                f.write(url)

class StoryListFragment : LifecycleFragment() {}

//源码
public interface LifecycleRegistryOwner extends LifecycleOwner {
    @Override
    LifecycleRegistry getLifecycle();
}

class MainObserve : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    internal fun start() {
        Log.d(TAG, "start: " + "init")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    internal fun create() {
        Log.d(TAG, "create: " + "init")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    internal fun stop() {
        Log.d(TAG, "stop: " + "init")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    internal fun destory() {
        Log.d(TAG, "destory: " + "init")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    internal fun resume() {
        Log.d(TAG, "resume: " + "init")
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    internal fun pause() {
        Log.d(TAG, "pause: " + "init")
    }
    companion object {
        private val TAG = "MyObserve"
    }
}

class StoryListViewModel(val app: Application): AndroidViewModel(app) {}

//使用了Dagger2， 不懂可以跳过。后面会写文章介绍。
//简单理解；等同于new， 创建实例
class StoryRepository @Inject
constructor(var db: AppDatabase) {

    companion object {
        var TAG = "StoryRepository"
    }

    fun insertStories(storys: List<Story>) {
        Flowable.just(storys)
                .observeOn(Schedulers.io())
                .subscribe {
                    db.beginTransaction()
                    try {
                        db.storyDao().insertStories(storys)
                        db.setTransactionSuccessful()
                    } finally {
                        db.endTransaction()
                    }
                }
    }
    fun loadAllStories(): LiveData<List<Story>> {
        var result = db.storyDao().loadAllStoriesLiveData()
        return  result
    }

    fun simlutateInsertData() {
        var list = ArrayList<Story>()

        for (i in 1..20) {
            var s = Story()
            s.id = (i)
            s.data = ((i * i).toString() + "--" + i.toString())
            s.displayData = ((i * i).toString() + "--" + i.toString())
            s.title = ((i * i).toString() + "--" + i.toString())
            s.image = ((i * i).toString() + "--" + i.toString())
            list.add(s)
        }
        insertStories(list)
    }
}

var storyList = MediatorLiveData<List<Story>>()

@Inject
//实例化StoryRepository
lateinit var storyRes: StoryRepository

class StoryListViewModel(val app: Application): AndroidViewModel(app) {
    companion object {
        val TAG = "StoryListViewModel"
    }
    var storyList = MediatorLiveData<List<Story>>()

    @Inject
    lateinit var storyRes: StoryRepository
    init {
        (app as ZhiJokeApplication).component.inject(this)
    }
    fun getStoryList():LiveData<List<Story>> {
        storyList.addSource(storyRes.loadAllStories(), {
            if (it == null || it.size == 0) {
                storyRes.simlutateInsertData()
                Thread.sleep(1000)
            }
            storyList.postValue(it)
        })
        return storyList
    }
}

var viewModel = ViewModelProviders.of(activity).get(StoryListViewModel::class.java)
        viewModel.getStoryList().observe(this, Observer {
            if (it != null) {
            // update UI
                mAdapter.setStories(it)
            }
        })

{'url': '/question/36007260', 'title': '女生坚持健身是种什么样的体验？', 'dec': ['健身']}
{'url': '/question/22132862', 'title': '女生如何选购适合自己的泳装？', 'dec': ['泳装']}
{'url': '/question/22918070', 'title': '女生如何健身锻造好身材？', 'dec': ['健身']}
{'url': '/question/24214727', 'title': '大胸妹子如何挑选合身又好看的比基尼？', 'dec': [ '比基尼']}
{'url': '/question/263451180', 'title': '你觉得健身时哪个训练动作最酷炫？', 'dec': ['健身']}
{'url': '/question/28586345', 'title': '有马甲线是种怎样的体验？', 'dec': ['马甲线']}
{'url': '/question/68734869', 'title': '2017 年，你解锁了哪些运动技能？可以用「视频」展示么？', 'dec': ['解锁']}
{'url': '/question/31983868', 'title': '有什么好看的泳装推荐？', 'dec': ['泳装']}

import scrapy
class Zhihu(scrapy.Spider):
    name = "zhihu"
    urls = ["https://www.zhihu.com/question/22856657"]
    yield request

    def start_requests(self):
        for url in self.urls:
            request = scrapy.Request(url=url, callback=self.parse)

    def parse(self, response):
        print(response.url)
        print(response.body)

#重试设置
RETRY_ENABLE = False

# 日志输出
LOG_ENABLED = True
LOG_LEVEL = "INFO"

# Obey robots.txt rules
ROBOTSTXT_OBEY = False

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
}

import scrapy
from bs4 import BeautifulSoup

class Zhihu(scrapy.Spider):
    name = "zhihu"
    urls = ["https://www.zhihu.com/question/22856657"]


    def start_requests(self):
        for url in self.urls:
            request = scrapy.Request(url=url, callback=self.parse)
            yield request

    def parse(self, response):
        print(response.url)
        resSoup = BeautifulSoup(response.body, 'lxml')
        items = resSoup.select("figure")
        print(len(items))
        for item in items:
            print(item)
            print(item.img)
            print(item.img['data-original'])

if __name__ == '__main__':
    options = webdriver.ChromeOptions()
    options.add_argument('headless')
    # driver = webdriver.Chrome(options=options)
    driver = webdriver.Chrome()
    driver.implicitly_wait(2)
    driver.get("https://www.zhihu.com/question/22856657")
    time.sleep(2)
    resSoup = BeautifulSoup(driver.page_source, 'lxml')
    items = resSoup.select("figure > span > div")
    print(len(items))
    for item in items:
        print(item)
    #driver.close()

if __name__ == '__main__':
    options = webdriver.ChromeOptions()
    options.add_argument('headless')
    # driver = webdriver.Chrome(options=options)
    driver = webdriver.Chrome()
    driver.implicitly_wait(2)
    driver.get("https://www.zhihu.com/question/22856657")
    time.sleep(2)

    count = 1
    css_selector = "#root > div > main > div > div.Question-main > div.Question-mainColumn > div > div.Card > button"
    css_selector2 = "#root > div > main > div > div.Question-main > div.Question-mainColumn > div > div.CollapsedAnswers-bar"
    while len(driver.find_elements_by_css_selector(css_selector)) == 0 and \
            len(driver.find_elements_by_css_selector(css_selector2)) == 0:
        print("count:" + str(count))
        js = "var q=document.documentElement.scrollTop=" + str(count * 200000)
        count += 1
        driver.execute_script(js)
        time.sleep(0.5)

    resSoup = BeautifulSoup(driver.page_source, 'lxml')
    items = resSoup.select("figure > span > div")
    print(len(items))
    for item in items:
        print(item)

class PhantomJSMiddleware(object):

    def __init__(self):
        options = webdriver.ChromeOptions()
        options.add_argument('headless')
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(1)

    def process_request(self, request, spider):
        print(request.url)
        driver = self.nextPage(request)
        return HtmlResponse(url=request.url, body=driver.page_source, encoding="utf-8")
        # 翻页操作

    def nextPage(self, request):
        self.driver.get(request.url)
        time.sleep(2)
        count = 1
        css_selector = "#root > div > main > div > div.Question-main > div.Question-mainColumn > div > div.Card > button"
        css_selector2 = "#root > div > main > div > div.Question-main > div.Question-mainColumn > div > div.CollapsedAnswers-bar"
        # css_selector = "div > a > img"
        # print(len(self.driver.find_elements_by_css_selector(css_selector)))
        while len(self.driver.find_elements_by_css_selector(css_selector)) == 0 and len(
                self.driver.find_elements_by_css_selector(css_selector2)) == 0:
            print("count:" + str(count))
            js = "var q=document.documentElement.scrollTop=" + str(count * 200000)
            count += 1
            self.driver.execute_script(js)
            time.sleep(0.5)
        print(count)
        time.sleep(2)
        return self.driver

    @classmethod
    # 信号的使用
    def from_crawler(cls, crawler):
        print("from_crawler")
        # This method is used by Scrapy to create your spiders.
        s = cls()
        crawler.signals.connect(s.spider_opened, signal=signals.spider_closed)
        return s

    def spider_opened(self, spider):
        print("spider close")
        self.driver.close()

DOWNLOADER_MIDDLEWARES = {
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None,
    'zhihu.middlewares.PhantomJSMiddleware': 100,
}

fun checkFloatWindowPermission(): Boolean {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        val result = Settings.canDrawOverlays(BaseContext.application)
        return result
    } else {
        //6.0 以下
        val result = checkRomFloatWindowPermission()
        return result
    }
    return true
}

//如下，经过我的测试，只有小米和魅族， 华为需要在`api<=19`时单独处理，其他正常。
fun checkRomFloatWindowPermission(): Boolean {

    val brand = Build.MANUFACTURER
    if (brand.contains("Xiaomi")) {
        //check miui permission
        return checkMeizuAndMIUIFloatWindowPermission()
    }
    if (brand.contains("Huawei") || brand.contains("HUAWEI")) {
        return checkMeizuAndMIUIFloatWindowPermission()
    }
    if (Build.VERSION.SDK_INT <= 19) {
        return true
    }
    when (brand) {
        "Meizu" -> return checkMeizuAndMIUIFloatWindowPermission()
        "OPPO" -> return true
        "vivo" -> return true
        "Sony" -> return true
        "Letv" -> return true
        "LG" -> return true
    }
    return true
}

//-------------- Meizu MIUI huawei start---------------------

fun checkMeizuAndMIUIFloatWindowPermission(): Boolean {
    if (Build.VERSION.SDK_INT >= 19) {
        return checkMeizuAndMIUIOp(24)
    }
    return true
}

fun checkMeizuAndMIUIOp(op: Int): Boolean {
    if (Build.VERSION.SDK_INT >= 19) {
        val opsManager = BaseContext.application.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
        try {
            val clazz = AppOpsManager::class.java
            val method = clazz.getDeclaredMethod("checkOp",
                    Int::class.javaPrimitiveType, Int::class.javaPrimitiveType, String::class.java)
            return AppOpsManager.MODE_ALLOWED == method.invoke(opsManager, op, Binder.getCallingUid(), BaseContext.application.packageName)
        } catch (e: Exception) {
            Logger.d(TAG, "checkOp", e)
        }
    } else {
        Logger.d(TAG, "Below API 19 cannot invoke!")
    }
    return false
}

//-------------- Meizu MIUI end ---------------------

fun applyFloatWindowPermission(context: Context) {
    if (Build.VERSION.SDK_INT >= 23) {
        applySystemPermission(context)
        return
    }
    val brand = Build.MANUFACTURER
    when (brand) {
        "Huawei", "HUAWEI" -> applyHuaweiPermission(context)
        "Xiaomi" -> applyMIUIPermSetting(context)
        "Meizu" -> applyMeizuPermission(context)
        "OPPO" -> openOppoPermSetting(context)
        "vivo" -> openVivoPermSetting(context)
        else -> applySystemPermission(context)
    }
}

//-------------- Sysytem start ---------------------

fun  applySystemPermission(activity: Activity) {
    val intent = Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION)
    intent.data = Uri.parse("package:" + activity.packageName)
    activity.startActivityForResult(intent, 1)

}

//-------------- Sysytem end ---------------------

//-------------- Meizu start---------------------
fun applyMeizuPermission(activity: Activity) {
    val intent = Intent("com.meizu.safe.security.SHOW_APPSEC")
    intent.setClassName("com.meizu.safe", "com.meizu.safe.security.AppSecActivity")
    intent.putExtra("packageName", activity.packageName)
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    activity.startActivity(intent)
}

//-------------- Meizu end ---------------------

//-------------- MIUI start---------------------
fun applyMIUIPermSetting(activity: Activity) {
    openMIUIPermSetting(activity)
}

fun openMIUIPermSetting(context: Context): Boolean {
    val i = Intent("miui.intent.action.APP_PERM_EDITOR")
    val componentName = ComponentName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity")
    i.component = componentName
    i.putExtra("extra_pkgname", context.packageName)
    try {
        context.startActivity(i)
    } catch (e: Exception) {
        Logger.e(TAG, "openMIUIPermSetting jump e:" + e.message)
        openSystemSetting(context)
        return false
    }
    return true
}
//-------------- MIUI start---------------------

//-------------- huawei start---------------------

fun applyHuaweiPermission(context: Context) {
    try {
        val intent = Intent()
        intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
        var comp = ComponentName("com.huawei.systemmanager", "com.huawei.systemmanager.addviewmonitor.AddViewMonitorActivity")//悬浮窗管理页面
        intent.component = comp
        val version = getEmuiVersion()
        Logger.d(TAG, "applyHuaweiPermission:"  + version)
        if (version == 3.0) {
            comp = ComponentName("com.huawei.systemmanager", "com.huawei.notificationmanager.ui.NotificationManagmentActivity")//悬浮窗管理页面
            intent.component = comp
            context.startActivity(intent)
            return
        }
        context.startActivity(intent)
//        if (version == 3.1) {
//            //emui 3.1 的适配
//            context.startActivity(intent)
//        } else {
//            //emui 3.0 的适配
//            comp = ComponentName("com.huawei.systemmanager", "com.huawei.notificationmanager.ui.NotificationManagmentActivity")//悬浮窗管理页面
//            intent.component = comp
//            context.startActivity(intent)
//        }
    } catch (e: Exception) {
        //抛出异常时提示信息
        Toast.makeText(context, "进入设置页面失败，请手动设置", Toast.LENGTH_LONG).show()
        Log.e(TAG, Log.getStackTraceString(e))
    }
}

fun getEmuiVersion(): Double {
    try {
        val emuiVersion = getSystemProperty("ro.build.version.emui") ?: return 4.0
        val version = emuiVersion.substring(emuiVersion.indexOf("_") + 1)
        return java.lang.Double.parseDouble(version)
    } catch (e: Exception) {
        e.printStackTrace()
    }
    return 4.0
}
//-------------- huawei end---------------------

// open app setting according to rom ----------------

fun applyBrandStrategy(activity: Activity) {
    val brand = Build.MANUFACTURER
    when (brand) {
        "Huawei", "HUAWEI" -> openHuaweiPermSetting(activity)
        "Xiaomi" -> openMIUIPermSetting(activity)
        "Meizu" -> openMeizuPermSetting(activity)
        "OPPO" -> openOppoPermSetting(activity)
        "vivo" -> openVivoPermSetting(activity)
        "Sony" -> openSonyPermSetting(activity)
        "Letv" -> openLetvPermSetting(activity)
        "LG" -> openLGPermSetting(activity)
        else -> openSystemSetting(activity)
    }
}

fun openMIUIPermSetting(activity: Activity): Boolean {
    val i = Intent("miui.intent.action.APP_PERM_EDITOR")
    val componentName = ComponentName("com.miui.securitycenter", "com.miui.permcenter.permissions.AppPermissionsEditorActivity")
    i.component = componentName
    i.putExtra("extra_pkgname", activity.packageName)
    try {
        activity.startActivity(i)
    } catch (e: Exception) {
        Logger.e(TAG, "openMIUIPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openMeizuPermSetting(activity: Activity): Boolean {
    val intent = Intent("com.meizu.safe.security.SHOW_APPSEC")
    intent.addCategory(Intent.CATEGORY_DEFAULT)
    intent.putExtra("packageName", activity.packageName)
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openMeizuPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openHuaweiPermSetting(activity: Activity): Boolean {
    val intent = Intent()
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    var comp = ComponentName("com.huawei.systemmanager", "com.huawei.permissionmanager.ui.MainActivity")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openHuaweiPermSetting jump e:" + e.message)
        comp = ComponentName("com.huawei.systemmanager", "com.huawei.permissionmanager.ui.SingleAppActivity")
        intent.component = comp
        try {
            activity.startActivity(intent)
        } catch (e1: Exception) {
            Logger.e(TAG, "openHuaweiPermSetting jump e1:" + e.message)
            openSystemSetting(activity)
            return false
        }
    }

    return true
}

fun openOppoPermSetting(activity: Activity): Boolean {
    val intent = Intent()
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    val comp = ComponentName("com.oppo.safe", "com.oppo.safe.permission.PermissionSettingsActivity")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openOppoPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openVivoPermSetting(activity: Activity): Boolean {
    val intent = Intent()
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    val comp = ComponentName("com.iqoo.secure", "com.iqoo.secure.MainActivity")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openVivoPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openSonyPermSetting(activity: Activity): Boolean {
    val intent = Intent()
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    val comp = ComponentName("com.sonymobile.cta", "com.sonymobile.cta.SomcCTAMainActivity")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openSonyPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openLGPermSetting(activity: Activity): Boolean {
    val intent = Intent("android.intent.action.MAIN")
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    val comp = ComponentName("com.android.settings", "com.android.settings.Settings\$AccessLockSummaryActivity")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openLGPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openLetvPermSetting(activity: Activity): Boolean {
    val intent = Intent()
    intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
    intent.putExtra("packageName", activity.packageName)
    val comp = ComponentName("com.letv.android.letvsafe", "com.letv.android.letvsafe.PermissionAndApps")
    intent.component = comp
    try {
        activity.startActivity(intent)
    } catch (e: Exception) {
        Logger.e(TAG, "openLetvPermSetting jump e:" + e.message)
        openSystemSetting(activity)
        return false
    }

    return true
}

fun openSystemSetting(activity: Activity): Boolean {
    val localIntent = Intent()
    localIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
    localIntent.action = "android.settings.APPLICATION_DETAILS_SETTINGS"
    localIntent.data = Uri.fromParts("package", activity.packageName, null)
    try {
        activity.startActivity(localIntent)
    } catch (e: Exception) {
        Logger.e(TAG, "openSystemSetting jump e:" + e.message)
        return false
    }

    return true
}

    private fun applySelfStartSetting() {

        var intent = Intent()
        try {
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
            var componentName: ComponentName? = null
            val brand = Build.MANUFACTURER
            when (brand) {
                "Xiaomi" -> {
                    componentName = ComponentName("com.miui.securitycenter", "com.miui.permcenter.autostart.AutoStartManagementActivity")
                }
                "samsung", "Samsung" -> {
                    componentName = ComponentName("com.samsung.android.sm" ,"com.samsung.android.sm.app.dashboard.SmartManagerDashBoardActivity")
                }
                "Huawei", "HUAWEI" -> {
                    componentName = ComponentName("com.huawei.systemmanager", "com.huawei.systemmanager.optimize.process.ProtectActivity")
                }
                "Meizu" -> {
                    componentName = ComponentName.unflattenFromString("com.meizu.safe/.permission.SmartBGActivity")
                }
                "OPPO" -> {
                    componentName = ComponentName.unflattenFromString("com.oppo.safe/.permission.startup.StartupAppListActivity")
                }
                "vivo" -> {
                    componentName = ComponentName.unflattenFromString("com.iqoo.secure/.safeguard.PurviewTabActivity")
                }
                "Letv" -> {
                    intent.action = "com.letv.android.permissionautoboot"
                }
                else -> {
                    intent.action = "android.settings.APPLICATION_DETAILS_SETTINGS"
                    intent.data = Uri.fromParts("package", packageName, null)
                }
            }
            intent.component = componentName
            startActivity(intent)
        } catch (e: Exception) {
            Logger.d(PhoneDialogActivity.TAG, "applySelfStartSetting:"  + e)
            intent = Intent(Settings.ACTION_SETTINGS)
            startActivity(intent)
        }
    }

1. BOARD 主板：The name of the underlying board, like goldfish. 
2.  BOOTLOADER 系统启动程序版本号：The system bootloader version number. 
3. BRAND 系统定制商：The consumer-visible brand with which the product/hardware will be associated, if any. 
4. CPU_ABI cpu指令集：The name of the instruction set (CPU type + ABI convention) of native code. 
5. CPU_ABI2 cpu指令集2：The name of the second instruction set (CPU type + ABI convention) of native code. 
6. DEVICE 设备参数：The name of the industrial design. 
7. DISPLAY 显示屏参数：A build ID string meant for displaying to the user 
8. FINGERPRINT 唯一识别码：A string that uniquely identifies this build. Do not attempt to parse this value. 
9. HARDWARE 硬件名称：The name of the hardware (from the kernel command line or /proc). 
10. HOST 
11. ID 修订版本列表：Either a changelist number, or a label like M4-rc20. 
12. MANUFACTURER 硬件制造商：The manufacturer of the product/hardware.（我们目前只需要关注这个静态属性即可）
13. MODEL 版本即最终用户可见的名称：The end-user-visible name for the end product. 
14. PRODUCT 整个产品的名称：The name of the overall product. 
15. RADIO 无线电固件版本：The radio firmware version number. 在API14后已过时。使用 getRadioVersion()代替。 
16. SERIAL 硬件序列号：A hardware serial number, if available. Alphanumeric only, case-insensitive. 
17. TAGS 描述build的标签,如未签名，debug等等。：Comma-separated tags describing the build, like unsigned,debug. 
18. TIME 
19. TYPE build的类型：The type of build, like user or eng. 
20. USER

获取设备电池信息：adb shell dumpsys battery
获取cpu信息：adb shell dumpsys cpuinfo
获取内存信息：adb shell dumpsys meminfo 
要获取具体应用的内存信息，可加上包名 
adb shell dumpsys meminfo PACKAGE_NAME
获取Activity信息：adb shell dumpsys activity
获取package信息：adb shell dumpsys package 
加上-h可以获取帮助信息 
获取某个包的信息：adb shell dumpsys package PACKAGE_NAME
获取通知信息：adb shell dumpsys notification
获取wifi信息：adb shell dumpsys wifi 
可以获取到当前连接的wifi名、搜索到的wifi列表、wifi强度等
获取电源管理信息：adb shell dumpsys power 
可以获取到是否处于锁屏状态：mWakefulness=Asleep或者mScreenOn=false
获取电话信息：adb shell dumpsys telephony.registry 
可以获取到电话状态，例如mCallState值为0，表示待机状态、1表示来电未接听状态、2表示电话占线状态 
mCallForwarding=false #是否启用呼叫转移 
mDataConnectionState=2 #0：无数据连接 1：正在创建数据连接 2：已连接mDataConnectionPossible=true #是否有数据连接mDataConnectionApn= #APN名称等

adb shell dumpsys activity top
//获取当前显示activity的详细信息，包括所属包名和activity名，activity的布局信息等等。

//电话相关权限
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
<uses-permission android:name="android.permission.CALL_PHONE"/>

    private void checkAndRquestCallPermission() {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "checkCallPermission: " + "没有打电话权限");
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, 1);// 1:code
        }
    }

    //重载activity的onRequestPermissionsResult方法
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == 1) {
            if (1 == grantResults.length && PackageManager.PERMISSION_GRANTED == grantResults[0]) {
                Log.d(TAG, "onRequestPermissionsResult: " + "已获取：" + permissions[0] + " 权限");
            }     
        } else {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }

    private void checkAndRquestCallPermission() {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "checkCallPermission: " + "没有电话权限");
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)) {
                Log.d(TAG, "checkCallPermission: " + "need phone permission");
                //弹出对话框，提示用户允许或者拒绝，允许则请求权限
            }
            //此处默认允许
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, 1);// 1:code
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == 1) {
            if (1 == grantResults.length && PackageManager.PERMISSION_GRANTED == grantResults[0]) {
                Log.d(TAG, "onRequestPermissionsResult: " + "以获取：" + permissions[0] + " 权限");
            }
            else {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)) {
//                  //用户没有勾选不再提示，并拒绝
                    Log.d(TAG, "onRequestPermissionsResult: " + "refuse one time");
                } else {
//                    用户勾选提示并拒绝
                    Log.d(TAG, "onRequestPermissionsResult: " + "refuse forever");
                    //跳转权限设置页
                }
            }
        } else {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }

public class PhoneReceiver extends BroadcastReceiver {
    private static final String TAG = "PhoneReceiver";
    private boolean mInComingFlag = false;
    private static String ACTION_NEW_INCOMMING_CALL = "android.intent.action.PHONE_STATE";
    private PhoneStateListener listen = new PhoneStateListener(){
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            super.onCallStateChanged(state, incomingNumber);
            switch (state) {
                case TelephonyManager.CALL_STATE_RINGING:
                    //电话打进响铃中，电话打出没有此状态
                    mInComingFlag = true;
                    Log.d(TAG, "onCallStateChanged: " + incomingNumber);
                    break;
                case TelephonyManager.CALL_STATE_IDLE:
                    //挂断电话
                    if (mInComingFlag) {
                        Log.d(TAG, "onCallStateChanged: " + "call hang up");
                    }
                    break;
                case TelephonyManager.CALL_STATE_OFFHOOK:
                    //电话接听
                    if (mInComingFlag) {
                        Log.d(TAG, "onCallStateChanged: " + "接听电话：" + incomingNumber);
                    }
            }
        }
    };

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
            //电话打出
            mInComingFlag = false;
            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
            Log.d(TAG, "onReceive: " + "call phoneNumber：" + phoneNumber);
        }
        if (intent.getAction().equals(ACTION_NEW_INCOMMING_CALL)) {
            //电话打进
            TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            tm.listen(listen, PhoneStateListener.LISTEN_CALL_STATE);

        }
    }
}

        <receiver android:name=".phone.PhoneReceiver"
                  android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.NEW_OUTGOING_CALL"/>
                <action android:name="android.intent.action.PHONE_STATE"/>
                <action android:name="android.intent.action.MY_SELF_RECEIVER"/>
            </intent-filter>
        </receiver>

                //发送自定义广播，PhoneReceiver接收
                Intent intent = new Intent(ACTION);
                intent.putExtra("Msg", "helloReceiver");
                sendBroadcast(intent);

    //选择语言并保存状态
    private void changeLanguage() {
        //弹出对话框或者其他方式选择语言，并持久化保存到本地
        AlertDialog.Builder builder = new AlertDialog.Builder(this);
        builder.setSingleChoiceItems(new String[]{"auto", "English", "简体中文"},
                getSharedPreferences("language", Context.MODE_PRIVATE).getInt("language", 0),
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        SharedPreferences preferences = getSharedPreferences("language", Context.MODE_PRIVATE);
                        SharedPreferences.Editor editor = preferences.edit();
                        Log.d(TAG, "onClick: " + which);
                        //保存设置
                        editor.putInt("language", which);
                        editor.apply();
                        dialog.dismiss();

                        Intent intent = new Intent(MultiLanguageActivity.this, MultiLanguageActivity.class);
                        //重新打开一个返回栈并清除前者
                        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
                        startActivity(intent);
                    }
                });
        AlertDialog dialog = builder.create();
        dialog.show();
    }

    //加载所保存的语言
    private void setLanguage() {
        SharedPreferences preferences = getSharedPreferences("language", Context.MODE_PRIVATE);
        int language = preferences.getInt("language", 0);

        Resources resources  = getResources();
        DisplayMetrics dispalyMetRics = resources.getDisplayMetrics();
        Configuration configuration = resources.getConfiguration();
        switch (language) {
            case 0:
                configuration.setLocale(Locale.getDefault());
                break;
            case 1:
                configuration.setLocale(Locale.ENGLISH);
                break;
            case 2:
                configuration.setLocale(Locale.CHINESE);
                break;
        }
        // FIXME: 2017/6/5
        resources.updateConfiguration(configuration, dispalyMetRics);
    }

getSupportActionBar().setTitle(R.string.app_name);

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP_MR1)
    private int checkDualSim() {
        int simNumber = 0;
        SubscriptionManager sm = SubscriptionManager.from(this);
        List<SubscriptionInfo> subs = sm.getActiveSubscriptionInfoList();
        if (subs == null) {
            d(TAG, "checkDualSim: " + "no sim");
            return simNumber;
        }
        if (subs.size() > 1) {
            simNumber = 2;
            d(TAG, "checkDualSim: " + "two sims");
        } else {
            d(TAG, "checkDualSim: " + "one sim");
            simNumber = 1;
        }
        for (SubscriptionInfo s: subs) {
            d(TAG, "checkDualSim: " + "simInfo:" + subs.toString());
        }
        return simNumber;
    }

//根据上述情况，初始化UI和拨打电话，尤其注意sim2的打电话情况
    @RequiresApi(api = Build.VERSION_CODES.M)
    private void callPhone(boolean isDualSim) {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
            Log.d(TAG, "callPhone: " + "no call phone permission");
            return;
        }
        String phoneNumber = mBinding.etPhoneNumber.getText().toString().trim();
        phoneNumber = TextUtils.isEmpty(phoneNumber) ? "13422284669" : phoneNumber;
        if (!isDualSim) {
            //单卡
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_CALL);
            intent.setData(Uri.parse("tel:" + phoneNumber));
            startActivity(intent);
            return;
        }
        TelecomManager telecomManager = (TelecomManager)getSystemService(Context.TELECOM_SERVICE);
        if(telecomManager != null) {
            List<PhoneAccountHandle> phoneAccountHandleList = telecomManager.getCallCapablePhoneAccounts();
            d(TAG, "callPhone: " + phoneAccountHandleList);
            d(TAG, "callPhone: " + phoneAccountHandleList.get(1).toString());
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_CALL);
            intent.setData(Uri.parse("tel:" + phoneNumber));
            intent.putExtra(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE, phoneAccountHandleList.get(1));
            startActivity(intent);
        }
    }

def post_order_traversal_tree(root):
    if root is None:
        return
    post_order_traversal_tree(root.left_child)
    post_order_traversal_tree(root.right_child)
    print(root.data, end="   ")

def post_order_traversal_tree_two(root):
    if root is None:
        return
    node_list = []
    node_list.append(root)
    node_set = set()
    node_set.add(None)
    while len(node_list) != 0:
        temp_node = node_list[-1]
        if temp_node.left_child in node_set and temp_node.right_child in node_set:
            print(temp_node.data, end="   ")
            node_list.pop()
            node_set.add(temp_node)
        else:
            if temp_node.right_child is not None:
                node_list.append(temp_node.right_child)
            if temp_node.left_child is not None:
                node_list.append(temp_node.left_child)
    print()

def post_order_traversal_tree_three(root):
    if root is None:
        return
    node_list = []
    node_set = set()
    node_set.add(None)
    temp_node = root
    while len(node_list) != 0 or temp_node is not None:
        while temp_node is not None:
            node_list.append(temp_node)
            temp_node = temp_node.left_child

        if len(node_list) != 0:
            temp_node = node_list[-1]
            if temp_node not in node_set :  #第一次出现在栈顶，对右子树做相同操作。
                node_set.add(temp_node)
                temp_node = temp_node.right_child
            else:
                print(temp_node.data, end="   ")
                node_list.pop()
                temp_node = None   #最后注意temp_node 出栈后，置为空，防止再次入栈。
    print()

#根节点入栈。根节点出栈并打印。左子树入栈，右子树入栈。重复上述操作。将打印结果反转即是后序遍历的结果。
def post_order_traversal_tree_four(root):
    if root is None:
        return
    node_list = []
    result = []
    node_list.append(root)
    while len(node_list) != 0:
        temp_node = node_list.pop()
        result.append(temp_node.data)
        if temp_node.left_child is not None:
            node_list.append(temp_node.left_child)
        if temp_node.right_child is not None:
            node_list.append(temp_node.right_child)
    for i in reversed(result):
        print(i, end="   ")
    print()

def longest_increasing_subsequence_one(array):
    temp_array = [1] * len(array)
    for index, _ in enumerate(array):
        for i in range(0, index):
            if array[i] < array[index] and temp_array[i] + 1 >= temp_array[index]:
                temp_array[index] = temp_array[i] + 1
    return max(temp_array)

#复制列表并排序，求两列表的最长公共子序列( LCS ): 动态规划
def longest_increasing_subsequence_two(array):
    copy_array = array[:]
    copy_array.sort()
    #中间结果
    temp_array = [[0 for i in range(len(array))] for j in range(len(copy_array))]
    for i in range(1, len(array)):
        for j in range(1, len(copy_array)):
            if array[i] == copy_array[j]:
                temp_array[i][j] = temp_array[i - 1][j - 1] + 1
            else:
                temp_array[i][j] = max(temp_array[i][j - 1],  temp_array[i - 1][j])
    #倒推求出最长公共子序列
    result = []
    i = len(array) - 1
    j = len(copy_array) - 1
    while i > 0 and j > 0:
        if array[i] == copy_array[j]:
            result.append(array[i])
            i -= 1
            j -= 1
        else:
            if temp_array[i][j - 1] >= temp_array[i - 1][j]:
                j -= 1
            else:
                i -= 1
    result.reverse()
    print(result)
    print(len(result))

//注意listener的实现
Observable.create(new ObservableOnSubscribe<View>() {
            @Override
            public void subscribe(final ObservableEmitter<View> e) throws Exception {
                listener = new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                    //do something
                        if (!e.isDisposed()) {
                            e.onNext(v);
                        }
                    }
                };
            }
        }).subscribe(new Consumer<View>() {
            @Override
            public void accept(@NonNull View view) throws Exception {
                ((Button)view).setText(i++ + "---");
            }
        });
//button监听没有区别
button.setOnClickListener(listener);

    private interface OnGetDataListener {
        void success(String data);
        void errorResult(Error error);
    }
/配合Rxjava2的observer的onNext， onComplete, onError, onSubscribe等去接收，错误时取消订阅等功能。

//首先申明list和一个subject观察者并初始化
private List<Integer> list = new ArrayList<>(0);
private Subject<List<Integer>> subject;

//oncreate()订阅
subject = PublishSubject.create();
subject.subscribe(new Consumer<List<Integer>>() {
        @Override
        public void accept(@NonNull List<Integer> integers) throws Exception {
            Log.d(TAG, "accept: " + integers);
        }
    });
    
//需要的时候发送：list加数据
    private void addInteger(int i) {
        list.add(i++);
        subject.onNext(list);
    }

tasks.withType(org.gradle.api.tasks.compile.JavaCompile) {
    options.encoding = "UTF-8"
}

Application mApp = (Application) getApplication();
Log.e(TAG, "getApp: "+mApp);
Context mContext = getApplicationContext();
Log.e(TAG, "onAppContext: "+mContext);
Context mContext2 = mApp.getApplicationContext();
Log.e(TAG, "onAppContext: "+ mContext2);
Log.e(TAG, "onBaseContext: "+ getBaseContext());
Log.e(TAG, "onThis: "+MainActivity.this);
TextView mTextView = (TextView) findViewById(R.id.textview);
Log.e(TAG, "ongetContentDescription(): "+mTextView.getContentDescription());
Log.e(TAG, "onGetContext: " + mTextView.getContext());

//输出结果
com.example.sw.testproject E/MainActivity: getApp: android.app.Application@fd09430
com.example.sw.testproject E/MainActivity: onAppContext: android.app.Application@fd09430
com.example.sw.testproject E/MainActivity: onAppContext: android.app.Application@fd09430
com.example.sw.testproject E/MainActivity: onBaseContext: android.app.ContextImpl@615e8a9
com.example.sw.testproject E/MainActivity: onThis: com.example.sw.testproject.MainActivity@279780b
com.example.sw.testproject E/MainActivity: ongetContentDescription(): null
com.example.sw.testproject E/MainActivity: onGetContext: com.example.sw.testproject.MainActivity@279780b
//说明：getContext()方式是对于一个activity中的view来说，供其调用，返回这个activity。

    private void checkNetworkConnection() {
      // BEGIN_INCLUDE(connect)
      ConnectivityManager connMgr =
          (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
      NetworkInfo activeInfo = connMgr.getActiveNetworkInfo();
      if (activeInfo != null && activeInfo.isConnected()) {
          wifiConnected = activeInfo.getType() == ConnectivityManager.TYPE_WIFI;
          mobileConnected = activeInfo.getType() == ConnectivityManager.TYPE_MOBILE;
          if(wifiConnected) {
              Log.i(TAG, getString(R.string.wifi_connection));
          } else if (mobileConnected){
              Log.i(TAG, getString(R.string.mobile_connection));
          }
      } else {
          Log.i(TAG, getString(R.string.no_wifi_or_mobile));
      }
      // END_INCLUDE(connect)
    }

String licenseTips = getString(R.string.app_license_tips);
SpannableString ss = new SpannableString(licenseTips);
ss.setSpan(new UnderlineSpan(), 7, licenseTips.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
mLicenseTips.setText(ss);

DisplayMetrics dm = getResources().getDisplayMetrics();
int w_screen = dm.widthPixels;
int h_screen = dm.heightPixels;

//子view的类型和宽高可以自己设定。
public class AutoBreakViewGroup extends ViewGroup {

    private int mScreenWidth;
    private int mHorizontalSpacing;
    private int mVerticalSpacing;

    public AutoBreakViewGroup(Context context) {
        super(context);
        init();
    }

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

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

    private void init() {
        DisplayMetrics dm = getResources().getDisplayMetrics();
        mScreenWidth = dm.widthPixels;
    }

    public void setmHorizontalSpacing(int mHorizontalSpacing) {
        this.mHorizontalSpacing = mHorizontalSpacing;
    }

    public void setmVerticalSpacing(int mVerticalSpacing) {
        this.mVerticalSpacing = mVerticalSpacing;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        measureChildren(widthMeasureSpec, heightMeasureSpec);
        setMeasuredDimension(width, height);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int mTotalHeight = 0;
        int mTotalWidth = 0;

        int mTempHeight = 0;

        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            int measureHeight = childView.getMeasuredHeight();
            int measureWidth = childView.getMeasuredWidth();
            mTempHeight = (measureHeight > mTempHeight) ? measureHeight : mTempHeight;
            if ((measureWidth + mTotalWidth + mHorizontalSpacing) > mScreenWidth) {
                mTotalWidth = 0;
                mTotalHeight += (mTempHeight + mVerticalSpacing);
                mTempHeight = 0;
            }
            childView.layout(mTotalWidth + mHorizontalSpacing, mTotalHeight,
                    measureWidth + mTotalWidth + mHorizontalSpacing, mTotalHeight + measureHeight);
            mTotalWidth += (measureWidth + mHorizontalSpacing);
        }
    }
}

//对照添加
buildscript {
    ext.kotlin_version = '1.1.2-5'
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'

allprojects {
    repositories {
        jcenter()
        maven { url 'https://maven.google.com' }
    }
}

    /// Architecture Components
    compile "android.arch.lifecycle:runtime:$ac_version"
    compile "android.arch.lifecycle:extensions:$ac_version"
    kapt "android.arch.lifecycle:compiler:$ac_version"
    /// Room
    compile "android.arch.persistence.room:runtime:$ac_version"
    kapt "android.arch.persistence.room:compiler:$ac_version"

@Entity(tableName = "stories")
class Story {
    @PrimaryKey
    var id = 0
    var data = ""
    var displayData = ""
    var title = ""
    var image = ""
}
//story作为数据库的一张表，可以指定列名，主键

@Dao
interface StoryDao {
    @Query("select * from stories")
    fun loadAllStories(): LiveData<List<Story>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertStories(list: List<Story>)
}
//对数据的操作，这里涉及插入和查询（查询的返回值可以是LiveData，list， Rxjava2等）

@Database(entities = arrayOf(Story::class), version = 1)
abstract class AppDatabase: RoomDatabase() {
    companion object {
        val TAG = "sw_story_db"
    }
    abstract fun storyDao(): StoryDao
}
//数据库， 通过dao操作数据。

object DatabaseManager {

    lateinit var db: AppDatabase

    fun initDb(context: Context) {
        db = Room.databaseBuilder(context, AppDatabase::class.java, AppDatabase.TAG).build()
    }

    fun insertStories(storys: List<Story>) {
        Flowable.just(storys)
                .observeOn(Schedulers.io())
                .subscribe {
                    db.beginTransaction()
                    try {
                        db.storyDao().insertStories(storys)
                        db.setTransactionSuccessful()
                    } finally {
                        db.endTransaction()
                    }
                }
    }
    fun loadAllStories(): LiveData<List<Story>> {
        return db.storyDao().loadAllStories()
    }

    fun simlutateInsertData() {
        var list = ArrayList<Story>()

        for (i in 1..20) {
            var s = Story()
            s.id = (i)
            s.data = ((i * i).toString() + "--" + i.toString())
            s.displayData = ((i * i).toString() + "--" + i.toString())
            s.title = ((i * i).toString() + "--" + i.toString())
            s.image = ((i * i).toString() + "--" + i.toString())
            list.add(s)
        }
        insertStories(list)
    }
}
//该单例对数据库封装了一层，方便处理db的各种操作（db初始化可使用依赖注入）
数据库插入不能在主线程，涉及事务。

//继承Appication，初始化并模拟插入数据
class ZhiJokeApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        DatabaseManager.initDb(this)
        DatabaseManager.simlutateInsertData()
    }
}

未玩待续

localhost:~ swensun$ cd ~
localhost:~ swensun$ mkdir aliyun
localhost:~ swensun$ sshfs 120.78.202.210:/  aliyun/

FROM python:latest

RUN apt-get update \
	&& apt-get install -y vim \
	&& rm -rf /var/lib/apt/lists/*

version: '2'
services:
  spider:
    image: pythonspider      
    volumes:
      - ./zhihu:/spider
    tty: true