Methodologies or patterns to disable/enable statements based on conditions?

Question

So basically if a device has internet, certain actions are allowed to happen and if there is no internet then certain actions aren't allow to run.

online mode & offline mode.

What are some ways to construct this type of situation, what are some patterns to use?

The obvious one that comes to mind is a flag as the condition and an if else statement to handle the code choice.

online = true
getconnection()
if {!getconnection){
    online = false
}
if (online) {
    do everything online
}else {
    do only offline stuff
}

What if there's already an existing base of code that needs this logic factored in, what's an optimal remedy for that situation?

Answer 1

Maybe this code will help:

if (CheckNetworkStatus.getInstance(context).isOnline()) {
    //do online stuff
} else {
    //do offline stuff
}

Answer 2

If the device's connectivity status remains static, I would use the strategy pattern.

You could have an interface (strategy) 'Features', with an 'OnlineFeatures' implementation and an 'OfflineFeatures' implentation, or you could have each individual feature as a strategy with an enabled implementation and a disabled implementation. I would generally choose the 2nd for more flexibility, but it might be overkill depending on the application design.

If the connectivity status needs to change dynamically, you could still use the strategy pattern, but it would depend on what state info you need to maintain between connectivity status changes.

As an example ( in C++, but I hope the idea is clear enough ): Say I want a calculator with 2 possible features, being able to add and being able to multiply. I want to have a trial version that only does addition, and a version with both features unlocked.

class IAddStrategy
{
  virtual int Add( int first, int second ) = 0;
}

class CAdd: public IAddStrategy
{
  virtual int Add( int first, int second ) override { return first + second; }
}

// if I wanted to disable add I could create a CDisabledAdd class

class IMultiplyStrategy
{
  virtual int Multiply( int first, int second ) = 0;
}

class CMultiply : public IMultiplyStrategy
{
  virtual int Multiply( int first, int second ) override { return first * second };
}

class CDisabledMultiply : public IMultiplyStrategy
{
  virtual int Multiply( int first, int second ) override { return 0; }
}

class CCalculator
{
  CCalculator( IAddStrategy &add, IMultiplyStrategy &multiply ) : _add(add), _multiply(multiply)

  int Add( int first, int second ) { return _add.add(first, second); }

  int Multiply( int first, int second ) { return _multiply.multiply(first, second); }

private:
  IAddStrategy &_add;
  IMultiplyStrategy &_multiply;
}

// You don't necessarily need a factory. If features enabled/disabled status needed to change dynamically, I would need set methods for the strategies on calculator as well.
class CCalculatorFactory
{
  CCalculator *CreateTrialCalculator() { return new CCalculator( new CAdd(), new CDisabledMultiply() ); }
  CCalculator *CreateCalculator() { return new CCalculator( new CAdd(), new CMultiply() ); }
}

I'm simply returning 0 for my disabled version, but you could implement your classes to provide enough info to provide more usefulfeedback, or have the implementation draw the appropriate ui feedback themselves.