AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

关于安卓自定义view实现轮播图

2022-06-22 153
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 目前市场上大部分app都会使用到轮播图，用于展示某些重要信息，通过自定义的形式来实现轮播图，使用起来更方便

前段时间自己自定义了一个轮播图，使用起来很简单，分享给大家使用，如有什么缺陷或是问题，请留言提出建议。

我自定义的类叫做BannerView.java，整个轮播图的实现都在这个类里面，在这个类里面我向外提供了很多方法，可以根据项目情况或是个人喜欢定义，比如有一个设置指示器位置的方法（左中右，默认是居中），一个设置指示器样式的方法，默认是引用我自己画的圆点，想要其他样式可以自己去定义，还有一个就是播放的时间方法，BannerView里面注释都很清楚。

先看看效果图吧，因为图片颜色原因在这里指示器看不是很清楚
image.png

这里分别使用 java代码 跟 kotlin代码 两种形式来实现功能

在看看使用的方法

一、在布局文件中添加自定义的轮播图控件
image.png

二、添加图片资源，这里添加了三张图片
image.png

三、最后一步，让轮播图轮播起来，那就是开启定时器，关闭页面是关闭定时器，在生命周期中调用
image.png

自此，轮播图功能就实现了，是不是很简单，好了接下来就是BannerView.java这个最重要的类了，简单说一下某些主要的实现功能，下文后面会给出完整代码

既然是自定义View，不关联任何布局xml文件，那么首先当然是动态创建最外层布局，我用了一个FrameLayout，里面包含一个ViewPager，在最下面是一个LinearLayout，用来存放指示器的，实现代码如下：
image.png

接下来是指示器的实现，也是动态创建的，同时还要设置指示器的位置，动态创建的过程代码量比较多，就不贴出。

这个自定义轮播图的原理是使用ViewPager来实现的，所以肯定需要一个ViewPager的适配器，里面最主要的方法是根据外面setData()时传入的List 的size来动态创建ImageView，然后使用Glide来加载图片，代码如下：
image.png

还有一点就是轮播图是可以手动滑动的，所以有一个需要注意的问题就是，当你手动滑动的时候，轮播图的自动播放功能要失效，当你不手动去滑动的时候，轮播图又可以自动去轮播，所以需要一个boolean去判断当前是否是出于手动滑动状态，若是，定时器就不向handler发送信息，不做切换图片的操作，当没有手动滑动，定时器就像handler发送信息，实现图片切换，代码如下：
image.png
image.png
image.png

好了就讲这么多了，其实挺简单的，若觉得不好，请给出建议，大家一起学习，若觉得好，就关注分享给身边需要的朋友吧

BannerView.java代码：

import android.content.Context;
import android.os.Handler;
import android.os.Message;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import com.bumptech.glide.Glide;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
 
import qin.zszc.com.basiclib.R;
 
/**
 * Created by xcfor on 2018/7/11.
 */
 
public class BannerView extends FrameLayout implements ViewPager.OnPageChangeListener {
 
    public final int INDICATOR_LOCATION_CENTER_BUTTON = 0x1;//指示器居中
    public final int INDICATOR_LOCATION_LEFT_BUTTON = 0x2;//指示器居左
    public final int INDICATOR_LOCATION_RIGHT_BUTTON = 0x3;//指示器居右
    public final int BANNER_DELAY_TIME = 1000; //轮播图延迟时间
    public final int BANNER_DEF_TIIME = 5000;//轮播图默认切换时间
 
    /**
     * 存放圆点指示器
     */
    private LinearLayout mIndecatorLayout;
    private PagerAdapter mAdapter;
    private List<String> mUrls; //图片路径list
    private Context mContext;
    private ViewPager mViewPager;
 
 
    private boolean mIsScrollingByUser;// 用户手动滑动广告中
    private int mIndicatorDotWidth;//轮播切换小圆点宽度默认宽度
    private int mCurrentPos = 0;//当前页pos
    private int mPrePos = 0; //历史页pos
    private int mCount;//轮播图总数
    private int mIndicatorLocation = 1;//默认值为1：居中  2：左  3：右
    private boolean mChangeIndecatorStyle = false;//是否自定义指示器的样式
    private float mScale;//显示度量的密度
 
