app/src/main/java/net/osdn/gokigen/gr2control/camera/ricohgr2/wrapper/connection/RicohGr2Connection.java

   1 package net.osdn.gokigen.gr2control.camera.ricohgr2.wrapper.connection;
   2
   3 import android.content.BroadcastReceiver;
   4 import android.content.Context;
   5 import android.content.DialogInterface;
   6 import android.content.Intent;
   7 import android.content.IntentFilter;
   8 import android.net.ConnectivityManager;
   9 import android.net.wifi.WifiInfo;
  10 import android.net.wifi.WifiManager;
  11 import android.provider.Settings;
  12 import android.util.Log;
  13
  14 import net.osdn.gokigen.gr2control.R;
  15 import net.osdn.gokigen.gr2control.camera.ICameraConnection;
  16 import net.osdn.gokigen.gr2control.camera.ICameraStatusReceiver;
  17
  18 import java.util.concurrent.Executor;
  19 import java.util.concurrent.Executors;
  20
  21 import androidx.annotation.NonNull;
  22 import androidx.appcompat.app.AlertDialog;
  23 import androidx.fragment.app.FragmentActivity;
  24
  25
  26 /**
  27  *
  28  *
  29  */
  30 public class RicohGr2Connection implements ICameraConnection
  31 {
  32     private final String TAG = toString();
  33     private final FragmentActivity context;
  34     private final ICameraStatusReceiver statusReceiver;
  35     private final BroadcastReceiver connectionReceiver;
  36     private final IUseGR2CommandNotify gr2CommandNotify;
  37     //private final ConnectivityManager connectivityManager;
  38     private final Executor cameraExecutor = Executors.newFixedThreadPool(1);
  39     //private final Handler networkConnectionTimeoutHandler;
  40     //private static final int MESSAGE_CONNECTIVITY_TIMEOUT = 1;
  41     private CameraConnectionStatus connectionStatus = CameraConnectionStatus.UNKNOWN;
  42
  43
  44     /**
  45      *
  46      *
  47      */
  48     public RicohGr2Connection(@NonNull final FragmentActivity context, @NonNull final ICameraStatusReceiver statusReceiver, @NonNull IUseGR2CommandNotify gr2CommandNotify)
  49     {
  50         Log.v(TAG, " RicohGr2Connection()");
  51         this.context = context;
  52         this.statusReceiver = statusReceiver;
  53         this.gr2CommandNotify = gr2CommandNotify;
  54         connectionReceiver = new BroadcastReceiver()
  55         {
  56             @Override
  57             public void onReceive(Context context, Intent intent)
  58             {
  59                 onReceiveBroadcastOfConnection(context, intent);
  60             }
  61         };
  62     }
  63
  64     /**
  65      *
  66      *
  67      */
  68     private void onReceiveBroadcastOfConnection(Context context, Intent intent)
  69     {
  70         statusReceiver.onStatusNotify(context.getString(R.string.connect_check_wifi));
  71         Log.v(TAG,context.getString(R.string.connect_check_wifi));
  72
  73         String action = intent.getAction();
  74         if (action == null)
  75         {
  76             //
  77             Log.v(TAG, "intent.getAction() : null");
  78             return;
  79         }
  80
  81         try
  82         {
  83             if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION))
  84             {
  85                 Log.v(TAG, "onReceiveBroadcastOfConnection() : CONNECTIVITY_ACTION");
  86
  87                 WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
  88                 if (wifiManager != null) {
  89                     WifiInfo info = wifiManager.getConnectionInfo();
  90                     if (wifiManager.isWifiEnabled() && info != null)
  91                     {
  92                         if (info.getNetworkId() == -1)
  93                         {
  94                             Log.v(TAG, "Network ID is -1, there is no currently connected network.");
  95                         }
  96                         else
  97                         {
  98                             Log.v(TAG, "Network ID is " + info.getNetworkId());
  99                         }
 100                         // 自動接続が指示されていた場合は、カメラとの接続処理を行う
 101                         connectToCamera();
 102                     }
 103                     else
 104                     {
 105                         if (info == null)
 106                         {
 107                             Log.v(TAG, "NETWORK INFO IS NULL.");
 108                         }
 109                         else
 110                         {
 111                             Log.v(TAG, "isWifiEnabled : " + wifiManager.isWifiEnabled() + " NetworkId : " + info.getNetworkId());
 112                         }
 113                     }
 114                 }
 115             }
 116         }
 117         catch (Exception e)
 118         {
 119             Log.w(TAG, "onReceiveBroadcastOfConnection() EXCEPTION" + e.getMessage());
 120             e.printStackTrace();
 121         }
 122     }
 123
 124     /**
 125      *
 126      *
 127      */
 128     @Override
 129     public void startWatchWifiStatus(Context context)
 130     {
 131         Log.v(TAG, "startWatchWifiStatus()");
 132         statusReceiver.onStatusNotify("prepare");
 133
 134         IntentFilter filter = new IntentFilter();
 135         filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
 136         filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
 137         context.registerReceiver(connectionReceiver, filter);
 138     }
 139
 140     /**
 141      *
 142      *
 143      */
 144     @Override
 145     public void stopWatchWifiStatus(Context context)
 146     {
 147         Log.v(TAG, "stopWatchWifiStatus()");
 148         context.unregisterReceiver(connectionReceiver);
 149         disconnect(false);
 150     }
 151
 152     /**
 153      *
 154      *
 155      */
 156     @Override
 157     public void disconnect(boolean powerOff)
 158     {
 159         Log.v(TAG, "disconnect()");
 160         disconnectFromCamera(powerOff);
 161         connectionStatus = CameraConnectionStatus.DISCONNECTED;
 162         statusReceiver.onCameraDisconnected();
 163     }
 164
 165
 166     /**
 167      *
 168      *
 169      */
 170     @Override
 171     public void connect()
 172     {
 173         Log.v(TAG, "connect()");
 174         connectToCamera();
 175     }
 176
 177
 178     /**
 179      *
 180      *
 181      */
 182     @Override
 183     public void alertConnectingFailed(String message)
 184     {
 185         Log.v(TAG, "alertConnectingFailed() : " + message);
 186         if (context != null)
 187         {
 188             final AlertDialog.Builder builder = new AlertDialog.Builder(context)
 189                     .setTitle(context.getString(R.string.dialog_title_connect_failed))
 190                     .setMessage(message)
 191                     .setPositiveButton(context.getString(R.string.dialog_title_button_retry), new DialogInterface.OnClickListener() {
 192                         @Override
 193                         public void onClick(DialogInterface dialog, int which) {
 194                             connect();
 195                         }
 196                     })
 197                     .setNeutralButton(R.string.dialog_title_button_network_settings, new DialogInterface.OnClickListener() {
 198                         @Override
 199                         public void onClick(DialogInterface dialog, int which) {
 200                             try {
 201                                 // Wifi 設定画面を表示する
 202                                 context.startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
 203                             } catch (android.content.ActivityNotFoundException ex) {
 204                                 // Activity が存在しなかった...設定画面が起動できなかった
 205                                 Log.v(TAG, "android.content.ActivityNotFoundException...");
 206
 207                                 // この場合は、再試行と等価な動きとする
 208                                 connect();
 209                             } catch (Exception e) {
 210                                 e.printStackTrace();
 211                             }
 212                         }
 213                     });
 214             context.runOnUiThread(new Runnable() {
 215                 @Override
 216                 public void run() {
 217                     builder.show();
 218                 }
 219             });
 220         }
 221     }
 222
 223     @Override
 224     public CameraConnectionStatus getConnectionStatus()
 225     {
 226         Log.v(TAG, "getConnectionStatus()");
 227         return (connectionStatus);
 228     }
 229
 230     /**
 231      *
 232      *
 233      */
 234     @Override
 235     public void forceUpdateConnectionStatus(CameraConnectionStatus status)
 236     {
 237         Log.v(TAG, "forceUpdateConnectionStatus()");
 238         connectionStatus = status;
 239     }
 240
 241     /**
 242      * カメラとの切断処理
 243      */
 244     private void disconnectFromCamera(final boolean powerOff)
 245     {
 246         Log.v(TAG, "disconnectFromCamera()");
 247         try
 248         {
 249             cameraExecutor.execute(new RicohGr2CameraDisconnectSequence(context, powerOff));
 250         }
 251         catch (Exception e)
 252         {
 253             e.printStackTrace();
 254         }
 255     }
 256
 257     /**
 258      * カメラとの接続処理
 259      */
 260     private void connectToCamera()
 261     {
 262         Log.v(TAG, "connectToCamera()");
 263         connectionStatus = CameraConnectionStatus.CONNECTING;
 264         try
 265         {
 266             cameraExecutor.execute(new RicohGr2CameraConnectSequence(context, statusReceiver, this, gr2CommandNotify));
 267         }
 268         catch (Exception e)
 269         {
 270             Log.v(TAG, "connectToCamera() EXCEPTION : " + e.getMessage());
 271             e.printStackTrace();
 272         }
 273     }
 274 }