/**
     * 获取布局ID,子类必须实现
     */
    protected abstract fun getLayoutId(): Int


    /**
     * 初始化 View 的相关操作，若有需要可在子类实现
     */
    protected open fun initView() {}

    /**
     * 初始化 Listener 事件的相关操作，若有需要可在子类实现
     */
    protected open fun initListener() {}


    /**
     * 初始化 Data 数据的相关操作，若有需要可在子类实现
     */
    protected open fun initData() {}


    /**
     * 在主线程弹出Toast 提示
     * @param msg 需要弹出的提示信息
     */
    protected open fun showToast(msg:String){
        runOnUiThread {
            toast(msg)
        }
    }

    /**
     * 在主线程弹出Toast 提示
     * @param stringRes 需要弹出的提示信息的string资源ID
     */
    protected open fun showToast(stringRes:Int){
        runOnUiThread {
            toast(getString(stringRes))
        }
    }

    /**
     * 跳转到另一个Activity，并且finish 掉当前Activity
     * 需要跳转的Activity必须继承于BaseActivity 或者
     * @param params 可变参数，需要通过intent传递的参数 eg:"key" to "value"
     */
    inline fun <reified T: BaseActivity> startActivityAndFinish(vararg params: Pair<String, Any?>) {
        startActivity<T>(*params)
        finish()
    }

 protected fun getRecyclerView():LoadMoreRecyclerView{
        return mRecyclerView
    }

    /**
     * 获取recyclerView的布局管理器，子类可重写该方法，来更改布局管理器
     */
    protected open fun getLayoutManager(): RecyclerView.LayoutManager {
        val layoutManager: LinearLayoutManager = LinearLayoutManager(this)
        //设置为垂直布局，这也是默认的
        layoutManager.orientation = OrientationHelper.VERTICAL
        return layoutManager
    }


    /**
     * 设置RecyclerView 的Adapter适配器
     * @param adapter 设置的Adapter，必须是BaseRecyclerAdapter的子类
     */
    protected fun <T> setAdapter(adapter: BaseRecyclerAdapter<T>) {
        mRecyclerView.adapter = adapter
    }

    /**
     * 设置刷新控件的颜色
     */
    protected fun setRefreshColorSchemeColors(@ColorInt vararg colors: Int) {
        mRefreshLayout.setColorSchemeColors(*colors)
    }
    /**
     * 设置刷新控件的颜色
     */
    protected fun setColorSchemeResources(@ColorRes vararg colorIds: Int) {
        mRefreshLayout.setColorSchemeResources(*colorIds)
    }

    /**
     * 设置刷新控件是否显示
     */
    protected fun isRefresh(isRefresh: Boolean) {
        mRefreshLayout.isRefreshing = false
    }

    /**
     * 刷新完成
     */
    protected fun refreshComplete() {
        mRefreshLayout.isRefreshing = false
    }

    /**
     * 刷新数据，子类实现该方法，进行数据请求
     */
    protected open fun refreshDatas() {

    }

    /**
     * 加载更多完成
     */
    protected fun loadMoreComplete() {
        mRecyclerView.loadMoreComplete(true)
    }

    /**
     * 设置是否可以加载更多
     */
    protected fun canLoadMore(canLoadMore: Boolean) {
        mRecyclerView.loadMoreEnable = canLoadMore
    }

    /**
     * 设置是否还有更多的数据
     */
    protected fun hasLoadMore(hasLoadMore: Boolean) {
        mRecyclerView.hasMore = hasLoadMore
    }

    /**
     * 加载新数据，子类实现该方法，进行数据请求
     */
    protected open fun loadMoreDatas() {

    }

