Changeset 8:16f40c44c354 for android/src/org

Timestamp:

07/08/10 01:14:22 (14 years ago)

Author:

lukacu

Branch:

default

Tags:

tip

Convert:

svn:f819dc9c-ca78-df11-852c-0018fe7759ca/trunk@9

Message:

More Android stuff: overlay & some layout fixes.

Location:

android/src/org/webstrips/android

Files:

• ComicViewerActivity.java (modified) (8 diffs)
• StripPane.java (modified) (7 diffs)

android/src/org/webstrips/android/ComicViewerActivity.java

@@ -35 +35 @@
 import android.widget.ProgressBar;
 import android.widget.RelativeLayout;
+import android.widget.TextView;
 
 public class ComicViewerActivity extends Activity {
 
+    private CanvasThread thread;
+    
     private StripPane pane;
 
+    private TextView title;
+    
     private RelativeLayout overlay;
 
@@ -87 +92 @@
             }
             progress.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
+            pane.setFrozen(visible);
         }
     };
 
+    final Handler overlayHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            boolean visible = msg.getData().getBoolean("visible");
+            overlay.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
+        }
+    };
+    
+    final Handler comicHandler = new Handler() {
+        public void handleMessage(Message msg) {
+            String t = msg.getData().getString("title");
+            title.setText(t);
+        }
+    };
+    
     final Handler errorHandler = new Handler() {
         public void handleMessage(Message msg) {
@@ -246 +266 @@
 
         progress.setVisibility(View.INVISIBLE);
+        
+        title = (TextView) findViewById(R.id.view_title);
     }
 
@@ -253 +275 @@
 
     }
-
+    
     @Override
     protected void onPause() {
+        if (thread != null) {
+            boolean retry = true;
+            thread.run = false;
+            while (retry) {
+                try {
+                    thread.join();
+                    retry = false;
+                } catch (InterruptedException e) {
+                    // we will try it again and again...
+                }
+            }
+        }
+        
         super.onPause();
         try {
@@ -268 +303 @@
         expectedStrip = null;
 
+
     }
 
@@ -292 +328 @@
                 0);
 
+        thread = new CanvasThread();
+        thread.run = true;
+        thread.start();
     }
 
@@ -483 +522 @@
         String title = EscapeSequences
                 .stripAmpersandSequence(((strip == null) ? "" : strip
-                        .getTitle()
-                        + " - "));
+                        .getTitle()));
 
         setTitle(control.getComic().getComicName() + " - " + title);
 
+        Message msg = comicHandler.obtainMessage();
+        Bundle b = new Bundle();
+        b.putString("title", title);
+        msg.setData(b);
+        comicHandler.sendMessage(msg);
+        
         currentStrip = strip;
         expectedStrip = currentStrip.getIdentifier();
@@ -622 +666 @@
     }
 
+    private static final long FRAME_LENGTH = 1000 / 25;
+    
+    private static final int OVERLAY_DELAY = 80;
+    
+    private int overlayCountdown = OVERLAY_DELAY;
+    
+    class CanvasThread extends Thread {
+
+        private boolean run = false;
+        
+        @Override
+        public void run() {
+
+            while (run) {
+
+                long miliseconds = System.currentTimeMillis();
+                
+                if (pane != null)
+                    pane.tick();
+
+                if (!dragging && !pane.isEmpty() && !pane.isFrozen()) {
+                    if (overlayCountdown > -1)
+                        overlayCountdown--;
+                } else {
+                    if (overlayCountdown != OVERLAY_DELAY) {
+                        Message msg = overlayHandler.obtainMessage();
+                        Bundle b = new Bundle();
+                        b.putBoolean("visible", false);
+                        msg.setData(b);
+                        overlayHandler.sendMessage(msg);
+                    }
+                    
+                    overlayCountdown = OVERLAY_DELAY;
+                }
+                
+                if (overlayCountdown == 0) {
+                    Message msg = overlayHandler.obtainMessage();
+                    Bundle b = new Bundle();
+                    b.putBoolean("visible", true);
+                    msg.setData(b);
+                    overlayHandler.sendMessage(msg);
+                }
+                
+                try {
+                    long sl = Math.max(0, FRAME_LENGTH - Math.abs(System.currentTimeMillis() - miliseconds));
+                    sleep(sl);
+                } catch (InterruptedException e) {
+                    break;
+                }
+                
+            }
+
+        }
+
+    }
 }

