画笔的基本属性：

setARGB(int a,int r,int g,int b);  设置绘制的颜色，a代表透明度，r，g，b代表颜色值。 
setAlpha(int a);                    设置绘制图形的透明度，设置范围是[0..255]
setColor(int color); 	            设置绘制的颜色，该颜色值包括透明度和RGB颜色。
setAntiAlias(boolean aa);       	设置是否使用抗锯齿功能，会消耗较大资源，绘制图形速度会变慢。一般在绘制棱角分明的图像时不需要抗锯齿。
setDither(boolean dither);  	    设定是否使用图像抖动处理，会使绘制出来的图片颜色更加平滑和饱满，图像更加清晰 
setStyle(Paint.Style style); 	    设置画笔的样式，Paint.Style.STROKE：描边，Paint.Style.FILL_AND_STROKE：描边并填充，Paint.Style.FILL：填充 
setStrokeWidth(float width); 	    当画笔样式为STROKE或FILL_OR_STROKE时，设置笔刷的粗细度,也就是线条宽度
setStrokeCap(Paint.Cap cap); 	    当画笔样式为STROKE或FILL_OR_STROKE时，设置笔刷的图形样式，如圆形样Cap.ROUND,或方形样式Cap.SQUARE
setStokeJoin(Paint.Join join);  	设置绘制时各图形的结合方式，如平滑效果等
setStrokeMiter(float miter)：        设置画笔倾斜度

文字相关属性：

setTextSize(float textSize);            设置绘制文字的字号大小
setLetterSpacing(float letterSpacing)   设置行间距，默认是0.
setFakeBoldText(boolean fakeBoldText);      模拟实现粗体文字 
setTextScaleX(float scaleX); 	    设置绘制文字x轴的缩放比例，可以实现文字的拉伸的效果，当值大于1会沿X轴水平放大文本，当值小于1会沿X轴水平缩放文本
setTextSkewX(float skewX);      设置斜体文字，skewX为倾斜弧度，值为负右倾值为正左倾
setUnderlineText(boolean underlineText); 	    设置带有下划线的文字效果
setStrikeThruText(boolean strikeThruText);      设置带有删除线的效果
setTextAlign(Paint.Align align);        设置绘制文字的对齐方向 可供选的方式有三种：CENTER,LEFT和RIGHT。
setTypeface(Typeface typeface); 	设置Typeface对象，即字体风格，包括粗体，斜体以及衬线体，非衬线体等 

画笔的特效
setFilterBitmap(boolean filter);  	        如果该项设置为true，则图像在动画进行中会滤掉对Bitmap图像的优化操作，加快显示速度，本设置项依赖于dither和xfermode的设置
setMaskFilter(MaskFilter maskfilter); 	    设置MaskFilter，可以用不同的MaskFilter实现滤镜的效果，如滤化，立体等
setColorFilter(ColorFilter colorfilter); 	        设置颜色过滤器，可以在绘制颜色时实现不用颜色的变换效果 
setPathEffect(PathEffect effect); 	        设置绘制路径的效果，如点画线等
setShader(Shader shader); 	        设置图像效果，使用Shader可以绘制出各种渐变效果 
setShadowLayer(float radius ,float dx,float dy,int color); 	    在图形下面设置阴影层，产生阴影效果，radius为阴影的角度，dx和dy为阴影在x轴和y轴上的距离，color为阴影的颜色
setXfermode(Xfermode xfermode); 设置图形重叠时的处理方式，如合并，取交集或并集，经常用来制作橡皮的擦除效果

@Override
protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    mPaint.setMaskFilter(new BlurMaskFilter(20, BlurMaskFilter.Blur.INNER));
    canvas.drawCircle(400,200,100,mPaint);
    mPaint.setMaskFilter(new BlurMaskFilter(20, BlurMaskFilter.Blur.NORMAL));
    canvas.drawCircle(400,450,100,mPaint);
    mPaint.setMaskFilter(new BlurMaskFilter(20, BlurMaskFilter.Blur.OUTER));
    canvas.drawCircle(400,700,100,mPaint);
    mPaint.setMaskFilter(new BlurMaskFilter(20, BlurMaskFilter.Blur.SOLID));
    canvas.drawCircle(400,950,100,mPaint);

    Bitmap bitmap = BitmapFactory.decodeResource(getResources(),R.drawable.test1);
    Bitmap b = bitmap.extractAlpha();
    canvas.drawBitmap(b,200,1150,mPaint);
    canvas.drawBitmap(bitmap,200,1150,null);
}

