Magic Cube

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

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube 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.                                                           //

//                                                                                               //

// Magic Cube 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 Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

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

package org.distorted.main;

import android.content.Intent;

import android.content.SharedPreferences;

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 com.google.firebase.analytics.FirebaseAnalytics;

import org.distorted.dialogs.RubikDialogError;

import org.distorted.dialogs.RubikDialogPrivacy;

import org.distorted.effects.BaseEffect;

import org.distorted.helpers.BlockController;

import org.distorted.helpers.TwistyActivity;

import org.distorted.helpers.TwistyPreRender;

import org.distorted.library.main.DistortedLibrary;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.type.Static4D;

import org.distorted.objects.TwistyObject;

import org.distorted.network.RubikScores;

import org.distorted.network.RubikNetwork;

import org.distorted.objects.ObjectList;

import org.distorted.screens.ScreenList;

import org.distorted.screens.RubikScreenPlay;

import org.distorted.tutorials.TutorialActivity;

import java.util.Locale;

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

public class RubikActivity extends TwistyActivity

{

    public static final float PADDING             = 0.01f;

    public static final float MARGIN              = 0.004f;

    public static final float LARGE_MARGIN        = 0.025f;

    public static final float BUTTON_TEXT_SIZE    = 0.05f;

    public static final float TITLE_TEXT_SIZE     = 0.06f;

    public static final float SOLVER_BMP_H_SIZE   = 0.11f;

    public static final float SOLVER_BMP_V_SIZE   = 0.06f;

    public static final float MENU_ITEM_SIZE      = 0.11f;

    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 TUTORIAL_ITEM_TEXT  = 0.100f;

    public static final float DIALOG_BUTTON_SIZE  = 0.06f;

    public static final float MENU_BIG_TEXT_SIZE  = 0.05f;

    public static final float MENU_MED_TEXT_SIZE  = 0.04f;

    public static final float MENU_SMALL_TEXT_SIZE= 0.035f;

    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;

    public static final int FLAGS2=  View.SYSTEM_UI_FLAG_LAYOUT_STABLE

                                   | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;

    private boolean mJustStarted;

    private FirebaseAnalytics mFirebaseAnalytics;

    private static int mScreenWidth, mScreenHeight;

    private boolean mPolicyAccepted, mIsChinese;

    private int mCurrentApiVersion;

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

    @Override

    protected void onCreate(Bundle savedState)

      {

      super.onCreate(savedState);

      DistortedLibrary.onCreate(0);

      setTheme(R.style.CustomActivityThemeNoActionBar);

      setContentView(R.layout.main);

      mJustStarted = true;

      mFirebaseAnalytics = FirebaseAnalytics.getInstance(this);

      DisplayMetrics displaymetrics = new DisplayMetrics();

      getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);

      mScreenWidth =displaymetrics.widthPixels;

      mScreenHeight=displaymetrics.heightPixels;

      mIsChinese = localeIsChinese();

      unlock();

      hideNavigationBar();

      cutoutHack();

