app/src/main/java/net/osdn/gokigen/cameratest/fuji/Connection.java

   1 package net.osdn.gokigen.cameratest.fuji;
   2
   3 import android.graphics.PointF;
   4 import android.util.Log;
   5
   6 import androidx.annotation.NonNull;
   7
   8 import net.osdn.gokigen.cameratest.fuji.statuses.FujiStatusChecker;
   9 import net.osdn.gokigen.cameratest.fuji.statuses.IFujiStatusNotify;
  10 import net.osdn.gokigen.cameratest.fuji.statuses.IFujiStatusRequest;
  11
  12 public class Connection implements IFujiStatusRequest
  13 {
  14     private final String TAG = toString();
  15     private final MessageSequence sequence;
  16     private final Communication comm;
  17     private final FujiStatusChecker statusChecker;
  18
  19     public Connection(@NonNull ILiveViewImage imageViewer, @NonNull IFujiStatusNotify notify)
  20     {
  21         this.comm = new Communication(imageViewer);
  22         this.sequence = new MessageSequence();
  23         this.statusChecker = new FujiStatusChecker(this, notify);
  24     }
  25
  26     public boolean start_connect()
  27     {
  28         boolean ret = false;
  29
  30         if (connect_to_camera())
  31         {
  32             ret = requestStatus();
  33             if (ret)
  34             {
  35                 // 定期監視の開始
  36                 statusChecker.start();
  37             }
  38         }
  39         return (ret);
  40     }
  41
  42     private boolean connect_to_camera()
  43     {
  44         try
  45         {
  46             ReceivedDataHolder rx_bytes;
  47             comm.connect_socket();
  48
  49             comm.send_to_camera(sequence.registration_message(), false);
  50             rx_bytes = comm.receive_from_camera();
  51             dump_bytes(0, rx_bytes);
  52             Thread.sleep(50);
  53
  54             // 応答エラーかどうかをチェックする
  55             if (rx_bytes.getData().length == 8)
  56             {
  57                 byte[] receiveData = rx_bytes.getData();
  58                 if ((receiveData[0] == 0x05)&&(receiveData[1] == 0x00)&&(receiveData[2] == 0x00)&&(receiveData[3] == 0x00)&&
  59                     (receiveData[4] == 0x19)&&(receiveData[5] == 0x20)&&(receiveData[6] == 0x00)&&(receiveData[7] == 0x00))
  60                 {
  61                     // 応答エラー...
  62                     return (false);
  63                 }
  64                 return (false);
  65             }
  66
  67             // start_messageを送信
  68             comm.send_to_camera(sequence.start_message(), true);
  69             rx_bytes = comm.receive_from_camera();
  70             dump_bytes(1, rx_bytes);
  71             Thread.sleep(50);
  72
  73 /**/
  74             //  なんだろう？？ (送信が必要なようだが）
  75             comm.send_to_camera(sequence.start_message2(), true);
  76             rx_bytes = comm.receive_from_camera();
  77             dump_bytes(2, rx_bytes);
  78             Thread.sleep(50);
  79 /**/
  80 /**/
  81             // two_part messageを発行 (その１)
  82             comm.send_to_camera(sequence.start_message3_1(), true);
  83             rx_bytes = comm.receive_from_camera();
  84             dump_bytes(3, rx_bytes);
  85             Thread.sleep(50);
  86
  87             // two_part messageを発行 (その２)
  88             comm.send_to_camera(sequence.start_message3_2(), false);
  89             rx_bytes = comm.receive_from_camera();
  90             dump_bytes(4, rx_bytes);
  91             Thread.sleep(50);
  92 /**/
  93
  94 /**/
  95             // remote mode
  96             comm.send_to_camera(sequence.start_message4(), true);
  97             rx_bytes = comm.receive_from_camera();
  98             dump_bytes(5, rx_bytes);
  99             Thread.sleep(50);
 100 /**/
 101 /**/
 102             // two_part messageを発行 (その１)
 103             comm.send_to_camera(sequence.start_message5_1(), true);
 104             rx_bytes = comm.receive_from_camera();
 105             dump_bytes(6, rx_bytes);
 106             Thread.sleep(50);
 107
 108             // two_part messageを発行 (その２)
 109             comm.send_to_camera(sequence.start_message5_2(), false);
 110             rx_bytes = comm.receive_from_camera();
 111             dump_bytes(7, rx_bytes);
 112             Thread.sleep(50);
 113 /**/
 114 /**/
 115             // ????
 116             comm.send_to_camera(sequence.start_message6(), true);
 117             rx_bytes = comm.receive_from_camera();
 118             dump_bytes(8, rx_bytes);
 119             Thread.sleep(50);
 120
 121             // ????
 122             comm.send_to_camera(sequence.start_message7(), true);
 123             rx_bytes = comm.receive_from_camera();
 124             dump_bytes(9, rx_bytes);
 125             Thread.sleep(50);
 126 /**/
 127 /**/
 128             // ????
 129             comm.send_to_camera(sequence.start_message8(), true);
 130             rx_bytes = comm.receive_from_camera();
 131             dump_bytes(10, rx_bytes);
 132             Thread.sleep(50);
 133 /**/
 134             // リモート制御の開始！
 135             comm.send_to_camera(sequence.camera_remote_message(), true);
 136
 137             // 応答OKの場合は、8バイト ({0x03, 0x00, 0x01, 0x20} + {0x10, 0x02, 0x00, 0x00} )が応答されるはず
 138             rx_bytes = comm.receive_from_camera();
 139             dump_bytes(11, rx_bytes);
 140             Thread.sleep(150);
 141
 142
 143             // 別のポートもオープンして動作を行う。 (1500ms程度待つといけるみたいだ...)
 144             Thread.sleep(2000);
 145             comm.start_stream();
 146             comm.start_response();
 147
 148             Log.v(TAG, "connect_to_camera DONE.");
 149             return (true);
 150         }
 151         catch (Exception e)
 152         {
 153             e.printStackTrace();
 154         }
 155         return (false);
 156     }
 157
 158     public void reset_to_camera()
 159     {
 160         try
 161         {
 162             comm.send_to_camera(sequence.reset_message(), true);
 163             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 164             dump_bytes(0, rx_bytes);
 165             statusChecker.stop();
 166             Thread.sleep(150);
 167         }
 168         catch (Exception e)
 169         {
 170             e.printStackTrace();
 171         }
 172     }
 173
 174     public void disconnect()
 175     {
 176         try
 177         {
 178             statusChecker.stop();
 179         }
 180         catch (Exception e)
 181         {
 182             e.printStackTrace();
 183         }
 184         try
 185         {
 186             comm.stop_stream();
 187         }
 188         catch (Exception e)
 189         {
 190             e.printStackTrace();
 191         }
 192         try
 193         {
 194             comm.stop_response();
 195         }
 196         catch (Exception e)
 197         {
 198             e.printStackTrace();
 199         }
 200         try
 201         {
 202             comm.disconnect_socket();
 203         }
 204         catch (Exception e)
 205         {
 206             e.printStackTrace();
 207         }
 208     }
 209
 210     @Override
 211     public boolean requestStatus()
 212     {
 213         try
 214         {
 215             comm.send_to_camera(sequence.status_request_message(), true);
 216             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 217             if (rx_bytes.getData().length > 0)
 218             {
 219                 // 受信したステータス情報を渡す
 220                 statusChecker.statusReceived(rx_bytes);
 221             }
 222             dump_bytes(12, rx_bytes);
 223
 224             return (true);
 225         }
 226         catch (Exception e)
 227         {
 228             e.printStackTrace();
 229         }
 230         return (false);
 231     }
 232
 233     private void dump_bytes(int indexNumber, ReceivedDataHolder data)
 234     {
 235         int index = 0;
 236         StringBuffer message;
 237         message = new StringBuffer();
 238         for (byte item : data.getData())
 239         {
 240             index++;
 241             message.append(String.format("%02x ", item));
 242             if (index >= 8)
 243             {
 244                 Log.v(TAG, " RX [" + indexNumber + "] " + message);
 245                 index = 0;
 246                 message = new StringBuffer();
 247             }
 248         }
 249         if (index != 0)
 250         {
 251             Log.v(TAG, " RX [" + indexNumber + "] "  + message);
 252         }
 253         System.gc();
 254     }
 255
 256     public boolean execute_focus_point(PointF point)
 257     {
 258         try
 259         {
 260             byte x = (byte) (0x000000ff & Math.round(point.x));
 261             byte y = (byte) (0x000000ff & Math.round(point.y));
 262             Log.v(TAG, "DRIVE AF (" + x + "," + y + ")");
 263
 264             comm.send_to_camera(sequence.execute_focus_lock(x, y), true);
 265
 266             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 267             dump_bytes(16, rx_bytes);
 268         }
 269         catch (Exception e)
 270         {
 271             e.printStackTrace();
 272         }
 273         return (false);
 274     }
 275
 276     public boolean execute_unlock_focus()
 277     {
 278         try
 279         {
 280             comm.send_to_camera(sequence.execute_focus_unlock(), true);
 281
 282             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 283             dump_bytes(17, rx_bytes);
 284         }
 285         catch (Exception e)
 286         {
 287             e.printStackTrace();
 288         }
 289         return (false);
 290     }
 291
 292     public boolean execute_shutter()
 293     {
 294         try
 295         {
 296             comm.send_to_camera(sequence.execute_shutter_message(), true);
 297
 298             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 299             dump_bytes(14, rx_bytes);
 300         }
 301         catch (Exception e)
 302         {
 303             e.printStackTrace();
 304         }
 305         return (false);
 306     }
 307 }