原 android 涂鸦（清屏，画笔，粗细，保存）以及canvas源码学习

原 android 涂鸦（清屏，画笔，粗细，保存）以及canvas源码学习
发表于2年前(2013-04-16 18:38) 阅读（6070） | 评论（9） 29人收藏此文章, 我要收藏
赞2
慕课网，程序员升职加薪神器，点击免费学习

canvas 涂鸦 源代码 清屏

更新：本文的内容只是一部分，这段时间添加了橡皮擦这个新功能，于是问题接二连三的来，比如说：如果用本文的内容去做橡皮擦的话，难！（至少我没解决，不是没背景图，就是有背景图但是更新要在下一下刷橡皮擦的时候才能更新效果），然后有个setbackgroundresource的函数，这个函数就可以了，但是问题又来了，比如说保存，清屏，但是我都解决了（清屏的话就是重新构造一个图，当clear的时候就把这张图赋值给以前的图片。保存的话我就是把绘下个图放到一张有背景的canvas上面，至是分辨率的问题自己去解决就行了，保证存下来的跟你用setbackgoundresource绘图看到的效果一致，需要源码的请联系我）

本人也是在网上查了很多文章后才做出来的，感觉网上的一些涂鸦功能不是很完善，在此就稍微完善了一下。先看下效果图吧（想做成全屏的话需要弄一张跟你屏幕一样大小的背景图，找不到也没关系，我有改尺寸的代码，一并献上）。代码下载请到http://www.oschina.net/code/snippet_729469_20445 其实涂鸦的难点就是如何能在canvas上进行清屏又能保存，至少目前我碰到的情况是这样，这就需要对canvas与bitmap的较为深入的理解了，这个你多写这方面的代码就行了，网上有许多涂鸦的作品，看看源代码。

涂鸦中关于canvas的学习需要掌握三点吧：1：view 2：onDraw函数 3：onTouchEvent

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
public class HandWrite extends View
{
Paint paint = null;
private Bitmap originalBitmap = null;
Bitmap new1Bitmap = null;
private Bitmap new2Bitmap = null;
private float clickX = 0,clickY = 0;
private float startX = 0,startY = 0;
private boolean isMove = true;
private boolean isClear = false;
int color = Color.WHITE;
float strokeWidth = 3.0f;
public HandWrite(Context context, AttributeSet attrs)
{
super(context, attrs);
// originalBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.t);
originalBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.a).copy(Bitmap.Config.ARGB_8888, true);
new1Bitmap = Bitmap.createBitmap(originalBitmap);
}

public void clear(){
    isClear = true;
    new2Bitmap = Bitmap.createBitmap(originalBitmap);
    invalidate();
}
public void setstyle(float strokeWidth){
    this.strokeWidth = strokeWidth;
}
@Override
protected void onDraw(Canvas canvas)
{
    super.onDraw(canvas);
    canvas.drawBitmap(HandWriting(new1Bitmap), 0, 0,null);

}

public Bitmap HandWriting(Bitmap originalBitmap)
{
    Canvas canvas = null;

    if(isClear){
        canvas = new Canvas(new2Bitmap);
    }
    else{
        canvas = new Canvas(originalBitmap);
    }
    paint = new Paint();
    paint.setStyle(Style.STROKE);
    paint.setAntiAlias(true);
    paint.setColor(color);
    paint.setStrokeWidth(strokeWidth);
    if(isMove){
        canvas.drawLine(startX, startY, clickX, clickY, paint);
    }

    startX = clickX;
    startY = clickY;

    if(isClear){
        return new2Bitmap;
    }
    return originalBitmap;
}

@Override
public boolean onTouchEvent(MotionEvent event)
{
    clickX = event.getX();
    clickY = event.getY();
    if(event.getAction() == MotionEvent.ACTION_DOWN){

        isMove = false;
        invalidate();
        return true;
    }
    else if(event.getAction() == MotionEvent.ACTION_MOVE){

        isMove = true;
        invalidate();
        return true;
    }

    return super.onTouchEvent(event);
}

