Android自定义View实现拼图小游戏

本文实例为大家分享了Android拼图小游戏的具体代码,供大家参考,具体内容如下

1、效果图:

运行时:

结束时:

2、PuzzleLayoutView:

public class PuzzleLayoutView extends RelativeLayout implements View.OnClickListener {

  //表示将其切成2*2拼图(默认4块)
  private int mColumn = 2;
  //容器的内边距
  private int mPadding;
  //每个块块的边距(横,纵  3:表示间距为3dp)
  private int mMargin = 3;
  //存储ImageView
  private ImageView[] mGamePintuItems;
  //Item的宽度(一致)
  private int mItemWidth;
  //游戏的图片
  private Bitmap mBitmap;
  //切图后的存储
  private List<ImagePieceBean> mItemBitmaps;
  //操作次数
  private boolean once;
  //容器宽度(游戏面板 高宽一致)
  private int mWidth;
  //设置游戏是否成功
  private boolean isGameSuccess;
  //设置游戏是否失败
  private boolean isGameOver;

  public GamePintuListner mListner;

  public PuzzleLayoutView(Context context) {
    this(context, null);
  }

  public PuzzleLayoutView(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
  }

  public PuzzleLayoutView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    init();
  }

  private void init() {
    mMargin = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 3,
        getResources().getDisplayMetrics());//将dp转化为px,或xp转化为px
    mPadding = min(getPaddingLeft(), getPaddingRight(), getPaddingTop(), getPaddingBottom());
  }

  //接口方法
  public interface GamePintuListner {

    void nextLevel(int nextLevel);//下一关

    void timechanged(int currentTime);//关卡时间

    void gameover();//游戏结束
  }

  public void setOnGamePintuListner(GamePintuListner mListner) {
    this.mListner = mListner;
  }

  private int level = 1;
  private static final int TIME_CHANGED = 0X123;
  private static final int NEXT_LEVEL = 0X124;

  private Handler handler = new Handler() {
    public void handleMessage(android.os.Message msg) {
      switch (msg.what) {
        case TIME_CHANGED:
          if (isGameSuccess || isGameOver)
            return;
          if (mListner != null) {
            mListner.timechanged(mTime);
            //时间结束后,游戏结束
            if (mTime == 0) {
              isGameOver = true;
              mListner.gameover();
            }
          }
          mTime--;
          //延迟1秒发送
          handler.sendEmptyMessageDelayed(TIME_CHANGED, 1000);
          break;
        case NEXT_LEVEL:
          level = level + 1;//切换到下一关
          if (mListner != null) {
            mListner.nextLevel(level);
          } else {
            nextLevel();
          }
        default:
          break;
      }
    }
  };

  private boolean isTimeEnabled = false;
  private int mTime;

  /**
   * 设置是否启动时间  (默认不启动)
   *
   * @param isTimeEnabled
   */
  public void setTimeEnabled(boolean isTimeEnabled) {
    this.isTimeEnabled = isTimeEnabled;
  }

  /**
   * 获取当前布局的大小(正方形)
   */
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    //取宽和高中的最小值
    mWidth = Math.min(getMeasuredHeight(), getMeasuredWidth());
    if (!once) {
      //调用进行切图,以及排序(方法)
      initBitmap();
      //调用设置ImageView(Item)的宽高等属性(方法)
      initItem();
      //判断是否开启时间(方法调用)
      checkTimeEnable();
      once = true;
    }
    setMeasuredDimension(mWidth, mWidth);//强制调用使面板为正方形
  }

  /**
   * 判断是否开启时间
   */
  private void checkTimeEnable() {
    if (isTimeEnabled) {
      //根据当前等级设置时间
      countTimeBaseLevel();
      //通知线程更新关卡时间
      handler.sendEmptyMessage(TIME_CHANGED);
    }

  }

  private void countTimeBaseLevel() {
    mTime = (int) Math.pow(2, level) * 60;//第一关120秒 第二关:240 第三关:480
  }

  /**
   * 进行切图,以及排序方法
   */
  private void initBitmap() {
    //将图片引入
    if (mBitmap == null) {
      mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.pic_view);//注意此处的导包
    }
    mItemBitmaps = ImageSplitterUtil.sqlitImage(mBitmap, mColumn);//返回长度为4 (2*2)
    //使用sort进行乱排序
    Collections.sort(mItemBitmaps, new Comparator<ImagePieceBean>() {
      public int compare(ImagePieceBean a, ImagePieceBean b) {//注意此处的a,b
        //是否大于0.5具有不确定性
        return Math.random() > 0.5 ? 1 : -1;
      }
    });
  }

  /**
   * 设置ImageView(Item)的宽高等属性方法
   */
  private void initItem() {
    //容器的宽度-Item内边距 =所有小块块加起来的/Item个数(宽度)  2:左边和右边边距
    mItemWidth = (mWidth - mPadding * 2 - mMargin * (mColumn - 1)) / mColumn;
    mGamePintuItems = new ImageView[mColumn * mColumn];//界面块块个数相*
    //生成我们的Item,设置Rule(Item间的关系,高矮等)
    for (int i = 0; i < mGamePintuItems.length; i++) {
      ImageView item = new ImageView(getContext());
      /**
       * item点击事件
       */
      item.setOnClickListener(this);
      item.setImageBitmap(mItemBitmaps.get(i).getBitmap());//此前以进行过乱排序
      mGamePintuItems[i] = item;//保存Item
      item.setId(i + 1);
      //在Item的tag中存储了index
      item.setTag(i + "_" + mItemBitmaps.get(i).getIndex());
      RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(mItemWidth, mItemWidth);
      //[设置游戏规则]
      //设置Item间横向间隙,通过rightMargin
      //不是最后一列
      if ((i + 1) % mColumn != 0) {
        lp.rightMargin = mMargin;
      }
      //不是第一列
      if (i % mColumn != 0) {
        lp.addRule(RelativeLayout.RIGHT_OF, mGamePintuItems[i - 1].getId());
      }
      //如果不是第一行,设置topMargin和rule
      if (i + 1 > mColumn) {
        lp.topMargin = mMargin;
        lp.addRule(RelativeLayout.BELOW, mGamePintuItems[i - mColumn].getId());
      }
      addView(item, lp);//添加到RelativeLayout中
    }
  }

  /**
   * 当过关失败,时间停止时调用此方法(重新开始此关卡)
   */
  public void restart() {
    isGameOver = false;//重置当前关卡
    mColumn--;
    nextLevel();
  }

  public void nextLevel() {
    this.removeAllViews();//移除当前所有View
    mAnimLayout = null;
    mColumn++;//由2*2 变为3*3游戏面版
    isGameSuccess = false;//游戏未成功(新的开始)
    checkTimeEnable();//下一关时间重新计算
    initBitmap();
    initItem();
  }

  /**
   * 获取多个参数的最小值
   */
  private int min(int... params) {//...传多个参数
    int min = params[0];//获取最小的
    for (int param : params) {//发现最小的则赋值
      if (param < min) {
        min = param;
      }
    }
    return min;
  }

  /**
   * 点击事件
   */
  private ImageView mFirst;//点击的IItem
  private ImageView mSecond;

  public void onClick(View v) {
    if (isAniming)
      return;
    //两次点击同一个Item
    if (mFirst == v) {
      mFirst.setColorFilter(null);
      mFirst = null;
      return;
    }
    if (mFirst == null) {
      mFirst = (ImageView) v;
      mFirst.setColorFilter(Color.parseColor("#5551c4d4"));//设置选中Item时的颜色(55为半透明)
    } else {
      mSecond = (ImageView) v;
      //交换我们的Item
      exchangeView();
    }
  }

  /**
   * 动画层
   */
  private RelativeLayout mAnimLayout;
  //设置图片进行切换时用户疯狂点击
  private boolean isAniming;

  /**
   * 交换我们的Item
   */
  private void exchangeView() {
    mFirst.setColorFilter(null);//去除颜色状态(高亮)
    //调用构造我们的动画层方法
    setUpAnimLayout();
    //进行图片的交换
    ImageView first = new ImageView(getContext());
    final Bitmap firstBitmap = mItemBitmaps.get(getImageIdByTag((String) mFirst.getTag())).getBitmap();
    first.setImageBitmap(firstBitmap);
    LayoutParams lp = new LayoutParams(mItemWidth, mItemWidth);
    lp.leftMargin = mFirst.getLeft() - mPadding;
    lp.topMargin = mFirst.getTop() - mPadding;
    first.setLayoutParams(lp);
    mAnimLayout.addView(first);//添加至动画层
    ImageView second = new ImageView(getContext());
    final Bitmap secondBitmap = mItemBitmaps.get(getImageIdByTag((String) mSecond.getTag())).getBitmap();
    second.setImageBitmap(secondBitmap);
    LayoutParams lp2 = new LayoutParams(mItemWidth, mItemWidth);
    lp2.leftMargin = mSecond.getLeft() - mPadding;
    lp2.topMargin = mSecond.getTop() - mPadding;
    second.setLayoutParams(lp2);
    mAnimLayout.addView(second);//添加至动画层

    //设置动画
    TranslateAnimation animFirst = new TranslateAnimation(0, mSecond.getLeft() - mFirst.getLeft(),
        0, mSecond.getTop() - mFirst.getTop());
    animFirst.setDuration(500);//设置动画时间
    animFirst.setFillAfter(true);//设置动画结束的位置
    first.startAnimation(animFirst);//启动动画

    TranslateAnimation animSecond = new TranslateAnimation(0, -mSecond.getLeft() + mFirst.getLeft(),
        0, -mSecond.getTop() + mFirst.getTop());
    animSecond.setDuration(500);//设置动画时间
    animSecond.setFillAfter(true);//设置动画结束的位置
    second.startAnimation(animSecond);//启动动画

    /**
     * 监听动画事件
     */
    animFirst.setAnimationListener(new Animation.AnimationListener() {
      public void onAnimationStart(Animation animation) {
        mFirst.setVisibility(View.INVISIBLE);//隐藏动画
        mSecond.setVisibility(View.INVISIBLE);
        isAniming = true;
      }

      public void onAnimationRepeat(Animation animation) {
      }

      public void onAnimationEnd(Animation animation) {

        String firstTag = (String) mFirst.getTag();
        String secondTag = (String) mSecond.getTag();
        mFirst.setImageBitmap(secondBitmap);
        mSecond.setImageBitmap(firstBitmap);
        mFirst.setTag(secondTag);
        mSecond.setTag(firstTag);
        mFirst.setVisibility(View.VISIBLE);//显示隐藏的图片
        mSecond.setVisibility(View.VISIBLE);
        //此处为空,并不是将对象设置为null 而是将mFirst与Bitmap对象链接的线断开
        mFirst = mSecond = null;//回到初始状态
        mAnimLayout.removeAllViews();//移除动画层的两个View
        //调用判断游戏成功时的方法
        checkSuccess();
        isAniming = false;
      }
    });
  }

  /**
   * 判断游戏是否成功
   */
  private void checkSuccess() {

    boolean isSuccess = true;
    for (int i = 0; i < mGamePintuItems.length; i++) {
      ImageView imageView = mGamePintuItems[i];
      //getImageIndex:上面的方法名(注意此处方法名)
      if (getImageIndex((String) imageView.getTag()) != i) {
        isSuccess = false;
      }
    }
    if (isSuccess) {
      isGameSuccess = true;
      handler.removeMessages(TIME_CHANGED);//进入下一关时的时间
      Log.e("TAG", "SUCCESS");
      Toast.makeText(getContext(), "Success,level up 游戏升级!!!", Toast.LENGTH_LONG).show();
      handler.sendEmptyMessage(NEXT_LEVEL);
    }
  }

  /**
   * 根据tag获取Id
   */
  public int getImageIdByTag(String tag) {
    String[] split = tag.split("_");
    return Integer.parseInt(split[0]);//拿ID
  }

  public int getImageIndex(String tag) {
    String[] split = tag.split("_");
    return Integer.parseInt(split[1]);//拿ID
  }

  /**
   * 构造我们的动画层
   */
  private void setUpAnimLayout() {
    if (mAnimLayout == null) {
      mAnimLayout = new RelativeLayout(getContext());
      addView(mAnimLayout);//添加到游戏面板中
    }
  }
}

