wear/src/main/java/jp/sfjp/gokigen/a01c/liveview/CameraLiveImageView.java

   1 package jp.sfjp.gokigen.a01c.liveview;
   2
   3 import android.content.Context;
   4 import android.content.SharedPreferences;
   5 import android.graphics.Bitmap;
   6 import android.graphics.BitmapFactory;
   7 import android.graphics.Canvas;
   8 import android.graphics.Color;
   9 import android.graphics.Paint;
  10 import android.graphics.PointF;
  11 import android.graphics.Rect;
  12 import android.graphics.RectF;
  13 import android.media.ExifInterface;
  14 import android.os.Looper;
  15 import android.preference.PreferenceManager;
  16 import android.util.AttributeSet;
  17 import android.util.DisplayMetrics;
  18 import android.util.Log;
  19 import android.util.TypedValue;
  20 import android.view.MotionEvent;
  21 import android.view.View;
  22 import android.widget.ImageView;
  23
  24 import java.util.Map;
  25 import java.util.Timer;
  26 import java.util.TimerTask;
  27
  28 import jp.co.olympus.camerakit.OLYCamera;
  29
  30 import jp.sfjp.gokigen.a01c.R;
  31 import jp.sfjp.gokigen.a01c.liveview.gridframe.GridFrameFactory;
  32 import jp.sfjp.gokigen.a01c.liveview.gridframe.IGridFrameDrawer;
  33 import jp.sfjp.gokigen.a01c.olycamerawrapper.ILevelGauge;
  34 import jp.sfjp.gokigen.a01c.preference.ICameraPropertyAccessor;
  35
  36 /**
  37  *   CameraLiveImageView :
  38  *    (OLYMPUS の ImageCaptureSample をカスタマイズ)
  39  *
  40  */
  41 public class CameraLiveImageView extends View implements CameraLiveViewListenerImpl.IImageDataReceiver, IAutoFocusFrameDisplay, ILiveImageStatusNotify
  42 {
  43     private final String TAG = toString();
  44
  45     private static final String EXIF_ORIENTATION = "Orientation";
  46
  47     private boolean showGridFeature = false;
  48     private boolean showLevelGaugeFeature = false;
  49     private ImageView.ScaleType imageScaleType;
  50     private Bitmap imageBitmap;
  51     private int imageRotationDegrees;
  52     private boolean showingFocusFrame = false;
  53     private IAutoFocusFrameDisplay.FocusFrameStatus focusFrameStatus;
  54     private RectF focusFrameRect;
  55     private Timer focusFrameHideTimer;
  56
  57     private IGridFrameDrawer gridFrameDrawer = null;
  58     private ShowMessageHolder messageHolder;
  59
  60     /**
  61      *   コンストラクタ
  62      *
  63      */
  64     public CameraLiveImageView(Context context)
  65     {
  66         super(context);
  67         initComponent(context);
  68     }
  69
  70     /**
  71      *   コンストラクタ
  72      *
  73      */
  74     public CameraLiveImageView(Context context, AttributeSet attrs)
  75     {
  76         super(context, attrs);
  77         initComponent(context);
  78     }
  79
  80     /**
  81      *   コンストラクタ
  82      *
  83      */
  84     public CameraLiveImageView(Context context, AttributeSet attrs, int defStyleAttr)
  85     {
  86         super(context, attrs, defStyleAttr);
  87         initComponent(context);
  88     }
  89
  90     /**
  91      * 初期化ロジック （preferenceからデータを読み出す）
  92      */
  93     private void initComponent(Context context)
  94     {
  95         messageHolder = new ShowMessageHolder();
  96
  97         imageScaleType = ImageView.ScaleType.FIT_CENTER;
  98         SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
  99
 100         showGridFeature = preferences.getBoolean(ICameraPropertyAccessor.SHOW_GRID_STATUS, true);
 101         showLevelGaugeFeature = preferences.getBoolean(ICameraPropertyAccessor.SHOW_LEVEL_GAUGE_STATUS, false);
 102
 103         int framingGridStatus = Integer.parseInt(preferences.getString(ICameraPropertyAccessor.FRAME_GRID, ICameraPropertyAccessor.FRAME_GRID_DEFAULT_VALUE));
 104         gridFrameDrawer = GridFrameFactory.getGridFrameDrawer(framingGridStatus);
 105
 106         // ダミーのビットマップデータ読み込み...画面表示のテスト用ロジック
 107         try
 108         {
 109             imageBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.momonga);
 110         }
 111         catch (Throwable t)
 112         {
 113             t.printStackTrace();
 114             imageBitmap = null;
 115         }
 116     }
 117
 118     /**
 119      *
 120      *
 121      */
 122     @Override
 123     protected void onAttachedToWindow()
 124     {
 125         super.onAttachedToWindow();
 126     }
 127
 128     /**
 129      *
 130      *
 131      */
 132     @Override
 133     protected void onDetachedFromWindow()
 134     {
 135         super.onDetachedFromWindow();
 136
 137         imageBitmap = null;
 138         if (focusFrameHideTimer != null)
 139         {
 140             focusFrameHideTimer.cancel();
 141             focusFrameHideTimer = null;
 142         }
 143     }
 144
 145     /**
 146      *
 147      *
 148      */
 149     @Override
 150     protected void onDraw(Canvas canvas)
 151     {
 152         super.onDraw(canvas);
 153
 154         // 画像の表示
 155         drawCanvas(canvas);
 156
 157         // メッセージの表示 (Overwrite)
 158         drawInformationMessages(canvas);
 159     }
 160
 161     /**
 162      *
 163      *
 164      */
 165     @Override
 166     public float getContentSizeWidth() {
 167         return getIntrinsicContentSizeWidth();
 168     }
 169
 170     /**
 171      *
 172      *
 173      */
 174     @Override
 175     public float getContentSizeHeight() {
 176         return getIntrinsicContentSizeHeight();
 177     }
 178
 179     /**
 180      *
 181      *
 182      */
 183     private float getIntrinsicContentSizeWidth()
 184     {
 185         if (imageBitmap == null)
 186         {
 187             return (1.0f);
 188         }
 189         return (imageBitmap.getWidth());
 190     }
 191
 192     /**
 193      *
 194      *
 195      */
 196     private float getIntrinsicContentSizeHeight()
 197     {
 198         if (imageBitmap == null)
 199         {
 200             return (1.0f);
 201         }
 202         return (imageBitmap.getHeight());
 203     }
 204
 205     /**
 206      * Sets a image to view.
 207      * (CameraLiveViewListenerImpl.IImageDataReceiver の実装)
 208      *
 209      * @param data     A image of live-view.
 210      * @param metadata A metadata of the image.
 211      */
 212     public void setImageData(byte[] data, Map<String, Object> metadata)
 213     {
 214         Bitmap bitmap;
 215         int rotationDegrees;
 216
 217         if (data != null && metadata != null)
 218         {
 219             // Create a bitmap.
 220             try
 221             {
 222                 bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
 223             }
 224             catch (OutOfMemoryError e)
 225             {
 226                 e.printStackTrace();
 227                 return;
 228             }
 229
 230             // Acquire a rotation degree of image.
 231             int orientation = ExifInterface.ORIENTATION_UNDEFINED;
 232             if (metadata.containsKey(EXIF_ORIENTATION))
 233             {
 234                 orientation = Integer.parseInt((String) metadata.get(EXIF_ORIENTATION));
 235             }
 236             switch (orientation)
 237             {
 238                 case ExifInterface.ORIENTATION_NORMAL:
 239                     rotationDegrees = 0;
 240                     break;
 241                 case ExifInterface.ORIENTATION_ROTATE_90:
 242                     rotationDegrees = 90;
 243                     break;
 244                 case ExifInterface.ORIENTATION_ROTATE_180:
 245                     rotationDegrees = 180;
 246                     break;
 247                 case ExifInterface.ORIENTATION_ROTATE_270:
 248                     rotationDegrees = 270;
 249                     break;
 250                 default:
 251                     rotationDegrees = 0;
 252                     break;
 253             }
 254             imageBitmap = bitmap;
 255             imageRotationDegrees = rotationDegrees;
 256         }
 257         refreshCanvas();
 258     }
 259
 260     /**
 261      * Returns a point which is detected by a motion event.
 262      *
 263      * @param event A motion event.
 264      * @return A point in the view finder. if a point is equal to null, the point is out of the view finder.
 265      */
 266     public PointF getPointWithEvent(MotionEvent event)
 267     {
 268         if (event == null || imageBitmap == null)
 269         {
 270             return null;
 271         }
 272
 273         PointF pointOnView = new PointF(event.getX(), event.getY());
 274         PointF pointOnImage = convertPointFromViewArea(pointOnView);
 275         float imageWidth;
 276         float imageHeight;
 277         if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 278             imageWidth = imageBitmap.getWidth();
 279             imageHeight = imageBitmap.getHeight();
 280         } else {
 281             imageWidth = imageBitmap.getHeight();
 282             imageHeight = imageBitmap.getWidth();
 283         }
 284         return (OLYCamera.convertPointOnLiveImageIntoViewfinder(pointOnImage, imageWidth, imageHeight, imageRotationDegrees));
 285     }
 286
 287     /**
 288      * Returns whether a image area contains a specified point.
 289      *
 290      * @param point The point to examine.
 291      * @return true if the image is not null or empty and the point is located within the rectangle; otherwise, false.
 292      */
 293     public boolean isContainsPoint(PointF point)
 294     {
 295         return ((point != null) && (new RectF(0, 0, 1, 1)).contains(point.x, point.y));
 296     }
 297
 298     /**
 299      * Hides the forcus frame.
 300      */
 301     public void hideFocusFrame()
 302     {
 303         if (focusFrameHideTimer != null)
 304         {
 305             focusFrameHideTimer.cancel();
 306             focusFrameHideTimer = null;
 307         }
 308         showingFocusFrame = false;
 309         refreshCanvas();
 310     }
 311
 312     /**
 313      * Shows the focus frame.
 314      *
 315      * @param rect     A rectangle of the focus frame on view area.
 316      * @param status   A status of the focus frame.
 317      * @param duration A duration of the focus frame showing.
 318      */
 319     @Override
 320     public void showFocusFrame(RectF rect, FocusFrameStatus status, double duration)
 321     {
 322         if (focusFrameHideTimer != null) {
 323             focusFrameHideTimer.cancel();
 324             focusFrameHideTimer = null;
 325         }
 326
 327         showingFocusFrame = true;
 328         focusFrameStatus = status;
 329         focusFrameRect = rect;
 330
 331         refreshCanvas();
 332
 333         if (duration > 0) {
 334             focusFrameHideTimer = new Timer();
 335             focusFrameHideTimer.schedule(new TimerTask() {
 336                 @Override
 337                 public void run() {
 338                     hideFocusFrame();
 339                 }
 340             }, (long) (duration * 1000));
 341         }
 342     }
 343
 344     /**
 345      *
 346      *
 347      */
 348     private void refreshCanvas()
 349     {
 350         if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
 351             invalidate();
 352         } else {
 353             postInvalidate();
 354         }
 355     }
 356
 357     /**
 358      * ビットマップの表示・画面表示の更新
 359      *
 360      * @param canvas キャンバス
 361      */
 362     private void drawCanvas(Canvas canvas)
 363     {
 364         // Clears the canvas.
 365         canvas.drawARGB(255, 0, 0, 0);
 366
 367         // ビットマップの取得
 368         Bitmap bitmapToShow = imageBitmap;
 369         if (bitmapToShow == null)
 370         {
 371             // 表示するビットマップがないとき
 372             return;
 373         }
 374
 375         // Rotates the image.
 376         int centerX = canvas.getWidth() / 2;
 377         int centerY = canvas.getHeight() / 2;
 378         canvas.rotate(imageRotationDegrees, centerX, centerY);
 379
 380         RectF viewRect = null;
 381
 382         //  Calculate the viewport of bitmap.
 383         if (imageScaleType == ImageView.ScaleType.FIT_CENTER)
 384         {
 385             viewRect = decideViewRect(canvas, bitmapToShow, imageRotationDegrees);
 386
 387             // Draws the bitmap.
 388             Rect imageRect = new Rect(0, 0, bitmapToShow.getWidth(), bitmapToShow.getHeight());
 389             canvas.drawBitmap(bitmapToShow, imageRect, viewRect, null);
 390         }
 391         else
 392         {
 393             // Sorry, other scale types are not supported.
 394             Log.v(TAG, "Sorry, other scale types are not supported. " + imageScaleType);
 395         }
 396
 397         // Cancels rotation of the canvas.
 398         canvas.rotate(-imageRotationDegrees, centerX, centerY);
 399
 400
 401         // フォーカスフレームを表示する
 402         if ((focusFrameRect != null) && (showingFocusFrame)) {
 403             if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 404                 drawFocusFrame(canvas, bitmapToShow.getWidth(), bitmapToShow.getHeight());
 405             } else {
 406                 drawFocusFrame(canvas, bitmapToShow.getHeight(), bitmapToShow.getWidth());
 407             }
 408         }
 409
 410         if (viewRect != null)
 411         {
 412             // グリッド（撮影補助線）の表示
 413             if ((showGridFeature) && (gridFrameDrawer != null))
 414             {
 415                 drawGridFrame(canvas, viewRect);
 416             }
 417
 418             // レベルゲージ（デジタル水準器）の表示
 419             if (showLevelGaugeFeature)
 420             {
 421                 drawLevelGauge(canvas, viewRect);
 422             }
 423         }
 424     }
 425
 426     /**
 427      *
 428      *
 429      */
 430     private RectF decideViewRect(Canvas canvas, Bitmap bitmapToShow, int degree)
 431     {
 432         final int srcWidth;
 433         final int srcHeight;
 434         if ((degree == 0) || (degree == 180))
 435         {
 436             srcWidth = bitmapToShow.getWidth();
 437             srcHeight = bitmapToShow.getHeight();
 438         }
 439         else
 440         {
 441             // Replaces width and height.
 442             srcWidth = bitmapToShow.getHeight();
 443             srcHeight = bitmapToShow.getWidth();
 444         }
 445
 446         int maxWidth = canvas.getWidth();
 447         int maxHeight = canvas.getHeight();
 448
 449         int centerX = canvas.getWidth() / 2;
 450         int centerY = canvas.getHeight() / 2;
 451
 452         float widthRatio = maxWidth / (float) srcWidth;
 453         float heightRatio = maxHeight / (float) srcHeight;
 454         float smallRatio = Math.min(widthRatio, heightRatio);
 455
 456         final int dstWidth;
 457         final int dstHeight;
 458         if (widthRatio < heightRatio)
 459         {
 460             // Fits to maxWidth with keeping aspect ratio.
 461             dstWidth = maxWidth;
 462             dstHeight = (int) (smallRatio * srcHeight);
 463         }
 464         else
 465         {
 466             // Fits to maxHeight with keeping aspect ratio.
 467             dstHeight = maxHeight;
 468             dstWidth = (int) (smallRatio * srcWidth);
 469         }
 470
 471         final float halfWidth = dstWidth * 0.5f;
 472         final float halfHeight = dstHeight * 0.5f;
 473         if ((degree == 0) || (degree == 180))
 474         {
 475             return (new RectF(
 476                     centerX - halfWidth,
 477                     centerY - halfHeight,
 478                     centerX - halfWidth + dstWidth,
 479                     centerY - halfHeight + dstHeight));
 480         }
 481
 482         // Replaces the width and height.
 483         return (new RectF(
 484                 centerX - halfHeight,
 485                 centerY - halfWidth,
 486                 centerX - halfHeight + dstHeight,
 487                 centerY - halfWidth + dstWidth));
 488     }
 489
 490     /**
 491      * AF枠の表示
 492      *
 493      * @param canvas      キャンバス
 494      * @param imageWidth  幅
 495      * @param imageHeight 高さ
 496      */
 497     private void drawFocusFrame(Canvas canvas, float imageWidth, float imageHeight)
 498     {
 499         //Log.v(TAG, "drawFocusFrame() :" + focusFrameStatus);
 500
 501         //  Calculate the rectangle of focus.
 502         RectF focusRectOnImage = OLYCamera.convertRectOnViewfinderIntoLiveImage(focusFrameRect, imageWidth, imageHeight, imageRotationDegrees);
 503         RectF focusRectOnView = convertRectFromImageArea(focusRectOnImage);
 504
 505         // Draw a rectangle to the canvas.
 506         Paint focusFramePaint = new Paint();
 507         focusFramePaint.setStyle(Paint.Style.STROKE);
 508         switch (focusFrameStatus) {
 509             case Running:
 510                 focusFramePaint.setColor(Color.WHITE);
 511                 break;
 512
 513             case Focused:
 514                 focusFramePaint.setColor(Color.GREEN);
 515                 break;
 516
 517             case Failed:
 518                 focusFramePaint.setColor(Color.RED);
 519                 break;
 520
 521             case Errored:
 522                 focusFramePaint.setColor(Color.YELLOW);
 523                 break;
 524         }
 525         float focusFrameStrokeWidth = 2.0f;
 526         DisplayMetrics dm = getResources().getDisplayMetrics();
 527         float strokeWidth = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, focusFrameStrokeWidth, dm);
 528         focusFramePaint.setStrokeWidth(strokeWidth);
 529         canvas.drawRect(focusRectOnView, focusFramePaint);
 530     }
 531
 532     /**
 533      * グリッドの表示
 534      *
 535      * @param canvas   キャンバスエリア
 536      * @param viewRect 表示領域
 537      */
 538     private void drawGridFrame(Canvas canvas, RectF viewRect)
 539     {
 540         RectF gridRect;
 541         if ((imageRotationDegrees == 0) || (imageRotationDegrees == 180)) {
 542             gridRect = new RectF(viewRect);
 543         } else {
 544             float height = viewRect.right - viewRect.left;
 545             float width = viewRect.bottom - viewRect.top;
 546             float left = (canvas.getWidth() / 2.0f) - (width / 2.0f);
 547             float top = (canvas.getHeight() / 2.0f) - (height / 2.0f);
 548             gridRect = new RectF(left, top, left + width, top + height);
 549         }
 550
 551         Paint framePaint = new Paint();
 552         framePaint.setStyle(Paint.Style.STROKE);
 553
 554         //DisplayMetrics dm = getResources().getDisplayMetrics();
 555         //float strokeWidth = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1.0f, dm);
 556         //framePaint.setStrokeWidth(strokeWidth);
 557         framePaint.setStrokeWidth(0.0f);
 558         framePaint.setColor(gridFrameDrawer.getDrawColor());
 559         gridFrameDrawer.drawFramingGrid(canvas, gridRect, framePaint);
 560     }
 561
 562     /**
 563      *   デジタル水準器の表示
 564      *
 565      */
 566     private void drawLevelGauge(Canvas canvas, RectF viewRect)
 567     {
 568        ILevelGauge levelGauge = messageHolder.getLevelGauge();
 569         if (levelGauge == null)
 570         {
 571             // デジタル水準器がとれない場合は、何もしない
 572             return;
 573         }
 574
 575         // レベルゲージの表示位置
 576         int height = (int) viewRect.bottom; // canvas.getHeight();
 577         int width =  (int) viewRect.right;  // canvas.getWidth();
 578         int centerX = width / 2;
 579         int centerY = height / 2;
 580
 581         //float maxBandWidth = width / 3.0f;     // ゲージの最大長 (画面の 1/3 ぐらい)
 582         float maxBandHeight = height / 3.0f;   // ゲージの最大長 (画面の 1/3 ぐらい)
 583         int barWidthInitial = 4;               // 表示するゲージの幅（の初期値）
 584         int barWidth;                          // 実際に表示するゲージの幅
 585
 586         Paint paint = new Paint();
 587
 588         // 垂直線
 589         float verticalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_VERTICAL);
 590         float verticalSize = verticalValue / 60.0f * maxBandHeight;  // 45度で切り替わるはずだが、一応...
 591         if (Math.abs(verticalSize) < 1.0f)
 592         {
 593             // 線引き限界以下、水平検出とする (この時の線は倍の長さにする)
 594             verticalSize = 1.0f;
 595             barWidth = barWidthInitial * 2;
 596         }
 597         else
 598         {
 599             barWidth = barWidthInitial;
 600         }
 601         paint.setStrokeWidth(barWidth);
 602         paint.setColor(levelGauge.getLevelColor(verticalValue));
 603         canvas.drawLine((width - barWidth), centerY, (width - barWidth), (centerY + verticalSize), paint);
 604
 605         // 水平線の表示
 606         float horizontalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_HORIZONTAL);
 607         paint.setStrokeWidth(2.0f);
 608         paint.setAntiAlias(true);
 609         paint.setColor(levelGauge.getLevelColor(horizontalValue));
 610         if ((imageRotationDegrees == 0) || (imageRotationDegrees == 180))
 611         {
 612             // 通常状態
 613             float YY = canvas.getHeight() / 2.0f; // centerY
 614             float diffY = (float) Math.sin(Math.toRadians(horizontalValue)) * (float) centerX;
 615             canvas.drawLine(0, (YY + diffY), width, (YY - diffY), paint);
 616         }
 617         else
 618         {
 619             // 縦持ち状態
 620             float XX = canvas.getWidth() / 2.0f; // centerX
 621             float diffX = (float) Math.sin(Math.toRadians(horizontalValue)) * (float) centerY;
 622             canvas.drawLine((XX + diffX), 0, (XX - diffX), canvas.getHeight(), paint);
 623
 624         }
 625 /*
 626         // 縦と同じ水平線を表示する場合...
 627         float horizontalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_HORIZONTAL);
 628         float horizontalSize = horizontalValue / 60.0f * maxBandWidth;  // 45度ぐらいで切り替わるはずだが、一応...
 629         if (Math.abs(horizontalSize) < 1.0f)
 630         {
 631             // 線引き限界以下、水平検出とする (この時の線は倍の長さにする）
 632             horizontalSize = 1.0f;
 633             barWidth = barWidthInitial * 2;
 634         }
 635         else
 636         {
 637             barWidth = barWidthInitial;
 638         }
 639         paint.setStrokeWidth(barWidth);
 640         paint.setColor(levelGauge.getLevelColor(horizontalValue));
 641         canvas.drawLine(centerX, (height - barWidth), (centerX + horizontalSize),  (height - barWidth), paint);
 642 */
 643     }
 644
 645     /**
 646      * 　 画面にメッセージを表示する
 647      */
 648     private void drawInformationMessages(Canvas canvas)
 649     {
 650         String message;
 651         RectF viewRect;
 652         if (imageBitmap != null)
 653         {
 654             // ビットマップの表示エリアに合わせて位置をチューニングする
 655             viewRect = decideViewRect(canvas, imageBitmap, 0);
 656         }
 657         else
 658         {
 659             // 適当なサイズ...
 660             viewRect = new RectF(5.0f, 0.0f, canvas.getWidth() - 5.0f, canvas.getHeight() - 55.0f);
 661         }
 662
 663         // 画面の中心に表示する
 664         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.CENTER);
 665         if ((message != null)&&(message.length() > 0))
 666         {
 667             Paint paint = new Paint();
 668             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.CENTER));
 669             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.CENTER));
 670             paint.setAntiAlias(true);
 671             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 672             float cx = (canvas.getWidth() / 2.0f) - (paint.measureText(message) / 2.0f);
 673             float cy = (canvas.getHeight() / 2.0f) - ((fontMetrics.ascent + fontMetrics.descent) / 2.0f);
 674             canvas.drawText(message, cx, cy, paint);
 675         }
 676
 677         // 画面上部左側に表示する
 678         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPLEFT);
 679         if ((message != null)&&(message.length() > 0))
 680         {
 681             Paint paintUp = new Paint();
 682             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPLEFT));
 683             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPLEFT));
 684             paintUp.setAntiAlias(true);
 685             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 686             canvas.drawText(message, viewRect.left + 3.0f, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 687         }
 688
 689         // 画面上部右側に表示する
 690         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPRIGHT);
 691         if ((message != null)&&(message.length() > 0))
 692         {
 693             Paint paintUp = new Paint();
 694             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPRIGHT));
 695             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPRIGHT));
 696             paintUp.setAntiAlias(true);
 697             float width = paintUp.measureText(message);
 698             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 699             canvas.drawText(message, (viewRect.right - 3.0f) - width, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 700         }
 701
 702         // 画面下部左側に表示する
 703         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWLEFT);
 704         if ((message != null)&&(message.length() > 0))
 705         {
 706             Paint paint = new Paint();
 707             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWLEFT));
 708             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWLEFT));
 709             paint.setAntiAlias(true);
 710             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 711             canvas.drawText(message, viewRect.left + 3.0f, viewRect.bottom - fontMetrics.bottom, paint);
 712         }
 713
 714         // 画面下部右側に表示する
 715         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWRIGHT);
 716         if ((message != null)&&(message.length() > 0))
 717         {
 718             Paint paint = new Paint();
 719             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWRIGHT));
 720             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWRIGHT));
 721             paint.setAntiAlias(true);
 722             float width = paint.measureText(message);
 723             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 724             canvas.drawText(message, (viewRect.right - 3.0f) - width, viewRect.bottom - fontMetrics.bottom, paint);
 725         }
 726
 727 /**/
 728         // 画面上部中央に表示する
 729         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPCENTER);
 730         if ((message != null)&&(message.length() > 0))
 731         {
 732             Paint paintUp = new Paint();
 733             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPCENTER));
 734             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPCENTER));
 735             paintUp.setAntiAlias(true);
 736             float width = paintUp.measureText(message) / 2.0f;
 737             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 738             canvas.drawText(message, (viewRect.centerX()) - width, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 739         }
 740
 741         // 画面下部中央に表示する
 742         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWCENTER);
 743         if ((message != null)&&(message.length() > 0))
 744         {
 745             Paint paint = new Paint();
 746             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWCENTER));
 747             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWCENTER));
 748             paint.setAntiAlias(true);
 749             float width = paint.measureText(message) / 2.0f;
 750             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 751             canvas.drawText(message, (viewRect.centerX()) - width, viewRect.bottom - fontMetrics.bottom, paint);
 752         }
 753 /**/
 754     }
 755
 756     /**
 757      * Converts a point on image area to a point on view area.
 758      *
 759      * @param point A point on image area. (e.g. a live preview image)
 760      * @return A point on view area. (e.g. a touch panel view)
 761      */
 762     private PointF convertPointFromImageArea(PointF point) {
 763         if (imageBitmap == null) {
 764             return new PointF();
 765         }
 766
 767         float viewPointX = point.x;
 768         float viewPointY = point.y;
 769         float imageSizeWidth;
 770         float imageSizeHeight;
 771         if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 772             imageSizeWidth = imageBitmap.getWidth();
 773             imageSizeHeight = imageBitmap.getHeight();
 774         } else {
 775             imageSizeWidth = imageBitmap.getHeight();
 776             imageSizeHeight = imageBitmap.getWidth();
 777         }
 778         float viewSizeWidth = this.getWidth();
 779         float viewSizeHeight = this.getHeight();
 780         float ratioX = viewSizeWidth / imageSizeWidth;
 781         float ratioY = viewSizeHeight / imageSizeHeight;
 782         float scale;
 783
 784         switch (imageScaleType) {
 785             case FIT_XY:
 786                 viewPointX *= ratioX;
 787                 viewPointY *= ratioY;
 788                 break;
 789             case FIT_CENTER:    // go to next label.
 790             case CENTER_INSIDE:
 791                 scale = Math.min(ratioX, ratioY);
 792                 viewPointX *= scale;
 793                 viewPointY *= scale;
 794                 viewPointX += (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 795                 viewPointY += (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 796                 break;
 797             case CENTER_CROP:
 798                 scale = Math.max(ratioX, ratioY);
 799                 viewPointX *= scale;
 800                 viewPointY *= scale;
 801                 viewPointX += (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 802                 viewPointY += (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 803                 break;
 804             case CENTER:
 805                 viewPointX += viewSizeWidth / 2.0 - imageSizeWidth / 2.0f;
 806                 viewPointY += viewSizeHeight / 2.0 - imageSizeHeight / 2.0f;
 807                 break;
 808             default:
 809                 break;
 810         }
 811         return new PointF(viewPointX, viewPointY);
 812     }
 813
 814     /**
 815      * Converts a point on view area to a point on image area.
 816      *
 817      * @param point A point on view area. (e.g. a touch panel view)
 818      * @return A point on image area. (e.g. a live preview image)
 819      */
 820     private PointF convertPointFromViewArea(PointF point) {
 821         if (imageBitmap == null) {
 822             return new PointF();
 823         }
 824
 825         float imagePointX = point.x;
 826         float imagePointY = point.y;
 827         float imageSizeWidth;
 828         float imageSizeHeight;
 829         if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 830             imageSizeWidth = imageBitmap.getWidth();
 831             imageSizeHeight = imageBitmap.getHeight();
 832         } else {
 833             imageSizeWidth = imageBitmap.getHeight();
 834             imageSizeHeight = imageBitmap.getWidth();
 835         }
 836         float viewSizeWidth = this.getWidth();
 837         float viewSizeHeight = this.getHeight();
 838         float ratioX = viewSizeWidth / imageSizeWidth;
 839         float ratioY = viewSizeHeight / imageSizeHeight;
 840         float scale;
 841
 842         switch (imageScaleType) {
 843             case FIT_XY:
 844                 imagePointX /= ratioX;
 845                 imagePointY /= ratioY;
 846                 break;
 847             case FIT_CENTER:    // go to next label.
 848             case CENTER_INSIDE:
 849                 scale = Math.min(ratioX, ratioY);
 850                 imagePointX -= (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 851                 imagePointY -= (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 852                 imagePointX /= scale;
 853                 imagePointY /= scale;
 854                 break;
 855             case CENTER_CROP:
 856                 scale = Math.max(ratioX, ratioY);
 857                 imagePointX -= (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 858                 imagePointY -= (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 859                 imagePointX /= scale;
 860                 imagePointY /= scale;
 861                 break;
 862             case CENTER:
 863                 imagePointX -= (viewSizeWidth - imageSizeWidth) / 2.0f;
 864                 imagePointY -= (viewSizeHeight - imageSizeHeight) / 2.0f;
 865                 break;
 866             default:
 867                 break;
 868         }
 869         return new PointF(imagePointX, imagePointY);
 870     }
 871
 872     /**
 873      * Converts a rectangle on image area to a rectangle on view area.
 874      *
 875      * @param rect A rectangle on image area. (e.g. a live preview image)
 876      * @return A rectangle on view area. (e.g. a touch panel view)
 877      */
 878     private RectF convertRectFromImageArea(RectF rect)
 879     {
 880         if (imageBitmap == null)
 881         {
 882             return new RectF();
 883         }
 884
 885         PointF imageTopLeft = new PointF(rect.left, rect.top);
 886         PointF imageBottomRight = new PointF(rect.right, rect.bottom);
 887
 888         PointF viewTopLeft = convertPointFromImageArea(imageTopLeft);
 889         PointF viewBottomRight = convertPointFromImageArea(imageBottomRight);
 890
 891         return (new RectF(viewTopLeft.x, viewTopLeft.y, viewBottomRight.x, viewBottomRight.y));
 892     }
 893
 894     /**
 895      *
 896      *
 897      */
 898     public void setShowGridFrame(boolean isShowGridFeature)
 899     {
 900         showGridFeature = isShowGridFeature;
 901         SharedPreferences preferences = android.support.v7.preference.PreferenceManager.getDefaultSharedPreferences(getContext());
 902         SharedPreferences.Editor editor = preferences.edit();
 903         editor.putBoolean(ICameraPropertyAccessor.SHOW_GRID_STATUS, showGridFeature);
 904         editor.apply();
 905     }
 906
 907     /**
 908      *
 909      *
 910      */
 911     @Override
 912     public void toggleShowGridFrame()
 913     {
 914         setShowGridFrame(!showGridFeature);
 915     }
 916
 917     /**
 918      *
 919      *
 920      */
 921     public void setShowLevelGauge(boolean isShowLevelGaugeFeature)
 922     {
 923         Log.v(TAG, "setShowLevelGauge : " + isShowLevelGaugeFeature);
 924         showLevelGaugeFeature = isShowLevelGaugeFeature;
 925         SharedPreferences preferences = android.support.v7.preference.PreferenceManager.getDefaultSharedPreferences(getContext());
 926         SharedPreferences.Editor editor = preferences.edit();
 927         editor.putBoolean(ICameraPropertyAccessor.SHOW_LEVEL_GAUGE_STATUS, showLevelGaugeFeature);
 928         editor.apply();
 929         ILevelGauge levelGauge = messageHolder.getLevelGauge();
 930         if (levelGauge == null)
 931         {
 932             // デジタル水準器がとれない場合は、何もしない
 933             Log.v(TAG, "setShowLevelGauge : levelGauge is null.");
 934             return;
 935         }
 936         levelGauge.updateLevelGaugeChecking(isShowLevelGaugeFeature);
 937     }
 938
 939     /**
 940      *
 941      *
 942      */
 943     @Override
 944     public void toggleShowLevelGauge()
 945     {
 946         setShowLevelGauge(!showLevelGaugeFeature);
 947     }
 948
 949     /**
 950      *
 951      *
 952      */
 953     @Override
 954     public boolean isShowLevelGauge()
 955     {
 956         return (showLevelGaugeFeature);
 957     }
 958
 959     /**
 960      *
 961      *
 962      */
 963     @Override
 964     public boolean isShowGrid()
 965     {
 966         return (showGridFeature);
 967     }
 968
 969
 970     /**
 971      *
 972      *
 973      */
 974     public IMessageDrawer getMessageDrawer()
 975     {
 976         return (messageHolder);
 977     }
 978 }