android/src/org/webstrips/android/StripPane.java

@@ -14 +14 @@
 public class StripPane extends SurfaceView implements SurfaceHolder.Callback {
 
-    private CanvasThread thread;
 
     private boolean dirty = true;
 
     private static Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
-    
-    private static class StipPaneData { 
-    
+
+    private static Paint frozenpaint;
+
+    static {
+
+        frozenpaint = new Paint(Paint.ANTI_ALIAS_FLAG);
+
+        frozenpaint.setAlpha(100);
+
+    }
+
+    private boolean frozen = false;
+
+    private static class StipPaneData {
+
         public PointF offset = new PointF();
-    
+
         public FloatTracker zoom = new FloatTracker(1, 1);
-    
+
         public Bitmap comicStrip;
 
     }
 
-    private FloatTracker velocityX = new FloatTracker(0, 0, 0.2f, 0.5f), velocityY = new FloatTracker(0, 0, 0.2f, 0.5f);
-    
+    private FloatTracker velocityX = new FloatTracker(0, 0, 0.2f, 0.5f),
+            velocityY = new FloatTracker(0, 0, 0.2f, 0.5f);
+
     private StipPaneData data = new StipPaneData();
 
@@ -37 +49 @@
         super(context, attr);
         getHolder().addCallback(this);
-        thread = new CanvasThread(getHolder());
-
 
     }
 
     private RectF canvasRect = new RectF();
-    
+
     public void setDirty() {
         dirty = true;
     }
-    
+
     public void setVelocity(float vx, float vy) {
-        
+
         velocityX.setValue(vx);
         velocityY.setValue(vy);
         dirty = true;
     }
-    
+
+    public void setFrozen(boolean frozen) {
+        this.frozen = frozen;
+        this.dirty = true;
+    }
+
     public Object getPersistentData() {
         return data;
     }
-    
+
     public void setPersistentData(Object o) {
         if (o instanceof StripPane.StipPaneData) {
@@ -65 +80 @@
         }
     }
-    
+
     @Override
     public void onDraw(Canvas canvas) {
@@ -71 +86 @@
             return;
         canvas.drawColor(Color.BLACK);
-        
-        canvas.drawBitmap(data.comicStrip, null, canvasRect, paint);
+
+        canvas.drawBitmap(data.comicStrip, null, canvasRect,
+                frozen ? frozenpaint : paint);
     }
 
@@ -80 +96 @@
 
             data.comicStrip = strip;
-            
+
             data.offset.x = 0;
             data.offset.y = 0;
@@ -86 +102 @@
         }
     }
-    
+
     public Bitmap getComicStrip() {
         return data.comicStrip;
     }
