content: /*
   * This file is part of LSPosed.
   *
   * LSPosed 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 3 of the License, or
   * (at your option) any later version.
   *
   * LSPosed 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 LSPosed.  If not, see <https://www.gnu.org/licenses/>.
   *
   * Copyright (C) 2020 EdXposed Contributors
   * Copyright (C) 2021 LSPosed Contributors
   */
  
  package org.lsposed.manager.ui.fragment;
  
  import android.app.Dialog;
  import android.content.Context;
  import android.content.pm.ApplicationInfo;
  import android.content.pm.PackageManager;
  import android.os.AsyncTask;
  import android.os.Bundle;
  import android.view.LayoutInflater;
  
  import androidx.annotation.NonNull;
  import androidx.appcompat.app.AppCompatDialogFragment;
  import androidx.fragment.app.FragmentManager;
  
  import org.lsposed.manager.App;
  import org.lsposed.manager.R;
  import org.lsposed.manager.databinding.FragmentCompileDialogBinding;
  import org.lsposed.manager.receivers.LSPManagerServiceHolder;
  import org.lsposed.manager.ui.dialog.BlurBehindDialogBuilder;
  
  import java.lang.ref.WeakReference;
  
  @SuppressWarnings("deprecation")
  public class CompileDialogFragment extends AppCompatDialogFragment {
      public static void speed(FragmentManager fragmentManager, ApplicationInfo info) {
          CompileDialogFragment fragment = new CompileDialogFragment();
          fragment.setCancelable(false);
          var bundle = new Bundle();
          bundle.putParcelable("appInfo", info);
          fragment.setArguments(bundle);
          fragment.show(fragmentManager, "compile_dialog");
      }
  
      @Override
      @NonNull
      public Dialog onCreateDialog(Bundle savedInstanceState) {
          var arguments = getArguments();
          ApplicationInfo appInfo = arguments != null ? arguments.getParcelable("appInfo") : null;
          if (appInfo == null) {
              throw new IllegalStateException("appInfo should not be null.");
          }
  
          FragmentCompileDialogBinding binding = FragmentCompileDialogBinding.inflate(LayoutInflater.from(requireActivity()), null, false);
          final PackageManager pm = requireContext().getPackageManager();
          var builder = new BlurBehindDialogBuilder(requireActivity())
                  .setIcon(appInfo.loadIcon(pm))
                  .setTitle(appInfo.loadLabel(pm))
                  .setView(binding.getRoot());
  
          var alertDialog = builder.create();
          new CompileTask(this).executeOnExecutor(App.getExecutorService(), appInfo.packageName);
          return alertDialog;
      }
  
      private static class CompileTask extends AsyncTask<String, Void, Throwable> {
  
          WeakReference<CompileDialogFragment> outerRef;
  
          CompileTask(CompileDialogFragment fragment) {
              outerRef = new WeakReference<>(fragment);
          }
  
          @Override
          protected Throwable doInBackground(String... commands) {
              try {
                  LSPManagerServiceHolder.getService().clearApplicationProfileData(commands[0]);
                  if (LSPManagerServiceHolder.getService().performDexOptMode(commands[0])) {
                      return null;
                  } else {
                      return new UnknownError();
                  }
              } catch (Throwable e) {
                  return e;
              }
          }
  
          @Override
          protected void onPostExecute(Throwable result) {
              Context context = App.getInstance();
              String text;
              if (result != null) {
                  if (result instanceof UnknownError) {
                      text = context.getString(R.string.compile_failed);
                  } else {
                      text = context.getString(R.string.compile_failed_with_info) + result;
                  }
              } else {
                  text = context.getString(R.string.compile_done);
              }
              try {
                  CompileDialogFragment fragment = outerRef.get();
                  if (fragment != null) {
                      fragment.dismissAllowingStateLoss();
                      var parent = fragment.getParentFragment();
                      if (parent instanceof BaseFragment) {
                          ((BaseFragment) parent).showHint(text, true);
                      }
                  }
              } catch (IllegalStateException ignored) {
              }
          }
      }
  }
  