    /**
     * 定时滚动定时器
     */
    private Timer mTimer;
    private TimerTask mTask;
 
 
    /**
     * 接收定时器信息的handler
     */
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            int what = msg.what;
            switch (what) {
                case 0:
                    if (mViewPager != null) {
                        if (!mIsScrollingByUser) {
                            if (mCurrentPos == mUrls.size()) {
                                mCurrentPos = 0;
                            } else {
                                mCurrentPos++;
                            }
                        }
                        mViewPager.setCurrentItem(mCurrentPos);
                    }
                    break;
            }
        }
    };
 
    public BannerView(@NonNull Context context) {
        super(context);
        this.mContext = context;
    }
 
    public BannerView(@NonNull Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        this.mContext = context;
    }
 
    public BannerView(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
 
 
    public void init() {
 
        if (mUrls.size() != 1) {
            mViewPager.addOnPageChangeListener(this);
        }
        //切换画面
        mViewPager.setPageTransformer(true, new MyPageTransformer());
        mIndecatorLayout.removeAllViews();
        //向线性布局中添加小圆点指示器
        if (mUrls.size()>1){
            View dot;
            LinearLayout.LayoutParams params;
            WindowManager windowManager = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
            DisplayMetrics displayMetrics = new DisplayMetrics();
            windowManager.getDefaultDisplay().getMetrics(displayMetrics);
            int width = displayMetrics.widthPixels;
            for (int i = 0; i < mCount; i++) {
                dot = new View(mContext);
                params = new LinearLayout.LayoutParams(mIndicatorDotWidth, mIndicatorDotWidth);
                params.setMargins(mIndicatorDotWidth, 0, 0, dip2px(10));
                dot.setLayoutParams(params);
                dot.setBackgroundResource(R.drawable.basiclib_dot_bg_selector);
                dot.setEnabled(false);//默认设为非选中
                mIndecatorLayout.addView(dot);
            }
            //指示器图标的位置
            switch (mIndicatorLocation){
                case INDICATOR_LOCATION_CENTER_BUTTON:
                    if (mCount % 2 == 0) {
                        mIndecatorLayout.setPadding(width / 2 - (mCount * mIndicatorDotWidth), 0, 0, 8);
                    } else {
                        mIndecatorLayout.setPadding(width / 2 - (mCount * mIndicatorDotWidth), 0, 0, 8);
                    }
                    break;
                case INDICATOR_LOCATION_LEFT_BUTTON:
                    mIndecatorLayout.setPadding(0, 0, 0, 8);
                    break;
                case INDICATOR_LOCATION_RIGHT_BUTTON:
                    mIndecatorLayout.setPadding(width - ((mCount * 2+1) * mIndicatorDotWidth), 0, 0, 8);
                    break;
            }
            int midPos = Integer.MAX_VALUE / 2 - Integer.MAX_VALUE / 2 % mCount;
            mCurrentPos = midPos;
            mIndecatorLayout.getChildAt(0).setEnabled(true);
            mViewPager.setCurrentItem(midPos);
        }else {
            mIndecatorLayout.setVisibility(GONE);
        }
 
    }
 
    /**
     * 设置指示器的位置
     *
     * @param location
     */
    public void relayoutIndicator(int location) {
        mIndicatorLocation = location;
    }
 
 
    /**
     * 自定义指示器入口
     *
     * @param style
     */
    public void customerIndicatorEntry(int style) {
        if (!mChangeIndecatorStyle) {
            return;
        } else {
            changeIndicator(style);
        }
    }
 
    /**
     * 改变指示器
     * @param style
     */
    public void changeIndicator(int style) {
        for (int i = 0; i < mCount; i++) {
            mIndecatorLayout.getChildAt(i).setBackgroundResource(style);
        }
    }
 
 
    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        //动态创建轮播图最外围布局
        mIndicatorDotWidth = dip2px(4);
        FrameLayout fl = new FrameLayout(mContext);
        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 
            ViewGroup.LayoutParams.MATCH_PARENT);
        mViewPager = new ViewPager(mContext);
        mViewPager.setLayoutParams(params);
        fl.addView(mViewPager);
 
        //动态创建指示器外围布局
        mIndecatorLayout = new LinearLayout(mContext);
        params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
        params.gravity = Gravity.BOTTOM;
        mIndecatorLayout.setLayoutParams(params);
        mIndecatorLayout.setOrientation(LinearLayout.HORIZONTAL);
        fl.addView(mIndecatorLayout);
        addView(fl);
    }
 
    /**
     * 获取数据
     */
    public void setData(List<String> urls) {
        if (urls.isEmpty()) {
            return;
        }
        this.mUrls = urls;
        mCount = mUrls.size();
        if (mAdapter == null) {
            mAdapter = new MyAdapter(mUrls);
            mViewPager.setAdapter(mAdapter);
        }else{
            //更新viewpager视图
            //--更新原点指示器
            mAdapter.notifyDataSetChanged();
        }
        init();
    }
 
    /**
     * 默认时间启动定时器
     */
    public void startBannerScrollTask(){
        if (mUrls.size() != 1){
            startBannerScrollTask(BANNER_DEF_TIIME);
        }
    }
 
    /**
     * 给外边调用，可以使用外边的适配器
     * @param timer
     */
    public void setScrollTask(Timer timer ,long timeSpace){
        if (mCount == 0){
            return;
        }
        mTask = new TimerTask() {
            @Override
            public void run() {
                if (!mIsScrollingByUser){
                    mHandler.sendEmptyMessage(0);
                }
 
            }
        };
        timer.schedule(mTask,BANNER_DELAY_TIME, timeSpace);
    }
 
 
    //开启轮播图定时器
    public void startBannerScrollTask(long timeSpace) {
        if (mCount == 0) {
            return;
        }
        mTimer = new Timer(true);
        mTask = new TimerTask() {
            @Override
            public void run() {
                if (!mIsScrollingByUser){
                    mHandler.sendEmptyMessage(0);
                }
 
            }
        };
        mTimer.schedule(mTask, BANNER_DELAY_TIME, timeSpace);//1000ms后按指定时间间隔轮播
    }
 
    /**
     * 关闭轮播图定时器
     */
    public void stopBannerTask() {
        if (mTask != null) {
            mTask.cancel();
        }
    }
 
 
 
    /**
     * 根据手机的分辨率从 dip 的单位 转成为 px(像素)
     * 改全变量
     */
    public  int dip2px(float dpValue) {
        mScale = mContext.getResources().getDisplayMetrics().density;
        return (int) (dpValue * mScale + 0.5f);
    }
 
    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
 
    }
 
    @Override
    public void onPageSelected(int position) {
        mCurrentPos = position;
        mIndecatorLayout.getChildAt(mPrePos % mUrls.size()).setEnabled(false);
        mIndecatorLayout.getChildAt(mCurrentPos % mUrls.size()).setEnabled(true);//设置true放后面，防止初始化时两个pos都为0时。没有默认选中
        mPrePos = mCurrentPos;
    }
 
    @Override
    public void onPageScrollStateChanged(int state) {
        if (state == 0) {//用户手动滑动广告时，取消自动翻页响应
            mIsScrollingByUser = false;
        } else {
            //用户手动滑动中
            mIsScrollingByUser = true;
        }
    }
 
    /**
     * 轮播图ViewPager适配器
     */
    class MyAdapter extends PagerAdapter {
        List<String> addUrls;
 
        public MyAdapter(List<String> addUrls) {
            this.addUrls = addUrls;
        }
 
        @Override
        public int getCount() {
            if (addUrls.size() == 1){
                return addUrls.size();
            }else {
                return Integer.MAX_VALUE;
            }
        }
 
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            ImageView imageView = new ImageView(mContext);
            String currentUrl = addUrls.get(position % addUrls.size());
            imageView.setScaleType(ImageView.ScaleType.FIT_XY);
            Glide.with(mContext).load(currentUrl).into(imageView);
            container.addView(imageView);
            return imageView;
        }
 
        @Override
        public boolean isViewFromObject(View view, Object object) {
            return view == object;
        }
 
        @Override
        public void destroyItem(ViewGroup container, int position, Object object) {
            container.removeView((View) object);
        }
 
    }
 
    /**
     * 添加viewPager页面切换效果
     */
    class MyPageTransformer implements ViewPager.PageTransformer {
 
        @Override
        public void transformPage(View page, float position) {
            final float normalizedposition = Math.abs(Math.abs(position) - 1);
            page.setAlpha(normalizedposition);
        }
    }
}