+
+    public boolean isEmpty() {
+        return data.comicStrip == null;
+    }
+    
+    public boolean isFrozen() {
+        return frozen;
+    }
     
     public void surfaceChanged(SurfaceHolder holder, int format, int width,
@@ -97 +121 @@
 
     public void surfaceCreated(SurfaceHolder holder) {
-        thread = new CanvasThread(getHolder());
-        thread.run = true;
-        thread.start();
         dirty = true;
+        canDraw = true;
     }
 
     public void surfaceDestroyed(SurfaceHolder holder) {
-        boolean retry = true;
-        thread.run = false;
-        while (retry) {
+        canDraw = false;
+    }
+    
+    private boolean canDraw = false;
+    
+    private static final long FRAME_LENGTH = 1000 / 20;
+
+    public void tick() {
+
+        if (!canDraw)
+            return;
+        
+        if (!frozen)
+            dirty |= !data.zoom.onGoal() || !velocityX.onGoal()
+                    || !velocityY.onGoal();
+
+        Canvas c = null;
+
+        if (dirty) {
+
             try {
-                thread.join();
-                retry = false;
-            } catch (InterruptedException e) {
-                // we will try it again and again...
+
+                data.zoom.track();
+
+                c = getHolder().lockCanvas(null);
+                synchronized (this) {
+
+                    if (data.comicStrip != null) {
+                        float width = data.zoom.getValue()
+                                * data.comicStrip.getWidth();
+                        float height = data.zoom.getValue()
+                                * data.comicStrip.getHeight();
+
+                        if (!frozen) {
+                            data.offset.x -= velocityX.track();
+                            data.offset.y -= velocityY.track();
+                        }
+
+                        data.offset.x = c.getWidth() > width ? -((c.getWidth() - width) / 2)
+                                : Math.min(width - c.getWidth(), Math.max(0,
+                                        data.offset.x));
+
+                        data.offset.y = c.getHeight() > height ? -((c
+                                .getHeight() - height) / 2) : Math.min(height
+                                - c.getHeight(), Math.max(0, data.offset.y));
+
+                        canvasRect.left = -data.offset.x;
+                        canvasRect.top = -data.offset.y;
+                        canvasRect.right = -data.offset.x + width;
+                        canvasRect.bottom = -data.offset.y + height;
+                    }
+
+                    onDraw(c);
+                    dirty = false;
+                }
+
+            } finally {
+
+                // do this in a finally so that if an exception is
+                // thrown
+                // during the above, we don't leave the Surface in an
+                // inconsistent state
+
+                if (c != null) {
+
+                    getHolder().unlockCanvasAndPost(c);
+
+                }
+
             }
         }
-    }
-
-    private static final long FRAME_LENGTH = 1000 / 20;
-    
-    class CanvasThread extends Thread {
-
-        private SurfaceHolder surfaceHolder;
-
-        private boolean run = false;
-        
-        public CanvasThread(SurfaceHolder surfaceHolder) {
-            this.surfaceHolder = surfaceHolder;
-        }
-
-        @Override
-        public void run() {
-
-            Canvas c;
-
-            while (run) {
-
-                c = null;
-
-                long miliseconds = System.currentTimeMillis();
-                
-                dirty |= !data.zoom.onGoal() || !velocityX.onGoal() || !velocityY.onGoal();
-                
-                if (dirty) {
-
-                    try {
-
-                        data.zoom.track();
-                        
-                        c = surfaceHolder.lockCanvas(null);
-                        synchronized (surfaceHolder) {
-                            
-                            if (data.comicStrip != null) {
-                                float width = data.zoom.getValue() * data.comicStrip.getWidth(); 
-                                float height = data.zoom.getValue() * data.comicStrip.getHeight();
-                                
-                                data.offset.x -= velocityX.track();
-                                data.offset.y -= velocityY.track();
-                                
-                                data.offset.x = c.getWidth() > width ? -((c.getWidth() - width) / 2) :
-                                    Math.min(width - c.getWidth(), Math.max(0, data.offset.x));
-
-                                data.offset.y = c.getHeight() > height ? -((c.getHeight() - height) / 2) :
-                                    Math.min(height - c.getHeight(), Math.max(0, data.offset.y));
-                                
-                                canvasRect.left = -data.offset.x;
-                                canvasRect.top = -data.offset.y;
-                                canvasRect.right = -data.offset.x + width;
-                                canvasRect.bottom = -data.offset.y + height;                            
-                            }
-                            
-                            
-                            
-                            onDraw(c);
-                            dirty = false;
-                        }
-
-                    } finally {
-
-                        // do this in a finally so that if an exception is
-                        // thrown
-                        // during the above, we don't leave the Surface in an
-                        // inconsistent state
-
-                        if (c != null) {
-
-                            surfaceHolder.unlockCanvasAndPost(c);
-
-                        }
-
-                    }
-                }
-
-                try {
-                    sleep(Math.min(FRAME_LENGTH, Math.abs(System.currentTimeMillis() - miliseconds)));
-                } catch (InterruptedException e) {
-                    break;
-                }
-                
-            }
-
-        }
-
-    }
-
-
-    
-    
+
+    }
+
 }