Ajouter des boutons dans une classe ?

**djmahdouch** · 04/05/2012, 15h38

Salut tous le monde,
J'ai besoin de votre aide au niveau développement d'une application Android pour mon PFE , je voulais ajouter au niveau d'une classe MjpegView personnaliser avec java des boutons , cette classe je l'ai trouvé dans google code elle sert à afficher un flux Streaming de type Mjpeg voila le lien de cette classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
package de.mjpegsample.MjpegView;
 
import java.io.IOException;
 
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
 
public class MjpegView extends SurfaceView implements SurfaceHolder.Callback {
        public final static int POSITION_UPPER_LEFT = 9;
        public final static int POSITION_UPPER_RIGHT = 3;
        public final static int POSITION_LOWER_LEFT = 12;
        public final static int POSITION_LOWER_RIGHT = 6;
 
        public final static int SIZE_STANDARD = 1;
        public final static int SIZE_BEST_FIT = 4;
        public final static int SIZE_FULLSCREEN = 8;
 
        private MjpegViewThread thread;
        private MjpegInputStream mIn = null;
        private boolean showFps = false;
        private boolean mRun = false;
        private boolean surfaceDone = false;
        private Paint overlayPaint;
        private int overlayTextColor;
        private int overlayBackgroundColor;
        private int ovlPos;
        private int dispWidth;
        private int dispHeight;
        private int displayMode;
        private boolean resume = false;
 
        private Context context;
 
        public class MjpegViewThread extends Thread {
                private SurfaceHolder mSurfaceHolder;
                private int frameCounter = 0;
                private long start;
                private Bitmap ovl;
 
                public MjpegViewThread(SurfaceHolder surfaceHolder, Context context) {
                        mSurfaceHolder = surfaceHolder;
                }
 
                private Rect destRect(int bmw, int bmh) {
                        int tempx;
                        int tempy;
                        if (displayMode == MjpegView.SIZE_STANDARD) {
                                tempx = (dispWidth / 2) - (bmw / 2);
                                tempy = (dispHeight / 2) - (bmh / 2);
                                return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
                        }
                        if (displayMode == MjpegView.SIZE_BEST_FIT) {
                                float bmasp = (float) bmw / (float) bmh;
                                bmw = dispWidth;
                                bmh = (int) (dispWidth / bmasp);
                                if (bmh > dispHeight) {
                                        bmh = dispHeight;
                                        bmw = (int) (dispHeight * bmasp);
                                }
                                tempx = (dispWidth / 2) - (bmw / 2);
                                tempy = (dispHeight / 2) - (bmh / 2);
                                return new Rect(tempx, tempy, bmw + tempx, bmh + tempy);
                        }
                        if (displayMode == MjpegView.SIZE_FULLSCREEN)
                                return new Rect(0, 0, dispWidth, dispHeight);
                        return null;
                }
 
                public void setSurfaceSize(int width, int height) {
                        synchronized (mSurfaceHolder) {
                                dispWidth = width;
                                dispHeight = height;
                        }
                }
 
                private Bitmap makeFpsOverlay(Paint p, String text) {
                        Rect b = new Rect();
                        p.getTextBounds(text, 0, text.length(), b);
                        int bwidth = b.width() + 2;
                        int bheight = b.height() + 2;
                        Bitmap bm = Bitmap.createBitmap(bwidth, bheight,
                                        Bitmap.Config.ARGB_8888);
                        Canvas c = new Canvas(bm);
                        p.setColor(overlayBackgroundColor);
                        c.drawRect(0, 0, bwidth, bheight, p);
                        p.setColor(overlayTextColor);
                        c.drawText(text, -b.left + 1,
                                        (bheight / 2) - ((p.ascent() + p.descent()) / 2) + 1, p);
                        return bm;
                }
 
