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.setColor(gridFrameDrawer.getDrawColor());
 558         gridFrameDrawer.drawFramingGrid(canvas, gridRect, framePaint);
 559     }
 560
 561     /**
 562      *   デジタル水準器の表示
 563      *
 564      */
 565     private void drawLevelGauge(Canvas canvas, RectF viewRect)
 566     {
 567        ILevelGauge levelGauge = messageHolder.getLevelGauge();
 568         if (levelGauge == null)
 569         {
 570             // デジタル水準器がとれない場合は、何もしない
 571             return;
 572         }
 573
 574         // レベルゲージの表示位置
 575         int height = (int) viewRect.bottom; // canvas.getHeight();
 576         int width =  (int) viewRect.right;  // canvas.getWidth();
 577         int centerX = width / 2;
 578         int centerY = height / 2;
 579
 580         float maxBandWidth = width / 3.0f;     // ゲージの最大長 (画面の 1/3 ぐらい)
 581         float maxBandHeight = height / 3.0f;   // ゲージの最大長 (画面の 1/3 ぐらい)
 582         int barWidthInitial = 4;               // 表示するゲージの幅（の初期値）
 583         int barWidth;                          // 実際に表示するゲージの幅
 584
 585         Paint paint = new Paint();
 586
 587         // 垂直線
 588         float verticalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_VERTICAL);
 589         float verticalSize = verticalValue / 60.0f * maxBandHeight;  // 45度で切り替わるはずだが、一応...
 590         if (Math.abs(verticalSize) < 1.0f)
 591         {
 592             // 線引き限界以下、水平検出とする (この時の線は倍の長さにする)
 593             verticalSize = 1.0f;
 594             barWidth = barWidthInitial * 2;
 595         }
 596         else
 597         {
 598             barWidth = barWidthInitial;
 599         }
 600         paint.setStrokeWidth(barWidth);
 601         paint.setColor(levelGauge.getLevelColor(verticalValue));
 602         canvas.drawLine((width - barWidth), centerY, (width - barWidth), (centerY + verticalSize), paint);
 603
 604         // 水平線の表示
 605         float horizontalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_HORIZONTAL);
 606         paint.setStrokeWidth(2.0f);
 607         paint.setAntiAlias(true);
 608         paint.setColor(levelGauge.getLevelColor(horizontalValue));
 609         if ((imageRotationDegrees == 0) || (imageRotationDegrees == 180))
 610         {
 611             // 通常状態
 612             float YY = canvas.getHeight() / 2.0f; // centerY
 613             float diffY = (float) Math.sin(Math.toRadians(horizontalValue)) * (float) centerX;
 614             canvas.drawLine(0, (YY + diffY), width, (YY - diffY), paint);
 615         }
 616         else
 617         {
 618             // 縦持ち状態
 619             float XX = canvas.getWidth() / 2.0f; // centerX
 620             float diffX = (float) Math.sin(Math.toRadians(horizontalValue)) * (float) centerY;
 621             canvas.drawLine((XX + diffX), 0, (XX - diffX), canvas.getHeight(), paint);
 622
 623         }
 624 /*
 625         // 縦と同じ水平線を表示する場合...
 626         float horizontalValue = levelGauge.getLevel(ILevelGauge.LevelArea.LEVEL_HORIZONTAL);
 627         float horizontalSize = horizontalValue / 60.0f * maxBandWidth;  // 45度ぐらいで切り替わるはずだが、一応...
 628         if (Math.abs(horizontalSize) < 1.0f)
 629         {
 630             // 線引き限界以下、水平検出とする (この時の線は倍の長さにする）
 631             horizontalSize = 1.0f;
 632             barWidth = barWidthInitial * 2;
 633         }
 634         else
 635         {
 636             barWidth = barWidthInitial;
 637         }
 638         paint.setStrokeWidth(barWidth);
 639         paint.setColor(levelGauge.getLevelColor(horizontalValue));
 640         canvas.drawLine(centerX, (height - barWidth), (centerX + horizontalSize),  (height - barWidth), paint);
 641 */
 642     }
 643
 644     /**
 645      * 　 画面にメッセージを表示する
 646      */
 647     private void drawInformationMessages(Canvas canvas)
 648     {
 649         String message;
 650         RectF viewRect;
 651         if (imageBitmap != null)
 652         {
 653             // ビットマップの表示エリアに合わせて位置をチューニングする
 654             viewRect = decideViewRect(canvas, imageBitmap, 0);
 655         }
 656         else
 657         {
 658             // 適当なサイズ...
 659             viewRect = new RectF(5.0f, 0.0f, canvas.getWidth() - 5.0f, canvas.getHeight() - 55.0f);
 660         }
 661
 662         // 画面の中心に表示する
 663         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.CENTER);
 664         if ((message != null)&&(message.length() > 0))
 665         {
 666             Paint paint = new Paint();
 667             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.CENTER));
 668             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.CENTER));
 669             paint.setAntiAlias(true);
 670             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 671             float cx = (canvas.getWidth() / 2.0f) - (paint.measureText(message) / 2.0f);
 672             float cy = (canvas.getHeight() / 2.0f) - ((fontMetrics.ascent + fontMetrics.descent) / 2.0f);
 673             canvas.drawText(message, cx, cy, paint);
 674         }
 675
 676         // 画面上部左側に表示する
 677         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPLEFT);
 678         if ((message != null)&&(message.length() > 0))
 679         {
 680             Paint paintUp = new Paint();
 681             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPLEFT));
 682             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPLEFT));
 683             paintUp.setAntiAlias(true);
 684             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 685             canvas.drawText(message, viewRect.left + 3.0f, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 686         }
 687
 688         // 画面上部右側に表示する
 689         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPRIGHT);
 690         if ((message != null)&&(message.length() > 0))
 691         {
 692             Paint paintUp = new Paint();
 693             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPRIGHT));
 694             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPRIGHT));
 695             paintUp.setAntiAlias(true);
 696             float width = paintUp.measureText(message);
 697             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 698             canvas.drawText(message, (viewRect.right - 3.0f) - width, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 699         }
 700
 701         // 画面下部左側に表示する
 702         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWLEFT);
 703         if ((message != null)&&(message.length() > 0))
 704         {
 705             Paint paint = new Paint();
 706             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWLEFT));
 707             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWLEFT));
 708             paint.setAntiAlias(true);
 709             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 710             canvas.drawText(message, viewRect.left + 3.0f, viewRect.bottom - fontMetrics.bottom, paint);
 711         }
 712
 713         // 画面下部右側に表示する
 714         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWRIGHT);
 715         if ((message != null)&&(message.length() > 0))
 716         {
 717             Paint paint = new Paint();
 718             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWRIGHT));
 719             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWRIGHT));
 720             paint.setAntiAlias(true);
 721             float width = paint.measureText(message);
 722             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 723             canvas.drawText(message, (viewRect.right - 3.0f) - width, viewRect.bottom - fontMetrics.bottom, paint);
 724         }
 725
 726 /**/
 727         // 画面上部中央に表示する
 728         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.UPCENTER);
 729         if ((message != null)&&(message.length() > 0))
 730         {
 731             Paint paintUp = new Paint();
 732             paintUp.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.UPCENTER));
 733             paintUp.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.UPCENTER));
 734             paintUp.setAntiAlias(true);
 735             float width = paintUp.measureText(message) / 2.0f;
 736             Paint.FontMetrics fontMetrics = paintUp.getFontMetrics();
 737             canvas.drawText(message, (viewRect.centerX()) - width, viewRect.top + (fontMetrics.descent - fontMetrics.ascent), paintUp);
 738         }
 739
 740         // 画面下部中央に表示する
 741         message = messageHolder.getMessage(ShowMessageHolder.MessageArea.LOWCENTER);
 742         if ((message != null)&&(message.length() > 0))
 743         {
 744             Paint paint = new Paint();
 745             paint.setColor(messageHolder.getColor(ShowMessageHolder.MessageArea.LOWCENTER));
 746             paint.setTextSize(messageHolder.getSize(ShowMessageHolder.MessageArea.LOWCENTER));
 747             paint.setAntiAlias(true);
 748             float width = paint.measureText(message) / 2.0f;
 749             Paint.FontMetrics fontMetrics = paint.getFontMetrics();
 750             canvas.drawText(message, (viewRect.centerX()) - width, viewRect.bottom - fontMetrics.bottom, paint);
 751         }
 752 /**/
 753     }
 754
 755     /**
 756      * Converts a point on image area to a point on view area.
 757      *
 758      * @param point A point on image area. (e.g. a live preview image)
 759      * @return A point on view area. (e.g. a touch panel view)
 760      */
 761     private PointF convertPointFromImageArea(PointF point) {
 762         if (imageBitmap == null) {
 763             return new PointF();
 764         }
 765
 766         float viewPointX = point.x;
 767         float viewPointY = point.y;
 768         float imageSizeWidth;
 769         float imageSizeHeight;
 770         if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 771             imageSizeWidth = imageBitmap.getWidth();
 772             imageSizeHeight = imageBitmap.getHeight();
 773         } else {
 774             imageSizeWidth = imageBitmap.getHeight();
 775             imageSizeHeight = imageBitmap.getWidth();
 776         }
 777         float viewSizeWidth = this.getWidth();
 778         float viewSizeHeight = this.getHeight();
 779         float ratioX = viewSizeWidth / imageSizeWidth;
 780         float ratioY = viewSizeHeight / imageSizeHeight;
 781         float scale;
 782
 783         switch (imageScaleType) {
 784             case FIT_XY:
 785                 viewPointX *= ratioX;
 786                 viewPointY *= ratioY;
 787                 break;
 788             case FIT_CENTER:    // go to next label.
 789             case CENTER_INSIDE:
 790                 scale = Math.min(ratioX, ratioY);
 791                 viewPointX *= scale;
 792                 viewPointY *= scale;
 793                 viewPointX += (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 794                 viewPointY += (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 795                 break;
 796             case CENTER_CROP:
 797                 scale = Math.max(ratioX, ratioY);
 798                 viewPointX *= scale;
 799                 viewPointY *= scale;
 800                 viewPointX += (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 801                 viewPointY += (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 802                 break;
 803             case CENTER:
 804                 viewPointX += viewSizeWidth / 2.0 - imageSizeWidth / 2.0f;
 805                 viewPointY += viewSizeHeight / 2.0 - imageSizeHeight / 2.0f;
 806                 break;
 807             default:
 808                 break;
 809         }
 810         return new PointF(viewPointX, viewPointY);
 811     }
 812
 813     /**
 814      * Converts a point on view area to a point on image area.
 815      *
 816      * @param point A point on view area. (e.g. a touch panel view)
 817      * @return A point on image area. (e.g. a live preview image)
 818      */
 819     private PointF convertPointFromViewArea(PointF point) {
 820         if (imageBitmap == null) {
 821             return new PointF();
 822         }
 823
 824         float imagePointX = point.x;
 825         float imagePointY = point.y;
 826         float imageSizeWidth;
 827         float imageSizeHeight;
 828         if (imageRotationDegrees == 0 || imageRotationDegrees == 180) {
 829             imageSizeWidth = imageBitmap.getWidth();
 830             imageSizeHeight = imageBitmap.getHeight();
 831         } else {
 832             imageSizeWidth = imageBitmap.getHeight();
 833             imageSizeHeight = imageBitmap.getWidth();
 834         }
 835         float viewSizeWidth = this.getWidth();
 836         float viewSizeHeight = this.getHeight();
 837         float ratioX = viewSizeWidth / imageSizeWidth;
 838         float ratioY = viewSizeHeight / imageSizeHeight;
 839         float scale;
 840
 841         switch (imageScaleType) {
 842             case FIT_XY:
 843                 imagePointX /= ratioX;
 844                 imagePointY /= ratioY;
 845                 break;
 846             case FIT_CENTER:    // go to next label.
 847             case CENTER_INSIDE:
 848                 scale = Math.min(ratioX, ratioY);
 849                 imagePointX -= (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 850                 imagePointY -= (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 851                 imagePointX /= scale;
 852                 imagePointY /= scale;
 853                 break;
 854             case CENTER_CROP:
 855                 scale = Math.max(ratioX, ratioY);
 856                 imagePointX -= (viewSizeWidth - imageSizeWidth * scale) / 2.0f;
 857                 imagePointY -= (viewSizeHeight - imageSizeHeight * scale) / 2.0f;
 858                 imagePointX /= scale;
 859                 imagePointY /= scale;
 860                 break;
 861             case CENTER:
 862                 imagePointX -= (viewSizeWidth - imageSizeWidth) / 2.0f;
 863                 imagePointY -= (viewSizeHeight - imageSizeHeight) / 2.0f;
 864                 break;
 865             default:
 866                 break;
 867         }
 868         return new PointF(imagePointX, imagePointY);
 869     }
 870
 871     /**
 872      * Converts a rectangle on image area to a rectangle on view area.
 873      *
 874      * @param rect A rectangle on image area. (e.g. a live preview image)
 875      * @return A rectangle on view area. (e.g. a touch panel view)
 876      */
 877     private RectF convertRectFromImageArea(RectF rect)
 878     {
 879         if (imageBitmap == null)
 880         {
 881             return new RectF();
 882         }
 883
 884         PointF imageTopLeft = new PointF(rect.left, rect.top);
 885         PointF imageBottomRight = new PointF(rect.right, rect.bottom);
 886
 887         PointF viewTopLeft = convertPointFromImageArea(imageTopLeft);
 888         PointF viewBottomRight = convertPointFromImageArea(imageBottomRight);
 889
 890         return (new RectF(viewTopLeft.x, viewTopLeft.y, viewBottomRight.x, viewBottomRight.y));
 891     }
 892
 893     /**
 894      *
 895      *
 896      */
 897     public void setShowGridFrame(boolean isShowGridFeature)
 898     {
 899         showGridFeature = isShowGridFeature;
 900         SharedPreferences preferences = android.support.v7.preference.PreferenceManager.getDefaultSharedPreferences(getContext());
 901         SharedPreferences.Editor editor = preferences.edit();
 902         editor.putBoolean(ICameraPropertyAccessor.SHOW_GRID_STATUS, showGridFeature);
 903         editor.apply();
 904     }
 905
 906     /**
 907      *
 908      *
 909      */
 910     @Override
 911     public void toggleShowGridFrame()
 912     {
 913         setShowGridFrame(!showGridFeature);
 914     }
 915
 916     /**
 917      *
 918      *
 919      */
 920     public void setShowLevelGauge(boolean isShowLevelGaugeFeature)
 921     {
 922         Log.v(TAG, "setShowLevelGauge : " + isShowLevelGaugeFeature);
 923         showLevelGaugeFeature = isShowLevelGaugeFeature;
 924         SharedPreferences preferences = android.support.v7.preference.PreferenceManager.getDefaultSharedPreferences(getContext());
 925         SharedPreferences.Editor editor = preferences.edit();
 926         editor.putBoolean(ICameraPropertyAccessor.SHOW_LEVEL_GAUGE_STATUS, showLevelGaugeFeature);
 927         editor.apply();
 928         ILevelGauge levelGauge = messageHolder.getLevelGauge();
 929         if (levelGauge == null)
 930         {
 931             // デジタル水準器がとれない場合は、何もしない
 932             Log.v(TAG, "setShowLevelGauge : levelGauge is null.");
 933             return;
 934         }
 935         levelGauge.updateLevelGaugeChecking(isShowLevelGaugeFeature);
 936     }
 937
 938     /**
 939      *
 940      *
 941      */
 942     @Override
 943     public void toggleShowLevelGauge()
 944     {
 945         setShowLevelGauge(!showLevelGaugeFeature);
 946     }
 947
 948     /**
 949      *
 950      *
 951      */
 952     @Override
 953     public boolean isShowLevelGauge()
 954     {
 955         return (showLevelGaugeFeature);
 956     }
 957
 958     /**
 959      *
 960      *
 961      */
 962     @Override
 963     public boolean isShowGrid()
 964     {
 965         return (showGridFeature);
 966     }
 967
 968
 969     /**
 970      *
 971      *
 972      */
 973     public IMessageDrawer getMessageDrawer()
 974     {
 975         return (messageHolder);
 976     }
 977 }