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 org.distorted.library.message.EffectMessageSender;

import java.util.ArrayList;

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

public class InternalStackFrameList

{

  private final static Object mLock = new Object();

  private static boolean mToDo = false;

  private static InternalStackFrame mCurrentFrame = null;

  private static ArrayList<InternalStackFrame> mFrameList = new ArrayList<>();

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

  static void onCreate(long taskId)

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

    boolean found = false;

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

      {

      frame = mFrameList.get(i);

      if( frame.getTaskId() == taskId )

        {

        mCurrentFrame = frame;

        found = true;

        break;

        }

      }

    if( !found )

      {

      synchronized(mLock)

        {

        mCurrentFrame = new InternalStackFrame(taskId);

        mFrameList.add(mCurrentFrame);

        }

      }

    mCurrentFrame.setInitialized(false);

    }

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

  static void onResume(long taskId)

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

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

      {

      frame = mFrameList.get(i);

      if( frame.getTaskId() == taskId )

        {

        mCurrentFrame = frame;

        break;

        }

      }

    mCurrentFrame.setInitialized(false);

    }

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

  static void onPause(long taskId)

    {

    int num = mFrameList.size();

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

      {

      if( mFrameList.get(i).getTaskId() == taskId )

        {

        synchronized(mLock)

          {

          mCurrentFrame.onPause();

          InternalStackFrame.onPauseCommon();

          mToDo = true;

          }

        break;

        }

      }

    }

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

  static void onDestroy(long taskId)

    {

    int num = mFrameList.size();

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

      {

      if( mFrameList.get(i).getTaskId() == taskId )

        {

        synchronized(mLock)

          {

          mFrameList.remove(i);

          if( num==1 ) InternalStackFrame.cleanCommon();

          }

        break;

        }

      }

    setInitialized(false);

    if( num<2 )

      {

      EffectMessageSender.stopSending();

      }

    }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

    InternalStackFrame.debugCommonList();

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

      {

      frame = mFrameList.get(i);

      frame.debugLists("frame "+i);

      }

    }

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

  @SuppressWarnings("unused")

  static void debugMap()

    {

    int num = mFrameList.size();

    InternalStackFrame frame;

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

      {

      frame = mFrameList.get(i);

      frame.debugMap("frame "+i);

      }

    }

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

// must be called from a thread holding OpenGL Context

  static boolean toDo()

    {

    if( mToDo )

      {

      mToDo = false;

      synchronized(mLock)

        {

        mCurrentFrame.toDo();

        InternalStackFrame.toDoCommon();

        }

      return true;

      }

    return false;

    }

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

  static void markFor(InternalObject obj, long id, int storage, int job)

    {

    synchronized(mLock)

      {

      mCurrentFrame.markFor(obj,id,storage,job);

      mToDo = true;

      }

    }

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

  static void removeFromDone(InternalObject obj, int storage)

    {

    synchronized(mLock)

      {

      mCurrentFrame.removeFromDoneList(obj,storage);

      }

    }

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

  static InternalStackFrame getCurrentFrame()

    {

    return mCurrentFrame;

    }

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

  static long getNextEffectsID()

    {

    return mCurrentFrame.getNextEffectsID();

    }

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

  static void setInitialized(boolean init)

    {

    mCurrentFrame.setInitialized(init);

    }

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

  static InternalNodeData getMapID(ArrayList<Long> key)

    {

    return mCurrentFrame.getMapID(key);

    }

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

  static InternalNodeData putNewDataToMap(ArrayList<Long> key)

    {

    return mCurrentFrame.putNewDataToMap(key);

    }

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

  static void removeKeyFromMap(ArrayList<Long> key)

    {

    mCurrentFrame.removeKeyFromMap(key);

    }

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

// PUBLIC API

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

  public static long getNextEffectID()

    {

    return mCurrentFrame.getNextEffectID();

    }

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

  public static boolean isInitialized()

    {

    return mCurrentFrame.isInitialized();

    }

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

  public static int getMax(int index)

    {

    return mCurrentFrame.getMax(index);

    }

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

  public static boolean setMax(int index,int max)

    {

    return mCurrentFrame.setMax(index,max);

    }

}