Distorted Android

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

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

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

/**

 * Any Object which gets uploaded to GPU memory and thus needs to be re-created (transparently to

 * applications!) whenever we lose OpenGL context.

 *

 * Keep all objects created in a static LinkedList. The point: we need to be able to mark

 * Objects for deletion, and delete all marked Objects later at a convenient time (that's

 * because we can only delete from a thread that holds the OpenGL context so here we provide a

 * framework where one is able to mark for deletion at any time and actual deletion takes place

 * on the next render).

*/

abstract class InternalObject

{

  static final int FAILED_TO_CREATE = 1;

  static final int NOT_CREATED_YET  = 2;

  static final int DONT_CREATE      = 3;

  static final int CREATED          = 4;

  static final int TYPE_USER = 0;

  static final int TYPE_TREE = 1;

  static final int TYPE_SYST = 2;

  private static final int JOB_CREATE = 0;

  private static final int JOB_DELETE = 1;

  private final static Object mLock = new Object();

  private long mID;

  private int mType;

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

  private static class Job

    {

    InternalObject object;

    int action;

    Job(InternalObject o, int a)

      {

      object = o;

      action = a;

      }

    }

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

  private static boolean mToDo = false;

  private static StackFrame mCurrentFrame = null;

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

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

  private static class StackFrame

    {

    private LinkedList<InternalObject> mDoneList;

    private HashMap<Long,Job> mToDoMap;

    private long mNextClientID;

    private long mNextSystemID;

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

    StackFrame()

      {

      mDoneList = new LinkedList<>();

      mToDoMap  = new HashMap<>();

      mNextClientID = 0;

      mNextSystemID = 0;

      }

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

    void onPause()

      {

      int num = mDoneList.size();

      try

        {

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

          {

          InternalObject object = mDoneList.removeFirst();

          Job job = new Job(object, JOB_CREATE);

          mToDoMap.put(object.mID,job);

          object.recreate();

          }

        }

      catch( Exception ignored )

        {

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

        }

      }

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

    void toDo()

      {

      for(Long key: mToDoMap.keySet())

        {

        Job job = mToDoMap.get(key);

        InternalObject object = job.object;

        if( job.action==JOB_CREATE )

          {

          object.create();

          mDoneList.add(object);

          }

        else if( job.action==JOB_DELETE )

          {

          object.delete();

          }

        }

      mToDoMap.clear();

      }

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

    long generateID(int type)

      {

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

      }

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

    void addToDoneList(InternalObject obj)

      {

      mDoneList.add(obj);

      }

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

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

      {

      mDoneList.remove(obj);

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

      }

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

    void debugLists(String frameMarker)

      {

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

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

      for(InternalObject object : mDoneList)

        {

        object.print("  ");

        }

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

      Job job;

      for(Long key: mToDoMap.keySet())

        {

        job = mToDoMap.get(key);

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

        }

      }

    }

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

  abstract void create();

  abstract void delete();

  abstract void recreate();

  abstract String printDetails();

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

// must be called from a thread holding OpenGL Context

  static boolean toDo()

    {

    if( mToDo )

      {

      mToDo = false;

      synchronized(mLock)

        {

        mCurrentFrame.toDo();

        }

      return true;

      }

    return false;

    }

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

  static void onCreate()

    {

    synchronized(mLock)

      {

      mCurrentFrame = new StackFrame();

      mFrameList.add(mCurrentFrame);

      mToDo = false;

      }

    }

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

  static void onPause()

    {

    synchronized(mLock)

      {

      mCurrentFrame.onPause();

      mToDo = true;

      }

    }

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

  static void onDestroy()

    {

    synchronized(mLock)

      {

      int num = mFrameList.size();

      if( num>0 )

        {

        mFrameList.remove(num-1);

        if( num>1 )

          {

          mCurrentFrame = mFrameList.get(num-2);

          mToDo = true;

          }

        else

          {

          mCurrentFrame = null;

          mToDo = false;

          }

        }

      }

    }

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

  @SuppressWarnings("unused")

  static void debugLists()

    {

    int num = mFrameList.size();

    StackFrame frame;

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

      {

      frame = mFrameList.get(i);

      frame.debugLists("frame "+i);

      }

    }

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

  private void print(String msg)

    {

    String str = "ID:"+mID;

    switch(mType)

      {

      case TYPE_SYST: str+=" SYSTEM "; break;

      case TYPE_USER: str+=" USER   "; break;

      case TYPE_TREE: str+=" TREE   "; break;

      default       : str+=" ERROR? ";

      }

    android.util.Log.e("Object", str+printDetails()+msg);

    }

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

  InternalObject(int type)

    {

    if( mCurrentFrame==null ) onCreate();

    mID = mCurrentFrame.generateID(type);

    mType= type;

    }

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

  void markWasCreatedImmediately()

    {

    mCurrentFrame.addToDoneList(this);

    }

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

  void markForCreation()

    {

    synchronized(mLock)

      {

      mCurrentFrame.markFor(this,mID,JOB_CREATE);

      mToDo = true;

      }

    }

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

// PUBLIC API

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

/**

 * Mark the underlying OpenGL object for deletion. Actual deletion will take place on the next render.

 */

  public void markForDeletion()

    {

    synchronized(mLock)

      {

      mCurrentFrame.markFor(this,mID,JOB_DELETE);

      mToDo = true;

      }

    }

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

/**

 * Return unique ID of this Object.

 */

  public long getID()

    {

    return mID;

    }

}