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

   1 package net.osdn.gokigen.cameratest.fuji;
   2
   3 import android.app.Activity;
   4 import android.graphics.PointF;
   5 import android.util.Log;
   6
   7 import androidx.annotation.NonNull;
   8
   9 import net.osdn.gokigen.cameratest.fuji.statuses.FujiStatusChecker;
  10 import net.osdn.gokigen.cameratest.fuji.statuses.IFujiStatusNotify;
  11 import net.osdn.gokigen.cameratest.fuji.statuses.IFujiStatusRequest;
  12
  13 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraProperties.FILM_SIMULATION;
  14 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraProperties.IMAGE_ASPECT;
  15 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraPropertyValues.FILM_SIMULATION_MAX;
  16 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraPropertyValues.FILM_SIMULATION_MIN;
  17 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraPropertyValues.IMAGE_ASPECT_MAX;
  18 import static net.osdn.gokigen.cameratest.fuji.statuses.IFujiCameraPropertyValues.IMAGE_ASPECT_MIN;
  19
  20 public class Connection implements IFujiStatusRequest
  21 {
  22     private final String TAG = toString();
  23     private final MessageSequence sequence;
  24     private final Communication comm;
  25     private final FujiStatusChecker statusChecker;
  26     private boolean pauseRequestStatus = false;
  27
  28     public Connection(@NonNull Activity activity, @NonNull ILiveViewImage imageViewer, @NonNull IFujiStatusNotify notify)
  29     {
  30         this.comm = new Communication(activity, imageViewer);
  31         this.sequence = new MessageSequence();
  32         this.statusChecker = new FujiStatusChecker(this, notify);
  33     }
  34
  35     public boolean start_connect(boolean isBothLiveView)
  36     {
  37         boolean ret = false;
  38
  39         if (connect_to_camera(isBothLiveView))
  40         {
  41             ret = requestStatus();
  42             if (ret)
  43             {
  44                 // 定期監視の開始
  45                 statusChecker.start();
  46             }
  47         }
  48         return (ret);
  49     }
  50
  51     private boolean connect_to_camera(boolean isBothLiveView)
  52     {
  53         try
  54         {
  55             ReceivedDataHolder rx_bytes;
  56             comm.connect_socket();
  57
  58             comm.send_to_camera(sequence.registration_message(), false, false);
  59             rx_bytes = comm.receive_from_camera();
  60             dump_bytes(0, rx_bytes);
  61             Thread.sleep(50);
  62
  63             // 応答エラーかどうかをチェックする
  64             if (rx_bytes.getData().length == 8)
  65             {
  66                 byte[] receiveData = rx_bytes.getData();
  67                 if ((receiveData[0] == 0x05)&&(receiveData[1] == 0x00)&&(receiveData[2] == 0x00)&&(receiveData[3] == 0x00)&&
  68                     (receiveData[4] == 0x19)&&(receiveData[5] == 0x20)&&(receiveData[6] == 0x00)&&(receiveData[7] == 0x00))
  69                 {
  70                     // 応答エラー...
  71                     return (false);
  72                 }
  73                 return (false);
  74             }
  75
  76             // start_messageを送信
  77             comm.send_to_camera(sequence.start_message(), true, true);
  78             rx_bytes = comm.receive_from_camera();
  79             dump_bytes(1, rx_bytes);
  80             Thread.sleep(50);
  81
  82             //  なんだろう？？ (送信が必要なようだが）
  83             comm.send_to_camera(sequence.start_message2(), true, true);
  84             rx_bytes = comm.receive_from_camera();
  85             dump_bytes(2, rx_bytes);
  86             Thread.sleep(50);
  87
  88             // two_part messageを発行 (その１)
  89             comm.send_to_camera(sequence.start_message3_1(), true, true);
  90             rx_bytes = comm.receive_from_camera();
  91             dump_bytes(3, rx_bytes);
  92             Thread.sleep(50);
  93
  94             if (rx_bytes.getData().length <= 50)
  95             {
  96                 // two_part messageを発行 (その２)
  97                 comm.send_to_camera(sequence.start_message3_2(), false, false);
  98                 rx_bytes = comm.receive_from_camera();
  99                 dump_bytes(4, rx_bytes);
 100                 Thread.sleep(50);
 101             }
 102
 103             // remote mode
 104             comm.send_to_camera(sequence.start_message4(), true, true);
 105             rx_bytes = comm.receive_from_camera();
 106             dump_bytes(5, rx_bytes);
 107             Thread.sleep(50);
 108
 109             if (!isBothLiveView)
 110             {
 111                 // two_part messageを発行 (その１)
 112                 comm.send_to_camera(sequence.start_message5_1(), true, false);
 113                 rx_bytes = comm.receive_from_camera();
 114                 dump_bytes(6, rx_bytes);
 115                 Thread.sleep(50);
 116
 117                 // two_part messageを発行 (その２)
 118                 comm.send_to_camera(sequence.start_message5_2(), true, true);
 119                 rx_bytes = comm.receive_from_camera();
 120                 dump_bytes(7, rx_bytes);
 121                 Thread.sleep(50);
 122
 123                 // ????
 124                 comm.send_to_camera(sequence.start_message6(), true, true);
 125                 rx_bytes = comm.receive_from_camera();
 126                 dump_bytes(8, rx_bytes);
 127                 Thread.sleep(50);
 128
 129                 // ????
 130                 comm.send_to_camera(sequence.query_camera_capabilities(), true, true);
 131                 rx_bytes = comm.receive_from_camera();
 132                 dump_bytes(9, rx_bytes);
 133                 Thread.sleep(50);
 134
 135                 // ????
 136                 comm.send_to_camera(sequence.start_message8(), true, true);
 137                 rx_bytes = comm.receive_from_camera();
 138                 dump_bytes(10, rx_bytes);
 139                 Thread.sleep(50);
 140             }
 141
 142             // リモート制御の開始！
 143             comm.send_to_camera(sequence.camera_remote_message(), true, true);
 144
 145             // 応答OKの場合は、8バイト ({0x03, 0x00, 0x01, 0x20} + {0x10, 0x02, 0x00, 0x00} )が応答されるはず
 146             rx_bytes = comm.receive_from_camera();
 147             dump_bytes(11, rx_bytes);
 148             Thread.sleep(150);
 149
 150
 151             // 別のポートもオープンして動作を行う。 (1500ms程度待つといけるみたいだ...)
 152             Thread.sleep(2000);
 153             comm.start_stream();
 154             comm.start_response();
 155
 156             Log.v(TAG, "connect_to_camera DONE.");
 157             return (true);
 158         }
 159         catch (Exception e)
 160         {
 161             e.printStackTrace();
 162         }
 163         return (false);
 164     }
 165
 166     public void reset_to_camera()
 167     {
 168         try
 169         {
 170             comm.send_to_camera(sequence.reset_message(), true, true);
 171             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 172             dump_bytes(0, rx_bytes);
 173             statusChecker.stop();
 174             Thread.sleep(150);
 175         }
 176         catch (Exception e)
 177         {
 178             e.printStackTrace();
 179         }
 180     }
 181
 182     public void disconnect()
 183     {
 184         try
 185         {
 186             statusChecker.stop();
 187         }
 188         catch (Exception e)
 189         {
 190             e.printStackTrace();
 191         }
 192         try
 193         {
 194             comm.stop_stream();
 195         }
 196         catch (Exception e)
 197         {
 198             e.printStackTrace();
 199         }
 200         try
 201         {
 202             comm.stop_response();
 203         }
 204         catch (Exception e)
 205         {
 206             e.printStackTrace();
 207         }
 208         try
 209         {
 210             comm.disconnect_socket();
 211         }
 212         catch (Exception e)
 213         {
 214             e.printStackTrace();
 215         }
 216     }
 217
 218     @Override
 219     public boolean requestStatus()
 220     {
 221         if (pauseRequestStatus)
 222         {
 223             // ステータス更新を一時停止する。
 224             return (false);
 225         }
 226         try
 227         {
 228             comm.send_to_camera(sequence.status_request_message(), true, true);
 229             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 230             if (rx_bytes.getData().length > 0)
 231             {
 232                 // 受信したステータス情報を渡す
 233                 statusChecker.statusReceived(rx_bytes);
 234             }
 235             dump_bytes(12, rx_bytes);
 236
 237             return (true);
 238         }
 239         catch (Exception e)
 240         {
 241             e.printStackTrace();
 242         }
 243         return (false);
 244     }
 245
 246     private void dump_bytes(int indexNumber, ReceivedDataHolder data)
 247     {
 248         int index = 0;
 249         StringBuffer message;
 250         message = new StringBuffer();
 251         for (byte item : data.getData())
 252         {
 253             index++;
 254             message.append(String.format("%02x ", item));
 255             if (index >= 8)
 256             {
 257                 Log.v(TAG, " RX [" + indexNumber + "] " + message);
 258                 index = 0;
 259                 message = new StringBuffer();
 260             }
 261         }
 262         if (index != 0)
 263         {
 264             Log.v(TAG, " RX [" + indexNumber + "] "  + message);
 265         }
 266         System.gc();
 267     }
 268
 269     public boolean execute_focus_point(PointF point)
 270     {
 271         try
 272         {
 273             byte x = (byte) (0x000000ff & Math.round(point.x));
 274             byte y = (byte) (0x000000ff & Math.round(point.y));
 275             Log.v(TAG, "DRIVE AF (" + x + "," + y + ")");
 276
 277             comm.send_to_camera(sequence.execute_focus_lock(x, y), true, true);
 278
 279             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 280             dump_bytes(16, rx_bytes);
 281         }
 282         catch (Exception e)
 283         {
 284             e.printStackTrace();
 285         }
 286         return (false);
 287     }
 288
 289     public boolean execute_change_film_simulation()
 290     {
 291         try
 292         {
 293             // 現在の値を入手
 294             int currentValue = statusChecker.getValue(FILM_SIMULATION);
 295             currentValue++;
 296             if (currentValue > FILM_SIMULATION_MAX)
 297             {
 298                 currentValue = FILM_SIMULATION_MIN;
 299             }
 300             return (updateProperty(FILM_SIMULATION, currentValue, true));
 301         }
 302         catch (Exception e)
 303         {
 304             e.printStackTrace();
 305         }
 306         return (false);
 307     }
 308
 309     public boolean execute_change_image_aspect()
 310     {
 311         try
 312         {
 313             // 現在の値を入手
 314             int currentValue = statusChecker.getValue(IMAGE_ASPECT);
 315             currentValue++;
 316             if (currentValue > IMAGE_ASPECT_MAX)
 317             {
 318                 currentValue = IMAGE_ASPECT_MIN;
 319             }
 320             return (updateProperty(IMAGE_ASPECT, currentValue, true));
 321         }
 322         catch (Exception e)
 323         {
 324             e.printStackTrace();
 325         }
 326         return (false);
 327     }
 328
 329     public boolean execute_query_camera_capability()
 330     {
 331         pauseRequestStatus = true;
 332         try
 333         {
 334             comm.send_to_camera(sequence.query_camera_capabilities(), true, true);
 335             Thread.sleep(50);
 336             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 337             dump_bytes(21, rx_bytes);
 338         }
 339         catch (Exception e)
 340         {
 341             e.printStackTrace();
 342         }
 343         pauseRequestStatus = false;
 344         return (false);
 345     }
 346
 347
 348     public boolean execute_unlock_focus()
 349     {
 350         try
 351         {
 352             comm.send_to_camera(sequence.execute_focus_unlock(), true, true);
 353
 354             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 355             dump_bytes(17, rx_bytes);
 356         }
 357         catch (Exception e)
 358         {
 359             e.printStackTrace();
 360         }
 361         return (false);
 362     }
 363
 364     public boolean execute_shutter()
 365     {
 366         try
 367         {
 368             comm.send_to_camera(sequence.execute_shutter_message(), true, true);
 369
 370             ReceivedDataHolder rx_bytes = comm.receive_from_camera();
 371             dump_bytes(14, rx_bytes);
 372         }
 373         catch (Exception e)
 374         {
 375             e.printStackTrace();
 376         }
 377         return (false);
 378     }
 379
 380     private boolean updateProperty(int commandCode, int setValue, boolean isShort)
 381     {
 382         pauseRequestStatus = true;
 383         ReceivedDataHolder rx_bytes;
 384         try {
 385             byte high = (byte) ((0x0000ff00 & commandCode) >> 8);
 386             byte low = (byte) (0x000000ff & commandCode);
 387
 388             byte data0 = (byte)((0xff000000 & setValue) >> 24);
 389             byte data1 = (byte)((0x00ff0000 & setValue) >> 16);
 390             byte data2 = (byte)((0x0000ff00 & setValue) >> 8);
 391             byte data3 = (byte)((0x000000ff & setValue));
 392
 393             // two_part messageを発行 (その１)
 394             comm.send_to_camera(sequence.update_property_1(high, low), true, false);
 395             Thread.sleep(50);
 396             rx_bytes = comm.receive_from_camera();
 397             dump_bytes(19, rx_bytes);
 398 /*
 399             // two_part messageを発行 (その１)  :  ダミーでもう一発...!
 400             comm.send_to_camera(sequence.update_property_1(high, low), true, false);
 401             Thread.sleep(50);
 402             rx_bytes = comm.receive_from_camera();
 403             dump_bytes(15, rx_bytes);
 404 */
 405             // two_part messageを発行 (その２)
 406             comm.send_to_camera((isShort) ? sequence.update_property_2(data2, data3) : sequence.update_property_2(data0, data1, data2, data3), true, true);
 407             Thread.sleep(50);
 408             rx_bytes = comm.receive_from_camera();
 409             dump_bytes(20, rx_bytes);
 410         }
 411         catch (Exception e)
 412         {
 413             e.printStackTrace();
 414         }
 415         pauseRequestStatus = false;
 416         return (false);
 417     }
 418 }