Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.main;

import java.io.InputStream;

import java.util.Locale;

import android.content.Intent;

import android.content.SharedPreferences;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.os.Build;

import android.os.Bundle;

import android.os.LocaleList;

import android.preference.PreferenceManager;

import android.util.DisplayMetrics;

import android.view.DisplayCutout;

import android.view.View;

import android.view.ViewGroup;

import android.view.WindowManager;

import android.widget.LinearLayout;

import androidx.appcompat.app.AppCompatActivity;

import com.google.firebase.analytics.FirebaseAnalytics;

import com.google.firebase.inappmessaging.FirebaseInAppMessaging;

import org.distorted.config.ConfigActivity;

import org.distorted.bandaged.BandagedCreatorActivity;

import org.distorted.dialogs.RubikDialogWhatsNew;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.messaging.RubikInAppMessanging;

import org.distorted.objectlib.main.ObjectControl;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.effects.BaseEffect;

import org.distorted.dialogs.RubikDialogError;

import org.distorted.dialogs.RubikDialogPrivacy;

import org.distorted.external.RubikScores;

import org.distorted.external.RubikNetwork;

import org.distorted.objects.RubikObject;

import org.distorted.objects.RubikObjectList;

import org.distorted.purchase.PurchaseActivity;

import org.distorted.screens.RubikScreenSolving;

import org.distorted.screens.ScreenList;

import org.distorted.screens.RubikScreenPlay;

import org.distorted.tutorials.TutorialActivity;

import static org.distorted.objectlib.main.TwistyObject.MESH_NICE;

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

public class RubikActivity extends AppCompatActivity

{

    public static final boolean SHOW_DOWNLOADED_DEBUG = false;

    public static final boolean SHOW_IAP_DEBUG        = true;

    public static final boolean USE_IAP               = false;

    public static final float PADDING             = 0.01f;

    public static final float SMALL_MARGIN        = 0.004f;

    public static final float BUTTON_TEXT_SIZE    = 0.05f;

    public static final float TITLE_TEXT_SIZE     = 0.06f;

    public static final float PATTERN_GROUP_TEXT  = 0.03f;

    public static final float PATTERN_CHILD_TEXT  = 0.02f;

    public static final float SCORES_LEVEL_TEXT   = 0.035f;

    public static final float SCORES_ITEM_TEXT    = 0.030f;

    public static final float TAB_WIDTH           = 0.066f;

    public static final float TAB_HEIGHT          = 0.066f;

    public static final float POPUP_PADDING       = 0.028f;

    public static final float POPUP_MARGIN        = 0.016f;

    public static final float RATIO_BAR           = 0.10f;

    public static final int FLAGS =  View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION

                                   | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN

                                   | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION

                                   | View.SYSTEM_UI_FLAG_FULLSCREEN

                                   | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;

    private static final int ACTIVITY_NUMBER = 0;

    private static final float RATIO_INSET= 0.09f;

    private static final String KEY_PLAY = "movesController_play";

    private static final String KEY_SOLV = "movesController_solv";

    private boolean mJustStarted;

    private FirebaseAnalytics mFirebaseAnalytics;

    private static int mScreenWidth, mScreenHeight;

    private boolean mPolicyAccepted, mIsChinese;

    private int mCurrentApiVersion;

    private int mHeightUpperBar, mHeightLowerBar;

    private int mOldVersion1, mOldVersion2, mOldVersion3;

    private String mOldVersion, mCurrVersion;

    private int mSolverIndex;

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

    @Override

    protected void onCreate(Bundle savedState)

      {

      super.onCreate(savedState);

      DistortedLibrary.onCreate(ACTIVITY_NUMBER);

      setTheme(R.style.MaterialThemeNoActionBar);

      setContentView(R.layout.main);

      mJustStarted = true;

      mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);

      mIsChinese = localeIsChinese();

      DisplayMetrics displaymetrics = new DisplayMetrics();

