2、列表item_圆头像_信息提示

 import android.app.Activity;
 import android.os.Bundle;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.BaseAdapter;
 import android.widget.ListView;
 import android.widget.Toast;
 import com.dk.view.drop.CoverManager;
 import com.dk.view.drop.WaterDrop;
 import com.dk.view.drop.DropCover.OnDragCompeteListener;

 public class MainActivity extends Activity {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         getActionBar().hide();
         CoverManager.getInstance().init(this);

         ListView mList = (ListView) findViewById(R.id.list);
         mList.setAdapter(new DemoAdapter());

         CoverManager.getInstance().setMaxDragDistance(150);
         CoverManager.getInstance().setExplosionTime(150);
     }

     class DemoAdapter extends BaseAdapter {
         @Override
         public int getCount() {
             return 99;
         }
         @Override
         public Object getItem(int position) {
             return null;
         }
         @Override
         public long getItemId(int position) {
             return 0;
         }
         @Override
         public View getView(final int position, View convertView,
                 ViewGroup parent) {
             convertView = LayoutInflater.from(MainActivity.this).inflate(
                     R.layout.view_list_item, null);
         WaterDrop drop = (WaterDrop) convertView.findViewById(R.id.drop);
         drop.setText(String.valueOf(position));
         drop.setOnDragCompeteListener(new OnDragCompeteListener() {
                 @Override
                 public void onDrag() {
                   Toast.makeText(MainActivity.this, "remove:" + position,
                             Toast.LENGTH_SHORT).show();
                 }
             });
             return convertView;
         }
     }
 }

 <?xml version="1.0" encoding="utf-8"?>

 <!-- R.layout.view_list_item -->
 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res/com.view.drop"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:gravity="center_vertical"
     android:orientation="horizontal" >

     <com.view.drop.CircleImageView
         android:layout_width="50dp"
         android:layout_height="50dp"
         android:src="@drawable/p3"
         app:border_color="#92DDED"
         app:border_width="3dp" />

     <LinearLayout
         android:layout_width="match_parent"
         android:layout_height="60dp"
         android:orientation="vertical" >
         <LinearLayout
             android:layout_width="match_parent"
             android:layout_height="30dp"
             android:layout_marginLeft="10dp"
             android:layout_marginRight="10dp"
             android:gravity="center_vertical" >
             <TextView
                 android:layout_width="match_parent"
                 android:layout_height="30dp"
                 android:layout_weight="1"
                 android:gravity="center_vertical"
                 android:text="Dean Ding"
                 android:textColor="#444444" />
             <TextView
                 android:layout_width="40dp"
                 android:layout_height="30dp"
                 android:gravity="center_vertical"
                 android:text="11:11"
                 android:textColor="#666666" />
         </LinearLayout>

         <LinearLayout
             android:layout_width="match_parent"
             android:layout_height="30dp"
             android:layout_marginLeft="10dp"
             android:layout_marginRight="10dp"
             android:gravity="center_vertical" >
             <TextView
                 android:layout_width="match_parent"
                 android:layout_height="30dp"
                 android:layout_weight="1"
                 android:gravity="center_vertical"
                 android:text="Hello World"
                 android:textColor="#666666" />

             <com.dk.view.drop.WaterDrop
                 android:id="@+id/drop"
                 android:layout_width="25dp"
                 android:layout_height="25dp"
                 android:gravity="center_vertical" />
         </LinearLayout>
     </LinearLayout>

 </LinearLayout>

 import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Bitmap;
 import android.graphics.BitmapShader;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.RectF;
 import android.graphics.Shader;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
 import android.util.AttributeSet;
 import android.widget.ImageView;

 /**
  * Copyright 2014 Henning Dodenhof
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy of
  * the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  * License for the specific language governing permissions and limitations under
  * the License.
  *
  * 圆头像
  *
  */
 public class CircleImageView extends ImageView {

     private static final ScaleType SCALE_TYPE = ScaleType.CENTER_CROP;

     private static final Bitmap.Config BITMAP_CONFIG = Bitmap.Config.ARGB_8888;
     private static final int COLORDRAWABLE_DIMENSION = 1;

     private static final int DEFAULT_BORDER_WIDTH = 0;
     private static final int DEFAULT_BORDER_COLOR = Color.BLACK;

     private final RectF mDrawableRect = new RectF();
     private final RectF mBorderRect = new RectF();

     private final Matrix mShaderMatrix = new Matrix();
     private final Paint mBitmapPaint = new Paint();
     private final Paint mBorderPaint = new Paint();

     private int mBorderColor = DEFAULT_BORDER_COLOR;
     private int mBorderWidth = DEFAULT_BORDER_WIDTH;

     private Bitmap mBitmap;
     private BitmapShader mBitmapShader;
     private int mBitmapWidth;
     private int mBitmapHeight;

     private float mDrawableRadius;
     private float mBorderRadius;

     private boolean mReady;
     private boolean mSetupPending;

     public CircleImageView(Context context) {
         super(context);
     }

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

     public CircleImageView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         super.setScaleType(SCALE_TYPE);

         TypedArray a = context.obtainStyledAttributes(attrs,
                 R.styleable.CircleImageView, defStyle, 0);

         mBorderWidth = a.getDimensionPixelSize(
                 R.styleable.CircleImageView_border_width, DEFAULT_BORDER_WIDTH);
         mBorderColor = a.getColor(R.styleable.CircleImageView_border_color,
                 DEFAULT_BORDER_COLOR);

         a.recycle();

         mReady = true;

         if (mSetupPending) {
             setup();
             mSetupPending = false;
         }
     }

     @Override
     public ScaleType getScaleType() {
         return SCALE_TYPE;
     }

     @Override
     public void setScaleType(ScaleType scaleType) {
         if (scaleType != SCALE_TYPE) {
             throw new IllegalArgumentException(String.format(
                     "ScaleType %s not supported.", scaleType));
         }
     }

     @Override
     protected void onDraw(Canvas canvas) {
         if (getDrawable() == null) {
             return;
         }

         canvas.drawCircle(getWidth() / 2, getHeight() / 2, mDrawableRadius,
                 mBitmapPaint);
         if (mBorderWidth != 0) {
             canvas.drawCircle(getWidth() / 2, getHeight() / 2, mBorderRadius,
                     mBorderPaint);
         }
     }

     @Override
     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
         super.onSizeChanged(w, h, oldw, oldh);
         setup();
     }

     public int getBorderColor() {
         return mBorderColor;
     }

     public void setBorderColor(int borderColor) {
         if (borderColor == mBorderColor) {
             return;
         }

         mBorderColor = borderColor;
         mBorderPaint.setColor(mBorderColor);
         invalidate();
     }

     public int getBorderWidth() {
         return mBorderWidth;
     }

     public void setBorderWidth(int borderWidth) {
         if (borderWidth == mBorderWidth) {
             return;
         }

         mBorderWidth = borderWidth;
         setup();
     }

     @Override
     public void setImageBitmap(Bitmap bm) {
         super.setImageBitmap(bm);
         mBitmap = bm;
         setup();
     }

     @Override
     public void setImageDrawable(Drawable drawable) {
         super.setImageDrawable(drawable);
         mBitmap = getBitmapFromDrawable(drawable);
         setup();
     }

     @Override
     public void setImageResource(int resId) {
         super.setImageResource(resId);
         mBitmap = getBitmapFromDrawable(getDrawable());
         setup();
     }

     private Bitmap getBitmapFromDrawable(Drawable drawable) {
         if (drawable == null) {
             return null;
         }

         if (drawable instanceof BitmapDrawable) {
             return ((BitmapDrawable) drawable).getBitmap();
         }

         try {
             Bitmap bitmap;

             if (drawable instanceof ColorDrawable) {
                 bitmap = Bitmap.createBitmap(COLORDRAWABLE_DIMENSION,
                         COLORDRAWABLE_DIMENSION, BITMAP_CONFIG);
             } else {
                 bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(),
                         drawable.getIntrinsicHeight(), BITMAP_CONFIG);
             }

             Canvas canvas = new Canvas(bitmap);
             drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
             drawable.draw(canvas);
             return bitmap;
         } catch (OutOfMemoryError e) {
             return null;
         }
     }

     private void setup() {
         if (!mReady) {
             mSetupPending = true;
             return;
         }

         if (mBitmap == null) {
             return;
         }

         mBitmapShader = new BitmapShader(mBitmap, Shader.TileMode.CLAMP,
                 Shader.TileMode.CLAMP);

         mBitmapPaint.setAntiAlias(true);
         mBitmapPaint.setShader(mBitmapShader);

         mBorderPaint.setStyle(Paint.Style.STROKE);
         mBorderPaint.setAntiAlias(true);
         mBorderPaint.setColor(mBorderColor);
         mBorderPaint.setStrokeWidth(mBorderWidth);

         mBitmapHeight = mBitmap.getHeight();
         mBitmapWidth = mBitmap.getWidth();

         mBorderRect.set(0, 0, getWidth(), getHeight());
         mBorderRadius = Math.min((mBorderRect.height() - mBorderWidth) / 2,
                 (mBorderRect.width() - mBorderWidth) / 2);

         mDrawableRect.set(mBorderWidth, mBorderWidth, mBorderRect.width()
                 - mBorderWidth, mBorderRect.height() - mBorderWidth);
         mDrawableRadius = Math.min(mDrawableRect.height() / 2,
                 mDrawableRect.width() / 2);

         updateShaderMatrix();
         invalidate();
     }

     private void updateShaderMatrix() {
         float scale;
         float dx = 0;
         float dy = 0;

         mShaderMatrix.set(null);

         if (mBitmapWidth * mDrawableRect.height() > mDrawableRect.width()
                 * mBitmapHeight) {
             scale = mDrawableRect.height() / (float) mBitmapHeight;
             dx = (mDrawableRect.width() - mBitmapWidth * scale) * 0.5f;
         } else {
             scale = mDrawableRect.width() / (float) mBitmapWidth;
             dy = (mDrawableRect.height() - mBitmapHeight * scale) * 0.5f;
         }

         mShaderMatrix.setScale(scale, scale);
         mShaderMatrix.postTranslate((int) (dx + 0.5f) + mBorderWidth,
                 (int) (dy + 0.5f) + mBorderWidth);

         mBitmapShader.setLocalMatrix(mShaderMatrix);
     }

 }

 import com.dk.view.drop.DropCover.OnDragCompeteListener;
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.os.Build.VERSION;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.ListView;
 import android.widget.RelativeLayout;
 import android.widget.ScrollView;
 import android.widget.TextView;
 // 红色圆圈
 public class WaterDrop extends RelativeLayout {
     private Paint mPaint = new Paint();
     private TextView mTextView;
     private DropCover.OnDragCompeteListener mOnDragCompeteListener;
     private boolean mHolderEventFlag;

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

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

     public void setText(String str) {
         mTextView.setText(str);
     }

     public void setTextSize(int size) {
         mTextView.setTextSize(size);
     }

     @SuppressLint("NewApi")
     private void init() {
         mPaint.setAntiAlias(true);
         if (VERSION.SDK_INT > 11) {
             setLayerType(View.LAYER_TYPE_SOFTWARE, null);
         }

         mTextView = new TextView(getContext());
         RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
         params.addRule(RelativeLayout.CENTER_IN_PARENT);
         mTextView.setTextSize(13);
         mTextView.setTextColor(0xffffffff);
         mTextView.setLayoutParams(params);
         addView(mTextView);
     }

     @Override
     protected void dispatchDraw(Canvas canvas) {
         mPaint.setColor(0xffff0000);
         canvas.drawCircle(getWidth() / 2, getHeight() / 2, 
                getWidth() / 2, mPaint);
         super.dispatchDraw(canvas);
     }

     @Override
     protected void onDraw(Canvas canvas) {
         super.onDraw(canvas);
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         ViewGroup parent = getScrollableParent();
         switch (event.getAction()) {
         case MotionEvent.ACTION_DOWN:
             mHolderEventFlag = !CoverManager.getInstance().isRunning();
             if (mHolderEventFlag) {
                 if (parent != null)
                     parent.requestDisallowInterceptTouchEvent(true);
                 CoverManager.getInstance().start(this, event.getRawX(), event.getRawY(), mOnDragCompeteListener);
             }
             break;
         case MotionEvent.ACTION_MOVE:
             if (mHolderEventFlag) {
                 CoverManager.getInstance().update(event.getRawX(), event.getRawY());
             }
             break;
         case MotionEvent.ACTION_UP:
         case MotionEvent.ACTION_CANCEL:
             if (mHolderEventFlag) {
                 if (parent != null)
                     parent.requestDisallowInterceptTouchEvent(false);
                 CoverManager.getInstance().finish(this, event.getRawX(), event.getRawY());
             }
             break;
         }

         return true;
     }

     private ViewGroup getScrollableParent() {
         View target = this;
         while (true) {
             View parent;
             try {
                 /**
                  * ViewRootImpl cannot be cast to android.view.View
                  */
                 parent = (View) target.getParent();
             } catch (Exception e) {
                 return null;
             }
             if (parent == null)
                 return null;
             if (parent instanceof ListView || parent instanceof ScrollView) {
                 return (ViewGroup) parent;
             }
             target = parent;
         }

     }

     public void setOnDragCompeteListener(OnDragCompeteListener 
                 onDragCompeteListener) {
         mOnDragCompeteListener = onDragCompeteListener;
     }
 }

<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

WaterDropLibrary  http://download.csdn.net/detail/androidsj/7948845