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(boolean isBothLiveView)
  27     {
  28         boolean ret = false;
  29
  30         if (connect_to_camera(isBothLiveView))
  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(boolean isBothLiveView)
  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             comm.send_to_camera(sequence.start_message2(), true);
  75             rx_bytes = comm.receive_from_camera();
  76             dump_bytes(2, rx_bytes);
  77             Thread.sleep(50);
  78
  79             // two_part messageを発行 (その１)
  80             comm.send_to_camera(sequence.start_message3_1(), true);
  81             rx_bytes = comm.receive_from_camera();
  82             dump_bytes(3, rx_bytes);
  83             Thread.sleep(50);
  84
  85             if (rx_bytes.getData().length <= 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             // remote mode
  95             comm.send_to_camera(sequence.start_message4(), true);
  96             rx_bytes = comm.receive_from_camera();
  97             dump_bytes(5, rx_bytes);
  98             Thread.sleep(50);
  99
 100             if (!isBothLiveView)
 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                 comm.send_to_camera(sequence.start_message6(), true);
 116                 rx_bytes = comm.receive_from_camera();
 117                 dump_bytes(8, rx_bytes);
 118                 Thread.sleep(50);
 119
 120                 // ????
 121                 comm.send_to_camera(sequence.start_message7(), true);
 122                 rx_bytes = comm.receive_from_camera();
 123                 dump_bytes(9, rx_bytes);
 124                 Thread.sleep(50);
 125
 126                 // ????
 127                 comm.send_to_camera(sequence.start_message8(), true);
 128                 rx_bytes = comm.receive_from_camera();
 129                 dump_bytes(10, rx_bytes);
 130                 Thread.sleep(50);
 131             }
 132
 133             // リモート制御の開始！
 134             comm.send_to_camera(sequence.camera_remote_message(), true);
 135
 136             // 応答OKの場合は、8バイト ({0x03, 0x00, 0x01, 0x20} + {0x10, 0x02, 0x00, 0x00} )が応答されるはず
 137             rx_bytes = comm.receive_from_camera();
 138             dump_bytes(11, rx_bytes);
 139             Thread.sleep(150);
 140
 141
 142             // 別のポートもオープンして動作を行う。 (1500ms程度待つといけるみたいだ...)
 143             Thread.sleep(2000);
 144             comm.start_stream();
 145             comm.start_response();
 146
 147             Log.v(TAG, "connect_to_camera DONE.");
 148             return (true);
 149         }
 150         catch (Exception e)
 151         {
 152             e.printStackTrace();
 153         }
 154         return (false);
 155     }
 156
 157     public void reset_to_camera()
 158     {
 159         try
 160         {
 161             comm.send_to_camera(sequence.reset_message(), true);
 162             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 163             dump_bytes(0, rx_bytes);
 164             statusChecker.stop();
 165             Thread.sleep(150);
 166         }
 167         catch (Exception e)
 168         {
 169             e.printStackTrace();
 170         }
 171     }
 172
 173     public void disconnect()
 174     {
 175         try
 176         {
 177             statusChecker.stop();
 178         }
 179         catch (Exception e)
 180         {
 181             e.printStackTrace();
 182         }
 183         try
 184         {
 185             comm.stop_stream();
 186         }
 187         catch (Exception e)
 188         {
 189             e.printStackTrace();
 190         }
 191         try
 192         {
 193             comm.stop_response();
 194         }
 195         catch (Exception e)
 196         {
 197             e.printStackTrace();
 198         }
 199         try
 200         {
 201             comm.disconnect_socket();
 202         }
 203         catch (Exception e)
 204         {
 205             e.printStackTrace();
 206         }
 207     }
 208
 209     @Override
 210     public boolean requestStatus()
 211     {
 212         try
 213         {
 214             comm.send_to_camera(sequence.status_request_message(), true);
 215             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 216             if (rx_bytes.getData().length > 0)
 217             {
 218                 // 受信したステータス情報を渡す
 219                 statusChecker.statusReceived(rx_bytes);
 220             }
 221             dump_bytes(12, rx_bytes);
 222
 223             return (true);
 224         }
 225         catch (Exception e)
 226         {
 227             e.printStackTrace();
 228         }
 229         return (false);
 230     }
 231
 232     private void dump_bytes(int indexNumber, ReceivedDataHolder data)
 233     {
 234         int index = 0;
 235         StringBuffer message;
 236         message = new StringBuffer();
 237         for (byte item : data.getData())
 238         {
 239             index++;
 240             message.append(String.format("%02x ", item));
 241             if (index >= 8)
 242             {
 243                 Log.v(TAG, " RX [" + indexNumber + "] " + message);
 244                 index = 0;
 245                 message = new StringBuffer();
 246             }
 247         }
 248         if (index != 0)
 249         {
 250             Log.v(TAG, " RX [" + indexNumber + "] "  + message);
 251         }
 252         System.gc();
 253     }
 254
 255     public boolean execute_focus_point(PointF point)
 256     {
 257         try
 258         {
 259             byte x = (byte) (0x000000ff & Math.round(point.x));
 260             byte y = (byte) (0x000000ff & Math.round(point.y));
 261             Log.v(TAG, "DRIVE AF (" + x + "," + y + ")");
 262
 263             comm.send_to_camera(sequence.execute_focus_lock(x, y), true);
 264
 265             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 266             dump_bytes(16, rx_bytes);
 267         }
 268         catch (Exception e)
 269         {
 270             e.printStackTrace();
 271         }
 272         return (false);
 273     }
 274
 275     public boolean execute_unlock_focus()
 276     {
 277         try
 278         {
 279             comm.send_to_camera(sequence.execute_focus_unlock(), true);
 280
 281             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 282             dump_bytes(17, rx_bytes);
 283         }
 284         catch (Exception e)
 285         {
 286             e.printStackTrace();
 287         }
 288         return (false);
 289     }
 290
 291     public boolean execute_shutter()
 292     {
 293         try
 294         {
 295             comm.send_to_camera(sequence.execute_shutter_message(), true);
 296
 297             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 298             dump_bytes(14, rx_bytes);
 299         }
 300         catch (Exception e)
 301         {
 302             e.printStackTrace();
 303         }
 304         return (false);
 305     }
 306
 307     public boolean updateProperty(int commandCode, int setValue)
 308     {
 309         ReceivedDataHolder rx_bytes;
 310         try {
 311             byte high = (byte) ((0x0000ff00 & commandCode) >> 8);
 312             byte low = (byte) (0x000000ff & commandCode);
 313
 314             byte data0 = (byte)((0xff000000 & setValue) >> 24);
 315             byte data1 = (byte)((0x00ff0000 & setValue) >> 16);
 316             byte data2 = (byte)((0x0000ff00 & setValue) >> 8);
 317             byte data3 = (byte)((0x000000ff & setValue));
 318
 319             // two_part messageを発行 (その１)
 320             comm.send_to_camera(sequence.update_property_1(high, low), true);
 321             rx_bytes = comm.receive_from_camera();
 322             dump_bytes(15, rx_bytes);
 323             Thread.sleep(50);
 324
 325             // two_part messageを発行 (その２)
 326             comm.send_to_camera(sequence.update_property_2(data0, data1, data2, data3), false);
 327             rx_bytes = comm.receive_from_camera();
 328             dump_bytes(16, rx_bytes);
 329         }
 330         catch (Exception e)
 331         {
 332             e.printStackTrace();
 333         }
 334         return (false);
 335     }
 336 }