Distorted Android

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

// Copyright 2020 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.main;

import java.util.LinkedList;

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

 * Implements a single 'frame' of all varaibles 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

 */

{

  private static class Job

    {

    InternalObject object;

    int action;

    Job(InternalObject o, int a)

      {

      object = o;

      action = a;

      }

    }

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

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

  private static long mCommonNextClientID                   = 0;                  // InternalObject

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

  private LinkedList<InternalObject> mDoneList;                   //

  private HashMap<Long,Job> mToDoMap;                             //

  private long mNextClientID;                                     // InternalObject

  private long mNextSystemID;                                     //

  private long mTaskId;                                           //

  private boolean mInitialized;                                   // DistortedLibrary

  private int[] mMax;                                             // EffectQueue

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

  private long mNextEffectsID;                                    // DistortedEffects;

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

  private long mNextEffectID;                                     // Effect;

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

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

  private long mNextNodeID;

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

  private long mNextQueueID;                                      //

  private 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<>();

    mNextSystemID = 0;

    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);

    }

    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);

      }

    }