public class MainActivity extends AppCompatActivity implements SeekBar.OnSeekBarChangeListener {

    private ImageView mImageView = null;
    private int Hvalue;
    private float Svalue;
    private float Vvalue;
    private SeekBar mHvalue;
    private SeekBar mSvalue;
    private int SMAX;
    private int VMAX;
    private SeekBar mVvalue;
    private Bitmap mBitmap;
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mImageView = (ImageView) findViewById(R.id.imageview);
        mHvalue = (SeekBar) findViewById(R.id.hvalue);
        mSvalue = (SeekBar) findViewById(R.id.svalue);
        mVvalue = (SeekBar) findViewById(R.id.vvalue);
        mHvalue.setOnSeekBarChangeListener(this);
        mSvalue.setOnSeekBarChangeListener(this);
        SMAX = mSvalue.getMax();
        VMAX = mVvalue.getMax();
        mVvalue.setOnSeekBarChangeListener(this);
        mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.test1);
    }

    @Override
    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {

        switch (seekBar.getId()) {
            case R.id.hvalue:
                Hvalue = progress;
                break;
            case R.id.svalue:
                if (SMAX != 0) {
                    Svalue = progress*1.0F/SMAX;
                }
                break;
            case R.id.vvalue:
                if(VMAX != 0) {
                    Vvalue = progress*1.0F/VMAX;;
                }
                break;
        }
        setHSV();

    }

    private void setHSV() {
        
        ColorMatrix hutMatrix = new ColorMatrix();
        //设置RGB 的色调值  第一个参数为R，G，B，第二个参数为具体的色调 
        hutMatrix.setRotate(0,Hvalue);
        hutMatrix.setRotate(1,Hvalue);
        hutMatrix.setRotate(2,Hvalue);

        ColorMatrix saturation = new ColorMatrix();
         //设置饱和度
        saturation.setSaturation(Svalue);

        ColorMatrix lumMatrix = new ColorMatrix();
        //设置亮度
        lumMatrix.setScale(Vvalue,Vvalue,Vvalue,1f);

        ColorMatrix colorMatrix = new ColorMatrix();
        //postConcat 用于将矩阵的作用效果混合，从而产生叠加效果
        colorMatrix.postConcat(hutMatrix);
        colorMatrix.postConcat(saturation);
        colorMatrix.postConcat(lumMatrix);

        Paint paint = new Paint();
        paint.setAntiAlias(true);
        paint.setDither(true);
        paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
        Bitmap bitmap = Bitmap.createBitmap(mBitmap.getWidth(), mBitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(bitmap);
        canvas.drawBitmap(mBitmap,0,0,paint);
        mImageView.setImageBitmap(bitmap);
    }

    @Override
    public void onStartTrackingTouch(SeekBar seekBar) {

    }
    @Override
    public void onStopTrackingTouch(SeekBar seekBar) {

    }
}

public LinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions,Shader.TileMode tile)
参数:
float x0: 渐变起始点x坐标
float y0:渐变起始点y坐标
float x1:渐变结束点x坐标
float y1:渐变结束点y坐标
int[] colors:颜色 的int 数组
float[] positions: 相对位置的颜色数组,可为null, 如果为null,颜色沿渐变线均匀分布
Shader.TileMode tile: 渲染器平铺模式

public LinearGradient(float x0, float y0, float x1, float y1, int color0, int color1,Shader.TileMode tile)
float x0: 渐变起始点x坐标
float y0:渐变起始点y坐标
float x1:渐变结束点x坐标
float y1:渐变结束点y坐标
int color0: 起始渐变色
int color1: 结束渐变色
Shader.TileMode tile: 渲染器平铺模式

public RadialGradient(float x, float y, float radius, int[] colors, float[] positions,Shader.TileMode tile)
float x:  圆心X坐标
float y:  圆心Y坐标
float radius: 半径
int[] colors:  渲染颜色数组
floate[] positions: 相对位置数组,可为null, 如果为null,颜色沿渐变线均匀分布
Shader.TileMode tile:渲染器平铺模式


public RadialGradient(float x, float y, float radius, int color0, int color1,Shader.TileMode tile)
float x:  圆心X坐标
float y:  圆心Y坐标
float radius: 半径
int color0: 圆心颜色
int color1: 圆边缘颜色
Shader.TileMode tile:渲染器平铺模式

