Distorted Android

import org.distorted.library.message.EffectListener;

import org.distorted.library.message.EffectMessage;

import org.distorted.library.message.EffectMessageSender;

  ArrayList<EffectListener> mListeners =null;

  int mNumListeners=0;  // ==mListeners.length(), but we only create mListeners if the first one gets added

  long mDistortedEffectsID;

  EffectQueue(long id, int numUniforms, int index)

    mDistortedEffectsID = id;

  public static void allocateQueues(EffectQueue[] queues, EffectQueue[] from, int flags, long id)

    queues[0] = (flags & DistortedLibrary.CLONE_MATRIX     ) != 0 ? from[0] : new EffectQueueMatrix(id);

    queues[1] = (flags & DistortedLibrary.CLONE_VERTEX     ) != 0 ? from[1] : new EffectQueueVertex(id);

    queues[2] = (flags & DistortedLibrary.CLONE_FRAGMENT   ) != 0 ? from[2] : new EffectQueueFragment(id);

    queues[3] = (flags & DistortedLibrary.CLONE_POSTPROCESS) != 0 ? from[3] : new EffectQueuePostprocess(id);

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void registerForMessages(EffectListener el)

    {

    if( mListeners==null ) mListeners = new ArrayList<>();

    if( !mListeners.contains(el) )

      {

      mListeners.add(el);

      mNumListeners++;

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

  public void deregisterForMessages(EffectListener el)

    {

    if( mListeners.remove(el) )

      {

      mNumListeners--;

      }

    }

    long removedID = mEffects[effect].getID();

    for(int i=0; i<mNumListeners; i++)

      EffectMessageSender.newMessage( mListeners.get(i), EffectMessage.EFFECT_REMOVED, removedID, mDistortedEffectsID);

                       if( job.notify )

                         {

                         for(int k=0; k<mNumListeners; k++)

                           EffectMessageSender.newMessage( mListeners.get(k), EffectMessage.EFFECT_REMOVED, mEffects[j].getID(), mDistortedEffectsID);

                         }

import org.distorted.library.message.EffectMessage;

  EffectQueueFragment(long id)

    super(id,NUM_UNIFORMS,INDEX);

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);

import org.distorted.library.message.EffectMessage;

  EffectQueueMatrix(long id)

    super(id,NUM_UNIFORMS,INDEX );

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);

import org.distorted.library.message.EffectMessage;

  EffectQueuePostprocess(long id)

    super(id,NUM_UNIFORMS,INDEX );

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);

import org.distorted.library.message.EffectMessage;

  EffectQueueVertex(long id)

    super(id,NUM_UNIFORMS,INDEX);

        for(int j=0; j<mNumListeners; j++)

          EffectMessageSender.newMessage( mListeners.get(j), EffectMessage.EFFECT_FINISHED, mEffects[i].getID(), mDistortedEffectsID);

import org.distorted.library.message.EffectListener;

    EffectQueue.allocateQueues(mQueues,null,0,mID);

    EffectQueue.allocateQueues(mQueues,dc.getQueues(),flags,mID);

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Adds the calling class to the list of Listeners that get notified each time some event happens 

 * to one of the Effects in our queues. Nothing will happen if 'el' is already in the list.

 * 

 * @param el A class implementing the EffectListener interface that wants to get notifications.

 */

  public void registerForMessages(EffectListener el)

    {

    for( int i=0; i<EffectType.LENGTH; i++)

      {

      mQueues[i].registerForMessages(el);

      }

    }

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Removes the calling class from the list of Listeners that get notified if something happens to Effects in our queue.

 * 

 * @param el A class implementing the EffectListener interface that no longer wants to get notifications.

 */

  public void deregisterForMessages(EffectListener el)

    {

    for( int i=0; i<EffectType.LENGTH; i++)

      {

      mQueues[i].deregisterForMessages(el);

      }

    }

import org.distorted.library.main.DistortedEffects;

 * This interface lets users of the DistortedLibrary library get notified when something happens to one of the effects.

 * To receive the notifications, we first have to register with a call to {@link DistortedEffects#registerForMessages(EffectListener)}.

 * List of all possible events that can happen is defined in {@link EffectMessage}

 * Gets called when event of type 'eventType' happens to effect 'effectID'.

 * @param eventType  Type of event that happened.

 * @param effectID   ID of the effect the event happened to, as returned by {@link org.distorted.library.effect.Effect#getID() }

 * @param objectID   the ID of the DistortedEffects object, as returned by {@link org.distorted.library.main.DistortedEffects#getID()},

 *                   this event happened to.

 * @see EffectMessage

  void effectMessage(final EffectMessage eventType, final long effectID, final long objectID);

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2016 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// Distorted is free software: you can redistribute it and/or modify                             //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Distorted is distributed in the hope that it will be useful,                                  //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                            //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.library.message;

///////////////////////////////////////////////////////////////////////////////////////////////////

import org.distorted.library.main.DistortedEffects;

/**

* Defines all possible events a class implementing the {@link EffectListener} interface can receive.

*/

public enum EffectMessage 

  {

/**

 * The effect has been removed. This can happen if someone explicitly removed the effect with a call to

 * {@link DistortedEffects#abortById(long)} (or one of the other 'abort' methods)

 */

  EFFECT_REMOVED,

/**

 * Interpolation of the effect has finished. 

 * <p>

 * If you set up an interpolated effect and set its Dynamic to do 3.5 interpolations of 1000 ms each

 * with calls to {@link org.distorted.library.type.Dynamic#setCount(float)} and {@link org.distorted.library.type.Dynamic#makeRunNowFor(long)},

 * then you are going to get this message exactly once after 3.5*1000 = 3500 milliseconds when the interpolation 

 * finishes. You will never get this message if you set the effect to go on indefinitely with a call to 

 * {@link org.distorted.library.type.Dynamic#setCount(float)} where float=0.0f.

 * <p>  

 * If then the end effect is equal to the effect's unity, then immediately after this message you

 * will also get a EFFECT_REMOVED message.

 */

  EFFECT_FINISHED

  }

///////////////////////////////////////////////////////////////////////////////////////////////////

    EffectMessage mMessage;

    long mObjectID;

    Message(EffectListener l, EffectMessage m, long effID, long objID)

      mListener = l;

      mMessage  = m;

      mEffectID = effID;

      mObjectID = objID;

        tmp.mListener.effectMessage(tmp.mMessage, tmp.mEffectID, tmp.mObjectID);

  public static void newMessage(EffectListener l, EffectMessage m, long effID, long objID)

    Message msg = mThis.new Message(l,m,effID,objID);

    mList.add(msg);

    synchronized(mThis)

      mNotify = true;

      mThis.notify();