3.8. Building Own Applications¶

/**
 * Class used for handling connection / disconnection operations,
 * with reference to a specific external service, called Channel.
 */
abstract class ChannelHandler

/**
 * Class used for representing an Atooma Module implementing
 * an integration with an external service, so requiring a
 * dedicated ChannelHandler to be provided.
 */
abstract class ChannelModule

/**
 * Singleton class used for managing all available
 * channel handlers.
 */
class ChannelsManager

/**
 * Returns the id of module that this ChannelHandler is
 * aimed to handle.
 */
abstract protected String getModuleId();

/**
 * Execute code for connecting to Channel. This commonly
 * consists in access to a specific authentication Activity.
 */
abstract protected void doConnection(Activity source);

/**
 * Implements logic for extracting token and username
 * from result intent.
 */
abstract protected void extractAndSaveDataFromResult(Context context, Intent data);

@Override
protected void doConnection(Activity source) {
  Intent intent = new Intent(source, GmailActivity.class);
  source.startActivityForResult(intent, 8888);
}

@Override
public boolean isConnected(Context context) {
  return !TextUtils.isEmpty(getToken(context));
}

@Override
protected String getModuleId() {
  return "GMAIL";
}

@Override
protected void extractAndSaveDataFromResult(Context context, Intent data) {
  // getting params
  String username = data.getStringExtra(GoogleOAuth2Activity.PARAM_EMAIL);
  String token = data.getStringExtra(GoogleOAuth2Activity.PARAM_TOKEN);
  // store params
  saveUser(context, username);
  saveToken(context, token);
}

/**
 * Returns the id of the ChannelHandler. It's common
 * to use module id for this step.
 */
abstract protected String getChannelHandlerKey();

/**
 * Returns a ChannelHandler instance.
 */
abstract protected ChannelHandler buildChannelHandler();

@Override
protected String getChannelHandlerKey() {
  return Channels.GMAIL;
}

@Override
protected ChannelHandler buildChannelHandler() {
  return new GmailChannelHandler();
}

//...

Atooma atooma = Atooma.with(context);
ChannelsManager cm = ChannelsManager.with(context);
try {
    if (atooma.getActiveRules().containsKey(id)) {
        Log.d(LOG_TAG, "already active rule: " + xml);
        return;
    }
    // loading xml with rule definition
    InputStream stream = context.getAssets().open(xml);
    // building rule definition
    RuleDefinition def = XMLDeserializer.deserialize(stream, id);
    if (cm.isActivable(def)) {
        // loading rule definition into engine
        atooma.loadRule(def);
        Log.d(LOG_TAG, "activated rule: " + xml);
    } else {
        Log.d(LOG_TAG, "unable to activate rule: " + xml);
    }
} catch (IOException ex) {
    Log.e(LOG_TAG, "unable to open xml from assets: " + xml);
} catch (XMLRuleException ex) {
    Log.e(LOG_TAG, "unable to deserialize xml: " + xml);
}

/**
 * Support method for loading location based rules
 * starting from locations provider
 */
public static void loadLocationRules(Context context, String template) {
  try {
    // getting singleton for accessing locations provider
    LocationsManager lm = LocationsManager.getInstance();
    // getting list of locations
    List<LocationWrapper> locations = lm.readLocationsList(context);
    // iterating over locations
    for (LocationWrapper location : locations) {
      // loading rule based on location
      loadRule(context, template, location);
    }
  } catch (AuthorityNotSetException ex) {
    Log.e(LogTags.LOCATION, ex.getMessage(), ex);
  }
}

/**
 * Support method for loading a location based rule encoded
 * by the provided xml template into engine, returning a
 * boolean value telling if operation was successfully
 * completed or not.
 */
public static boolean loadRule(Context context, String xml, LocationWrapper location) {
  // can activate rule?
  if (OwnLocationsProvider.pushLocation(location)) {
    // we are using a template, so we must use location
    // as seed for building rule id
    String id = MD5.compute(xml) + location.getLabel();
    loadRule(context, xml, id);
    return true;
  }
  return false;
}

