Android - Cargar una captura de la camara en una view para dibujar sobre ella

   
Vista:
Imágen de perfil de Juan Jose

Cargar una captura de la camara en una view para dibujar sobre ella

Publicado por Juan Jose (12 intervenciones) el 29/04/2016 13:32:53
hola a todos:

Tengo una pequeña app , que es un pequeño paint.

y quisera que en la vista en donde dibujo, quisiera cargar la captura que haga con la camara de fotos del dispositivo.

El codigo de la app:

DibujoActivity:

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
183
184
185
186
187
188
189
190
191
192
193
194
195
import android.app.Activity;
import android.content.ContentResolver;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
 
//para los colores
import android.view.View;
import android.widget.ImageButton;
import android.widget.LinearLayout;
 
import java.util.UUID;
import android.provider.MediaStore;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.view.View.OnClickListener;
import android.widget.Toast;
 
public class DibujoActivity extends Activity implements OnClickListener {
 
    private DrawingView drawView;
    private ImageButton currPaint,drawBtn,newBtn,saveBtn,eraseBt;
 
    //medidas del pincel
    private float smallBrush, mediumBrush, largeBrush;
 
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
 
 
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        drawView = (DrawingView) findViewById(R.id.drawing);
 
        LinearLayout paintLayout = (LinearLayout) findViewById(R.id.paint_colors2);
 
 
        //pinceles
        smallBrush = getResources().getInteger(R.integer.small_size);
        mediumBrush = getResources().getInteger(R.integer.medium_size);
        largeBrush = getResources().getInteger(R.integer.large_size);
 
        //referencia al boton dibujar
        drawBtn = (ImageButton)findViewById(R.id.draw_btn);
        drawBtn.setOnClickListener(this);
 
        //referencia al boton nuevo
        newBtn = (ImageButton)findViewById(R.id.new_btn);
        newBtn.setOnClickListener(this);
 
        //referencia al boton guardar
        saveBtn=(ImageButton)findViewById(R.id.save_btn);
        saveBtn.setOnClickListener(this);
 
        //referencia al bonto limpiar
        eraseBt=(ImageButton)findViewById(R.id.erase_btn);
        eraseBt.setOnClickListener(this);
 
        //escogemos el valor
        currPaint = (ImageButton) paintLayout.getChildAt(5);
 
        //y cambiamos el boton de creacion con
        currPaint.setImageDrawable(getResources().getDrawable(R.drawable.paint_pressed));
 
 
    }
 
        //metodo paint clicke
        public void paintClicked(View view){
 
            if(view!=currPaint){
 
                ImageButton imgView = (ImageButton)view;
                String color = view.getTag().toString();
 
                drawView.setColor(color);
                //e implementamos para que el boton vuelva a la normalidad
                imgView.setImageDrawable(getResources().getDrawable(R.drawable.paint_pressed));
                currPaint.setImageDrawable(getResources().getDrawable(R.drawable.paint));
                currPaint=(ImageButton)view;
            }
 
        }
        //on click  para dibujar
 
    @Override
    public void onClick(View v) {
        //modificado a v
        if(v.getId()==R.id.draw_btn){
            //para elegir size de pincel
            final Dialog brushDialog = new Dialog(this);
            brushDialog.setTitle("Tamaño Brocha:");
            //creacion del menu de pincel
            brushDialog.setContentView(R.layout.brush_chooser);
            //completamos el dialogo con
            brushDialog.show();
 
            //on click del menu de pincel
            ImageButton smallBtn = (ImageButton)brushDialog.findViewById(R.id.small_brush);
            smallBtn.setOnClickListener(new OnClickListener(){
                @Override
                public void onClick(View v) {
                    drawView.setBrushSize(smallBrush);
                    drawView.setLastBrushSize(smallBrush);
                    brushDialog.dismiss();
                }
            });
 
            ImageButton mediumBtn = (ImageButton)brushDialog.findViewById(R.id.medium_brush);
            mediumBtn.setOnClickListener(new OnClickListener(){
                @Override
                public void onClick(View v) {
                    drawView.setBrushSize(mediumBrush);
                    drawView.setLastBrushSize(mediumBrush);
                    brushDialog.dismiss();
                }
            });
 
            ImageButton largeBtn = (ImageButton)brushDialog.findViewById(R.id.large_brush);
            largeBtn.setOnClickListener(new OnClickListener(){
                @Override
                public void onClick(View v) {
                    drawView.setBrushSize(largeBrush);
                    drawView.setLastBrushSize(largeBrush);
                    brushDialog.dismiss();
                }
            });
 
 
        }else if(v.getId()==R.id.new_btn){
            //dialogo de nuevo botn para dibujar
            AlertDialog.Builder newDialog = new AlertDialog.Builder(this);
            newDialog.setTitle("Nuevo Dibujo");
            newDialog.setMessage("¿Empezamos de Nuevo?");
            newDialog.setPositiveButton("Si", new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int which){
                    drawView.startNew();
                    dialog.dismiss();
                }
            });
            newDialog.setNegativeButton("No", new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int which){
                    dialog.cancel();
                }
            });
            newDialog.show();
 
        }else if(v.getId()==R.id.save_btn){
            //guardar el dibujo
            AlertDialog.Builder saveDialog = new AlertDialog.Builder(this);
            saveDialog.setTitle("Guardar Dibujo");
            saveDialog.setMessage("Guardar dibujo");
            saveDialog.setPositiveButton("Si", new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int which){
                    //Guardamos el dibujo
                    drawView.setDrawingCacheEnabled(true);
 
 
                    String imgSaved = MediaStore.Images.Media.insertImage(
                            getContentResolver(), drawView.getDrawingCache(),"foto.png","dibujo");
 
                    //definimos si se guarda o no la imagen
                    if(imgSaved!=null){
                       Toast.makeText(getApplicationContext(),
                                "Guardamos la imagen!", Toast.LENGTH_SHORT).show();
 
                    }
                    else{
                        Toast.makeText(getApplicationContext(),
                                "La imagen no se ha guardado", Toast.LENGTH_SHORT).show();
 
                    }
                    //y limpiamos el cache para evitar reescribir
                    drawView.destroyDrawingCache();
 
 
                }
            });
            saveDialog.setNegativeButton("Cancel", new DialogInterface.OnClickListener(){
                public void onClick(DialogInterface dialog, int which){
                    dialog.cancel();
                }
            });
            saveDialog.show();
 
        }else if(v.getId()==R.id.erase_btn){
            Toast.makeText(getApplicationContext(),"Vamos a Encalar", Toast.LENGTH_SHORT).show();
            //limpiamos la vista
            drawView.startNew();
 
        }
    }
}