abstract class BaseRecyclerAdapter<T> : RecyclerView.Adapter<VH>(), View.OnClickListener, View.OnLongClickListener {
    private val mDatas: MutableList<T> = ArrayList<T>()
    private lateinit var context: Context
    private var clickListener: OnItemClickListener<T>? = null
    private var longClickListener: OnItemLongClickListener<T>? = null


    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
        context = parent.context
        val convertView = LayoutInflater.from(parent.context).inflate(getLayoutId(viewType), parent, false)
        convertView.setOnClickListener(this)
        convertView.setOnLongClickListener(this)
        return VH(convertView)
    }

    /**
     * 设置Item 的点击事件
     */
    fun setOnItemClick(listener: OnItemClickListener<T>) {
        clickListener = listener
    }

    /**
     * 设置Item 的点击事件
     */
    fun setOnItemClick(onClick: (view:View,position:Int,data:T) -> Unit) {
        clickListener = object :  OnItemClickListener<T> {
            override fun onItemClick(view: View, position: Int, data: T) {
                onClick(view,position,data)
            }
        }
    }

    /**
     * 设置Item 的长按事件
     */
    fun setOnItemLongClick(listener:OnItemLongClickListener<T>) {
        longClickListener = listener
    }

    /**
     * 设置Item 的长按事件
     */
    fun setOnItemLongClick(onLongClick: (view:View,position:Int,data:T) -> Boolean) {
        longClickListener = object : OnItemLongClickListener<T> {
            override fun onItemLongClick(view: View, position: Int, data: T):Boolean {
                return onLongClick(view,position,data)
            }
        }
    }

    override fun onClick(p0: View?) {
        val position:Int = p0?.getTag(R.id.itemViewPosition) as Int
        val data:T = mDatas.get(position)
        clickListener?.onItemClick(p0,position,data)
    }

    override fun onLongClick(p0: View?): Boolean {
        val position:Int = p0?.getTag(R.id.itemViewPosition) as Int
        val data:T = mDatas.get(position)
        return longClickListener?.onItemLongClick(p0,position,data) ?: true
    }

    /**
     * 设置数据,并且会清空原数据列表
     * @param datas 新的数据列表
     */
    open fun setDatas(datas: List<T>) {
        mDatas.clear()
        mDatas.addAll(datas)
        notifyDataSetChanged()
    }

    /**
     * 添加新的数据列表到原数据列表末尾
     * @param datas 新的数据列表
     */
    open fun addDatas(datas: List<T>) {
        mDatas.addAll(datas)
        notifyDataSetChanged()
    }

    /**
     * 添加新的数据列表到原数据列表的指定位置
     * @param position 需要添加的指定位置
     * @param datas 新的数据列表
     */
    open fun addDatas(position: Int, datas: List<T>) {
        val pos = if (position > mDatas.size) {
            mDatas.size
        } else position
        mDatas.addAll(pos, datas)
        notifyDataSetChanged()
    }

    /**
     * 更新数据列表指定位置上的数据
     * @param position 需要更新数据的位置
     * @param data 更新后的数据
     */
    open fun updateData(position: Int, data: T) {
        if (position < mDatas.size) {
            mDatas.removeAt(position)
            mDatas.add(position, data)
            notifyItemChanged(position)
        }
    }

    /**
     * 添加新的数据到原数据列表末尾
     * @param datas 新的数据
     */
    open fun addData(data: T) {
        mDatas.add(data)
        notifyItemInserted(mDatas.size - 1)
    }

    /**
     * 添加新的数据到原数据列表的指定位置
     * @param position 需要添加的指定位置
     * @param data 新的数据
     */
    open fun addData(position: Int, data: T) {
        val pos = if (position > mDatas.size) {
            mDatas.size
        } else position
        mDatas.add(pos, data)
        notifyItemInserted(pos)
    }

    /**
     * 移除指定位置上的数据
     * @param position 需要添加的指定位置
     */
    open fun removeDataAt(position: Int) {
        if (position < mDatas.size) {
            mDatas.removeAt(position)
            notifyItemRemoved(position)
        }
    }

    protected open fun showToast(msg: String) {
        context.runOnUiThread {
            context.toast(msg)
        }
    }

    /**
     * 移除指定的数据
     * @param data 需要移除的数据实体
     */
    open fun removeData(data: T) {
        if (mDatas.contains(data)) {
            val position = mDatas.indexOf(data)
            mDatas.removeAt(position)
            notifyItemRemoved(position)
        }
    }

    /**
     * 根据View的类型获取对应的Item布局的ID
     */
    @LayoutRes
    abstract fun getLayoutId(viewType: Int): Int


    /**
     * 绑定ViewHolder 时执行的方法，在此方法里处理对Item的view的操作
     */
    abstract fun onBindVH(holder: VH, position: Int, datas: T)

    /**
     * 返回数据的数量
     */
    override fun getItemCount(): Int {
        return mDatas.size
    }

    override fun onBindViewHolder(holder: VH, position: Int) {
        holder.itemView.setTag(R.id.itemViewPosition, position)
        onBindVH(holder, position, mDatas.get(position))
    }


}

/**
 *Item 的点击事件
 */
interface OnItemClickListener<T> {
    fun onItemClick(view: View, position: Int, data: T)
}

/**
 *Item 的长按事件
 */
interface OnItemLongClickListener<T> {
    fun onItemLongClick(view: View, position: Int, data: T):Boolean
}

/**
 * 所有的Adapter 使用的ViewHolder
 */
class VH(itemView: View) : RecyclerView.ViewHolder(itemView) {


    /**
     * 根据View的id获取对应的View
     */
    inline fun <reified E : View> getView(@IdRes viewId: Int): E {
        return itemView.find<E>(viewId)
    }

    /**
     * 对TextView及其子类设置文本内容
     * @param viewId 对应的View 的id
     * @param value 需要设置的文本内容
     */
    inline fun setText(@IdRes viewId: Int, value: String) {
        val view: View = this.getView(viewId)
        if (view is TextView) {
            val tv: TextView = view
            tv.text = value
        }
    }

    /**
     * 对TextView及其子类设置文本内容
     * @param viewId 对应的View 的id
     * @param value 需要设置的文本内容
     */
    inline fun setText(@IdRes viewId: Int, value: Spannable) {
        val view: View = this.getView(viewId)
        if (view is TextView) {
            val tv: TextView = view
            tv.text = value
        }
    }

    /**
     * 对TextView及其子类设置文本内容
     * @param viewId 对应的View 的id
     * @param stringRes 需要设置的文本资源的id
     */
    inline fun setText(@IdRes viewId: Int, @StringRes stringRes: Int) {
        val view: View = this.getView(viewId)
        if (view is TextView) {
            val tv: TextView = view
            tv.setText(stringRes)
        }
    }