工具类:ImageSplitterUtil

public class ImageSplitterUtil {

  /**
   * 传入bitmap,切成piece*piece块
   */
  public static List<ImagePieceBean> sqlitImage(Bitmap bitmap, int piece) {
    List<ImagePieceBean> ImagePieceBeans = new ArrayList<>();

    int width = bitmap.getWidth();//拿到图片宽高
    int height = bitmap.getHeight();
    int pieceWidth = Math.min(width, height) / piece;//得到每一块的宽度

    for (int i = 0; i < piece; i++) {//切第一行
      for (int j = 0; j < piece; j++) {//循环切第二,三行
        ImagePieceBean ImagePieceBean = new ImagePieceBean();
        ImagePieceBean.setIndex(j + i * piece);//第一次i为0,第0行 j++递增 0-6
        int x = j * pieceWidth;//第一次循环X,Y为0
        int y = i * pieceWidth;
        ImagePieceBean.setBitmap(Bitmap.createBitmap(bitmap, x, y, pieceWidth, pieceWidth));
        ImagePieceBeans.add(ImagePieceBean);
      }
    }
    return ImagePieceBeans;
  }
}

实体类:ImagePieceBean

public class ImagePieceBean {

  private int index;  //表示当前第几块
  private Bitmap bitmap;  //当前图片