这个view的代码网上有，这里面必须得实现两个重要的方法，一个是onDraw一个是onTouchEvent，onDraw是在你每次触碰屏幕的时候都会触发，包括你初始化的时候。onTouchEvent就是在你触碰屏幕后采取的相应操作。其实涂鸦的关键就是通过drawLine将瞬间变化的两点连起来画成直线，然后画在canvas上的bitmap上。
在mainActivity中我实现了一个菜单按钮

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
public class CanvasDrawActivity extends Activity
{
private static final String TAG = “CanvasDrawActivity”;
/* Called when the activity is first created. /
private int width;
private int height;
private HandWrite handWrite = null;
private Button clear = null;
private int whichColor = 0;
private int whichStrokeWidth = 0;

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
       requestWindowFeature(Window.FEATURE_NO_TITLE);
       getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
            WindowManager.LayoutParams.FLAG_FULLSCREEN);

    setContentView(R.layout.main);

    handWrite = (HandWrite)findViewById(R.id.handwriteview);

}



@Override
public boolean onCreateOptionsMenu(Menu menu) {
    // TODO Auto-generated method stub
    menu.add(0, 1, 1, "清屏");
    menu.add(0, 2, 2, "颜色");                 
    menu.add(0, 3, 3, "画笔");
    menu.add(0, 4, 4, "保存");
    return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // TODO Auto-generated method stub
    if(item.getItemId() == 4){

        File f = new File(Environment.getExternalStorageDirectory()
                .getAbsolutePath() + "/aaa.jpg");
        try {

            saveMyBitmap(f, handWrite.new1Bitmap);

        } catch (IOException e) {
            e.printStackTrace();
        } 


    }else if(item.getItemId() == 1){

        handWrite.clear();            

    }else if(item.getItemId() == 2){

        Dialog mDialog = new AlertDialog.Builder(CanvasDrawActivity.this)
        .setTitle("颜色设置")
        .setSingleChoiceItems(new String[]{"白色","绿色","红色"}, whichColor, new DialogInterface.OnClickListener() 
        {

            @Override
            public void onClick(DialogInterface dialog, int which) 
            {
                // TODO Auto-generated method stub
                switch(which)
                {
                    case 0:
                    {

                        handWrite.color = Color.WHITE;
                        whichColor = 0;
                        break;
                    }
                    case 1:
                    {

                        handWrite.color = Color.GREEN;
                        whichColor = 1;
                        break;
                    }
                    case 2:
                    {

                        handWrite.color = Color.RED;
                        whichColor = 2;
                        break;
                    }
                }
            }
        })
        .setPositiveButton("确定", new DialogInterface.OnClickListener() 
        {

            @Override
            public void onClick(DialogInterface dialog, int which) 
            {
                // TODO Auto-generated method stub
                dialog.dismiss();
            }
        })
        .create();
        mDialog.show();



    }else if(item.getItemId() == 3){


        Dialog mDialog = new AlertDialog.Builder(CanvasDrawActivity.this)
         .setTitle("画笔设置")
         .setSingleChoiceItems(new String[]{"细","中","粗"}, whichStrokeWidth, new DialogInterface.OnClickListener() 
         {

             @Override
             public void onClick(DialogInterface dialog, int which) 
             {
                 // TODO Auto-generated method stub
                 switch(which)
                 {
                     case 0:
                     {

                         handWrite.strokeWidth = 3.0f;
                         whichStrokeWidth = 0;
                         break;
                     }
                     case 1:
                     {

                         handWrite.strokeWidth = 6.0f;   
                         whichStrokeWidth = 1;
                         break;
                     }
                     case 2:
                     {
                         handWrite.strokeWidth = 9.0f;
                         whichStrokeWidth = 2;
                         break;
                     }
                 }
             }
         })
         .setPositiveButton("确定", new DialogInterface.OnClickListener() 
         {

             @Override
             public void onClick(DialogInterface dialog, int which) 
             {
                 // TODO Auto-generated method stub
                 dialog.dismiss();
             }
         })
         .create();
         mDialog.show();


    }
    return super.onOptionsItemSelected(item);
}


public void saveMyBitmap(File f, Bitmap mBitmap) throws IOException {
    try {
        f.createNewFile();
        FileOutputStream fOut = null;
        fOut = new FileOutputStream(f); 
        mBitmap.compress(Bitmap.CompressFormat.PNG, 100, fOut);
        fOut.flush();
        fOut.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
这些就是通过菜单选项对相应的canvas上面的paint进行设置即可达到效果。
那么现在就看看涂鸦这个程序上与canvas相关的几个函数的源码吧！（初始函数，drawLine，drawBitmap这3个）canvas.java文件位于android2.3.3/frameworks/base/graphics/java/android/graphics

canvas(Bitmap bitmap)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// assigned in constructors, freed in finalizer
final int mNativeCanvas;

private Bitmap  mBitmap;    // if not null, mGL must be null


// Package-scoped for quick access.
int mDensity = Bitmap.DENSITY_NONE;

public Canvas(Bitmap bitmap) {
    if (!bitmap.isMutable()) {
        throw new IllegalStateException(
                        "Immutable bitmap passed to Canvas constructor");
    }
    throwIfRecycled(bitmap);
    mNativeCanvas = initRaster(bitmap.ni());
    mBitmap = bitmap;
    mDensity = bitmap.mDensity;
}

这个初始化比较简单，就主要是一个叫做initRaster(bitmap.ni（）)这个函数
?
1
private static native int initRaster(int nativeBitmapOrZero);
这个需要涉及到向底层本地函数传递一个int参数，那么这个bitmap.ni()是什么呢？查看bitmap.java同样位于android2.3.3/frameworks/base/graphics/java/android/graphics
?
1
2
3
4
5
6
7
/* package */ final int ni() {
return mNativeBitmap;
}

// Note:  mNativeBitmap is used by FaceDetector_jni.cpp
// Don't change/rename without updating FaceDetector_jni.cpp
private final int mNativeBitmap;

也就是想下面传递的是mNativeBitmap这个值，而这个值会在FaceDetector_jni.cpp中使用。
那么initRaster怎么实现的呢，看Canvas.cpp位于android/frameworks/base/core/jni/android/graphics,注册函数有

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{“initRaster”,”(I)I”, (void*) SkCanvasGlue::initRaster},
{“native_drawBitmap”,”(IIFFIIII)V”,
(void*) SkCanvasGlue::drawBitmap__BitmapFFPaint},
{“native_drawLine”,”(IFFFFI)V”, (void*) SkCanvasGlue::drawLine__FFFFPaint},
{“native_drawColor”,”(III)V”, (void*) SkCanvasGlue::drawColor__II},
{“native_drawPaint”,”(II)V”, (void*) SkCanvasGlue::drawPaint},
{“drawPoint”, “(FFLandroid/graphics/Paint;)V”,
(void*) SkCanvasGlue::drawPoint},
{“drawPoints”, “([FIILandroid/graphics/Paint;)V”,
(void*) SkCanvasGlue::drawPoints},
{“drawLines”, “([FIILandroid/graphics/Paint;)V”,
(void*) SkCanvasGlue::drawLines},
{“native_drawLine”,”(IFFFFI)V”, (void*) SkCanvasGlue::drawLine__FFFFPaint},
{“native_drawRect”,”(ILandroid/graphics/RectF;I)V”,
(void*) SkCanvasGlue::drawRect__RectFPaint},
{“native_drawRect”,”(IFFFFI)V”, (void*) SkCanvasGlue::drawRect__FFFFPaint},
{“native_drawOval”,”(ILandroid/graphics/RectF;I)V”,
(void*) SkCanvasGlue::drawOval},
{“native_drawCircle”,”(IFFFI)V”, (void*) SkCanvasGlue::drawCircle},
{“native_drawArc”,”(ILandroid/graphics/RectF;FFZI)V”,
其实这些就是对canva的常见操作，包括下面遇到的drawline，drawBitmap，请看： drawBitmap（Bitmap bitmap,float, left,float top, Paint ,paint）
?
1
2
3
4
5
6
public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
throwIfRecycled(bitmap);
native_drawBitmap(mNativeCanvas, bitmap.ni(), left, top,
paint != null ? paint.mNativePaint : 0, mDensity, mScreenDensity,
bitmap.mDensity);
}
drawLine(float startX, float startY, float stopX, float stopY, Paint paint)

?
1
2
3
4
5
public void drawLine(float startX, float startY, float stopX, float stopY,
Paint paint) {
native_drawLine(mNativeCanvas, startX, startY, stopX, stopY,
paint.mNativePaint);
}
他们实际上都是使用的SkCanvasGlue中的对应函数，而这个时候，canvas已经不再撒过去那个canvas了，它换成了SKCanvas。
比如说drawBitmap，这个是在注册函数中表示的对应的函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
SkCanvas* canvas, SkBitmap* bitmap,
jfloat left, jfloat top,
SkPaint* paint, jint canvasDensity,
jint screenDensity, jint bitmapDensity) {
SkScalar left_ = SkFloatToScalar(left);
SkScalar top_ = SkFloatToScalar(top);

    if (canvasDensity == bitmapDensity || canvasDensity == 0
            || bitmapDensity == 0) {
        if (screenDensity != 0 && screenDensity != bitmapDensity) {
            SkPaint filteredPaint;
            if (paint) {
                filteredPaint = *paint;
            }
            filteredPaint.setFilterBitmap(true);
            canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
        } else {
            canvas->drawBitmap(*bitmap, left_, top_, paint);
        }
    } else {
        canvas->save();
        SkScalar scale = SkFloatToScalar(canvasDensity / (float)bitmapDensity);
        canvas->translate(left_, top_);
        canvas->scale(scale, scale);

        SkPaint filteredPaint;
        if (paint) {
            filteredPaint = *paint;
        }
        filteredPaint.setFilterBitmap(true);

        canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);

        canvas->restore();
    }
}

它最终调用的就是SKCanvas中的
?
1
canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
类似的，其他的一些canvas的操作都是调用的SKCanvas的对应的方法。(skcanvas与skia的关系请大家网上查询)
那么SKCnvas的源码究竟存放在哪里呢？android/external/skia/src/core，因为所有的方法的实现都是类似的，这里我就单独选择一个简单的drawLine吧

?
1
2
3
4
5
6
7
8
void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1,
const SkPaint& paint) {
SkPoint pts[2];

pts[0].set(x0, y0);
pts[1].set(x1, y1);
this->drawPoints(kLines_PointMode, 2, pts, paint);

}
就是将亮点的坐标值存放在一个SKPoint数组中然后作为参数传递给drawPoints函数，继续找drawPoints
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void SkCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
const SkPaint& paint) {
if ((long)count <= 0) {
return;
}

SkASSERT(pts != NULL);

ITER_BEGIN(paint, SkDrawFilter::kPoint_Type)

while (iter.next()) {
    iter.fDevice->drawPoints(iter, mode, count, pts, paint);
}

ITER_END

}
首先确保这个数组的非空的存在性，然后用一个迭代器去不断的drawPoint，因为fDevice十一个SKDevice*类型。然后查看DKDevice.cpp文件，同样位于android/external/skia/src/core
?
1
2
3
4
void SkDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) {
draw.drawPoints(mode, count, pts, paint);
}
调用的是SkDraw中的drawPoints方法
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
void SkDraw::drawPoints(SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) const {
// if we’re in lines mode, force count to be even
if (SkCanvas::kLines_PointMode == mode) {
count &= ~(size_t)1;
}

if ((long)count <= 0) {
    return;
}

SkAutoRestoreBounder arb;

if (fBounder) {
    if (!bounder_points(fBounder, mode, count, pts, paint, *fMatrix)) {
        return;
    }
    // clear the bounder for the rest of this function, so we don't call it
    // again later if we happen to call ourselves for drawRect, drawPath,
    // etc.
    arb.clearBounder(this);
}

SkASSERT(pts != NULL);
SkDEBUGCODE(this->validate();)

 // nothing to draw
if (fClip->isEmpty() ||
    (paint.getAlpha() == 0 && paint.getXfermode() == NULL)) {
    return;
}

PtProcRec rec;
if (rec.init(mode, paint, fMatrix, fClip)) {
    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);

    SkPoint             devPts[MAX_DEV_PTS];
    const SkMatrix*     matrix = fMatrix;
    SkBlitter*          bltr = blitter.get();
    PtProcRec::Proc     proc = rec.chooseProc(bltr);
    // we have to back up subsequent passes if we're in polygon mode
    const size_t backup = (SkCanvas::kPolygon_PointMode == mode);

    do {
        size_t n = count;
        if (n > MAX_DEV_PTS) {
            n = MAX_DEV_PTS;
        }
        matrix->mapPoints(devPts, pts, n);
        proc(rec, devPts, n, bltr);
        pts += n - backup;
        SkASSERT(count >= n);
        count -= n;
        if (count > 0) {
            count += backup;
        }
    } while (count != 0);
} else {
    switch (mode) {
        case SkCanvas::kPoints_PointMode: {
            // temporarily mark the paint as filling.
            SkAutoPaintStyleRestore restore(paint, SkPaint::kFill_Style);

            SkScalar width = paint.getStrokeWidth();
            SkScalar radius = SkScalarHalf(width);

            if (paint.getStrokeCap() == SkPaint::kRound_Cap) {
                SkPath      path;
                SkMatrix    preMatrix;

                path.addCircle(0, 0, radius);
                for (size_t i = 0; i < count; i++) {
                    preMatrix.setTranslate(pts[i].fX, pts[i].fY);
                    // pass true for the last point, since we can modify
                    // then path then
                    this->drawPath(path, paint, &preMatrix, (count-1) == i);
                }
            } else {
                SkRect  r;

                for (size_t i = 0; i < count; i++) {
                    r.fLeft = pts[i].fX - radius;
                    r.fTop = pts[i].fY - radius;
                    r.fRight = r.fLeft + width;
                    r.fBottom = r.fTop + width;
                    this->drawRect(r, paint);
                }
            }
            break;
        }
        case SkCanvas::kLines_PointMode:
        case SkCanvas::kPolygon_PointMode: {
            count -= 1;
            SkPath path;
            SkPaint p(paint);
            p.setStyle(SkPaint::kStroke_Style);
            size_t inc = (SkCanvas::kLines_PointMode == mode) ? 2 : 1;
            for (size_t i = 0; i < count; i += inc) {
                path.moveTo(pts[i]);
                path.lineTo(pts[i+1]);
                this->drawPath(path, p, NULL, true);
                path.rewind();
            }
            break;
        }
    }
}

}
我起初看的时候瞬间想砸电脑，这得耽误我晚上的dota时间啊，但是细看，你会注意到那个case语句，因为我们分析的是drawLine函数，而drawLine函数传入的是kLines_PointMode,那么我们就分析这个语句，其实就这一个for循环
?
1
2
3
4
5
6
for (size_t i = 0; i < count; i += inc) {
path.moveTo(pts[i]);
path.lineTo(pts[i+1]);
this->drawPath(path, p, NULL, true);
path.rewind();
}
它再一次不甘寂寞地调用了SKpath的两个函数以及自身的drawPath函数
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
void SkPath::moveTo(SkScalar x, SkScalar y) {
SkDEBUGCODE(this->validate();)

int      vc = fVerbs.count();
SkPoint* pt;

if (vc > 0 && fVerbs[vc - 1] == kMove_Verb) {
    pt = &fPts[fPts.count() - 1];
} else {
    pt = fPts.append();
    *fVerbs.append() = kMove_Verb;
}
pt->set(x, y);

fBoundsIsDirty = true;

}

