Distorted Android

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

// Copyright 2020 Leszek Koltunski  leszek@koltunski.pl                                          //

//                                                                                               //

// This file is part of Distorted.                                                               //

//                                                                                               //

// This library is free software; you can redistribute it and/or                                 //

// modify it under the terms of the GNU Lesser General Public                                    //

// License as published by the Free Software Foundation; either                                  //

// version 2.1 of the License, or (at your option) any later version.                            //

//                                                                                               //

// This library 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                             //

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

//                                                                                               //

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

// License along with this library; if not, write to the Free Software                           //

// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA                //

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

package org.distorted.library.main;

import org.distorted.library.effect.EffectType;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

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

/**

 * Implements a single 'frame' of all variables needed to remember the internal state of the library.

 * Such a frame must be remembered in a list whenever current Activity using the library fires off

 * another Activity which also wants to use the library. When that happens, we create a new 'frame',

 * remember the old one. When the second Activity ends and we come back to the first, we destroy the

 * second frame and recall the first.

 * <p>

 * Not part of public API, do not document

 *

 * @y.exclude

 */

public class InternalStackFrame

{

  private static class Job

    {

    InternalObject object;

    int action;

    Job(InternalObject o, int a)

      {

      object = o;

      action = a;

      }

    }

  private static final LinkedList<InternalObject> mCommonDoneList = new LinkedList<>(); //

  private static final HashMap<Long,Job> mCommonToDoMap           = new HashMap<>();    // Common

  private static long mCommonNextClientID                         = 0;                  // InternalObject

  private static long mCommonNextSystemID                         = 0;                  // (postprocessing)

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

  private final LinkedList<InternalObject> mDoneList;             //

  private final HashMap<Long,Job> mToDoMap;                       //

  private final long mTaskId;                                     //

  private long mNextClientID;                                     // InternalObject

  private long mNextSystemID;                                     //

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

  private boolean mInitialized;                                   // DistortedLibrary

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

  private final int[] mMax;                                       // EffectQueue

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

  private long mNextEffectsID;                                    // DistortedEffects;

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

  private long mNextEffectID;                                     // Effect;

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

  private final HashMap<ArrayList<Long>, InternalNodeData> mMapNodeID;// InternalNodeData

  private long mNextNodeID;

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

  private final ArrayList<InternalMaster.Slave> mSlaves;          // InternalMaster

  ////////////////////////////////////////////////////////////////// EffectQueue

  private long mNextQueueID;                                      //

  private final HashMap<ArrayList<Long>,Long> mMapID;             // maps lists of Effect IDs (longs)

                                                                  // to a single long - the queue ID.

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

  InternalStackFrame(long taskID)

    {

    mDoneList     = new LinkedList<>();

    mToDoMap      = new HashMap<>();

    mMapNodeID    = new HashMap<>();

    mSlaves       = new ArrayList<>();

    mMapID        = new HashMap<>();

    mNextEffectsID= 0;

    mNextClientID = 0;

    mNextSystemID = 0;

    mNextNodeID   = 0;

    mNextQueueID  = 1;

    mTaskId       = taskID;

    mMax          = new int[EffectType.LENGTH];

    EffectType.reset(mMax);

    }

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

  long getTaskId()

    {

    return mTaskId;

    }

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

  static void onPauseCommon()

    {

    onPauseGeneric(mCommonDoneList,mCommonToDoMap);

    }

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

  void onPause()

    {

    onPauseGeneric(mDoneList,mToDoMap);

    }

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