BannerView.kt代码：

import android.annotation.SuppressLint
import android.content.Context
import android.os.Handler
import android.os.Message
import android.util.AttributeSet
import android.util.DisplayMetrics
import android.view.Gravity
import android.view.View
import android.view.ViewGroup
import android.view.WindowManager
import android.widget.FrameLayout
import android.widget.ImageView
import android.widget.LinearLayout
 
import androidx.viewpager.widget.PagerAdapter
import androidx.viewpager.widget.ViewPager
import com.bumptech.glide.Glide
import com.example.testproject.R
import java.util.*
 
class BannerView : FrameLayout, ViewPager.OnPageChangeListener {
 
    private val INDICATOR_LOCATION_CENTER_BUTTON: Int = 0x1//指示器居中
    private val INDICATOR_LOCATION_LEFT_BUTTON: Int = 0x2//指示器居左
    private val INDICATOR_LOCATION_RIGHT_BUTTON: Int = 0x3//指示器居右
    private val BANNER_DELAY_TIME: Long = 1000//轮播图延迟时间
    private val BANNER_DEF_TIIME: Long = 5000//轮播图默认切换时间
 
    private var mIndecatorLayout: LinearLayout? = null
    private var mAdapter: PagerAdapter? = null
    private var mUrls: MutableList<String>? = null
    private var mViewPager: ViewPager? = null
    private var mContext: Context? = null
 