      // askForPermissions();

      }

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

    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)(0.8f*insetHeight);

        layoutHid.setLayoutParams(paramsHid);

        }

      final float RATIO = 0.10f;

      float height = getScreenHeightInPixels();

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

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

      ViewGroup.LayoutParams paramsTop = layoutTop.getLayoutParams();

      paramsTop.height = (int)(height*RATIO);

      layoutTop.setLayoutParams(paramsTop);

      ViewGroup.LayoutParams paramsBot = layoutBot.getLayoutParams();

      paramsBot.height = (int)(height*RATIO);

      layoutBot.setLayoutParams(paramsBot);

      }

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

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

        }

      }

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

    private void askForPermissions()

      {

      final int REQUEST_EXTERNAL_STORAGE = 1;

      String[] PERMISSIONS_STORAGE =

        {

        android.Manifest.permission.READ_EXTERNAL_STORAGE,

        android.Manifest.permission.WRITE_EXTERNAL_STORAGE

        };

      int permission = androidx.core.app.ActivityCompat.checkSelfPermission(this, android.Manifest.permission.WRITE_EXTERNAL_STORAGE);

      if (permission != android.content.pm.PackageManager.PERMISSION_GRANTED)

        {

        androidx.core.app.ActivityCompat.requestPermissions( this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE );

        }

      }

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

    @Override

    protected void onPause() 

      {

      super.onPause();

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

      view.onPause();

      DistortedLibrary.onPause(0);

      BlockController.onPause();

      RubikNetwork.onPause();

      savePreferences();

      }

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

    @Override

    protected void onResume() 

      {

      super.onResume();

      DistortedLibrary.onResume(0);

      BlockController.onResume();

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

      view.onResume();

      view.initialize();

      restorePreferences();

      ScreenList.setScreen(this);

      unblockEverything();

      if( mJustStarted )

        {

        mJustStarted = false;

        RubikScores scores = RubikScores.getInstance();

        scores.incrementNumRuns();

        scores.setCountry(this);

        }

      boolean success = false;

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

      int object = play.getObject();

      int size   = play.getSize();

      if( object>=0 && object< ObjectList.NUM_OBJECTS )

        {

        ObjectList obj = ObjectList.getObject(object);

        int[] sizes = obj.getSizes();

        int sizeIndex = ObjectList.getSizeIndex(object,size);

        if( sizeIndex>=0 && sizeIndex<sizes.length )

          {

          success = true;

          view.getPreRender().changeObject(obj,size);

          }

        }

      if( !success )

        {

        ObjectList obj = ObjectList.getObject(RubikScreenPlay.DEF_OBJECT);

        int s = RubikScreenPlay.DEF_SIZE;

        play.setObjectAndSize(this,obj,s);

        view.getPreRender().changeObject(obj,s);

        }

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

      }

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

    @Override

    protected void onDestroy() 

      {

      DistortedLibrary.onDestroy(0);

      super.onDestroy();

      }

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

    private void savePreferences()

      {

      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);

      SharedPreferences.Editor editor = preferences.edit();

      editor.putBoolean("policyAccepted", mPolicyAccepted);

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

        }

      ScreenList.savePreferences(editor);

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

      view.getPreRender().savePreferences(editor);

      editor.apply();

      }

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

    private void restorePreferences()

      {

      SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);

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

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

        }

      ScreenList.restorePreferences(preferences);

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

      view.getPreRender().restorePreferences(preferences);

      RubikScores scores = RubikScores.getInstance();

      if( scores.isVerified() )

        {

        FirebaseAnalytics analytics = getAnalytics();

        analytics.setUserId(scores.getName());

        }

      }

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

    private void PrivacyPolicy()

      {

      RubikDialogPrivacy priDiag = new RubikDialogPrivacy();

      priDiag.show(getSupportFragmentManager(), null);

      }

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

    void OpenGLError()

      {

      RubikDialogError errDiag = new RubikDialogError();

      errDiag.show(getSupportFragmentManager(), null);

      }

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

// PUBLIC API

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

    public FirebaseAnalytics getAnalytics()

      {

      return mFirebaseAnalytics;

      }

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

    public TwistyObject getObject()

      {

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

      RubikPreRender pre = view.getPreRender();

      return pre.getObject();

      }

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

    public DistortedScreen getScreen()

      {

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

      RubikRenderer renderer = view.getRenderer();

      return renderer.getScreen();

      }

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

    public RubikPreRender getPreRender()

      {

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

      return view.getPreRender();

      }

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

    public TwistyPreRender getTwistyPreRender()

      {

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

      return view.getPreRender();

      }

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

    public RubikSurfaceView getSurfaceView()

      {

      return findViewById(R.id.rubikSurfaceView);

      }

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

    public int getScreenWidthInPixels()

      {

      return mScreenWidth;

      }

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

    public int getScreenHeightInPixels()

      {

      return mScreenHeight;

      }

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

    public void changeObject(ObjectList newObject, int newSize, boolean reportChange)

      {

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

      RubikPreRender pre = view.getPreRender();

      if( reportChange )

        {

        TwistyObject oldObject = pre.getObject();

        if( oldObject!=null )

          {

          ObjectList oldList = oldObject.getObjectList();

          int oldNum = oldObject.getNumLayers();

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

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

          StringBuilder name = new StringBuilder();

          name.append(oldList.name());

          name.append('_');

          name.append(oldNum);

          name.append(' ');

          name.append(fps);

          name.append(" --> ");

          name.append(newObject.name());

          name.append('_');

          name.append(newSize);

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

              }

            }

          }

        }

      pre.changeObject(newObject,newSize);

      }

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

    public void setupObject(ObjectList object, int size, int[][] moves)

      {

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

      RubikPreRender pre = view.getPreRender();

      pre.setupObject(object,size,moves);

      }

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

    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 setControlState(boolean on)

      {

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

      RubikRenderer renderer = view.getRenderer();

      renderer.setControlState(on);

      }

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

    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 blockEverything(int place)

      {

      setLock();

      TwistyPreRender pre = getPreRender();

      pre.blockEverything(place);

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

      play.setLockState(this);

      }

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

    public void unblockEverything()

      {

      unsetLock();

      TwistyPreRender pre = getPreRender();

      pre.unblockEverything();

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

      play.setLockState(this);

      }

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

    public Static4D getCurrQuat()

      {

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

      return view.getQuat();

      }

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

    public void switchTutorial(String url, ObjectList object, int size)

      {

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

      myIntent.putExtra("url", url);

      myIntent.putExtra("obj", object.ordinal());

      myIntent.putExtra("siz", size);

      startActivity(myIntent);

      }

}