      getWindowManager().getDefaultDisplay().getRealMetrics(displaymetrics);

      mScreenWidth =displaymetrics.widthPixels;

      mScreenHeight=displaymetrics.heightPixels;

      hideNavigationBar();

      cutoutHack();

      computeBarHeights();

      mCurrVersion = getAppVers();

      mSolverIndex = 0;

      Thread thread = new Thread()

        {

        public void run()

          {

          RubikInAppMessanging listener = new RubikInAppMessanging();

          FirebaseInAppMessaging.getInstance().addClickListener(listener);

          }

        };

      thread.start();

      }

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

// this does not include possible insets

    private void computeBarHeights()

      {

      int barHeight = (int)(mScreenHeight*RATIO_BAR);

      mHeightLowerBar = barHeight;

      mHeightUpperBar = barHeight;

      LinearLayout layoutTop = findViewById(R.id.upperBar);

      LinearLayout layoutBot = findViewById(R.id.lowerBar);

      ViewGroup.LayoutParams paramsTop = layoutTop.getLayoutParams();

      paramsTop.height = mHeightUpperBar;

      layoutTop.setLayoutParams(paramsTop);

      ViewGroup.LayoutParams paramsBot = layoutBot.getLayoutParams();

      paramsBot.height = mHeightLowerBar;

      layoutBot.setLayoutParams(paramsBot);

      }

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

    private void hideNavigationBar()

      {

      mCurrentApiVersion = Build.VERSION.SDK_INT;

      if(mCurrentApiVersion >= Build.VERSION_CODES.KITKAT)

        {

        final View decorView = getWindow().getDecorView();

        decorView.setSystemUiVisibility(FLAGS);

        decorView.setOnSystemUiVisibilityChangeListener(new View.OnSystemUiVisibilityChangeListener()

          {

          @Override

          public void onSystemUiVisibilityChange(int visibility)

            {

            if((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0)

              {

              decorView.setSystemUiVisibility(FLAGS);

              }

            }

          });

        }

      }

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

    @Override

    public void onAttachedToWindow()

      {

      super.onAttachedToWindow();

      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)

        {

        DisplayCutout cutout = getWindow().getDecorView().getRootWindowInsets().getDisplayCutout();

        int insetHeight = cutout!=null ? cutout.getSafeInsetTop() : 0;

        LinearLayout layoutHid = findViewById(R.id.hiddenBar);

        ViewGroup.LayoutParams paramsHid = layoutHid.getLayoutParams();

        paramsHid.height = (int)(insetHeight*RATIO_INSET);

        layoutHid.setLayoutParams(paramsHid);

        mHeightUpperBar += paramsHid.height;

        }

      }

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

