Updates pull request from Roman Tsypuk to convert the build system from

ant to gradle.  Removes linux and windows application launch scripts and
produces an executable jar with all resources included.

src/main/java/io/github/dsheirer/alias/action/RecurringAction.java

@@ -0,0 +1,181 @@
+package io.github.dsheirer.alias.action;
+
+import io.github.dsheirer.alias.Alias;
+import io.github.dsheirer.message.Message;
+
+import javax.swing.*;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlTransient;
+import java.awt.*;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public abstract class RecurringAction extends AliasAction
+{
+    @XmlTransient
+    protected AtomicBoolean mRunning = new AtomicBoolean(false);
+    @XmlTransient
+    private ScheduledFuture<?> mPerpetualAction;
+    @XmlTransient
+    protected ScheduledExecutorService mScheduledExecutorService;
+
+    protected Interval mInterval = Interval.ONCE;
+    protected int mPeriod = 5;
+
+    public abstract void performAction(Alias alias, Message message);
+
+    @Override
+    public void execute(ScheduledExecutorService scheduledExecutorService, Alias alias, Message message)
+    {
+        mScheduledExecutorService = scheduledExecutorService;
+
+        if(mRunning.compareAndSet(false, true))
+        {
+            switch(mInterval)
+            {
+                case ONCE:
+                    performThreadedAction(alias, message);
+                    /* Don't reset */
+                    break;
+                case DELAYED_RESET:
+                    performThreadedAction(alias, message);
+                    mScheduledExecutorService.schedule(new ResetTask(), mPeriod, TimeUnit.SECONDS);
+                    break;
+                case UNTIL_DISMISSED:
+                    mPerpetualAction = mScheduledExecutorService.scheduleAtFixedRate(
+                        new PerformActionTask(alias, message), mPeriod, mPeriod, TimeUnit.SECONDS);
+
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("<html><div width='250'>Alias [");
+                    sb.append(alias.getName());
+                    sb.append("] is active in message [");
+                    sb.append(message.toString());
+                    sb.append("]</div></html>");
+
+                    final String text = sb.toString();
+
+                    EventQueue.invokeLater(new Runnable()
+                    {
+                        @Override
+                        public void run()
+                        {
+                            JOptionPane.showMessageDialog(null, text,
+                                "Alias Alert", JOptionPane.INFORMATION_MESSAGE);
+
+                            dismiss(false);
+
+                            mScheduledExecutorService.schedule(new ResetTask(), 15, TimeUnit.SECONDS);
+                        }
+                    });
+                    break;
+                default:
+            }
+        }
+    }
+
+    /**
+     * Spawns the performAction() event into a new thread so that it doesn't
+     * delay any decoder actions.
+     */
+    private void performThreadedAction(final Alias alias, final Message message)
+    {
+        mScheduledExecutorService.schedule(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                performAction(alias, message);
+            }
+        }, 0, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public void dismiss(boolean reset)
+    {
+        if(mPerpetualAction != null)
+        {
+            mPerpetualAction.cancel(true);
+
+            mPerpetualAction = null;
+        }
+
+        if(reset)
+        {
+            mRunning.set(false);
+        }
+    }
+
+    @XmlAttribute
+    public int getPeriod()
+    {
+        return mPeriod;
+    }
+
+    public void setPeriod(int period)
+    {
+        mPeriod = period;
+    }
+
+    @XmlAttribute
+    public Interval getInterval()
+    {
+        return mInterval;
+    }
+
+    public void setInterval(Interval interval)
+    {
+        mInterval = interval;
+
+        mRunning.set(false);
+    }
+
+    public enum Interval
+    {
+        ONCE("Once"),
+        DELAYED_RESET("Once, Reset After Delay"),
+        UNTIL_DISMISSED("Until Dismissed");
+
+        private String mLabel;
+
+        private Interval(String label)
+        {
+            mLabel = label;
+        }
+
+        public String toString()
+        {
+            return mLabel;
+        }
+    }
+
+    public class PerformActionTask implements Runnable
+    {
+        private Alias mAlias;
+        private Message mMessage;
+
+        public PerformActionTask(Alias alias, Message message)
+        {
+            mAlias = alias;
+            mMessage = message;
+        }
+
+        @Override
+        public void run()
+        {
+			/* Don't use the performThreadedAction() method, since this is
+			 * already running in a separate thread */
+            performAction(mAlias, mMessage);
+        }
+    }
+
+    public class ResetTask implements Runnable
+    {
+        @Override
+        public void run()
+        {
+            mRunning.set(false);
+        }
+    }
+}