void SkPath::lineTo(SkScalar x, SkScalar y) {
SkDEBUGCODE(this->validate();)

if (fVerbs.count() == 0) {
    fPts.append()->set(0, 0);
    *fVerbs.append() = kMove_Verb;
}
fPts.append()->set(x, y);
*fVerbs.append() = kLine_Verb;

fBoundsIsDirty = true;

}

void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& paint,
const SkMatrix* prePathMatrix, bool pathIsMutable) const {
SkDEBUGCODE(this->validate();)

// nothing to draw
if (fClip->isEmpty() ||
    (paint.getAlpha() == 0 && paint.getXfermode() == NULL)) {
    return;
}

SkPath*         pathPtr = (SkPath*)&origSrcPath;
bool            doFill = true;
SkPath          tmpPath;
SkMatrix        tmpMatrix;
const SkMatrix* matrix = fMatrix;

if (prePathMatrix) {
    if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style ||
            paint.getRasterizer()) {
        SkPath* result = pathPtr;

        if (!pathIsMutable) {
            result = &tmpPath;
            pathIsMutable = true;
        }
        pathPtr->transform(*prePathMatrix, result);
        pathPtr = result;
    } else {
        if (!tmpMatrix.setConcat(*matrix, *prePathMatrix)) {
            // overflow
            return;
        }
        matrix = &tmpMatrix;
    }
}
// at this point we're done with prePathMatrix
SkDEBUGCODE(prePathMatrix = (const SkMatrix*)0x50FF8001;)