    /**
     * 对ImageView及其子类设置图片
     * @param viewId 对应的View 的id
     * @param resId 需要设置的图片资源的id
     */
    inline fun setImageResource(@IdRes viewId: Int, @DrawableRes resId: Int) {
        val view: View = getView(viewId)
        if (view is ImageView) {
            val iv: ImageView = view
            iv.imageResource = resId
        }
    }

    /**
     * 对ImageView及其子类设置图片
     * @param viewId 对应的View 的id
     * @param imgUrl 需要设置的网络图片的地址
     */
    inline fun setImageUrl(@IdRes viewId: Int, imgUrl: String) {
        val view: View = getView(viewId)
        if (view is ImageView) {
            val iv: ImageView = view
            iv.loadImage(imgUrl)
        }
    }

    /**
     * 对View及其子类设置背景图片
     * @param viewId 对应的View 的id
     * @param resId 需要设置的背景图片的资源地址
     */
    inline fun setBackgroundResource(@IdRes viewId: Int, @DrawableRes resId: Int) {
        val view: View = getView(viewId)
        view.setBackgroundResource(resId)
    }

    /**
     * 对View及其子类设置背景颜色
     * @param viewId 对应的View 的id
     * @param color 需要设置的背景颜色
     */
    inline fun setBackgroundColor(@IdRes viewId: Int, @ColorInt color: Int) {
        val view: View = getView(viewId)
        view.setBackgroundColor(color)
    }


    /**
     * 对View及其子类设置点击事件
     * @param viewId 对应的View 的id
     * @param color 需要设置的背景颜色
     */
    inline fun setOnClick(@IdRes viewId: Int, crossinline onClick: (View) -> Unit) {
        val view: View = getView(viewId)
        view.setOnClickListener {
            onClick.invoke(it)
        }
    }

}

inline fun ImageView.loadImage(imgUrl: String): ImageView {
    ImageUtils.loadImageUrl(this.context, imgUrl, this)
    return this
}

inline fun ImageView.loadBitmap(imgUrl: String): ImageView {
    ImageUtils.loadImageBitmap(this.context, imgUrl, this)
    return this
}

inline fun ImageView.loadGif(imgUrl: String): ImageView {
    ImageUtils.loadImageGif(this.context, imgUrl, this)
    return this
}

inline fun ImageView.loadImgCallBack(imgUrl: String, requestListener: RequestListener<Bitmap>): ImageView {
    ImageUtils.loadImageCallBack(this.context, imgUrl, this, requestListener)
    return this
}

	/**
     * dip转换为px
     */
    fun dip2px(dp: Int): Int {
        return (dp * density).toInt()
    }


    /**
     * px转换为dip
     */
    fun px2dip(px:  Float): Int {
        return (px / density).toInt()
    }

    /**
     * 获取屏幕宽度
     */
    fun appWidth(): Int {
        return Resources.getSystem().getDisplayMetrics().widthPixels
    }

    /**
     * 获取屏幕高度
     */
    fun appHeight(): Int {
        return Resources.getSystem().getDisplayMetrics().heightPixels
    }

