vp+小圆点

最新推荐文章于 2024-03-30 11:14:08 发布
最新推荐文章于 2024-03-30 11:14:08 发布
阅读量525 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34308476/article/details/51563424
版权
package com.example.android_atuoviewpager;

public class HeadImage {

    private String IndexArtid;
    private String IndexImgurl;
    private String clickUrl;
    private int artType;
    public String getIndexArtid() {
        return IndexArtid;
    }
    public void setIndexArtid(String indexArtid) {
        IndexArtid = indexArtid;
    }
    public String getIndexImgurl() {
        return IndexImgurl;
    }
    public void setIndexImgurl(String indexImgurl) {
        IndexImgurl = indexImgurl;
    }
    public String getClickUrl() {
        return clickUrl;
    }
    public void setClickUrl(String clickUrl) {
        this.clickUrl = clickUrl;
    }
    public int getArtType() {
        return artType;
    }
    public void setArtType(int artType) {
        this.artType = artType;
    }
    
}




package com.example.android_atuoviewpager;

import java.lang.ref.WeakReference;

import android.os.Handler;
import android.os.Message;

public class ImageHandler extends Handler{  
    
    /**
     * 请求更新显示的View。
     */  
    protected static final int MSG_UPDATE_IMAGE  = 1;  
    /**
     * 请求暂停轮播。
     */  
    protected static final int MSG_KEEP_SILENT   = 2;  
    /**
     * 请求恢复轮播。
     */  
    protected static final int MSG_BREAK_SILENT  = 3;  
    /**
     * 记录最新的页号，当用户手动滑动时需要记录新页号，否则会使轮播的页面出错。
     * 例如当前如果在第一页，本来准备播放的是第二页，而这时候用户滑动到了末页，
     * 则应该播放的是第一页，如果继续按照原来的第二页播放，则逻辑上有问题。
     */  
    protected static final int MSG_PAGE_CHANGED  = 4;  
       
    //轮播间隔时间  
    protected static final long MSG_DELAY = 8000;  
       
    //使用弱引用避免Handler泄露.这里的泛型参数可以不是Activity，也可以是Fragment等  
    private WeakReference<MainActivity> weakReference;  
    private int currentItem = 0;  
       
    protected ImageHandler(WeakReference<MainActivity> wk){  
        weakReference = wk;  
    }  
       
    @Override  
    public void handleMessage(Message msg) {  
        super.handleMessage(msg);  
//        Log.d(LOG_TAG, "receive message " + msg.what);  
        MainActivity activity = weakReference.get();  
        if (activity==null){  
            //Activity已经回收，无需再处理UI了  
            return ;  
        }  
        //检查消息队列并移除未发送的消息，这主要是避免在复杂环境下消息出现重复等问题。  
        if (activity.handler.hasMessages(MSG_UPDATE_IMAGE)){  
            activity.handler.removeMessages(MSG_UPDATE_IMAGE);  
        }  
        switch (msg.what) {  
        case MSG_UPDATE_IMAGE:  
            currentItem++;  
            activity.viewPager.setCurrentItem(currentItem);  
            //准备下次播放  
            activity.handler.sendEmptyMessageDelayed(MSG_UPDATE_IMAGE, MSG_DELAY);  
            break;  
        case MSG_KEEP_SILENT:  
            //只要不发送消息就暂停了  
            break;  
        case MSG_BREAK_SILENT:  
            activity.handler.sendEmptyMessageDelayed(MSG_UPDATE_IMAGE, MSG_DELAY);  
            break;  
        case MSG_PAGE_CHANGED:  
            //记录当前的页号，避免播放的时候页面显示不正确。  
            currentItem = msg.arg1;  
            break;  
        default:  
            break;  
        }   
    }  
}





package com.example.android_atuoviewpager;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

import org.json.JSONArray;
import org.json.JSONObject;

import com.android.volley.toolbox.NetworkImageView;
import com.example.utils.JsonUtils;
import com.example.utils.VolleyTool;
import com.example.utils.JsonUtils.JsonStringCallBack;
import com.example.utils.JsonUtils.RequestTimeOutCallBack;