public class OwnLocationsProvider {

  private static final String LOG_TAG = "Location";

  /**
   * Collection used for putting locations to be used
   * as output for getArea method
   */
  private static List<LocationWrapper> LOCATIONS_QUEUE = new ArrayList<>();

  /**
   * Collection used for putting locations already used in
   * with current rule
   */
  private static List<LocationWrapper> ACTIVE_RULES = new ArrayList<>();

  /**
   * Provider method used in xml rule location_notification.xml
   */
  public static VT_Area_Wrapper getArea() {
    LocationWrapper wrapper = popLocation();
    if (wrapper != null) {
      return new VT_Area_Wrapper(wrapper);
    } else {
      Log.e(LOG_TAG, "missing location parameter");
      return null;
    }
  }

  /**
   * Add a location to the collection storing the ones
   * to be used for activating rules
   */
  public static synchronized boolean pushLocation(LocationWrapper location) {
    // putting in queue just in case rule doesn't exist yet
    boolean toPush = !ACTIVE_RULES.contains(location);
    if (toPush) {
      ACTIVE_RULES.add(location);
      LOCATIONS_QUEUE.add(location);
    }
    return toPush;
  }

  /**
   * Get a location from the collection storing the ones
   * to be used for activating rules, then removes it from
   * such collection
   */
  public static synchronized LocationWrapper popLocation() {
    LocationWrapper location = null;
    int index = LOCATIONS_QUEUE.size() - 1;
    if (index >= 0) {
      location = LOCATIONS_QUEUE.get(index);
      LOCATIONS_QUEUE.remove(index);
    }
    return location;
  }

}

/**
 * Representation of template rules data. In our case, implementation
 * of this class should include just management of a Location object.
 */
class TemplateRule

/**
 * Representation of the queue for rules data. It mus implement
 * method getWrapperObjects, that is aimed to provide a map with
 * all values to be pushed into rule with an external provider call.
 */
class TemplateRuleDataQueue<T extends TemplateRule>

/**
 * Representation of the storage for rules data. It is
 * currently implemented by using SharedPreferences, but
 * in future multiple implementations will be provided.
 */
class TemplateDataStorageHelper<T extends TemplateRule>

public class LocationRuleData extends TemplateRule {

  private LocationWrapper mLocation;

  public LocationRuleData(String id, String template, LocationWrapper location) {
    super(id, template);
    mLocation = location;
  }

  public LocationWrapper getLocation() {
    return mLocation;
  }

  @Override
  protected TemplateRuleDataQueue getQueue() {
    // let's suppose to exploit a singleton implementation
    return LocationRuleDataQueue.getInstance();
  }

  @Override
  protected TemplateDataStorageHelper getStorageHelper() {
    // let's suppose to exploit a singleton implementation
    return LocationRuleStorageHelper.getInstance();
  }

}

public class LocationRuleDataQueue extends TemplateRuleDataQueue<LocationRuleData> {

  public static final String LOCATION_PARAM = "location";

  // ...

  @Override
  protected Map<String,ValueTypeWrapper> getWrapperObjects(LocationRuleData item) {
    Map<String,ValueTypeWrapper> wrappers = new TreeMap<>();
    wrappers.put(LOCATION_PARAM, new VT_Area_Wrapper(item.getLocation()));
    return wrappers;
  }

}

public class LocationRuleStorageHelper extends TemplateDataStorageHelper<LocationRuleData> {

  // ...

  @Override
  protected String getStorageFilename() {
    return "locations";
  }

  @Override
  protected Class<LocationRuleData[]> getItemArrayClass() {
    return LocationRuleData[].class;
  }

}

public class LocationRuleProvider {

  public static VT_Area_Wrapper getArea(String ruleId) {
    VT_Area_Wrapper wrapper = (VT_Area_Wrapper) LocationRuleDataQueue.getInstance()
      .getParamWrapper(ruleId, LocationRuleDataQueue.LOCATION_PARAM);
    return wrapper;
  }

}