// do not avoid cutouts

    private void cutoutHack()

      {

      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)

        {

        getWindow().getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;

        }

      }

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

    @Override

    public void onWindowFocusChanged(boolean hasFocus)

      {

      super.onWindowFocusChanged(hasFocus);

      if(mCurrentApiVersion >= Build.VERSION_CODES.KITKAT && hasFocus)

        {

        getWindow().getDecorView().setSystemUiVisibility(FLAGS);

        }

      }

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

    @Override

    protected void onPause() 

      {

      super.onPause();

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      view.onPause();

      DistortedLibrary.onPause(ACTIVITY_NUMBER);

      RubikNetwork.onPause();

      savePreferences();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      DistortedLibrary.onResume(ACTIVITY_NUMBER);

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      view.onResume();

      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);

      restorePreferences(preferences,mJustStarted);

      ScreenList.setScreen(this);

      restoreMoves(preferences);

      if( mJustStarted )

        {

        mJustStarted = false;

        RubikScores scores = RubikScores.getInstance();

        scores.incrementNumRuns();

        scores.setCountry(this);

        RubikObjectList.restoreMeshState(preferences);

        }

      int object = RubikObjectList.getCurrObject();

      changeIfDifferent(object,view.getObjectControl());

      if( mIsChinese && !mPolicyAccepted ) privacyPolicy();

      else

        {

        if( !mOldVersion.equals(mCurrVersion) )

          {

          displayNovelties();

          }

        else

          {

          if( USE_IAP ) view.setShowStars();

          }

        }

      }

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

    private void privacyPolicy()

      {

      RubikDialogPrivacy priDiag = new RubikDialogPrivacy();

      priDiag.show(getSupportFragmentManager(), null);

      }

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

    private void displayNovelties()

      {

      Bundle bundle = new Bundle();

      bundle.putString("argument",mOldVersion);

      RubikDialogWhatsNew newDialog = new RubikDialogWhatsNew();

      newDialog.setArguments(bundle);

      newDialog.show(getSupportFragmentManager(), RubikDialogWhatsNew.getDialogTag() );

      }

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

    @Override

    protected void onDestroy() 

      {

      DistortedLibrary.onDestroy(ACTIVITY_NUMBER);

      super.onDestroy();

      }

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

    private String getAppVers()

      {

      try

        {

        PackageInfo pInfo = getPackageManager().getPackageInfo( getPackageName(), 0);

        return pInfo.versionName;

        }

      catch (PackageManager.NameNotFoundException e)

        {

        return "unknown";

        }

      }

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

    private void savePreferences()

      {

      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);

      SharedPreferences.Editor editor = preferences.edit();

      editor.putBoolean("policyAccepted", mPolicyAccepted);

      editor.putString("appVersion", mCurrVersion );

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

        {

        BaseEffect.Type.getType(i).savePreferences(editor);

        }

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

        {

        ScreenList.getScreen(i).getScreenClass().savePreferences(editor);

        }

      RubikObjectList.savePreferences(editor);

      RubikObjectList.saveMeshState(editor);

      ScreenList.savePreferences(editor);

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      view.getObjectControl().savePreferences(editor);

      ScreenList curr = ScreenList.getCurrentScreen();

      if( curr==ScreenList.PLAY )

        {

        RubikScreenPlay play = (RubikScreenPlay)ScreenList.PLAY.getScreenClass();

        play.saveMovePreferences(KEY_PLAY,editor);

        }

      if( curr==ScreenList.SOLV )

        {

        RubikScreenSolving solv = (RubikScreenSolving)ScreenList.SOLV.getScreenClass();

        solv.saveMovePreferences(KEY_SOLV,editor);

        }

      boolean success = editor.commit();

      if( !success ) android.util.Log.e("D", "Failed to save preferences");

      }

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

    private void restorePreferences(SharedPreferences preferences, boolean justStarted)

      {

      mPolicyAccepted = preferences.getBoolean("policyAccepted", false);

      mOldVersion = preferences.getString("appVersion","");

      parseOldVersion(mOldVersion);

      RubikObjectList.restorePreferences(this,preferences,justStarted);

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

        {

        BaseEffect.Type.getType(i).restorePreferences(preferences);

        }

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

        {

        ScreenList.getScreen(i).getScreenClass().restorePreferences(preferences);

        }

      RubikScores scores = RubikScores.getInstance();

      if( scores.isVerified() )

        {

        FirebaseAnalytics analytics = getAnalytics();

        analytics.setUserId(scores.getName());

        }

      // all old users upgrading from version <1.11.4, where there was no concept of 'stars',

      // get all the stars they have earned

      int numStars = scores.getNumStars();

      if( justStarted && numStars==0 && oldVersionLessThan(1,11,4) )

        {

        scores.correctNumStars();

        }

      // in 1.11.5 we have introduced IAP. When upgrading from something less than 1.11.5 to

      // something at least 1.11.5, mark all solved objects as free.

      // this needs to be after the above ScreenList.getScreen(i).getScreenClass().restorePreferences()

      // as that restores the Records which we need here

      // also needs to be after RubikObjectList.restorePreferences()

      if( USE_IAP && justStarted && oldVersionLessThan(1,11,5) && !mCurrVersion.equals("1.11.4") )

        {

        RubikObjectList.firstUpgradeMarkAllSolvedAsFree();

        }

      ScreenList.restorePreferences(preferences);

      // Versions <= 1.8.6 did not save their 'appVersion' to preferences, therefore in their

      // case the 'mOldVersion' - version of the app which saved the preferences on the last

      // go - is empty.

      // Between versions 1.8.6 and 1.9.0, the order of the cubits in TwistyCube has changed.

      // If someone has scrambled the cube with v. 1.8.6, then upgraded to 1.9.0 and re-started

      // the app, because of the different order of the cubits - his cube would be messed up.

      // So in such case, i.e. on fresh upgrade from version<=1.8.6 to version>=1.9.0, do not

      // restore the object scrambling.

      if( !mOldVersion.equals("") )

        {

        RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

        view.getObjectControl().restorePreferences(preferences);

        }

      }

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

    private void parseOldVersion(String version)

      {

      if( version==null ) return;

      try

        {

        String[] parts = version.split("\\.");

        if( parts.length==3 )

          {

          mOldVersion1 = Integer.parseInt(parts[0]);

          mOldVersion2 = Integer.parseInt(parts[1]);

          mOldVersion3 = Integer.parseInt(parts[2]);

          }

        }

      catch(Exception ignored)

        {

        mOldVersion1 = 0;

        mOldVersion2 = 0;

        mOldVersion3 = 0;

        }

      }

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

    private boolean oldVersionLessThan(int v1, int v2, int v3)

      {

      if( mOldVersion1<v1 ) return true;

      if( mOldVersion1>v1 ) return false;

      if( mOldVersion2<v2 ) return true;

      if( mOldVersion2>v2 ) return false;

      return mOldVersion3<v3;

      }

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

    private void restoreMoves(SharedPreferences preferences)

      {

      ScreenList curr = ScreenList.getCurrentScreen();

      if( curr==ScreenList.PLAY )

        {

        RubikScreenPlay play = (RubikScreenPlay)ScreenList.PLAY.getScreenClass();

        play.restoreMovePreferences(this,KEY_PLAY,preferences);

        }

      if( curr==ScreenList.SOLV )

        {

        RubikScreenSolving solv = (RubikScreenSolving)ScreenList.SOLV.getScreenClass();

        solv.restoreMovePreferences(this,KEY_SOLV,preferences);

        }

      }

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

    void OpenGLError()

      {

      RubikDialogError errDiag = new RubikDialogError();

      errDiag.show(getSupportFragmentManager(), null);

      }

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