    private var mIsScrellingByUser: Boolean = false
    private var mIndicatorDotWidth: Int = 0
    private var mCurrentPos: Int = 0
    private var mPrePos: Int = 0
    private var mCount: Int = 0
    private var mIndicatorLocation: Int = 1
    private var mChangeIndecatorStyle: Boolean = false
    private var mScale: Float = 0.0f
 
    private var mTimer: Timer? = null
    private var mTask: TimerTask? = null
 
    constructor(context: Context) : super(context) {
        this.mContext = context
    }
 
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
        this.mContext = context
    }
 
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(context, attrs, defStyleAttr){
        this.mContext = context
    }
 
    private var mHandler: Handler = @SuppressLint("HandlerLeak")
    object : Handler() {
        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            val what = msg.what
            if (what == 0) {
                if (!mIsScrellingByUser) {
                    mCurrentPos = if (mCurrentPos == mUrls?.size) 0
                    else mCurrentPos.plus(1)
                }
                mViewPager?.currentItem = mCurrentPos
            }
        }
    }
 
    private fun init() {
        if (mUrls?.size != 1)
            mViewPager?.addOnPageChangeListener(this)
        //切换画面
        mViewPager?.setPageTransformer(true, MyPageTransformer())
        mIndecatorLayout?.removeAllViews()
        //向线性布局中添加小圆点指示器
        if (mUrls?.size?.compareTo(1)!! > 0) {
            var dot: View
            var params: LinearLayout.LayoutParams
            val windowManager: WindowManager = mContext?.getSystemService(Context.WINDOW_SERVICE) as WindowManager
            val display = DisplayMetrics()
            windowManager.defaultDisplay.getMetrics(display)
            val width: Int = display.widthPixels
            for (item in 0 until mCount) {
                dot = View(mContext)
                params = LinearLayout.LayoutParams(mIndicatorDotWidth, mIndicatorDotWidth)
                params.setMargins(mIndicatorDotWidth, 0, 0, dip2px(10f))
                dot.layoutParams = params
                dot.setBackgroundResource(R.mipmap.ic_launcher)
                dot.isEnabled = false
                mIndecatorLayout?.addView(dot)
            }
            //指示器图标的位置
            when (mIndicatorLocation) {
                INDICATOR_LOCATION_CENTER_BUTTON ->
                    if (mCount % 2 == 0)
                        mIndecatorLayout?.setPadding(width / 2 - (mCount * mIndicatorDotWidth), 0, 0, 8)
                    else
                        mIndecatorLayout?.setPadding(width / 2 - (mCount * mIndicatorDotWidth), 0, 0, 8)
                INDICATOR_LOCATION_LEFT_BUTTON -> mIndecatorLayout?.setPadding(0, 0, 0, 8)
                INDICATOR_LOCATION_RIGHT_BUTTON -> mIndecatorLayout?.setPadding(width - ((mCount * 2 + 1) * mIndicatorDotWidth), 0, 0, 8)
            }
            val midPos: Int = Int.MAX_VALUE / 2 - Int.MAX_VALUE / 2 % mCount
            mCurrentPos = midPos
            mIndecatorLayout?.getChildAt(0)?.isEnabled = true
            mViewPager?.currentItem = midPos
        } else {
            mIndecatorLayout?.visibility = View.GONE
        }
    }
 
    /**
     * 设置指示器的位置
     */
    fun relayoutIndicator(location: Int) {
        mIndicatorLocation = location
    }
 
    /**
     * 自定义指示器入口
     */
    fun customerIndicatorEntry(style: Int) {
        if (!mChangeIndecatorStyle)
            return
        else
            changeIndicator(style)
    }
 
    /**
     * 改变指示器
     */
    private fun changeIndicator(style: Int) {
        for (item in 0 until mCount) {
            mIndecatorLayout?.getChildAt(item)?.setBackgroundResource(style)
        }
    }
 
    private fun dip2px(dpValue: Float): Int {
        mScale = mContext?.resources?.displayMetrics?.density!!
        return (dpValue * mScale + 0.5f).toInt()
    }
 
    override fun onFinishInflate() {
        super.onFinishInflate()
        //动态创建轮播图最外围布局
        mIndicatorDotWidth = dip2px(4f)
        val fl = FrameLayout(mContext!!)
        val params = LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
        mViewPager = ViewPager(mContext!!)
        mViewPager?.layoutParams = params
        fl.addView(mViewPager)
        //动态创建指示器外围布局
        mIndecatorLayout = LinearLayout(mContext!!)
        params.height = ViewGroup.LayoutParams.WRAP_CONTENT
        params.gravity = Gravity.BOTTOM
        mIndecatorLayout?.layoutParams = params
        mIndecatorLayout?.orientation = LinearLayout.HORIZONTAL
        fl.addView(mIndecatorLayout)
        addView(fl)
    }
 
    /**
     * 获取数据
     */
    fun setData(urls: MutableList<String>) {
        if (urls.isEmpty()) return
        this.mUrls = urls
        mCount = mUrls!!.size
        if (mAdapter == null) {
            mAdapter = MyAdapter(mUrls!!, mContext!!)
            mViewPager?.adapter = mAdapter
        } else {
            mAdapter?.notifyDataSetChanged()
        }
        init()
    }
 
    /**
     * 启动定时器（默认时间）
     */
    fun startBannerScrollTask() {
        if (mUrls?.size != 1)
            startBannerScrollTask(BANNER_DEF_TIIME)
    }
 
    /**
     * 给外部调用，可以使用外边的适配器
     */
    fun setScrollTask(timer: Timer, timeSpace: Long) {
        if (mCount == 0)
            return
        mTask = object : TimerTask() {
            override fun run() {
                if (!mIsScrellingByUser)
                    mHandler.sendEmptyMessage(0)
            }
        }
        timer.schedule(mTask, BANNER_DELAY_TIME, timeSpace)
    }
 
    /**
     * 开启轮播图定时器
     */
    private fun startBannerScrollTask(timeSpace: Long) {
        if (mCount == 0)
            return
        mTimer = Timer(true)
        mTask = object : TimerTask() {
            override fun run() {
                if (!mIsScrellingByUser)
                    mHandler.sendEmptyMessage(0)
            }
        }
        mTimer?.schedule(mTask, BANNER_DELAY_TIME, timeSpace)
    }
 
    /**
     * 关闭轮播图定时器
     */
    fun stopBannerTask() {
        if (mTask != null)
            mTask?.cancel()
    }
 
    override fun onPageScrollStateChanged(state: Int) {
        mIsScrellingByUser = state != 0
    }
 
    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
    }
 
    override fun onPageSelected(position: Int) {
        mCurrentPos = position
        mIndecatorLayout?.getChildAt(mPrePos % mUrls?.size!!)?.isEnabled = false
        mIndecatorLayout?.getChildAt(mCurrentPos % mUrls?.size!!)?.isEnabled = true
        mPrePos = mCurrentPos
    }
 
    class MyAdapter(addUrls: MutableList<String>, ct: Context) : PagerAdapter() {
        private var addUrls: MutableList<String>? = addUrls
        private var context: Context = ct
 
        override fun isViewFromObject(view: View, `object`: Any): Boolean {
            return view == `object`
        }
 
        override fun destroyItem(container: ViewGroup, position: Int, `object`: Any) {
            container.removeView(`object` as View?)
        }
 
        override fun instantiateItem(container: ViewGroup, position: Int): Any {
            val img = ImageView(context)
            val currentUrl = addUrls?.get(position % addUrls?.size!!)
            img.scaleType = ImageView.ScaleType.FIT_XY
            Glide.with(context).load(currentUrl).into(img)
            container.addView(img)
            return img
        }
 
        override fun getCount(): Int {
            return if (addUrls?.size == 1)
                addUrls?.size!!
            else
                Int.MAX_VALUE
        }
 
    }
 
    class MyPageTransformer : ViewPager.PageTransformer {
        override fun transformPage(page: View, position: Float) {
            val normalizedPosition: Float = Math.abs(Math.abs(position)-1)
            page.alpha = normalizedPosition
        }
    }
}
文章标签：
Java
Android开发
数据格式
XML
Kotlin
关键词：
Android自定义
Android自定义View
Android View
Android实现
小陆要努力
目录
相关文章
shuj
|
2月前
|
数据可视化 Android开发 开发者
安卓应用开发中的自定义View组件
【10月更文挑战第5天】在安卓应用开发中，自定义View组件是提升用户交互体验的利器。本篇将深入探讨如何从零开始创建自定义View，包括设计理念、实现步骤以及性能优化技巧，帮助开发者打造流畅且富有创意的用户界面。
shuj
87 0
天下无贼001
|
23天前
|
搜索推荐 前端开发 Android开发
安卓应用开发中的自定义视图实现
【10月更文挑战第30天】在安卓开发的海洋中，自定义视图是那抹不可或缺的亮色，它为应用界面的个性化和交互体验的提升提供了无限可能。本文将深入探讨如何在安卓平台创建自定义视图，并展示如何通过代码实现这一过程。我们将从基础出发，逐步引导你理解自定义视图的核心概念，然后通过一个实际的代码示例，详细讲解如何将理论应用于实践，最终实现一个美观且具有良好用户体验的自定义控件。无论你是想提高自己的开发技能，还是仅仅出于对安卓开发的兴趣，这篇文章都将为你提供价值。
天下无贼001
33 4
shuj
|
24天前
|
Android开发 开发者 UED
安卓开发中自定义View的实现与性能优化
【10月更文挑战第28天】在安卓开发领域，自定义View是提升应用界面独特性和用户体验的重要手段。本文将深入探讨如何高效地创建和管理自定义View，以及如何通过代码和性能调优来确保流畅的交互体验。我们将一起学习自定义View的生命周期、绘图基础和事件处理，进而探索内存和布局优化技巧，最终实现既美观又高效的安卓界面。
shuj
30 5
大树营养快线
|
2月前
|
缓存 数据处理 Android开发
在 Android 中使用 RxJava 更新 View
【10月更文挑战第20天】使用 RxJava 来更新 View 可以提供更优雅、更高效的解决方案。通过合理地运用操作符和订阅机制，我们能够轻松地处理异步数据并在主线程中进行 View 的更新。在实际应用中，需要根据具体情况进行灵活运用，并注意相关的注意事项和性能优化，以确保应用的稳定性和流畅性。可以通过不断的实践和探索，进一步掌握在 Android 中使用 RxJava 更新 View 的技巧和方法，为开发高质量的 Android 应用提供有力支持。
大树营养快线
11 2
mao29955
|
2月前
|
缓存 调度 Android开发
Android 在子线程更新 View
【10月更文挑战第21天】在 Android 开发中，虽然不能直接在子线程更新 View，但通过使用 Handler、AsyncTask 或 RxJava 等方法，可以实现子线程操作并在主线程更新 View 的目的。在实际应用中，需要根据具体情况选择合适的方法，并注意相关的注意事项和性能优化，以确保应用的稳定性和流畅性。可以通过不断的实践和探索，进一步掌握在子线程更新 View 的技巧和方法，为开发高质量的 Android 应用提供支持。
mao29955
32 2
游客syv66y3m2ksnc
|
2月前
|
XML 前端开发 Android开发
Android面试高频知识点(3) 详解Android View的绘制流程
Android面试高频知识点(3) 详解Android View的绘制流程
游客syv66y3m2ksnc
18 0
Android面试高频知识点(3) 详解Android View的绘制流程
悟道了凡
|
2月前
|
XML 前端开发 Android开发
Android面试高频知识点(3) 详解Android View的绘制流程
Android面试高频知识点(3) 详解Android View的绘制流程
悟道了凡
25 2
stefanie燕
|
2月前
|
XML 前端开发 Android开发
Android View的绘制流程和原理详细解说
Android View的绘制流程和原理详细解说
stefanie燕
39 3
游客moiomvrp3vyac2
|
2月前
|
XML 前端开发 Java
安卓应用开发中的自定义View组件
【10月更文挑战第5天】自定义View是安卓应用开发的一块基石，它为开发者提供了无限的可能。通过掌握其原理和实现方法，可以创造出既美观又实用的用户界面。本文将引导你了解自定义View的创建过程，包括绘制技巧、事件处理以及性能优化等关键步骤。
游客moiomvrp3vyac2
29 1
浩码农
|
Android开发
自定义android 4.0以上的对话框风格
做个笔记，这里是Dialog的风格，如果是用AlertDialog创建的，不能直接用。在styles.xml的写法： 22sp @color/font_green 1 true @st...
浩码农
707 0