import android.os.Bundle;
import android.os.Message;
import android.app.Activity;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
import android.widget.LinearLayout.LayoutParams;

public class MainActivity extends Activity {

    private static final String LOG_TAG = "MainActivity";  
    public ImageHandler handler = new ImageHandler(new WeakReference<MainActivity>(this));  
    public ViewPager viewPager;
    private ImageAdapter imageAdapter;
    ArrayList<NetworkImageView> newImageViews;
    private List<HeadImage> imageLists;
    private NetworkImageView networkImageView;
    private ViewGroup group; // 图中小圆点Group
    private ImageView[] imageDots = null; // 小圆点数组集合
    
    // 假数据
    private String json_path = "http://open.cms.pcpop.com/Mobile/GetPop_Mobile.ashx?method=hand&Eid=8613&HandType=Index_pic#";
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);  
            //初始化iewPager的内容  
            viewPager = (ViewPager) findViewById(R.id.main_viewpager);  
            group = (ViewGroup) findViewById(R.id.point_group);
            parseImageData();
            viewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {  
                   
                //配合Adapter的currentItem字段进行设置。  
                @Override  
                public void onPageSelected(int arg0) {  
                    handler.sendMessage(Message.obtain(handler, ImageHandler.MSG_PAGE_CHANGED, arg0, 0));  
                    int currentPosition = arg0 % newImageViews.size();
                    for (int i = 0; i < newImageViews.size(); i++) {
                        imageDots[currentPosition]
                                .setBackgroundResource(R.drawable.test_greenicon);
                        if (currentPosition != i) {
                            imageDots[i]
                                    .setBackgroundResource(R.drawable.test_grayicon);
                        }
                    }
                }  
                   
                @Override  
                public void onPageScrolled(int arg0, float arg1, int arg2) {  
                }  
                   
                //覆写该方法实现轮播效果的暂停和恢复  
                @Override  
                public void onPageScrollStateChanged(int arg0) {  
                    switch (arg0) {  
                    case ViewPager.SCROLL_STATE_DRAGGING:  
                        handler.sendEmptyMessage(ImageHandler.MSG_KEEP_SILENT);  
                        break;  
                    case ViewPager.SCROLL_STATE_IDLE:  
                        handler.sendEmptyMessageDelayed(ImageHandler.MSG_UPDATE_IMAGE, ImageHandler.MSG_DELAY);  
                        break;  
                    default:  
                        break;  
                    }  
                }  
            });  
            viewPager.setCurrentItem(Integer.MAX_VALUE/2);//默认在中间，使用户看不到边界  
            //开始轮播效果  
            handler.sendEmptyMessageDelayed(ImageHandler.MSG_BREAK_SILENT, ImageHandler.MSG_DELAY);  
        }

    private void parseImageData() {
        JsonUtils.parseJsonString(this, json_path,
                new JsonStringCallBack() {

                    @Override
                    public void jsonStringCallBack(String jsonString) {
                        parseJsonImage(jsonString);
                        System.out.println("---->>"+imageLists.get(0).getClickUrl()+"---->>");
                        imageAdapter = new ImageAdapter(newImageViews);
                        viewPager.setAdapter(imageAdapter);
                        imageAdapter.notifyDataSetChanged();
                    }
                }, new RequestTimeOutCallBack() {

                    @Override
                    public void timeOutCallBack(String timeOutString) {
                        
                    }
                }, VolleyTool.getInstance(this).getmRequestQueue());
    }
    /**
     * 解析首页焦点图数据
     *
     * @param jsonString
     *            获取到的json字符串
     * @return
     */
    private List<HeadImage> parseJsonImage(String jsonString) {
        imageLists = new ArrayList<HeadImage>();
        newImageViews = new ArrayList<NetworkImageView>();
        try {
            JSONObject jsonObject = new JSONObject(jsonString)
                    .getJSONObject("info");
            JSONArray jsonArray = jsonObject.getJSONArray("infolist");
            for (int i = 0; i < jsonArray.length(); i++) {
                JSONObject jsonElement = jsonArray.getJSONObject(i);
                HeadImage headImage = new HeadImage();
                headImage.setIndexArtid(jsonElement.getString("IndexArtid"));
                headImage.setIndexImgurl(jsonElement.getString("IndexImgurl"));
                headImage.setClickUrl(jsonElement.getString("ClickUrl"));
                headImage.setArtType(jsonElement.getInt("ArtType"));
                imageLists.add(headImage);
            }
            for (int i = 0; i < imageLists.size(); i++) {
                networkImageView = new NetworkImageView(this);
                networkImageView.setScaleType(ScaleType.FIT_XY);
                networkImageView
                        .setDefaultImageResId(R.drawable.ic_launcher);
                networkImageView.setImageUrl(
                        imageLists.get(i).getIndexImgurl(), VolleyTool
                                .getInstance(this).getmImageLoader());
                newImageViews.add(networkImageView);
            }
            group.removeAllViews();
            imageDots = new ImageView[imageLists.size()];
            for (int i = 0; i < imageDots.length; i++) {
                imageDots[i] = new ImageView(this);
                // 设置参数
                LayoutParams params = new LayoutParams(15, 15);
                params.gravity = Gravity.CENTER_HORIZONTAL;
                params.setMargins(6, 0, 6, 0);
                imageDots[i].setLayoutParams(params);
                imageDots[i].setPadding(20, 0, 20, 0);
                if (i == 0) {
                    imageDots[i]
                            .setBackgroundResource(R.drawable.test_greenicon);
                } else {
                    imageDots[i]
                            .setBackgroundResource(R.drawable.test_grayicon);
                }
                group.addView(imageDots[i]);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return imageLists;
    }

    public class ImageAdapter extends PagerAdapter {

        private ArrayList<NetworkImageView> viewlist ;  
           
        public ImageAdapter(ArrayList<NetworkImageView> viewlist) {  
            this.viewlist = viewlist;  
        }  

        @Override  
        public int getCount() {  
            //设置成最大，使用户看不到边界  
            return Integer.MAX_VALUE;  
        }  

        @Override  
        public boolean isViewFromObject(View arg0, Object arg1) {  
            return arg0==arg1;  
        }  
         @Override    
         public void destroyItem(ViewGroup container, int position,    
                 Object object) {    
             //Warning：不要在这里调用removeView  
         }    
         @Override    
         public Object instantiateItem(ViewGroup container, int position) {  
             //对ViewPager页号求模取出View列表中要显示的项  
             position %= viewlist.size();  
             if (position<0){  
                 position = viewlist.size()+position;  
             }  
             ImageView view = viewlist.get(position);  
             //如果View已经在之前添加到了一个父组件，则必须先remove，否则会抛出IllegalStateException。  
             ViewParent vp =view.getParent();  
             if (vp!=null){  
                 ViewGroup parent = (ViewGroup)vp;  
                 parent.removeView(view);  
             }  
             container.addView(view);    
             //add listeners here if necessary  
             return view;    
         }
    }
}


package com.example.utils;

import android.graphics.Bitmap;
import android.support.v4.util.LruCache;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.ImageLoader.ImageCache;

public class ImageLoaderUtils {

    private static ImageLoader imageLoader;

    public static ImageLoader getImageLoader(RequestQueue requestQueue) {    
        if (imageLoader == null) {//单例模式
            imageLoader = new ImageLoader(requestQueue, new ImageCache() {
                
                
                private LruCache<String, Bitmap> cache = new LruCache<String, Bitmap>(
                        (int) Runtime.getRuntime().maxMemory() / 4) {//因图片很多故在此处为4，本应为8

                    @Override
                    protected void entryRemoved(boolean evicted, String key,
                            Bitmap oldValue, Bitmap newValue) {
                        super.entryRemoved(evicted, key, oldValue, newValue);
                        //如果为true为存满后 挤出来的
                        if (evicted) {
                            oldValue.recycle();
                            oldValue = null;
                        }
                    }

                    @Override
                    protected int sizeOf(String key, Bitmap value) {
                        return value.getRowBytes() * value.getHeight();
                        
                    }

                };

                @Override
                public void putBitmap(String url, Bitmap bitmap) {
                    // TODO Auto-generated method stub
                    cache.put(url, bitmap);
                }

                @Override
                public Bitmap getBitmap(String url) {
                    // TODO Auto-generated method stub
                    return cache.get(url);
                }
            });
        }
        return imageLoader;
    }
    
    public static void LetImageLoaderToGc(){
        imageLoader=null;
    }
}




package com.example.utils;

import android.content.Context;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.Volley;

public class VolleyTool {
    private static VolleyTool mInstance = null;
    private RequestQueue mRequestQueue;
    private ImageLoader mImageLoader;
    
    private VolleyTool(Context context){
        mRequestQueue = Volley.newRequestQueue(context);
        mImageLoader = ImageLoaderUtils.getImageLoader(mRequestQueue);
    }
    
    public static VolleyTool getInstance(Context context){
        if (mInstance==null) {
            mInstance = new VolleyTool(context);
        }
        return mInstance;
    }

    public RequestQueue getmRequestQueue() {
        return mRequestQueue;
    }

    public ImageLoader getmImageLoader() {
        return mImageLoader;
    }

    public void release() {
        this.mImageLoader = null;
        this.mRequestQueue = null;
        mInstance = null;
    }

}



package com.example.utils;

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONObject;

import android.content.Context;
import android.util.Log;

import com.android.volley.AuthFailureError;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.Response.Listener;
import com.android.volley.RetryPolicy;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;
import com.android.volley.toolbox.JsonArrayRequest;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.StringRequest;

public class JsonUtils {

    /**
     * 解析json数据的工具类
     *
     * @param context
     * @param json_path
     * @param callBack
     * @param queue
     */
    public static void parseJsonString(Context context, String json_path,
            final JsonStringCallBack callBack,
            final RequestTimeOutCallBack timeOutCallBack, RequestQueue queue) {
        StringRequest request = new StringRequest(json_path,
                new Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        // TODO Auto-generated method stub
                        callBack.jsonStringCallBack(response);
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        timeOutCallBack.timeOutCallBack(error.getMessage());
                    }
                }) {
            @Override
            protected Response<String> parseNetworkResponse(
                    NetworkResponse response) {
                String str = null;
                try {
                    str = new String(response.data, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return Response.success(str,
                        HttpHeaderParser.parseCacheHeaders(response));
            }
        };

        request.setRetryPolicy(new DefaultRetryPolicy(4000,
                DefaultRetryPolicy.DEFAULT_MAX_RETRIES,
                DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));

        // 添加到队列中
        queue.add(request);
    }

    /**
     * 解析数组开始的json字符串
     *
     * @param context
     * @param json_path
     * @param callBack
     * @param queue
     */
    public static void parseJsonArray(Context context, String json_path,
            final JsonArrayCallBack callBack, RequestQueue queue) {
        JsonArrayRequest request = new JsonArrayRequest(json_path,
                new Listener<JSONArray>() {
                    @Override
                    public void onResponse(JSONArray response) {
                        // TODO Auto-generated method stub
                        callBack.jsonArrayCallBack(response);
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        // TODO Auto-generated method stub
                        Log.i("TAG", error.getMessage());
                    }
                });
        // 添加到队列中
        queue.add(request);
    }

    /**
     *
     * @param context
     * @param json_path
     * @param callBack
     */
    public static void parseJsonObject(Context context, String json_path,
            final Map<String, String> map, final JsonObjectCallBack callBack,
            RequestQueue queue) {
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(
                Request.Method.POST, json_path, null,
                new Response.Listener<JSONObject>() {
                    @Override
                    public void onResponse(JSONObject response) {
                        // TODO Auto-generated method stub
                        // System.out.println("----->>response=" + response);
                        callBack.jsonObjectCallBack(response);
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        // TODO Auto-generated method stub

                    }

                })

        {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                return map;
            }

            @Override
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap<String, String> headers = new HashMap<String, String>();
                headers.put("Accept", "application/json");
                headers.put("Content-Type", "application/json; charset=UTF-8");
                return headers;

            }
        };
        queue.add(jsonObjectRequest);
    }

    // 解析json对象的回调接口
    public interface JsonObjectCallBack {
        public void jsonObjectCallBack(JSONObject jsonObject);

    }

    // 解析json数组的回调接口
    public interface JsonArrayCallBack {
        public void jsonArrayCallBack(JSONArray jsonArray);
    }

    // 解析json字符串的回调接口
    public interface JsonStringCallBack {
        public void jsonStringCallBack(String jsonString);
    }
    // 請求超時的回調接口
    public interface RequestTimeOutCallBack {
        public void timeOutCallBack(String timeOutString);
    }
}