/**
     * 设置页面显示类型
     *
     * @param type
     */
    fun setEmptyType(type: Int) {
        _setEmptyType(type, true)
    }

    /**
     * 设置页面显示类型
     *
     * @param type
     */
    private fun _setEmptyType(type: Int, isShow: Boolean) {
        this.emptyType = type
        when (type) {
            TYPE_EMPTY -> {
                layoutLoading!!.visibility = View.GONE
                layoutReload!!.visibility = View.GONE
                layoutEmpty!!.visibility = View.VISIBLE
                btnReload!!.visibility = View.GONE
                ivEmptyImg!!.visibility = View.VISIBLE
            }
            TYPE_LOADING -> {
                layoutLoading!!.visibility = View.VISIBLE
                layoutEmpty!!.visibility = View.GONE
                layoutReload!!.visibility = View.GONE
                if (tvLoadingMsg != null) {
                    tvLoadingMsg!!.text = "正在加载..."
                }
            }
            TYPE_RELOAD -> {
                layoutLoading!!.visibility = View.GONE
                layoutEmpty!!.visibility = View.GONE
                layoutReload!!.visibility = View.VISIBLE
                btnReload!!.visibility = View.VISIBLE
                ivEmptyImg!!.visibility = View.VISIBLE
            }
        }
        if (isShow) {
            show()
        }
    }

    /**
     * 设置空数据界面的背景色
     *
     * @param color 背景色
     */
    fun setEmptyBackgroundColor(color: Int) {
        layoutEmpty!!.setBackgroundColor(color)
    }

    /**
     * 设置错误描述
     *
     * @param resId
     */
    fun setEmptyText(@StringRes resId: Int) {
        if (tvEmptyMsg != null) {
            tvEmptyMsg!!.text = mContext!!.getString(resId)
        }
    }

    /**
     * 设置错误描述
     *
     * @param text
     */
    fun setEmptyText(text: CharSequence?) {
        var text = text
        if (text == null) {
            text = ""
        }
        if (tvEmptyMsg != null) {
            tvEmptyMsg!!.text = text
        }
    }


    /**
     * 设置错误描述字体大小
     *
     * @param size
     */
    fun setEmptyTextSize(size: Float) {
        if (tvEmptyMsg != null) {
            tvEmptyMsg!!.setTextSize(TypedValue.COMPLEX_UNIT_PX, size)
        }
    }

    /**
     * 设置错误描述颜色
     *
     * @param color
     */
    fun setEmptyTextColor(color: Int) {
        if (tvEmptyMsg != null) {
            tvEmptyMsg!!.setTextColor(color)
        }
    }

    /**
     * 设置错误描述颜色
     *
     * @param colors
     */
    fun setEmptyTextColor(colors: ColorStateList) {
        if (tvEmptyMsg != null) {
            tvEmptyMsg!!.setTextColor(colors)
        }
    }

    /**
     * 设置页面图片
     *
     * @param resId
     */
    fun setEmptyImgResource(@DrawableRes resId: Int) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            this.noDataImg = mContext!!.getDrawable(resId)
        } else {
            this.noDataImg = mContext!!.resources.getDrawable(resId)
        }
        if (ivEmptyImg != null) {
            ivEmptyImg!!.setImageResource(resId)
        }
    }


    /**
     * 设置页面图片
     *
     * @param noDataImg
     */
    fun setEmptyImg(noDataImg: Drawable) {
        this.noDataImg = noDataImg
        if (ivEmptyImg != null) {
            ivEmptyImg!!.setImageDrawable(noDataImg)
        }
    }

    /**
     * 获取加载按钮文字
     */
    fun getReloadBtnText(): String? {
        return reloadBtnText
    }

    /**
     * 设置重新加载按钮文字
     *
     * @param resId
     */
    fun setReloadBtnText(resId: Int) {
        this.reloadBtnText = mContext!!.getString(resId)
        if (btnReload != null) {
            btnReload!!.text = this.reloadBtnText
        }
    }

    /**
     * 设置重新加载按钮文字
     *
     * @param reloadBtnText
     */
    fun setReloadBtnText(reloadBtnText: String) {
        this.reloadBtnText = reloadBtnText
        if (btnReload != null) {
            btnReload!!.text = this.reloadBtnText
        }
    }


    /**
     * 设置重新加载按钮文字大小
     *
     * @param reloadBtnTextSize
     */
    fun setReloadBtnTextSize(reloadBtnTextSize: Float) {
        this.reloadBtnTextSize = reloadBtnTextSize
        if (btnReload != null) {
            btnReload!!.setTextSize(TypedValue.COMPLEX_UNIT_PX, this.reloadBtnTextSize)
        }
    }


    /**
     * 设置重新加载按钮文字颜色
     *
     * @param color
     */
    fun setReloadBtnTextColor(color: Int) {
        this.reloadBtnTextColor = color
        if (btnReload != null) {
            btnReload!!.setTextColor(this.reloadBtnTextColor)
        }
    }

    /**
     * 设置重新加载按钮文字颜色
     *
     * @param colors
     */
    fun setReloadBtnTextColor(colors: ColorStateList) {
        if (btnReload != null) {
            btnReload!!.setTextColor(colors)
        }
    }


    /**
     * 设置加载按钮背景
     *
     * @param reloadBackground
     */
    fun setReloadBtnBackground(reloadBackground: Drawable) {
        this.reloadBtnBackground = reloadBackground
        if (btnReload != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                btnReload!!.background = this.reloadBtnBackground
            } else {
                btnReload!!.setBackgroundDrawable(this.reloadBtnBackground)
            }
        }
    }

    /**
     * 设置加载按钮背景
     *
     * @param color
     */
    fun setReloadBtnBackgroundColor(color: Int) {
        this.reloadBtnBackground = ColorDrawable(color)
        if (btnReload != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                btnReload!!.background = this.reloadBtnBackground
            } else {
                btnReload!!.setBackgroundDrawable(this.reloadBtnBackground)
            }
        }
    }

    /**
     * 设置加载按钮背景
     *
     * @param resId
     */
    fun setReloadBtnBackgroundResource(resId: Int) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            this.reloadBtnBackground = mContext!!.getDrawable(resId)
        } else {
            this.reloadBtnBackground = mContext!!.resources.getDrawable(resId)
        }
        if (btnReload != null) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
                btnReload!!.background = this.reloadBtnBackground
            } else {
                btnReload!!.setBackgroundDrawable(this.reloadBtnBackground)
            }
        }
    }

    /**
     * 获取加载提示文字
     */
    fun getReloadText(): String? {
        return reloadText
    }

    /**
     * 设置重新加载提示文字
     *
     * @param resId
     */
    fun setReloadText(resId: Int) {
        this.reloadText = mContext!!.getString(resId)
        if (tvReloadMsg != null) {
            tvReloadMsg!!.text = this.reloadText
        }
    }

    /**
     * 设置重新加载提示文字
     *
     * @param reloadText
     */
    fun setReloadText(reloadText: String) {
        this.reloadText = reloadText
        if (tvReloadMsg != null) {
            tvReloadMsg!!.text = this.reloadText
        }
    }


    /**
     * 设置重新加载提示文字大小
     *
     * @param reloadTextSize
     */
    fun setReloadTextSize(reloadTextSize: Float) {
        this.reloadTextSize = reloadTextSize
        if (tvReloadMsg != null) {
            tvReloadMsg!!.setTextSize(TypedValue.COMPLEX_UNIT_PX, this.reloadTextSize)
        }
    }


    /**
     * 设置重新加载提示文字颜色
     *
     * @param color
     */
    fun setReloadTextColor(color: Int) {
        this.reloadTextColor = color
        if (tvReloadMsg != null) {
            tvReloadMsg!!.setTextColor(this.reloadTextColor)
        }
    }

    /**
     * 设置重新加载提示文字颜色
     *
     * @param colors
     */
    fun setReloadTextColor(colors: ColorStateList) {
        if (tvReloadMsg != null) {
            tvReloadMsg!!.setTextColor(colors)
        }
    }

    /**
     * 设置页面图片
     *
     * @param resId
     */
    fun setReloadImgResource(@DrawableRes resId: Int) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            this.reloadImage = mContext!!.getDrawable(resId)
        } else {
            this.reloadImage = mContext!!.resources.getDrawable(resId)
        }
        if (ivReloadImg != null) {
            ivReloadImg!!.setImageResource(resId)
        }
    }


    /**
     * 设置页面图片
     *
     * @param reloadImage
     */
    fun setReloadImg(reloadImage: Drawable) {
        this.reloadImage = reloadImage
        if (ivReloadImg != null) {
            ivReloadImg!!.setImageDrawable(reloadImage)
        }
    }


    /**
     * 设置加载提示文字
     *
     * @param resId
     */
    fun setLoadingText(resId: Int) {
        this.loadingText = mContext!!.getString(resId)
        if (tvLoadingMsg != null) {
            tvLoadingMsg!!.text = this.loadingText
        }
    }

    /**
     * 设置加载提示文字
     *
     * @param loadingText
     */
    fun setLoadingText(loadingText: String) {
        this.loadingText = loadingText
        if (tvLoadingMsg != null) {
            tvLoadingMsg!!.text = this.loadingText
        }
    }

    /**
     * 显示此视图
     */
    fun show() {
        this.visibility = View.VISIBLE
    }

    /**
     * 隐藏此视图
     */
    fun hide() {
        this.visibility = View.GONE
    }

    /**
     * 设置重新加载监听事件
     *
     * @param listener
     */
    fun setOnReloadListener(listener: OnReloadListener) {
        this.onReloadListener = listener
    }


    interface OnReloadListener {
        fun onReload()
    }

    companion object {
        const val TYPE_EMPTY = 0 // 页面为空，没有数据时展示
        const val TYPE_LOADING = 1 // 正在加载视图
        const val TYPE_RELOAD = 2 // 加载失败，显示重新加载视图
    }