/*
    If the device thickness < 1.0, then make it a hairline, and
    modulate alpha if the thickness is even smaller (e.g. thickness == 0.5
    should modulate the alpha by 1/2)
*/

SkAutoPaintRestoreColorStrokeWidth aprc(paint);

// can we approximate a thin (but not hairline) stroke with an alpha-modulated
// hairline? Only if the matrix scales evenly in X and Y, and the device-width is
// less than a pixel
if (paint.getStyle() == SkPaint::kStroke_Style && paint.getXfermode() == NULL) {
    SkScalar width = paint.getStrokeWidth();
    if (width > 0 && map_radius(*matrix, &width)) {
        int scale = (int)SkScalarMul(width, 256);
        int alpha = paint.getAlpha() * scale >> 8;

        // pretend to be a hairline, with a modulated alpha
        ((SkPaint*)&paint)->setAlpha(alpha);
        ((SkPaint*)&paint)->setStrokeWidth(0);
    }
}

if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
    doFill = paint.getFillPath(*pathPtr, &tmpPath);
    pathPtr = &tmpPath;
}

if (paint.getRasterizer()) {
    SkMask  mask;
    if (paint.getRasterizer()->rasterize(*pathPtr, *matrix,
                        &fClip->getBounds(), paint.getMaskFilter(), &mask,
                        SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
        this->drawDevMask(mask, paint);
        SkMask::FreeImage(mask.fImage);
    }
    return;
}

// avoid possibly allocating a new path in transform if we can
SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;

// transform the path into device space
pathPtr->transform(*matrix, devPathPtr);

SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);