public SweepGradient(float cx, float cy, int[] colors, float[] positions)
Parameters:
cx	渲染中心点x 坐标
cy	渲染中心y 点坐标
colors	围绕中心渲染的颜色数组，至少要有两种颜色值
positions	相对位置的颜色数组,可为null, 如果为null,颜色沿渐变线均匀分布


public SweepGradient(float cx, float cy, int color0, int color1)
Parameters:
cx	渲染中心点x 坐标
cy	渲染中心点y 坐标
color0	起始渲染颜色
color1	结束渲染颜色

public class ShaderView extends View {
    private Context mContext = null;
    public ShaderView(Context context) {
        super(context);
        mContext = context;
        init();
    }

    public ShaderView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        init();
    }

    public ShaderView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        init();
    }

    private Paint mPaint;
    private void init() {
        mPaint = new Paint();
        mPaint.setDither(true);
        mPaint.setAntiAlias(true);

    }
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        mPaint.setShader(new LinearGradient(0,0,200,200, Color.BLUE,Color.YELLOW, Shader.TileMode.CLAMP));
        canvas.drawRoundRect(0,0,1024,400,2F,3F,mPaint);

        mPaint.setShader(new RadialGradient(400,800,500, Color.YELLOW,Color.BLUE, Shader.TileMode.CLAMP));
        canvas.drawRoundRect(0,400,1024,800,2F,3F,mPaint);

        mPaint.setShader(new SweepGradient(400,1200,Color.BLUE,Color.RED));
        canvas.drawRoundRect(0,800,1024,1200,2F,3F,mPaint);

        Bitmap bitmap = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.test1);
        mPaint.setShader(new BitmapShader(bitmap, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT));
        canvas.drawCircle(500,1600,400,mPaint);
    }
}

TextView textView = (TextView) findViewById(R.id.text1);
textView.setShadowLayer(20,30,20, Color.DKGRAY);

Button ButtomView = (Button) findViewById(R.id.text2);
ButtomView.setShadowLayer(30,50,80, Color.DKGRAY);

public class PathEffectView extends View {

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

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

    public PathEffectView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    private Paint mPaint;
    private void init() {
        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(3);
        initPath();
    }

    private Path mPath;
    private void initPath() {
        mPath = new Path();
        mPath.moveTo(10, 50);
        for (int i = 0; i <= 30; i++) {
            mPath.lineTo(i * 35, (float) (Math.random() * 500+300));
        }
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawPath(mPath,mPaint);
    }
}
 

protected void onActivityResult(int requestCode, int resultCode, Intent data) {
	if (requestCode == TTS_DATA_CHECK) {
		if (resultCode == Engine.CHECK_VOICE_DATA_PASS) {
			//表示已经安装了语言包
		}
		super.onActivityResult(requestCode, resultCode, data);
	}
}

Intent webIntent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
webIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_WEB_SEARCH);
startActivityForResult(webIntent, 0);

ClipData newClip = ClipData.newPlainText("newClips", mSetClipEt.getText().toString());

ClipData.newUri(getContentResolver(), "label", uri);

MyData md = new MyData("kimifdw",26);  
//定义字符串  
String baseToString ="";  
//1.将对象转换成字符串  
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
try  
{  
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);  
    objectOutputStream.writeObject(md);  
    baseToString = Base64.encodeToString(byteArrayOutputStream.toByteArray(), Base64.DEFAULT);  
    objectOutputStream.close();  
}  
catch(Exception e)  
{  
    e.printStackTrace();  
} 

byte[] base64ToString = Base64.decode(item.getText().toString(), Base64.DEFAULT);  
//从流中读取数据  
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(base64ToString);  
try  
{  
      ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);  
      MyData md = (MyData)objectInputStream.readObject();  
     objectInputStream.close();  
      txtView.setText(md.toString());  
}  
catch(Exception e)  
{  
      e.printStackTrace();  
} 

Intent  testIntent = newIntent();
testIntent.setComponent(new ComponentName("包名","包名.xxxService"));
booleanisbind=bindService(testIntent,serviceConnection,Context.BIND_AUTO_CREATE);

package com.ideallist.testaidlclient;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.idealist.testaidl.bean.Person;
import com.idealist.testaidl.callback.IResultCallback;
import com.idealist.testaidl.service.IMyAidlInterface;