/**
 * 设置ImageView的形式，圆角矩形，圆形，或椭圆
 **/
var shape = SHAPE_REC: Int
        get() = shape
        set(shape) {
            this.shape = shape
            invalidate()
        }
/**
 * 设置ImageView边框颜色
 **/
 var borderColor: Int
        get() = mBorderColor
        set(mBorderColor) {
            this.mBorderColor = mBorderColor
            mBorderPaint.color = mBorderColor
            invalidate()
        }
	/**
 	 * 设置ImageView的圆角
 	 **/
    var roundRadius: Float
        get() = mRoundRadius
        set(mRoundRadius) {
            this.mRoundRadius = mRoundRadius
            invalidate()
        }
	/**
 	 * 设置ImageView的边框宽度
 	 **/
    fun setBorderSize(mBorderSize: Int) {
        this.borderSize = mBorderSize.toFloat()
        mBorderPaint.strokeWidth = mBorderSize.toFloat()
        initRect()
        invalidate()
    }
	/**
 	 * 设置ImageView的图片资源
 	 **/
override fun setImageResource(resId: Int) {
        super.setImageResource(resId)
        mBitmap = ImageUtils.getBitmapFromDrawable(drawable)
        setupBitmapShader()
    }
	/**
 	 * 设置ImageView的Drawable
 	 **/		
    override fun setImageDrawable(drawable: Drawable?) {
        super.setImageDrawable(drawable)
        mBitmap = ImageUtils.getBitmapFromDrawable(drawable)
        setupBitmapShader()
    }

    

abstract class BaseRxActivity : BaseActivity(), LifecycleProvider<ActivityEvent> {
    private val lifecycleSubject:BehaviorSubject<ActivityEvent> = BehaviorSubject.create()

    @CheckResult
    override fun lifecycle(): Observable<ActivityEvent> {
        return lifecycleSubject.hide()
    }

    @CheckResult
    override fun <T> bindUntilEvent(event: ActivityEvent): LifecycleTransformer<T> {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event)
    }

    @CheckResult
    override fun <T> bindToLifecycle(): LifecycleTransformer<T> {
        return RxLifecycleAndroid.bindActivity(lifecycleSubject)
    }

    @CallSuper
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleSubject.onNext(ActivityEvent.CREATE)
    }

    @CallSuper
    override fun onStart() {
        super.onStart()
        lifecycleSubject.onNext(ActivityEvent.START)
    }

    @CallSuper
    override fun onResume() {
        super.onResume()
        lifecycleSubject.onNext(ActivityEvent.RESUME)
    }

    @CallSuper
    override fun onPause() {
        lifecycleSubject.onNext(ActivityEvent.PAUSE)
        super.onPause()
    }

    @CallSuper
    override fun onStop() {
        lifecycleSubject.onNext(ActivityEvent.STOP)
        super.onStop()
    }

    @CallSuper
    override fun onDestroy() {
        lifecycleSubject.onNext(ActivityEvent.DESTROY)
        super.onDestroy()
    }
}