  public ImagePieceBean() {
  }

  //快捷键构造方法 Source 倒3
  public ImagePieceBean(int index, Bitmap bitmap) {
    this.index = index;
    this.bitmap = bitmap;
  }

  public int getIndex() {
    return index;
  }

  public void setIndex(int index) {
    this.index = index;
  }

  public Bitmap getBitmap() {
    return bitmap;
  }

  public void setBitmap(Bitmap bitmap) {
    this.bitmap = bitmap;
  }

  public String toString() {
    return "ImagePiece [index=" + index + ", bitmap=" + bitmap + "]";
  }
}

3、使用方法:GameActivity

/**
 * 总结:
 * 1.自定义控件选择,九宫格,RelativeLayout, id+Rule
 * 2.切图
 * 3.动画图层
 * 4.pause resume restart
 * 5.游戏时间 Handler sendMessageDelayed() 延迟一秒发送线程
 */
public class GameActivity extends AppCompatActivity {

  private PuzzleLayoutView puzzleLayoutView;
  private TextView mLevel, mTime;

  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.activity_game);

    mLevel = this.findViewById(R.id.id_level);
    mTime = this.findViewById(R.id.id_time);
    puzzleLayoutView = this.findViewById(R.id.puzzle_layout_view);
    puzzleLayoutView.setTimeEnabled(true);
    //监听事件
    puzzleLayoutView.setOnGamePintuListner(new PuzzleLayoutView.GamePintuListner() {
      public void timechanged(int currentTime) {
        //此处为int 注意加""
        mTime.setText(currentTime + "秒");
      }

      public void nextLevel(final int nextLevel) {
        //弹出提示框
        new AlertDialog.Builder(GameActivity.this).setTitle("游戏信息")
            .setMessage("游戏升级").setPositiveButton("进入下一关",
            new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
                //游戏结束后,调用下一关
                puzzleLayoutView.nextLevel();
                mLevel.setText("第" + +nextLevel + "关");
              }
            }).show();
      }

      public void gameover() {
        //弹出提示框
        new AlertDialog.Builder(GameActivity.this).setTitle("游戏信息")
            .setMessage("游戏结束!").setPositiveButton("是否继续该关卡?",
            new DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
                puzzleLayoutView.restart();//重新启动
              }
            }).setNegativeButton("是否放弃该游戏!", new DialogInterface.OnClickListener() {
          public void onClick(DialogInterface dialog, int which) {
            finish();
          }
        }).show();
      }
    });
  }
}