// PUBLIC API

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

    public FirebaseAnalytics getAnalytics()

      {

      return mFirebaseAnalytics;

      }

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

    public int getHeightUpperBar()

      {

      return mHeightUpperBar;

      }

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

    public int getHeightLowerBar()

      {

      return mHeightLowerBar;

      }

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

    public TwistyObject getObject()

      {

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      return view.getObjectControl().getObject();

      }

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

    public DistortedScreen getScreen()

      {

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      return view.getRenderer().getScreen();

      }

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

    public ObjectControl getControl()

      {

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      return view.getObjectControl();

      }

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

    public int getScreenWidthInPixels()

      {

      return mScreenWidth;

      }

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

    public int getScreenHeightInPixels()

      {

      return mScreenHeight;

      }

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

    public void changeObject(int newObject, boolean reportChange)

      {

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      ObjectControl control = view.getObjectControl();

      TwistyObject oldObject = control.getObject();

      changeIfDifferent(newObject,control);

      if( reportChange && oldObject!=null )

        {

        RubikObject robject = RubikObjectList.getObject(newObject);

        String newName = robject==null ? "NULL" : robject.getUpperName();

        float fps = view.getRenderer().getFPS();

        fps = (int)(fps+0.5f);

        StringBuilder name = new StringBuilder();

        name.append(oldObject.getShortName());

        name.append(' ');

        name.append(fps);

        name.append(" --> ");

        name.append(newName);

        if( BuildConfig.DEBUG )

          {

          android.util.Log.e("rubik", name.toString());

          }

        else

          {

          FirebaseAnalytics analytics = getAnalytics();

          if( analytics!=null )

            {

            Bundle bundle = new Bundle();

            bundle.putString(FirebaseAnalytics.Param.ITEM_NAME, name.toString());

            analytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM, bundle);

            }

          }

        }

      }

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

    public void changeIfDifferent(int ordinal, ObjectControl control)

      {

      RubikObject object = RubikObjectList.getObject(ordinal);

      int meshState = object!=null ? object.getMeshState() : MESH_NICE;

      int iconMode  = TwistyObject.MODE_NORM;

      InputStream jsonStream = object==null ? null : object.getObjectStream(this);

      InputStream meshStream = object==null ? null : object.getMeshStream(this);

      String name = object==null ? "NULL" : object.getUpperName();

      control.changeIfDifferent(ordinal,name,meshState,iconMode,jsonStream,meshStream);

      }

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

    public static int getDrawableSize()

      {

      if( mScreenHeight<1000 ) return 0;

      if( mScreenHeight<1600 ) return 1;

      if( mScreenHeight<1900 ) return 2;

      return 3;

      }

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

    public static int getDrawable(int small, int medium, int big, int huge)

      {

      int size = getDrawableSize();

      switch(size)

        {

        case 0 : return small;

        case 1 : return medium;

        case 2 : return big;

        default: return huge;

        }

      }

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

    public void acceptPrivacy()

      {

      mPolicyAccepted = true;

      }

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

    public void declinePrivacy()

      {

      finish();

      }

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

    public static boolean localeIsChinese()

      {

      String language;

      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)

        {

        language= LocaleList.getDefault().get(0).getLanguage();

        }

      else

        {

        language= Locale.getDefault().getLanguage();

        }

      return language.equals("zh");

      }

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

    public boolean isVertical()

      {

      RubikSurfaceView view = findViewById(R.id.rubikSurfaceView);

      return view.isVertical();

      }

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

    public void switchTutorial(String url, int objectOrdinal)

      {

      Intent intent = new Intent(this, TutorialActivity.class);

      intent.putExtra("url", url);

      intent.putExtra("obj", objectOrdinal);

      startActivity(intent);

      }

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

    public void switchConfig(int objectOrdinal)

      {

      Intent intent = new Intent(this, ConfigActivity.class);

      intent.putExtra("obj", objectOrdinal);

      startActivity(intent);

      }

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

    public void switchToBandagedCreator()

      {

      Intent intent = new Intent(this, BandagedCreatorActivity.class);

      startActivity(intent);

      }

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

    public void switchToPurchase(int objectOrdinal)

      {

      Intent intent = new Intent(this, PurchaseActivity.class);

      intent.putExtra("obj", objectOrdinal);

      startActivity(intent);

      }

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

    public void reloadObject(String shortName)

      {

      TwistyObject currObject = getObject();

      String name = currObject==null ? "" : currObject.getShortName();

      if( name.toLowerCase(Locale.ENGLISH).equals(shortName) )

        {

        RubikObject object = RubikObjectList.getObject(name);

        if( object!=null )

          {

          int meshState = object.getMeshState();

          int iconMode  = TwistyObject.MODE_NORM;

          InputStream jsonStream = object.getObjectStream(this);

          InputStream meshStream = object.getMeshStream(this);

          ObjectControl control = getControl();

          control.changeObject(-1,meshState,iconMode,jsonStream,meshStream);

          }

        }

      }

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

    public void setSolverIndex(int index)

      {

      mSolverIndex = index;

      }

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

    public int getSolverIndex()

      {

      return mSolverIndex;

      }

}