abstract class BaseRxFragment : BaseFragment(), LifecycleProvider<FragmentEvent> {
    private val lifecycleSubject:BehaviorSubject<FragmentEvent> = BehaviorSubject.create()

    override fun lifecycle(): Observable<FragmentEvent> {
        return lifecycleSubject.hide()
    }

    @CheckResult
    override fun <T> bindUntilEvent(event: FragmentEvent): LifecycleTransformer<T> {
        return RxLifecycle.bindUntilEvent(lifecycleSubject, event)
    }

    @CheckResult
    override fun <T> bindToLifecycle(): LifecycleTransformer<T> {
        return RxLifecycleAndroid.bindFragment(lifecycleSubject)
    }

    @CallSuper
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleSubject.onNext(FragmentEvent.CREATE)
    }


    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        lifecycleSubject.onNext(FragmentEvent.CREATE_VIEW)
        return super.onCreateView(inflater, container, savedInstanceState)
    }


    @CallSuper
    override fun onStart() {
        super.onStart()
        lifecycleSubject.onNext(FragmentEvent.START)
    }

    @CallSuper
    override fun onResume() {
        super.onResume()
        lifecycleSubject.onNext(FragmentEvent.RESUME)
    }

    @CallSuper
    override fun onPause() {
        lifecycleSubject.onNext(FragmentEvent.PAUSE)
        super.onPause()
    }

    @CallSuper
    override fun onStop() {
        lifecycleSubject.onNext(FragmentEvent.STOP)
        super.onStop()
    }

    override fun onDestroyView() {
        lifecycleSubject.onNext(FragmentEvent.DESTROY_VIEW)
        super.onDestroyView()
    }

    @CallSuper
    override fun onDestroy() {
        lifecycleSubject.onNext(FragmentEvent.DESTROY)
        super.onDestroy()
    }
}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.OneObserver
 * @description 请求返回结果，返回json数据必须符合 {"code":"0000","msg":""}
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
abstract class BaseObserver<T : ResponseResult> : Observer<T> {

    /**
     * 请求开始 处理基本的loading框的显示等
     *
     * @param d
     */
    fun onStart(d: Disposable) {
        Log.e(
            TAG,
            "===========单个接口请求开始========================================="
        )
    }

    /**
     * 此方法必须实现
     *
     * @param result 请求成功的结果
     */
    abstract fun onSuccess(result: T)

    /**
     * 请求失败
     *
     * @param code 错误码
     * @param msg  错误提示语
     */
    fun onFailure(code: String, msg: String?) {
        Log.e(
            TAG,
            "接口请求失败===code = " + code + "errorMsg =" + msg 
        )
    }

    /**
     * 请求都完成时之行此方法
     */
    fun onFinish() {

    }

    override fun onSubscribe(d: Disposable) {
        onStart(d)
    }

    override fun onNext(result: T) {
        if (BaseResponse.REQUEST_OK == result.code) {
            onSuccess(result)
            Log.i(TAG, "请求成功responseBody====" + JSON.toJSONString(result))
        } else {
            onFailure(result.code, result.msg)
        }

    }

    override fun onError(e: Throwable) {
        var errorMsg = ""
        var errorCode = 0
        if (e is HttpException) {
            val httpException = e as HttpException
            errorCode = httpException.response().code()
            if (404 == errorCode || 500 == errorCode) {
                errorMsg = "请求异常，请稍候重试！"
            } else {

            }

        } else {
            //todo 设置固定的错误码及错误提示
        }
        onFailure(errorCode.toString(), errorMsg)
    }

    override fun onComplete() {
        onFinish()
    }

    companion object {
        private val TAG = "request"
    }
}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.OneResponse
 * @description 请求返回结果数据基类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
open class BaseResponse(val code: String = "0000", val msg: String = ""): Serializable {
    companion object {
        val REQUEST_OK = "0000"  //请求成功的code码
        val REQUEST_ERROR = "-1" //请求失败的code码
    }
}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.ResponseResult
 * @description 请求返回结果数据 符合 {"code":"0000","msg":"","data":{},"datas":[]} 的基类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
class ResponseResult :BaseResponse(), Serializable

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.OneObserver
 * @description 请求返回结果，返回json数据必须符合  {"code":"0000","msg":"","data":{},"datas":[]},data 和 datas 的数据 bean 相同
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
abstract class BaseObserver1<DATA : Serializable> : Observer<ResponseResult1<DATA>> {

    /**
     * 请求开始 处理基本的loading框的显示等
     *
     * @param d
     */
    fun onStart(d: Disposable) {
        Log.e(
            TAG,
            "===========单个接口请求开始  =========="
        )
    }

    /**
     * 此方法必须实现
     *
     * @param result 请求成功的结果
     */
    abstract fun onSuccess(result: ResponseResult1<DATA>)