// how does filterPath() know to fill or hairline the path??? <mrr>
if (paint.getMaskFilter() &&
        paint.getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fClip,
                                          fBounder, blitter.get())) {
    return; // filterPath() called the blitter, so we're done
}

if (fBounder && !fBounder->doPath(*devPathPtr, paint, doFill)) {
    return;
}

if (doFill) {
    if (paint.isAntiAlias()) {
        SkScan::AntiFillPath(*devPathPtr, *fClip, blitter.get());
    } else {
        SkScan::FillPath(*devPathPtr, *fClip, blitter.get());
    }
} else {    // hairline
    if (paint.isAntiAlias()) {
        SkScan::AntiHairPath(*devPathPtr, fClip, blitter.get());
    } else {
        SkScan::HairPath(*devPathPtr, fClip, blitter.get());
    }
}

}
再调用skmatrix，skmask，skscan。。。。图形化的东西了解太少了，鄙人就做抛砖引玉的作用吧，分析到此结束，希望大侠补充了。
最后，在背景图上需要改大小的，这里有代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
public class test {

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub

    BufferedImage image;
    try {
        image = ImageIO.read(new File("D:\\t.JPG"));
        resize(image, 300, 300); 

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }  


}

private static void resize(BufferedImage source, int targetW, int targetH) throws IOException {
    // TODO Auto-generated method stub

        int type = source.getType();  
        BufferedImage target = null;  
        double sx = (double) targetW / source.getWidth();  
        double sy = (double) targetH / source.getHeight();  
        // 这里想实现在targetW，targetH范围内实现等比缩放。如果不需要等比缩放  
        // 则将下面的if else语句注释即可  

// if (sx > sy)
// {
// sx = sy;
// targetW = (int) (sx * source.getWidth());
// }
// else
// {
// sy = sx;
// targetH = (int) (sy * source.getHeight());
// }
// if (type == BufferedImage.TYPE_CUSTOM)
// { // handmade
ColorModel cm = source.getColorModel();
WritableRaster raster = cm.createCompatibleWritableRaster(targetW,
targetH);
boolean alphaPremultiplied = cm.isAlphaPremultiplied();
target = new BufferedImage(cm, raster, alphaPremultiplied, null);
// }
// else
// {
// //固定宽高，宽高一定要比原图片大
// //target = new BufferedImage(targetW, targetH, type);
// target = new BufferedImage(800, 600, type);
// }

        Graphics2D g = target.createGraphics();  

        //写入背景  
        g.drawImage(ImageIO.read(new File("D:\\t.jpg")), 0, 0, null);  

        // smoother than exlax:  
        g.setRenderingHint(RenderingHints.KEY_RENDERING,  
                RenderingHints.VALUE_RENDER_QUALITY);  
        g.drawRenderedImage(source, AffineTransform.getScaleInstance(sx, sy));  
        g.dispose();  
        ImageIO.write(target, "png", new FileOutputStream("D:\\a.JPG"));

}

这个java工程就是把D盘的t.jpg图片改成300*300的a.jpg图片，这个就得根据你屏幕的大小了。