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.app.Activity;
   4 import android.content.BroadcastReceiver;
   5 import android.content.Context;
   6 import android.content.DialogInterface;
   7 import android.content.Intent;
   8 import android.content.IntentFilter;
   9 import android.net.ConnectivityManager;
  10 import android.net.wifi.WifiInfo;
  11 import android.net.wifi.WifiManager;
  12 import android.provider.Settings;
  13 import android.util.Log;
  14
  15 import net.osdn.gokigen.gr2control.R;
  16 import net.osdn.gokigen.gr2control.camera.ICameraConnection;
  17 import net.osdn.gokigen.gr2control.camera.ICameraStatusReceiver;
  18
  19 import java.util.concurrent.Executor;
  20 import java.util.concurrent.Executors;
  21
  22 import androidx.annotation.NonNull;
  23 import androidx.appcompat.app.AlertDialog;
  24
  25
  26 /**
  27  *
  28  *
  29  */
  30 public class RicohGr2Connection implements ICameraConnection
  31 {
  32     private final String TAG = toString();
  33     private final Activity 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 Activity 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         final AlertDialog.Builder builder = new AlertDialog.Builder(context)
 187                 .setTitle(context.getString(R.string.dialog_title_connect_failed))
 188                 .setMessage(message)
 189                 .setPositiveButton(context.getString(R.string.dialog_title_button_retry), new DialogInterface.OnClickListener() {
 190                     @Override
 191                     public void onClick(DialogInterface dialog, int which)
 192                     {
 193                         connect();
 194                     }
 195                 })
 196                 .setNeutralButton(R.string.dialog_title_button_network_settings, new DialogInterface.OnClickListener() {
 197                     @Override
 198                     public void onClick(DialogInterface dialog, int which)
 199                     {
 200                         try
 201                         {
 202                             // Wifi 設定画面を表示する
 203                             context.startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
 204                         }
 205                         catch (android.content.ActivityNotFoundException ex)
 206                         {
 207                             // Activity が存在しなかった...設定画面が起動できなかった
 208                             Log.v(TAG, "android.content.ActivityNotFoundException...");
 209
 210                             // この場合は、再試行と等価な動きとする
 211                             connect();
 212                         }
 213                         catch (Exception e)
 214                         {
 215                             e.printStackTrace();
 216                         }
 217                     }
 218                 });
 219         context.runOnUiThread(new Runnable()
 220         {
 221             @Override
 222             public void run()
 223             {
 224                 builder.show();
 225             }
 226         });
 227     }
 228
 229     @Override
 230     public CameraConnectionStatus getConnectionStatus()
 231     {
 232         Log.v(TAG, "getConnectionStatus()");
 233         return (connectionStatus);
 234     }
 235
 236     /**
 237      *
 238      *
 239      */
 240     @Override
 241     public void forceUpdateConnectionStatus(CameraConnectionStatus status)
 242     {
 243         Log.v(TAG, "forceUpdateConnectionStatus()");
 244         connectionStatus = status;
 245     }
 246
 247     /**
 248      * カメラとの切断処理
 249      */
 250     private void disconnectFromCamera(final boolean powerOff)
 251     {
 252         Log.v(TAG, "disconnectFromCamera()");
 253         try
 254         {
 255             cameraExecutor.execute(new RicohGr2CameraDisconnectSequence(context, powerOff));
 256         }
 257         catch (Exception e)
 258         {
 259             e.printStackTrace();
 260         }
 261     }
 262
 263     /**
 264      * カメラとの接続処理
 265      */
 266     private void connectToCamera()
 267     {
 268         Log.v(TAG, "connectToCamera()");
 269         connectionStatus = CameraConnectionStatus.CONNECTING;
 270         try
 271         {
 272             cameraExecutor.execute(new RicohGr2CameraConnectSequence(context, statusReceiver, this, gr2CommandNotify));
 273         }
 274         catch (Exception e)
 275         {
 276             Log.v(TAG, "connectToCamera() EXCEPTION : " + e.getMessage());
 277             e.printStackTrace();
 278         }
 279     }
 280 }