对应布局:activity_game

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:layout_margin="10dp"
  android:gravity="center_horizontal"
  android:orientation="vertical">

  <RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <TextView
      android:id="@+id/id_level"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:gravity="center"
      android:text="1"
      android:textSize="25sp"
      android:textStyle="bold" />

    <TextView
      android:id="@+id/id_time"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:layout_alignParentRight="true"
      android:gravity="center"
      android:text="120"
      android:textColor="#ea7821"
      android:textSize="25sp"
      android:textStyle="bold" />
  </RelativeLayout>

  <ImageView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_marginBottom="10dp"
    android:src="@drawable/pic_view" />

  <com.helloworld.game.utils.PuzzleLayoutView
    android:id="@+id/puzzle_layout_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="3dp" />

</LinearLayout>

注意:pic_view图片资源自行更换

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Android实现美女拼图游戏详解

    先来看看效果: 图片切分很多份,点击交换拼成一张完整的:这样关卡也很容易设计,3 3:4 4:5 5:6 6:一直下去 加了个切换动画,效果还是不错的,其实游戏就是自定义了一个控件,下面我们开始自定义之旅. 游戏的设计 首先我们分析下如何设计这款游戏: 1.我们需要一个容器,可以放这些图片的块块,为了方便,我们准备使用RelativeLayout配合addRule实现 2.每个图片的块块,我们准备使用ImageView 3.点击交换,我们准备使用传统的TranslationAnimation来实

  • Android实现九宫格拼图游戏

    经常有同学问到,使用Android能不能开发游戏呢?能开发那些游戏呢?由于操作系统和开发语言局限,一般开发安卓手机游戏,我们很少使用其自带语言开发.而是使用指定编译器和语言完成,能够使界面更流畅,用户体验感更好.但是对于一些常见小游戏,使用JAVA语言开发运行,还是不在话下的,那在本篇博客中,我将给大家简单介绍一下,九宫格拼图游戏的开发过程,基本逻辑和思路我将在代码的注释中体现. 九宫格拼图游戏,相信大家小时候都玩过.大概逻辑是,将1张图采用3*3的方式,分成9部分,将第3行3列的小图取出,打乱

  • 基于Android平台实现拼图小游戏

    一.需求描述 拼图是一款益智类经典游戏了,本游戏学习了一些前辈们的经验,整体来说讲,将图片用切图工具进行切割,监听用户手指滑动事件,当用户对凌乱的图片,在一定的时间内拼凑恢复成原来的样子,则成功闯关. 根据游戏不同的关卡对图片进行动态的切割.玩家可以在随意交换任意两张图片,通过遍历切割好的每块图片,将用户选中的图片,进行替换: 其中主要的功能为: 动态对图片进行切割成所需要的份数. 玩家任意点击的两张图片能够进行正确交换. 实现交换图片的动画切换效果. 实现过关逻辑. 实现游戏时间逻辑控制. 游

  • Android利用ViewDragHelper轻松实现拼图游戏的示例

    前言 最近一段时间看了一些介绍ViewDragHelper的博客,感觉这是一个处理手势滑动的神奇,看完以后就想做点东西练练手,于是就做了这个Android拼图小游戏. 先上个效果图 源码 https://github.com/kevin-mob/Puzzle ViewDragHelper 其实ViewDragHelper并不是第一个用于分析手势处理的类,gesturedetector也是,但是在和拖动相关的手势分析方面gesturedetector只能说是勉为其难. 关于ViewDragHelp

  • Android实现拼图小游戏

    本文实例为大家分享了Android实现拼图小游戏的具体代码,供大家参考,具体内容如下 目标效果: 1.activity_main.xml页面: <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schem

  • Android拼图游戏 玩转从基础到应用手势变化

    相信大家在小的时候都玩过拼图游戏,现如今,手机普及,能在手机上玩的游戏越来越多,于是乎,重温小时候,编写这个简易拼图游戏,而且也能进一步加深Android的一些基础知识. 老规矩,先是效果图: 这里我把为了演示效果,把图片打乱的很少,在代码里可以更改. 首先,有个默认的图片,可以用来拼图,也可以选择你喜欢的图片进行拼图,拼图的过程会记录移动的步数,并且当游戏胜利的时候会弹出一个笑脸提示,游戏胜利,用了多少步数. ps:感兴趣的完全可以继续在这上面进行扩展,比如增加游戏难度的选项,可以将图片分成更

  • Android自定义View实现拼图小游戏

    本文实例为大家分享了Android拼图小游戏的具体代码,供大家参考,具体内容如下 1.效果图: 运行时: 结束时: 2.PuzzleLayoutView: public class PuzzleLayoutView extends RelativeLayout implements View.OnClickListener { //表示将其切成2*2拼图(默认4块) private int mColumn = 2; //容器的内边距 private int mPadding; //每个块块的边距

  • Android自定义View实现五子棋小游戏

    本文实例为大家分享了Android实现五子棋小游戏的具体代码,供大家参考,具体内容如下 配图: 代码: package com.example.fiveson; import java.util.LinkedList; import java.util.List; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphic

  • android自定义View实现简单五子棋游戏

    做一个五子棋练练手,没什么特别的,再复习一下自定义View的知识,onMeasure,MeasureSpec , onDraw以及OnTouchEvent方法等. 效果图 代码如下: package com.fivechess; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas;

  • Android自定义View实现游戏摇杆键盘的方法示例

    前言 本文主要给大家介绍的是关于Android自定义View实现游戏摇杆键盘的相关内容,为什么会有这篇文章呢?因为在之前的一个项目,操作方向的方式为上下左右,左上需要同时按住左键和右键的方式进行操作. 如下图: 近来需要升级项目,操作方式改为类似王者荣耀的摇杆操作. 如下图: 好了,下面话不多说了,跟着小编来一起看看是如何实现的吧. 绘制背景 实现遥感按钮,需要绘制背景,绘制中心的遥感按钮.绘制遥感背景,需要创建一个RemoteViewBg类,存储背景图,减少重复创建bitmap. Remote

  • Android自定义view实现阻尼效果的加载动画

    效果: 需要知识: 1. 二次贝塞尔曲线 2. 动画知识 3. 基础自定义view知识 先来解释下什么叫阻尼运动 阻尼振动是指,由于振动系统受到摩擦和介质阻力或其他能耗而使振幅随时间逐渐衰减的振动,又称减幅振动.衰减振动.[1] 不论是弹簧振子还是单摆由于外界的摩擦和介质阻力总是存在,在振动过程中要不断克服外界阻力做功,消耗能量,振幅就会逐渐减小,经过一段时间,振动就会完全停下来.这种振幅随时间减小的振动称为阻尼振动.因为振幅与振动的能量有关,阻尼振动也就是能量不断减少的振动.阻尼振动是非简谐运

  • Android自定义View 仿QQ侧滑菜单的实现代码

    先看看QQ的侧滑效果 分析一下 先上原理图(不知道能否表达的清楚 ==) -首先这里使用了 Android 的HorizontalScrollView 水平滑动布局作为容器,当然我们需要继承它自定义一个侧滑视图 - 这个容器里面有一个父布局(一般用LinerLayout,本demo用的是),这个父布局里面有且只有两个子控件(布局),初始状态菜单页的位置在Y轴上存在偏移这样可以就可以形成主页叠在菜单页的上方的视觉效果:然后在滑动的过程程中 逐渐修正偏移,最后菜单页和主页并排排列.原理搞清了实现起来

  • Android自定义View实现等级滑动条的实例

     Android自定义View实现等级滑动条的实例 实现效果图: 思路: 首先绘制直线,然后等分直线绘制点: 绘制点的时候把X值存到集合中. 然后绘制背景图片,以及图片上的数字. 点击事件down的时候,换小图片为大图片.move的时候跟随手指移动. up的时候根据此时的X计算最近的集合中的点,然后自动吸附回去. 1,自定义属性 <?xml version="1.0" encoding="utf-8"?> <resources> <de

  • Android自定义View实现loading动画加载效果

    项目开发中对Loading的处理是比较常见的,安卓系统提供的不太美观,引入第三发又太麻烦,这时候自己定义View来实现这个效果,并且进行封装抽取给项目提供统一的loading样式是最好的解决方式了. 先自定义一个View,继承自LinearLayout,在Layout中,添加布局控件 /** * Created by xiedong on 2017/3/7. */ public class Loading_view extends LinearLayout { private Context m

  • Android自定义View的三个构造函数

    自定义View有三个构造方法,它们的作用是不同的. public MyView(Context context) { super(context); } public MyView(Context context, AttributeSet attrs) { super(context, attrs); } public MyView(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, de

随机推荐