import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private IMyAidlInterface mInterface = null;
    private Button mBindServiceBtn = null;
    private Button mUnbindServceBtn = null;
    private Button mSetPersonInfoBtn = null;
    private Button mGetPersonInfoBtn = null;
    private boolean isBind = false;
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mInterface = IMyAidlInterface.Stub.asInterface(iBinder);
            isBind = true;
            Toast.makeText(MainActivity.this, "Binded to Server !",Toast.LENGTH_LONG).show();
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            if(mInterface != null) {
                mInterface = null;
            }
            Toast.makeText(MainActivity.this, "Ubind to Server !",Toast.LENGTH_LONG).show();
            isBind = false;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mBindServiceBtn = (Button) findViewById(R.id.bindservice);
        mUnbindServceBtn = (Button) findViewById(R.id.unbindservice);
        mSetPersonInfoBtn = (Button) findViewById(R.id.setpersonInfo);
        mGetPersonInfoBtn = (Button) findViewById(R.id.getpersonInfo);

        mBindServiceBtn.setOnClickListener(this);
        mUnbindServceBtn.setOnClickListener(this);
        mSetPersonInfoBtn.setOnClickListener(this);
        mGetPersonInfoBtn.setOnClickListener(this);
    }

    private IResultCallback.Stub mResultCallBack = new IResultCallback.Stub() {
        @Override
        public void reportResult(String result) throws RemoteException {
            Toast.makeText(MainActivity.this, "Result = " + result,Toast.LENGTH_LONG).show();
        }
    };

    @Override
    public void onClick(View view) {
        int id = view.getId();
        switch (id) {
            case R.id.bindservice:
                if(!isBind) {
                    Intent intent = new Intent("android.intent.action.MyAIDLService");
                    intent.setPackage("com.idealist.testaidl");
                    bindService(intent, conn, BIND_AUTO_CREATE);
                }
                break;
            case R.id.unbindservice:
                if(isBind) {
                    unbindService(conn);
                }
                break;
            case R.id.setpersonInfo:
                if(mInterface != null ) {
                    Person person = new Person();
                    person.setName("Jimmy");
                    person.setTel("1111111111");
                    try {
                        mInterface.savePersonInfo(person,mResultCallBack);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case R.id.getpersonInfo:
                if(mInterface != null ) {
                    try {
                        List<Person> mList = mInterface.getPersonInfos();
                        for (Person p : mList) {
                            Toast.makeText(MainActivity.this,"Name = " + p.getName()+" : "+ " Tel "+ p.getTel(),Toast.LENGTH_LONG).show();
                        }
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
                break;

        }
    }
}

requestLocationUpdates(provider, minTime, minDistance, listener)

//创建一个URL对象
uri = new URL("http://php.weather.sina.com.cn/xml.php&city="+ URLEncoder.encode(“惠州”, "gb2312")+ "&password=DJOYnieT8234jlsK&day=0");

// 获得HttpURLConnection 实例
HttpURLConnection  urlConnection = (HttpURLConnection)url.openConnection();

HttpGet httpget = new HttpGet("http://php.weather.sina.com.cn/xml.php&city=" + URLEncoder.encode(“惠州”, "gb2312")+ "&password=DJOYnieT8234jlsK&day=0");

If(httpresponse.getStatusLine().getStatusCode()==HttpStatus.SC_OK){
}

EntityUtils.toString(httpresponse.getEntity());
EntityUtils. toByteArray (httpresponse.getEntity());
httpresponse.getEntity().getContent()

HttpPost  httppost = new HttpPost(“http://php.weather.sina.com.cn/xml.php”);

List<NameValuePair> param = new ArrayList<NameValuePair>();
Param.add(new BasicNameValuePair(“city”,”huizhou”));
Param.add(new BasicNameValuePair(“password”, “DJOYnieT8234jlsK”));
Param.add(new BasicNameValuePair(“day”, “0”));
Httppost.setEntity(new UrlEncodedFormEntity(param,”utf-8”));

If(httpresponse.getStatusLine().getStatusCode()==HttpStatus.SC_OK){
}

charset = getContentCharSet(entity);  
result = EntityUtils.toString(entity, charset);  
//获取页面编码方式
public static String getContentCharSet(final HttpEntity entity) {   
    String charset = null;   
    if (entity.getContentType() != null) {    
        HeaderElement values[] = entity.getContentType().getElements();   
        if (values.length > 0) {   
            NameValuePair param = values[0].getParameterByName("charset" );   
            if (param != null) {   
                charset = param.getValue();   
            }   
        }   
    }   
    if(StringUtils.isEmpty(charset)){  
        charset = "UTF-8";  
    }  
    return charset;   
}