                public void run() {
                        start = System.currentTimeMillis();
                        PorterDuffXfermode mode = new PorterDuffXfermode(
                                        PorterDuff.Mode.DST_OVER);
                        Bitmap bm;
                        int width;
                        int height;
                        Rect destRect;
                        Canvas c = null;
                        Paint p = new Paint();
                        String fps = "";
                        while (mRun) {
                                if (surfaceDone) {
                                        try {
                                                c = mSurfaceHolder.lockCanvas();
                                                synchronized (mSurfaceHolder) {
                                                        try {
                                                                bm = mIn.readMjpegFrame();
                                                                destRect = destRect(bm.getWidth(),
                                                                                bm.getHeight());
                                                                c.drawColor(Color.BLACK);
                                                                c.drawBitmap(bm, null, destRect, p);
                                                                if (showFps) {
                                                                        p.setXfermode(mode);
                                                                        if (ovl != null) {
                                                                                height = ((ovlPos & 1) == 1) ? destRect.top
                                                                                                : destRect.bottom
                                                                                                                - ovl.getHeight();
                                                                                width = ((ovlPos & 8) == 8) ? destRect.left
                                                                                                : destRect.right
                                                                                                                - ovl.getWidth();
                                                                                c.drawBitmap(ovl, width, height, null);
                                                                        }
                                                                        p.setXfermode(null);
                                                                        frameCounter++;
                                                                        if ((System.currentTimeMillis() - start) >= 1000) {
                                                                                fps = String.valueOf(frameCounter)
                                                                                                + "fps";
                                                                                frameCounter = 0;
                                                                                start = System.currentTimeMillis();
                                                                                ovl = makeFpsOverlay(overlayPaint, fps);
                                                                        }
                                                                }
                                                        } catch (IOException e) {
                                                        }
                                                }
                                        } finally {
                                                if (c != null)
                                                        mSurfaceHolder.unlockCanvasAndPost(c);
                                        }
                                }
                        }
                }
        }
 
        private void init(Context context) {
 
                this.context = context;
                SurfaceHolder holder = getHolder();
                holder.addCallback(this);
                thread = new MjpegViewThread(holder, context);
                setFocusable(true);
                if (!resume) {
                        resume = true;
                        overlayPaint = new Paint();
                        overlayPaint.setTextAlign(Paint.Align.LEFT);
                        overlayPaint.setTextSize(12);
                        overlayPaint.setTypeface(Typeface.DEFAULT);
                        overlayTextColor = Color.WHITE;
                        overlayBackgroundColor = Color.BLACK;
                        ovlPos = MjpegView.POSITION_LOWER_RIGHT;
                        displayMode = MjpegView.SIZE_STANDARD;
                        dispWidth = getWidth();
                        dispHeight = getHeight();
                        Log.i("AppLog", "init");
                }
        }
 
        public void startPlayback() {
                if (mIn != null) {
                        mRun = true;
                        thread.start();
                }
        }
 
        public void resumePlayback() {
                mRun = true;
                init(context);
                Log.i("AppLog", "resume");
                thread.start();
        }
 
        public void stopPlayback() {
                mRun = false;
                boolean retry = true;
                while (retry) {
                        try {
                                thread.join();
                                retry = false;
                        } catch (InterruptedException e) {
                        }
                }
        }
 
        public MjpegView(Context context, AttributeSet attrs) {
                super(context, attrs);
                init(context);
        }
 
        public void surfaceChanged(SurfaceHolder holder, int f, int w, int h) {
                thread.setSurfaceSize(w, h);
        }
 
        public void surfaceDestroyed(SurfaceHolder holder) {
                surfaceDone = false;
                stopPlayback();
        }
 
        public MjpegView(Context context) {
                super(context);
                init(context);
        }
 
        public void surfaceCreated(SurfaceHolder holder) {
                surfaceDone = true;
        }
 
        public void showFps(boolean b) {
                showFps = b;
        }
 
        public void setSource(MjpegInputStream source) {
                mIn = source;
                startPlayback();
        }
 
        public void setOverlayPaint(Paint p) {
                overlayPaint = p;
        }
 
        public void setOverlayTextColor(int c) {
                overlayTextColor = c;
        }
 
        public void setOverlayBackgroundColor(int c) {
                overlayBackgroundColor = c;
        }
 
        public void setOverlayPosition(int p) {
                ovlPos = p;
        }
 
        public void setDisplayMode(int s) {
                displayMode = s;
        }
}

je voulais ajouter 3 boutons sous l'image en utilisant le code java pas le XML .
si vous pouvez m'aider à réaliser mon objective et où mettre le code des boutons comment faire l'appel .
Merci d'avance .
Bonne journée.

**marwwwwwa** · 28/01/2013, 16h40

Salut,
merci pour le code mais j'ai pas compris les rôles des méthodes est ce que vous pouvez m'envoyer un lien ou un tutoriel pour bien comprendre.
Merci.

**nicroman** · 28/01/2013, 17h14

Envoyé par djmahdouch

je voulais ajouter 3 boutons sous l'image en utilisant le code java pas le XML .
si vous pouvez m'aider à réaliser mon objective et où mettre le code des boutons comment faire l'appel.

Déjà ce n'est pas possible dans ce code là... ce code décrit une "View" donc impossible d'y rajouter d'autres views, dynamiquement ou non.
Et puis de toute manière ... ce n'est pas son rôle... c'est le rôle du layout "parent", que ce soit proprement par XML, ou salement par Java.

Ajouter des boutons dans une classe ?

Composants graphiques Android

Discussions similaires

Partager

Partager