    /**
     * 请求失败
     *
     * @param code 错误码
     * @param msg  错误提示语
     */
    fun onFailure(code: String, msg: String?) {
        Log.e(
            TAG,
            "接口请求失败============code = " + code + "errorMsg =" + msg    )
    }

    /**
     * 请求都完成时之行此方法
     */
    open fun onFinish() {

    }

    override fun onSubscribe(d: Disposable) {
        onStart(d)
    }

    override fun onNext(result: ResponseResult1<DATA>) {
        if (BaseResponse.REQUEST_OK == result.code) {
            onSuccess(result)
            Log.i(TAG, "请求成功responseBody====" + JSON.toJSONString(result))
        } else {
            onFailure(result.code, result.msg)
        }

    }

    override fun onError(e: Throwable) {
        var errorMsg = ""
        var errorCode = 0
        if (e is HttpException) {
            val httpException = e as HttpException
            errorCode = httpException.response().code()
            if (404 == errorCode || 500 == errorCode) {
                errorMsg = "请求异常，请稍候重试！"
            } else {

            }

        } else {
            //todo 设置固定的错误码及错误提示
        }
        onFailure(errorCode.toString(), errorMsg)
    }

    override fun onComplete() {
        onFinish()
    }

    companion object {
        private val TAG = "request"
    }
}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.ResponseResult
 * @description 请求返回结果数据 符合 {"code":"0000","msg":"","data":{},"datas":[]} 的基类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
class ResponseResult1<DATA:Serializable>(
    val data: DATA?,
    val datas: MutableList<DATA>? = ArrayList()
) :BaseResponse(), Serializable

package cn.onestravel.library.kotlin.rxrequest.common

import android.util.Log
import io.reactivex.Observer
import io.reactivex.disposables.Disposable
import retrofit2.HttpException
import java.io.Serializable

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.OneObserver2
 * @description 请求返回结果，返回json数据必须符合 {"code":"0000","msg":"","data":{},"datas":[]},data 和 datas 的数据 bean 可以不相同
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
abstract class BaseObserver2<DATA : Serializable,ITEM:Serializable> : Observer<ResponseResult2<DATA,ITEM>>, ObserverResult<ResponseResult2<DATA,ITEM>> {
    /**
     * 请求开始 处理基本的loading框的显示等
     *
     * @param d
     */
    override fun onStart(d: Disposable) {
        Log.e(
             BaseObserver2.TAG,
            "===========单个接口请求开始  =========="
        )
    }

    /**
     * 此方法必须实现
     *
     * @param result 请求成功的结果
     */
    abstract override fun onSuccess(result: ResponseResult2<DATA, ITEM>)

    /**
     * 请求失败
     *
     * @param code 错误码
     * @param msg  错误提示语
     */
    override fun onFailure(code: String, msg: String?) {
        Log.e(
             BaseObserver2.TAG,
            "接口请求失败============code = " + code + "errorMsg =" + msg    )
    }

    /**
     * 请求都完成时之行此方法
     */
    override fun onFinish() {

    }

    override fun onSubscribe(d: Disposable) {
        onStart(d)
    }
    override fun onNext(baseObject: ResponseResult2<DATA,ITEM>) {
        //        Log.i("responseBody====",)
        if (BaseResponse.REQUEST_OK == baseObject.code) {
            onSuccess(baseObject)
        } else {
            onFailure(baseObject.code, baseObject.msg)
        }
    }

    /**
     *
     */
    override fun onError(e: Throwable) {
        var errorMsg = ""
        var errorCode = 0
        if (e is HttpException) {
            val httpException = e as HttpException
            errorCode = httpException.response().code()
            if (404 == errorCode || 500 == errorCode) {
                errorMsg = "请求异常，请稍候重试！"
            } else {

            }

        } else {
            //todo 设置固定的错误码及错误提示
        }
        onFailure(errorCode.toString(), errorMsg)
    }

    override fun onComplete() {
        onFinish()
    }

    companion object {
        private val TAG = "RequestBaseObserver2"
    }
}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.common.ResponseResult
 * @description 请求返回结果数据 符合 {"code":"0000","msg":"","data":{},"datas":[]} 的基类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
class ResponseResult2<DATA:Serializable,ITEM:Serializable>(
    val data: DATA?,
    val datas: MutableList<ITEM>? = ArrayList()
) :BaseResponse(), Serializable

abstract class BaseLoader<S : BaseService> {
    protected val mServiceManager: RetrofitServiceManager by lazy { RetrofitServiceManager.INSTANCE }
    protected val mService: S by lazy { createService() }

    /**
     * 创建 Service 实例
     */
    abstract fun createService(): S

    /**
     * 设置Observable的工作线程
     * @param observable
     * @param <T>
     * @return
    </T> */
    fun <T> observe(observable: Observable<T>): Observable<T> {
        return observable.subscribeOn(Schedulers.io())
            .unsubscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
    }


}

