AMPExtension.java

  1. /**
  2.  *
  3.  * Copyright 2014 Vyacheslav Blinov
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.amp.packet;

  19. import java.util.Collections;
  20. import java.util.List;
  21. import java.util.concurrent.CopyOnWriteArrayList;

  23. import org.jivesoftware.smack.packet.ExtensionElement;

  25. import org.jivesoftware.smackx.amp.AMPDeliverCondition;
  26. import org.jivesoftware.smackx.amp.AMPExpireAtCondition;
  27. import org.jivesoftware.smackx.amp.AMPMatchResourceCondition;

  29. public class AMPExtension implements ExtensionElement {

  31.     public static final String NAMESPACE = "http://jabber.org/protocol/amp";
  32.     public static final String ELEMENT = "amp";

  34.     private final CopyOnWriteArrayList<Rule> rules = new CopyOnWriteArrayList<>();
  35.     private boolean perHop = false;

  37.     private final String from;
  38.     private final String to;
  39.     private final Status status;

  41.     /**
  42.      * Create a new AMPExtension instance with defined from, to and status attributes. Used to create incoming packets.
  43.      * @param from jid that triggered this amp callback.
  44.      * @param to receiver of this amp receipt.
  45.      * @param status status of this amp receipt.
  46.      */
  47.     public AMPExtension(String from, String to, Status status) {
  48.         this.from = from;
  49.         this.to = to;
  50.         this.status = status;
  51.     }

  53.     /**
  54.      * Create a new amp request extension to be used with outgoing message.
  55.      */
  56.     public AMPExtension() {
  57.         this.from = null;
  58.         this.to = null;
  59.         this.status = null;
  60.     }

  62.     /**
  63.      * Get the JID that triggered this AMP callback.
  64.      * @return jid that triggered this amp callback.
  65.      */
  66.     public String getFrom() {
  67.         return from;
  68.     }

  70.     /**
  71.      * Get the receiver of this AMP receipt.
  72.      * @return receiver of this amp receipt.
  73.      */
  74.     public String getTo() {
  75.         return to;
  76.     }

  78.     /**
  79.      * Status of this amp notification.
  80.      * @return Status for this amp
  81.      */
  82.     public Status getStatus() {
  83.         return status;
  84.     }

  86.     /**
  87.      * Returns a unmodifiable List of the rules in the packet.
  88.      *
  89.      * @return a unmodifiable List of the rules in the packet.
  90.      */
  91.     public List<Rule> getRules() {
  92.         return Collections.unmodifiableList(rules);
  93.     }

  95.     /**
  96.      * Adds a rule to the amp element. Amp can have any number of rules.
  97.      *
  98.      * @param rule the rule to add.
  99.      */
  100.     public void addRule(Rule rule) {
  101.         rules.add(rule);
  102.     }

  104.     /**
  105.      * Returns a count of the rules in the AMP packet.
  106.      *
  107.      * @return the number of rules in the AMP packet.
  108.      */
  109.     public int getRulesCount() {
  110.         return rules.size();
  111.     }

  113.     /**
  114.      * Sets this amp ruleset to be "per-hop".
  115.      *
  116.      * @param enabled true if "per-hop" should be enabled
  117.      */
  118.     public synchronized void setPerHop(boolean enabled) {
  119.         perHop = enabled;
  120.     }

  122.     /**
  123.      * Returns true is this ruleset is "per-hop".
  124.      *
  125.      * @return true is this ruleset is "per-hop".
  126.      */
  127.     public synchronized boolean isPerHop() {
  128.         return perHop;
  129.     }

  131.     /**
  132.      * Returns the XML element name of the extension sub-packet root element.
  133.      * Always returns "amp"
  134.      *
  135.      * @return the XML element name of the stanza extension.
  136.      */
  137.     @Override
  138.     public String getElementName() {
  139.         return ELEMENT;
  140.     }

  142.     /**
  143.      * Returns the XML namespace of the extension sub-packet root element.
  144.      * According the specification the namespace is always "http://jabber.org/protocol/xhtml-im"
  145.      *
  146.      * @return the XML namespace of the stanza extension.
  147.      */
  148.     @Override
  149.     public String getNamespace() {
  150.         return NAMESPACE;
  151.     }

  153.     /**
  154.      * Returns the XML representation of a XHTML extension according the specification.
  155.      **/
  156.     @Override
  157.     public String toXML(org.jivesoftware.smack.packet.XmlEnvironment enclosingNamespace) {
  158.         StringBuilder buf = new StringBuilder();
  159.         buf.append('<').append(getElementName()).append(" xmlns=\"").append(getNamespace()).append('"');
  160.         if (status != null) {
  161.             buf.append(" status=\"").append(status.toString()).append('"');
  162.         }
  163.         if (to != null) {
  164.             buf.append(" to=\"").append(to).append('"');
  165.         }
  166.         if (from != null) {
  167.             buf.append(" from=\"").append(from).append('"');
  168.         }
  169.         if (perHop) {
  170.             buf.append(" per-hop=\"true\"");
  171.         }
  172.         buf.append('>');

  174.         // Loop through all the rules and append them to the string buffer
  175.         for (Rule rule : getRules()) {
  176.             buf.append(rule.toXML());
  177.         }

  179.         buf.append("</").append(getElementName()).append('>');
  180.         return buf.toString();
  181.     }

  183.     /**
  184.      * XEP-0079 Rule element. Defines AMP Rule parameters. Can be added to AMPExtension.
  185.      */
  186.     public static class Rule {
  187.         public static final String ELEMENT = "rule";

  189.         private final Action action;
  190.         private final Condition condition;

  192.         public Action getAction() {
  193.             return action;
  194.         }

  196.         public Condition getCondition() {
  197.             return condition;
  198.         }

  200.         /**
  201.          * Create a new amp rule with specified action and condition. Value will be taken from condition argument
  202.          * @param action action for this rule
  203.          * @param condition condition for this rule
  204.          */
  205.         public Rule(Action action, Condition condition) {
  206.             if (action == null)
  207.                 throw new NullPointerException("Can't create Rule with null action");
  208.             if (condition == null)
  209.                 throw new NullPointerException("Can't create Rule with null condition");

  211.             this.action = action;
  212.             this.condition = condition;
  213.         }

  215.         private String toXML() {
  216.             return "<" + ELEMENT + " " + Action.ATTRIBUTE_NAME + "=\"" + action.toString() + "\" " +
  217.                     Condition.ATTRIBUTE_NAME + "=\"" + condition.getName() + "\" " +
  218.                     "value=\"" + condition.getValue() + "\"/>";
  219.         }
  220.     }

  222.     /**
  223.      * Interface for defining XEP-0079 Conditions and their values.
  224.      * @see AMPDeliverCondition
  225.      * @see AMPExpireAtCondition
  226.      * @see AMPMatchResourceCondition
  227.      **/
  228.     public interface Condition {
  229.         String getName();
  230.         String getValue();

  232.         String ATTRIBUTE_NAME = "condition";
  233.     }

  235.     /**
  236.      * amp action attribute.
  237.      * See http://xmpp.org/extensions/xep-0079.html#actions-def
  238.      **/
  239.     public enum Action {
  240.         /**
  241.          * The "alert" action triggers a reply &lt;message/&gt; stanza to the sending entity.
  242.          * This &lt;message/&gt; stanza MUST contain the element &lt;amp status='alert'/&gt;,
  243.          * which itself contains the &lt;rule/&gt; that triggered this action. In all other respects,
  244.          * this action behaves as "drop".
  245.          */
  246.         alert,
  247.         /**
  248.          * The "drop" action silently discards the message from any further delivery attempts
  249.          * and ensures that it is not placed into offline storage.
  250.          * The drop MUST NOT result in other responses.
  251.          */
  252.         drop,
  253.         /**
  254.          * The "error" action triggers a reply &lt;message/&gt; stanza of type "error" to the sending entity.
  255.          * The &lt;message/&gt; stanza's &lt;error/&gt; child MUST contain a
  256.          * &lt;failed-rules xmlns='http://jabber.org/protocol/amp#errors'/&gt; error condition,
  257.          * which itself contains the rules that triggered this action.
  258.          */
  259.         error,
  260.         /**
  261.          * The "notify" action triggers a reply &lt;message/&gt; stanza to the sending entity.
  262.          * This &lt;message/&gt; stanza MUST contain the element &lt;amp status='notify'/&gt;, which itself
  263.          * contains the &lt;rule/&gt; that triggered this action. Unlike the other actions,
  264.          * this action does not override the default behavior for a server.
  265.          * Instead, the server then executes its default behavior after sending the notify.
  266.          */
  267.         notify;

  269.         public static final String ATTRIBUTE_NAME = "action";
  270.     }

  272.     /**
  273.      * amp notification status as defined by XEP-0079.
  274.      */
  275.     public enum Status {
  276.         alert,
  277.         error,
  278.         notify
  279.     }
  280. }
Created with JaCoCo 0.8.6.202009150832