  static void onPauseGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map)

    {

    int num = list.size();

    try

      {

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

        {

        InternalObject object = list.removeFirst();

        Job job = new Job(object, InternalObject.JOB_CREATE);

        map.put(object.getID(),job);

        object.recreate();

        }

      }

    catch( Exception ignored )

      {

      // something else removed an object in the meantime; ignore

      }

    }

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

  void toDo()

    {

    toDoGeneric(mDoneList,mToDoMap);

    }

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

  static void toDoCommon()

    {

    toDoGeneric(mCommonDoneList,mCommonToDoMap);

    }

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

  static void toDoGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map)

    {

    for(Long key: map.keySet())

      {

      Job job = map.get(key);

      InternalObject object = job.object;

      if( job.action==InternalObject.JOB_CREATE )

        {

        object.create();

        list.add(object);

        }

      else if( job.action==InternalObject.JOB_DELETE )

        {

        object.delete();

        }

      }

    map.clear();

    }

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

  static void cleanCommon()

    {

    mCommonDoneList.clear();

    mCommonToDoMap.clear();

    mCommonNextClientID = 0;

    mCommonNextSystemID = 0;

    }

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

  long generateID(int type, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      return type==InternalObject.TYPE_SYST ? --mNextSystemID : ++mNextClientID;

      }

    else

      {

      return type==InternalObject.TYPE_SYST ? --mCommonNextSystemID : ++mCommonNextClientID;

      }

    }

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

  void addToDoneList(InternalObject obj, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      if( !mDoneList.contains(obj) )

        {

        mDoneList.add(obj);

        }

      }

    else

      {

      if( !mCommonDoneList.contains(obj) ) mCommonDoneList.add(obj);

      }

    }

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

  void removeFromDoneList(InternalObject obj, int storage)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      mDoneList.remove(obj);

      }

    else

      {

      mCommonDoneList.remove(obj);

      }

    }

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

  void markFor(InternalObject obj, long id, int storage, int jobType)

    {

    if( storage==InternalObject.STORAGE_PRIVATE )

      {

      mDoneList.remove(obj);

      mToDoMap.put(id, new Job(obj,jobType) );

      }

    else

      {

      mCommonDoneList.remove(obj);

      mCommonToDoMap.put(id, new Job(obj,jobType) );

      }

    }

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

  boolean isInitialized()

    {

    return mInitialized;

    }

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

  void setInitialized(boolean init)

    {

    mInitialized = init;

    }

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

  long getNextEffectsID()

    {

    return ++mNextEffectsID;

    }

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

  long getNextEffectID()

    {

    return mNextEffectID++;

    }

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

  int getMax(int index)

    {

    return mMax[index];

    }

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

  boolean setMax(int index, int max)

    {

    if( !mInitialized || max<mMax[index] )

      {

      mMax[index] = max;

      return true;

      }

    return false;

    }

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

  public HashMap<ArrayList<Long>,Long> getMap()

    {

    return mMapID;

    }

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

  public long getNextQueueID()

    {

    mNextQueueID++;

    return mNextQueueID-1;

    }

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

  InternalNodeData getMapID(ArrayList<Long> key)

    {

    return mMapNodeID.get(key);

    }

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

  InternalNodeData putNewDataToMap(ArrayList<Long> key)

    {

    InternalNodeData data = new InternalNodeData(++mNextNodeID,key);

    mMapNodeID.put(key,data);

    return data;

    }

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

  void removeKeyFromMap(ArrayList<Long> key)

    {

    mMapNodeID.remove(key);

    }

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

  ArrayList<InternalMaster.Slave> getSet()

    {

    return mSlaves;

    }

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

  void debugLists(String frameMarker)

    {

    debugListsGeneric(mDoneList,mToDoMap,frameMarker);

    }

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

  static void debugCommonList()

    {

    debugListsGeneric(mCommonDoneList,mCommonToDoMap,"Common");

    }

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

  static void debugListsGeneric(LinkedList<InternalObject> list, HashMap<Long,Job> map,String frameMarker)

    {

    android.util.Log.e("Object", frameMarker);

    android.util.Log.e("Object", "  Done list:");

    for(InternalObject object : list)

      {

      object.print("  ");

      }

    android.util.Log.e("Object", "  ToDo list:");

    Job job;

    for(Long key: map.keySet())

      {

      job = map.get(key);

      job.object.print(job.action==InternalObject.JOB_CREATE ? " create":" delete");

      }

    }

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

  void debugMap(String frameMarker)

    {

    android.util.Log.e("Object", frameMarker);

    InternalNodeData tmp;

    for(ArrayList<Long> key: mMapNodeID.keySet())

      {

      tmp = mMapNodeID.get(key);

      android.util.Log.e("NodeData", "NodeID: "+tmp.ID+" <-- "+key);

      }

    }

  }