/**
 * @name cn.onestravel.library.kotlin.rxrequest.service.RetrofitServiceManager
 * @description 生成接口实例的管理类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
class RetrofitServiceManager private constructor() {
    private val mRetrofit: Retrofit
    init {
        val interceptorBuild = HttpCommonInterceptor.Builder()
     
        val logging = HttpLoggingInterceptor()
        logging.level = HttpLoggingInterceptor.Level.BODY
        val okHttpClientBuild = OkHttpClient.Builder()
        okHttpClientBuild.connectTimeout(CONNECTION_TIMEOUT.toLong(), TimeUnit.SECONDS)
            .readTimeout(READ_TIMEOUT.toLong(), TimeUnit.SECONDS)
            .writeTimeout(WRITE_TIMEOUT.toLong(), TimeUnit.SECONDS)
            .addInterceptor(interceptorBuild.build())//拦截器添加公共请求参数
            .addInterceptor(RetryInterceptor(2))//重试三次的拦截
                        .addInterceptor(logging)//请求日志打印

        //初始化Retrofit
        mRetrofit = Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .client(okHttpClientBuild.build())
            .build()

    }



    /**
     * 生成对应接口的实例
     *
     * @param service
     * @param <T>
     * @return
    </T> */
    fun <T:BaseService> create(service: Class<T>): T {
        return mRetrofit.create(service)

    }

    companion object {
        val INSTANCE by lazy { RetrofitServiceManager() }
        private const val CONNECTION_TIMEOUT = 5
        private const val READ_TIMEOUT = 20
        private const val WRITE_TIMEOUT = 10
        private const val BASE_URL = "http://192.168.1.12:9090/"
    }
}

/**
 * @name  BaseMvpActivity
 * @description 所有Mvp架构的 Activity 的基类
 * @createTime 2018/12/12 17:00
 * @author onestravel
 * @version 1.0.0
 */
abstract class BaseMvpActivity<V : BaseMvpView, P : BaseMvpPresenter<V>> : BaseActivity(), BaseMvpView {
    private val presenter by lazy { createPresenter() }
    private var mLoadingDialog: LoadingDialog? = null
    protected abstract fun createPresenter(): P

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (presenter == null) {
            throw  NullPointerException("Presenter is null! Do you return null in createPresenter()?")
        }
        presenter.onMvpAttachView(this as V, savedInstanceState)
    }


    override fun onStart() {
        super.onStart()
        presenter.let {
            it.onMvpStart()
        }
    }

    override fun onResume() {
        super.onResume()
        presenter.let {
            it.onMvpResume()
        }
    }

    override fun onPause() {
        presenter.let {
            it.onMvpPause()
        }
        super.onPause()
    }

    override fun onStop() {
        presenter.let {
            it.onMvpStop()
        }
        super.onStop()
    }


    override fun onSaveInstanceState(outState: Bundle?) {
        super.onSaveInstanceState(outState)
        presenter?.let {
            it.onMvpSaveInstanceState(outState)
        }
    }

    override fun onDestroy() {
        presenter?.let {
            it.onMvpDetachView(false)
            it.onMvpDestroy()
        }
        mLoadingDialog?.let {
            it.destroy()
            mLoadingDialog = null
        }
        super.onDestroy()
    }

    override fun showLoading(content: String?) {
        if (mLoadingDialog == null) {
            mLoadingDialog = LoadingDialog.getInstance(this)
            mLoadingDialog!!.title = content?:"正在加载..."
            if (!mLoadingDialog!!.isShowing) {
                mLoadingDialog!!.show()
            }
        }
    }

    override fun hideLoading() {
        mLoadingDialog?.let {
            mLoadingDialog!!.dismiss()
        }
    }

    override fun onResponseError(msg: String?) {
        msg?.let {
            showToast(msg)
        }
    }

}

/**
 * @name  BaseMvpPresenterImpl
 * @description 所有界面presenter的接口类
 * @createTime 2018/12/12 16:27
 * @author onestravel
 * @version 1.0.0
 */

interface BaseMvpPresenter<in V : BaseMvpView> {
    fun onMvpAttachView(view: V, savedInstanceState: Bundle?)

    fun onMvpStart()

    fun onMvpResume()

    fun onMvpPause()

    fun onMvpStop()

    fun onMvpSaveInstanceState(savedInstanceState: Bundle?)

    fun onMvpDetachView(retainInstance: Boolean)

    fun onMvpDestroy()

}

/**
 * @name  BaseMvpPresenterImpl
 * @description 所有界面presenter的接口类
 * @createTime 2018/12/12 16:27
 * @author onestravel
 * @version 1.0.0
 */

interface BaseMvpPresenter<in V : BaseMvpView> {
    fun onMvpAttachView(view: V, savedInstanceState: Bundle?)

    fun onMvpStart()

    fun onMvpResume()

    fun onMvpPause()

    fun onMvpStop()

    fun onMvpSaveInstanceState(savedInstanceState: Bundle?)

    fun onMvpDetachView(retainInstance: Boolean)

    fun onMvpDestroy()

}

/**
 * @name  BaseMvpPresenterImpl
 * @description 所有界面presenter的接口类
 * @createTime 2018/12/12 16:27
 * @author onestravel
 * @version 1.0.0
 */

interface BaseMvpPresenter<in V : BaseMvpView> {
    fun onMvpAttachView(view: V, savedInstanceState: Bundle?)

    fun onMvpStart()

    fun onMvpResume()

    fun onMvpPause()

    fun onMvpStop()

    fun onMvpSaveInstanceState(savedInstanceState: Bundle?)

    fun onMvpDetachView(retainInstance: Boolean)

    fun onMvpDestroy()

}