<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="240dip">

    <android.support.v4.view.ViewPager
        android:id="@+id/main_viewpager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

    <LinearLayout
        android:id="@+id/point_group"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="20.0dip"
        android:layout_gravity="center_horizontal|bottom"
        android:orientation="horizontal">
    </LinearLayout>
</FrameLayout>






惺惺惜惺没有什么不tong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android实现图片轮播效果的两种方法
01-05
大家在使用APP的过程中，经常会看到上部banner图片轮播的效果，那么今天我们就一起来学习一下，android中图片轮询的几种实现方法： 第一种:使用动画的方法实现：(代码繁琐) 这种发放需要：两个动画效果，一个布局，一个主类来实现，不多说了，来看代码吧： public class IamgeTrActivity extends Activity { /** Called when the activity is first created. */ public ImageView imageView; public ImageView imageView2; public Animati
Android：快速上手好看简约的轮播图
m0_58941767的博客
06-19 3463
本期介绍Android的一项比较好用的轮播图，这是github上一个比较优秀的开源库，今天带大家来学习一下，这个开源库的基本用法。先上演示视频：QQ视频20230618211556一、如何引入本次分享的是一个关于Android轮播图的一种实现方法，希望大家可以有所收获。
ANDROID进阶之路 - 五分钟内快速实现轮播图效果
xiaozhang0414的博客
07-13 1678
isShowIndicatorOnlyOne 当只有一张图片的时候是否显示指示点 boolean，默认为false，不显示。pointsPosition 指示点显示位置 LEFT、CENTER、RIGHT类型，默认为CENTER。pointNormal 指示器未选中时状态点 drawable，不设置的话为默认状态点。pointSelect 指示器选中时状态点 drawable，不设置的话为默认状态点。pointsVisibility 是否显示指示器 boolean类型，默认为true。
【Android】Android中使用CarouselView实现轮播图的效果
yao_yaoya的博客
12-12 1566
在Android中使用CarouselView实现图片轮播的效果。
Android实例——轮播图
松仔Log的博客
01-10 3006
带标题的轮播图效果图attrs.xmlactivity_main.xmllooppager.xmlMyViewPager.javaSizeUtils.javaLooperPager.javaViewPagerItem.javaLooperPagerAdapter.javaMainActivity.java 效果图 可实现自动轮播，且标题和指示器（红点）随图片切换 attrs.xml res/value下创建attrs.xml，实现自定义属性，用于控制控件中标题是否显示、显示几张图片（未实现）、轮播时间 &
无限轮播+小圆点
08-20
无限轮播+小圆点
自动轮播+小圆点实现
07-28
轮播——小圆点
Viewpager无限轮播+小圆点
04-25
Viewpager无限轮播+小圆点
android viewpager 左右无限循环滑动 + 小圆点指示器
11-18
android viewpager 实现了左右无限循环滑动 并且内附可自定义的小圆点指示器
[Android实例] ViewPager实现图片+小圆点切换
11-13
看了好多小伙伴和我一样在寻找焦点图片对应地下小圆点的例子 我自己做好了 特地来分享一下 主要框架为3部分 上半部分是图片左右切换 下半部分是textview的一个显示 并且添加了滚动条 底部就是小圆点了 当显示第几张...
Android Viewpager3D广告轮播
______夏日飞雨
06-11 858
Android Viewpager3D广告轮播 MainActivity public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setCont
android轮播图实现方案,Android轮播图实现教程
weixin_42567279的博客
05-26 3130
ListView的headerView设置为轮播图之后结合上/下拉刷新/加载的模式成为现在大多数APP的一个必须具备的功能，对于许多初学者来说想要实现轮播图这样一个集线程睡眠、自动处理、替换过程中刷新UI界面的组合功能非常困难，没有思路，感觉无从下手，去搜索各种实现方案，发现目前充斥着大量的类似于使用弃用组件Gallery这样的例子。本篇博客将通过分析轮播图的各个注意事项及实现思路来实现一个简易的...
安卓实现轮播图
twenty_four_7的博客
05-30 7054
安卓实现轮播图 一、实现纯颜色作为背景的轮播图 1.首先在主活动的xml文件下面添加一个ViewPager <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/ap
Android 实现图片轮播的三种方法
最新发布
2401_84010176的博客
03-30 846
/配合Adapter的currentItem字段进行设置。@Override@Override//覆写该方法实现轮播效果的暂停和恢复@Overridebreak;break;});//默认在中间，使用户看不到边界//开始轮播效果二、Gallery(deprecated) + Timer/**这里的数值，限制了每次滚动的最大长度，图片宽度为480PX。这里设置600效果好一些。
Android 实现图片轮播的三种方法，移动开发平台
m0_66145114的博客
01-28 3634
} @Override public void handleMessage(Message msg) { super.handleMessage(msg); Log.d(LOG_TAG, "receive message " + msg.what); MainActivity activity = weakReference.get(); if (activity==null){ //Activity已经回收，无需再处理UI了 return ; } //检查消息队列并移除未发送的消息，这主要是避免在复杂环境
Android 实现图片轮播的三种方法，2024届毕业生还没找到Android开发工作
时间与思念
03-25 983
光有这些思路和搞懂单个知识的应用是还远远不够的，在Android开源框架设计思想中的知识点还是比较多的，想要搞懂还得学会整理和规划：我们常见的**Android热修复框架、插件化框架、组件化框架、图片加载框架、网络访问框架、RxJava响应式编程框架、IOC依赖注入框架、最近架构组件Jetpack等等Android第三方开源框架，**这些都是属于Android开源框架设计思想的。如下图所示：这位阿里P8大佬针对以上知识点，熬夜整理出了一本长达1042页的完整版如何解读开源框架设计思想。
Android---Banner轮播图
热门推荐
qq_44950283的博客
12-22 1万+
实现一个简单的轮播图效果，Banner框架已经帮我们做了一个适配器--能够帮助我们快速开发，完成首页轮播图效果的需求。
最新kotlin android 轮播图的实现，超简单 - android banner
qq_39909614的博客
09-02 4474
写在前面 本人android小白，刚学kotlinandroid ，所以这篇文章是给小白看的 由于项目中需要使用到轮播图，自己造轮子不太可能所以肯定是要用到第三方库的 但是我发现网上大部分都是java android的，或者又有一些都是太老旧 正文 此次采用的是youth5201314的banner库，这个项目在github上也是拥有超多的star 第一步 在gradle中添加banner 和 glide 依赖 （这里用到glide是需要用到他的图片加载，也可以不用具体请参考.....
【转载】简单实现android轮播图
weixin_43695721的博客
04-06 2686
【转载】简单实现android轮播图 轮播图是很常用的一个效果 核心功能已经实现 没有什么特殊需求 自己没事研究的 所以封装的不太好 一些地方还比较糙 为想要研究轮播图的同学提供个参考 目前测试图片为mipmap中的图片 没有写从网络加载图片 可自行根据需求在getShowView()方法中修改（可以使用Glide加载网络图片） 1、定时切换 通过handle延时发送通知改变界面 然后在切换viewpage的界面之后 再次发送此延时通知 就ok咯 还可以通过timer定时器实现 2、无限轮播效果 如果我们
banner 小圆点
11-08
banner小圆点是指在Banner控件中，用于指示当前轮播图位置的小圆点。通常情况下，小圆点会随着轮播图的切换而改变颜色或者位置，以便用户更好地了解当前所处的轮播图位置。在上述提供的代码中，使用了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值