el layout tiene una vista de dibujo, creo que la idea seria cambiar el background con la captura de la imagen:

1
2
3
4
5
6
7
8
9
10
<com.example.ainhoa.dibujo.DrawingView
        android:id="@+id/drawing"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginBottom="3dp"
        android:layout_marginLeft="5dp"
        android:layout_marginRight="5dp"
        android:layout_marginTop="3dp"
        android:layout_weight="1"
        android:background="#FFFFFF" />

y esta es la vista en la que se dibuja con la libreria canvas:

DrawingView:

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
import android.content.Context;
import android.graphics.Color;
import android.view.View;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.view.MotionEvent;
import android.util.AttributeSet;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.util.TypedValue;
 
 
/**
 * Created by Ainhoa on 15/04/2016.
 */
public class DrawingView extends View {
 
    //creacion de las variables
    //drawing path
    private Path drawPath;
    //drawing and canvas paint
    private Paint drawPaint, canvasPaint;
    //initial color
    private int paintColor = 0xFF660000;
    //variable
    private Canvas drawCanvas;
    //canvas bitmap
    private Bitmap canvasBitmap;
 
    //variables size pincel
    private float brushSize, lastBrushSize;
 
 
    public DrawingView(Context context, AttributeSet attrs){
        super(context, attrs);
        setupDrawing();
 
    }
    private void setupDrawing(){
        //get drawing area setup for interaction
        drawPath = new Path();
        drawPaint = new Paint();
        //coger el color
        drawPaint.setColor(paintColor);
 
        //propiedades
        drawPaint.setAntiAlias(true);
        drawPaint.setStrokeWidth(20);
        drawPaint.setStyle(Paint.Style.STROKE);
        drawPaint.setStrokeJoin(Paint.Join.ROUND);
        drawPaint.setStrokeCap(Paint.Cap.ROUND);
 
        canvasPaint = new Paint(Paint.DITHER_FLAG);
 
        //para cambiar de pincel
        brushSize = getResources().getInteger(R.integer.medium_size);
        lastBrushSize = brushSize;
 
        drawPaint.setStrokeWidth(brushSize);
    }
 
    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        //instanciamos
        canvasBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
        drawCanvas = new Canvas(canvasBitmap);
    }
 
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
 
        //e implementamos
        canvas.drawBitmap(canvasBitmap, 0, 0, canvasPaint);
        canvas.drawPath(drawPath, drawPaint);
 
    }
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        //detect user touch
        float touchX = event.getX();
        float touchY = event.getY();
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                drawPath.moveTo(touchX, touchY);
                break;
            case MotionEvent.ACTION_MOVE:
                drawPath.lineTo(touchX, touchY);
                break;
            case MotionEvent.ACTION_UP:
                drawCanvas.drawPath(drawPath, drawPaint);
                drawPath.reset();
                break;
            default:
                return false;
        }
        invalidate();
        return true;
 
        //escoger los colores
    }
 
    //metodo para cambiar el color
    public void setColor(String newColor){
        invalidate();
        //para cambiar el color
        paintColor = Color.parseColor(newColor);
        drawPaint.setColor(paintColor);
 
    }
 
    //size del pincel para dibujar
    public void setBrushSize(float newSize){
 
        float pixelAmount = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                newSize, getResources().getDisplayMetrics());
        brushSize=pixelAmount;
        drawPaint.setStrokeWidth(brushSize);
    }
    //devuelve valor de los pinceles
    public void setLastBrushSize(float lastSize){
        lastBrushSize=lastSize;
    }
    public float getLastBrushSize(){
        return lastBrushSize;
    }
 
    //metodo para escribir una nuevo dibujo
    public void startNew(){
        drawCanvas.drawColor(0, PorterDuff.Mode.CLEAR);
        invalidate();
    }
 
 
}

la idea es cargar la imagen de la captura de la camara en la view, para dibujar sobre ella.

Alguna idea para hacerlo.


Gracias a todos.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder