mirror of
https://gitee.com/zhangsken/AndroidIDE.git
synced 2026-10-16 07:49:44 +08:00
Akash Yadav
1724 lines
67 KiB
Java
Executable File
1724 lines
67 KiB
Java
Executable File
/*
|
|
* This file is part of AndroidIDE.
|
|
*
|
|
*
|
|
*
|
|
* AndroidIDE 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.
|
|
*
|
|
* AndroidIDE 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 AndroidIDE. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
package com.itsaky.androidide;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.app.ProgressDialog;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.graphics.drawable.GradientDrawable;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.text.TextUtils;
|
|
import android.view.Gravity;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.CheckBox;
|
|
import android.widget.LinearLayout;
|
|
import androidx.activity.result.ActivityResult;
|
|
import androidx.activity.result.ActivityResultLauncher;
|
|
import androidx.activity.result.contract.ActivityResultContracts;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.appcompat.app.ActionBarDrawerToggle;
|
|
import androidx.appcompat.app.AlertDialog;
|
|
import androidx.appcompat.view.menu.MenuBuilder;
|
|
import androidx.appcompat.widget.TooltipCompat;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.view.GravityCompat;
|
|
import androidx.fragment.app.Fragment;
|
|
import androidx.lifecycle.ViewModelProvider;
|
|
import androidx.transition.Slide;
|
|
import androidx.transition.TransitionManager;
|
|
import com.blankj.utilcode.util.ClipboardUtils;
|
|
import com.blankj.utilcode.util.FileUtils;
|
|
import com.blankj.utilcode.util.IntentUtils;
|
|
import com.blankj.utilcode.util.KeyboardUtils;
|
|
import com.blankj.utilcode.util.ResourceUtils;
|
|
import com.blankj.utilcode.util.SizeUtils;
|
|
import com.blankj.utilcode.util.ThrowableUtils;
|
|
import com.blankj.utilcode.util.ZipUtils;
|
|
import com.google.android.material.bottomsheet.BottomSheetBehavior;
|
|
import com.google.android.material.dialog.MaterialAlertDialogBuilder;
|
|
import com.google.android.material.navigation.NavigationView;
|
|
import com.google.android.material.tabs.TabLayout;
|
|
import com.google.android.material.tabs.TabLayoutMediator;
|
|
import com.itsaky.androidide.adapters.DiagnosticsAdapter;
|
|
import com.itsaky.androidide.adapters.EditorBottomSheetTabAdapter;
|
|
import com.itsaky.androidide.adapters.SearchListAdapter;
|
|
import com.itsaky.androidide.app.StudioActivity;
|
|
import com.itsaky.androidide.databinding.ActivityEditorBinding;
|
|
import com.itsaky.androidide.databinding.LayoutDiagnosticInfoBinding;
|
|
import com.itsaky.androidide.databinding.LayoutSearchProjectBinding;
|
|
import com.itsaky.androidide.fragments.FileTreeFragment;
|
|
import com.itsaky.androidide.fragments.NonEditableEditorFragment;
|
|
import com.itsaky.androidide.fragments.SearchResultFragment;
|
|
import com.itsaky.androidide.fragments.sheets.OptionsListFragment;
|
|
import com.itsaky.androidide.fragments.sheets.ProgressSheet;
|
|
import com.itsaky.androidide.fragments.sheets.TextSheetFragment;
|
|
import com.itsaky.androidide.handlers.BuildServiceHandler;
|
|
import com.itsaky.androidide.handlers.FileOptionsHandler;
|
|
import com.itsaky.androidide.handlers.IDEHandler;
|
|
import com.itsaky.androidide.interfaces.DiagnosticClickListener;
|
|
import com.itsaky.androidide.interfaces.EditorActivityProvider;
|
|
import com.itsaky.androidide.lsp.IDELanguageClientImpl;
|
|
import com.itsaky.androidide.managers.PreferenceManager;
|
|
import com.itsaky.androidide.managers.ToolsManager;
|
|
import com.itsaky.androidide.models.DiagnosticGroup;
|
|
import com.itsaky.androidide.models.LogLine;
|
|
import com.itsaky.androidide.models.SaveResult;
|
|
import com.itsaky.androidide.models.SearchResult;
|
|
import com.itsaky.androidide.models.SheetOption;
|
|
import com.itsaky.androidide.project.AndroidProject;
|
|
import com.itsaky.androidide.project.IDEProject;
|
|
import com.itsaky.androidide.services.LogReceiver;
|
|
import com.itsaky.androidide.services.builder.IDEService;
|
|
import com.itsaky.androidide.shell.ShellServer;
|
|
import com.itsaky.androidide.tasks.TaskExecutor;
|
|
import com.itsaky.androidide.utils.DialogUtils;
|
|
import com.itsaky.androidide.utils.EditorBottomSheetBehavior;
|
|
import com.itsaky.androidide.utils.Environment;
|
|
import com.itsaky.androidide.utils.LSPUtils;
|
|
import com.itsaky.androidide.utils.Logger;
|
|
import com.itsaky.androidide.utils.RecursiveFileSearcher;
|
|
import com.itsaky.androidide.utils.Symbols;
|
|
import com.itsaky.androidide.viewmodel.EditorViewModel;
|
|
import com.itsaky.androidide.views.MaterialBanner;
|
|
import com.itsaky.androidide.views.SymbolInputView;
|
|
import com.itsaky.androidide.views.editor.CodeEditorView;
|
|
import com.itsaky.inflater.values.ValuesTableFactory;
|
|
import com.itsaky.lsp.java.models.JavaServerConfiguration;
|
|
import com.itsaky.lsp.java.models.JavaServerSettings;
|
|
import com.itsaky.lsp.models.DiagnosticItem;
|
|
import com.itsaky.lsp.models.InitializeParams;
|
|
import com.itsaky.lsp.models.Range;
|
|
import com.itsaky.toaster.Toaster;
|
|
import com.unnamed.b.atv.model.TreeNode;
|
|
import io.github.rosemoe.sora.event.ContentChangeEvent;
|
|
import io.github.rosemoe.sora.event.Unsubscribe;
|
|
import java.io.File;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.concurrent.CompletionException;
|
|
import java.util.regex.Pattern;
|
|
import java.util.stream.Collectors;
|
|
import me.piruin.quickaction.ActionItem;
|
|
import me.piruin.quickaction.QuickAction;
|
|
import org.jetbrains.annotations.Contract;
|
|
|
|
public class EditorActivity extends StudioActivity
|
|
implements FileTreeFragment.FileActionListener,
|
|
TabLayout.OnTabSelectedListener,
|
|
NavigationView.OnNavigationItemSelectedListener,
|
|
DiagnosticClickListener,
|
|
IDEHandler.Provider,
|
|
EditorActivityProvider,
|
|
OptionsListFragment.OnOptionsClickListener {
|
|
|
|
public static final String EXTRA_PROJECT = "project";
|
|
public static final String KEY_BOTTOM_SHEET_SHOWN = "editor_bottomSheetShown";
|
|
private static final String TAG_FILE_OPTIONS_FRAGMENT = "file_options_fragment";
|
|
private static final int ACTION_ID_CLOSE = 100;
|
|
private static final int ACTION_ID_OTHERS = 101;
|
|
private static final int ACTION_ID_ALL = 102;
|
|
private static final Logger LOG = Logger.instance("EditorActivity");
|
|
/**
|
|
* MenuItem(s) that are related to the build process
|
|
*
|
|
* <p>These items will be disabled once the build process starts and will be enabled after the
|
|
* execution
|
|
*/
|
|
private final int[] BUILD_IDS = {
|
|
R.id.menuEditor_quickRun,
|
|
R.id.menuEditor_runDebug,
|
|
R.id.menuEditor_runRelease,
|
|
R.id.menuEditor_runBuild,
|
|
R.id.menuEditor_runBundle,
|
|
R.id.menuEditor_runClean,
|
|
R.id.menuEditor_runCleanBuild,
|
|
R.id.menuEditor_lint,
|
|
R.id.menuEditor_lintDebug,
|
|
R.id.menuEditor_lintRelease
|
|
};
|
|
|
|
private ActivityEditorBinding mBinding;
|
|
private LayoutDiagnosticInfoBinding mDiagnosticInfoBinding;
|
|
private EditorBottomSheetTabAdapter bottomSheetTabAdapter;
|
|
private final LogReceiver mLogReceiver = new LogReceiver().setLogListener(this::appendApkLog);
|
|
private FileTreeFragment mFileTreeFragment;
|
|
private TreeNode mLastHeld;
|
|
private SymbolInputView symbolInput;
|
|
private BuildServiceHandler mBuildServiceHandler;
|
|
private FileOptionsHandler mFileOptionsHandler;
|
|
private QuickAction mTabCloseAction;
|
|
private TextSheetFragment mDaemonStatusFragment;
|
|
private OptionsListFragment mFileOptionsFragment;
|
|
private ProgressSheet mSearchingProgress;
|
|
private AlertDialog mFindInProjectDialog;
|
|
private ActivityResultLauncher<Intent> mUIDesignerLauncher;
|
|
private EditorBottomSheetBehavior<? extends View> mEditorBottomSheet;
|
|
private EditorViewModel mViewModel;
|
|
|
|
@Override
|
|
protected View bindLayout() {
|
|
mBinding = ActivityEditorBinding.inflate(getLayoutInflater());
|
|
mDiagnosticInfoBinding = mBinding.diagnosticInfo;
|
|
return mBinding.getRoot();
|
|
}
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
setSupportActionBar(mBinding.editorToolbar);
|
|
|
|
mViewModel = new ViewModelProvider(this).get(EditorViewModel.class);
|
|
getProjectFromIntent();
|
|
|
|
mFileTreeFragment = FileTreeFragment.newInstance(this.getAndroidProject());
|
|
mDaemonStatusFragment = new TextSheetFragment().setTextSelectable(true);
|
|
|
|
setupDrawerToggle();
|
|
loadFragment(mFileTreeFragment);
|
|
|
|
symbolInput = new SymbolInputView(this);
|
|
mBinding.bottomSheet.textContainer.addView(
|
|
symbolInput, 0, new ViewGroup.LayoutParams(-1, -2));
|
|
mBinding.tabs.addOnTabSelectedListener(this);
|
|
|
|
setupEditorBottomSheet();
|
|
createQuickActions();
|
|
|
|
mBuildServiceHandler = new BuildServiceHandler(this);
|
|
mFileOptionsHandler = new FileOptionsHandler(this);
|
|
|
|
startServices();
|
|
|
|
KeyboardUtils.registerSoftInputChangedListener(this, __ -> onSoftInputChanged());
|
|
registerLogReceiver();
|
|
setupContainers();
|
|
setupDiagnosticInfo();
|
|
|
|
mUIDesignerLauncher =
|
|
registerForActivityResult(
|
|
new ActivityResultContracts.StartActivityForResult(),
|
|
this::onGetUIDesignerResult);
|
|
}
|
|
|
|
private void setupDrawerToggle() {
|
|
ActionBarDrawerToggle toggle =
|
|
new ActionBarDrawerToggle(
|
|
this,
|
|
mBinding.editorDrawerLayout,
|
|
mBinding.editorToolbar,
|
|
R.string.app_name,
|
|
R.string.app_name);
|
|
mBinding.editorDrawerLayout.addDrawerListener(toggle);
|
|
mBinding.startNav.setNavigationItemSelectedListener(this);
|
|
toggle.syncState();
|
|
}
|
|
|
|
private void setupEditorBottomSheet() {
|
|
bottomSheetTabAdapter = new EditorBottomSheetTabAdapter(this);
|
|
mBinding.bottomSheet.pager.setAdapter(bottomSheetTabAdapter);
|
|
|
|
final var mediator =
|
|
new TabLayoutMediator(
|
|
mBinding.bottomSheet.tabs,
|
|
mBinding.bottomSheet.pager,
|
|
true,
|
|
true,
|
|
(tab, position) -> tab.setText(bottomSheetTabAdapter.getTitle(position)));
|
|
|
|
mediator.attach();
|
|
mBinding.bottomSheet.pager.setUserInputEnabled(false);
|
|
mBinding.bottomSheet.pager.setOffscreenPageLimit(
|
|
bottomSheetTabAdapter.getItemCount() - 1); // DO not remove any views
|
|
|
|
mEditorBottomSheet =
|
|
(EditorBottomSheetBehavior<? extends View>)
|
|
EditorBottomSheetBehavior.from(mBinding.bottomSheet.getRoot());
|
|
mEditorBottomSheet.setBinding(mBinding.bottomSheet);
|
|
mEditorBottomSheet.addBottomSheetCallback(
|
|
new BottomSheetBehavior.BottomSheetCallback() {
|
|
@Override
|
|
public void onStateChanged(@NonNull View bottomSheet, int newState) {
|
|
mBinding.bottomSheet.textContainer.setVisibility(
|
|
newState == BottomSheetBehavior.STATE_EXPANDED
|
|
? View.INVISIBLE
|
|
: View.VISIBLE);
|
|
}
|
|
|
|
@Override
|
|
public void onSlide(@NonNull View bottomSheet, float slideOffset) {
|
|
mBinding.bottomSheet.textContainer.setAlpha(1f - slideOffset);
|
|
}
|
|
});
|
|
|
|
mBinding.bottomSheet.tabs.addOnTabSelectedListener(
|
|
new TabLayout.OnTabSelectedListener() {
|
|
|
|
@Override
|
|
public void onTabSelected(TabLayout.Tab tab) {
|
|
final var fragment =
|
|
bottomSheetTabAdapter.getFragmentAtIndex(tab.getPosition());
|
|
if (fragment instanceof NonEditableEditorFragment) {
|
|
mBinding.bottomSheet.clearFab.show();
|
|
} else {
|
|
mBinding.bottomSheet.clearFab.hide();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTabUnselected(TabLayout.Tab tab) {}
|
|
|
|
@Override
|
|
public void onTabReselected(TabLayout.Tab tab) {}
|
|
});
|
|
|
|
TooltipCompat.setTooltipText(
|
|
mBinding.bottomSheet.clearFab, getString(R.string.title_clear_output));
|
|
mBinding.bottomSheet.clearFab.setOnClickListener(
|
|
v -> {
|
|
final var fragment =
|
|
bottomSheetTabAdapter.getFragmentAtIndex(
|
|
mBinding.bottomSheet.tabs.getSelectedTabPosition());
|
|
if (fragment instanceof NonEditableEditorFragment) {
|
|
final var editor = (NonEditableEditorFragment) fragment;
|
|
if (editor.getEditor() != null) {
|
|
editor.getEditor().setText("");
|
|
}
|
|
}
|
|
});
|
|
|
|
if (!getApp().getPrefManager().getBoolean(KEY_BOTTOM_SHEET_SHOWN)
|
|
&& mEditorBottomSheet.getState() != BottomSheetBehavior.STATE_EXPANDED) {
|
|
mEditorBottomSheet.setState(BottomSheetBehavior.STATE_EXPANDED);
|
|
new Handler(Looper.getMainLooper())
|
|
.postDelayed(
|
|
() -> {
|
|
mEditorBottomSheet.setState(BottomSheetBehavior.STATE_COLLAPSED);
|
|
getApp().getPrefManager().putBoolean(KEY_BOTTOM_SHEET_SHOWN, true);
|
|
},
|
|
1500);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onBackPressed() {
|
|
if (mBinding.getRoot().isDrawerOpen(GravityCompat.END)) {
|
|
mBinding.getRoot().closeDrawer(GravityCompat.END);
|
|
} else if (mBinding.getRoot().isDrawerOpen(GravityCompat.START)) {
|
|
mBinding.getRoot().closeDrawer(GravityCompat.START);
|
|
} else if (getDaemonStatusFragment().isShowing()) {
|
|
getDaemonStatusFragment().dismiss();
|
|
} else if (mFileOptionsFragment != null && mFileOptionsFragment.isShowing()) {
|
|
mFileOptionsFragment.dismiss();
|
|
} else if (mEditorBottomSheet.getState() == BottomSheetBehavior.STATE_EXPANDED) {
|
|
mEditorBottomSheet.setState(BottomSheetBehavior.STATE_COLLAPSED);
|
|
} else {
|
|
confirmProjectClose();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onPause() {
|
|
dispatchOnPauseToEditors();
|
|
super.onPause();
|
|
}
|
|
|
|
@Override
|
|
protected void onResume() {
|
|
super.onResume();
|
|
|
|
try {
|
|
checkForCompilerModule();
|
|
dispatchOnResumeToEditors();
|
|
mFileTreeFragment.listProjectFiles();
|
|
} catch (Throwable th) {
|
|
LOG.error("Failed to update files list", th);
|
|
getApp().toast(R.string.msg_failed_list_files, Toaster.Type.ERROR);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected void onDestroy() {
|
|
closeProject(false);
|
|
try {
|
|
unregisterReceiver(mLogReceiver);
|
|
} catch (Throwable th) {
|
|
LOG.error("Failed to unregister LogReceiver", th);
|
|
}
|
|
super.onDestroy();
|
|
}
|
|
|
|
@Override
|
|
@SuppressLint("AlwaysShowAction")
|
|
public boolean onPrepareOptionsMenu(Menu menu) {
|
|
for (int id : BUILD_IDS) {
|
|
MenuItem item = menu.findItem(id);
|
|
if (item != null) {
|
|
boolean enabled = getBuildService() != null && !getBuildService().isBuilding();
|
|
item.setEnabled(enabled);
|
|
item.getIcon().setAlpha(enabled ? 255 : 76);
|
|
}
|
|
}
|
|
|
|
MenuItem run1 = menu.findItem(R.id.menuEditor_quickRun);
|
|
MenuItem run2 = menu.findItem(R.id.menuEditor_run);
|
|
MenuItem undo = menu.findItem(R.id.menuEditor_undo);
|
|
MenuItem redo = menu.findItem(R.id.menuEditor_redo);
|
|
MenuItem save = menu.findItem(R.id.menuEditor_save);
|
|
MenuItem def = menu.findItem(R.id.menuEditor_gotoDefinition);
|
|
MenuItem ref = menu.findItem(R.id.menuEditor_findReferences);
|
|
MenuItem comment = menu.findItem(R.id.menuEditor_commentLine);
|
|
MenuItem uncomment = menu.findItem(R.id.menuEditor_uncommentLine);
|
|
MenuItem findFile = menu.findItem(R.id.menuEditor_findFile);
|
|
MenuItem viewLayout = menu.findItem(R.id.menuEditor_viewLayout);
|
|
|
|
if (KeyboardUtils.isSoftInputVisible(this)) {
|
|
run1.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
run2.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
undo.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
|
|
redo.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
|
|
|
|
viewLayout.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
} else {
|
|
run1.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
|
|
run2.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
|
|
undo.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
redo.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
|
|
viewLayout.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
|
|
}
|
|
|
|
final var editor = getCurrentEditor();
|
|
final var file = editor != null ? editor.getFile() : null;
|
|
final var notNull = editor != null && file != null;
|
|
final var isJava = notNull && file.getName().endsWith(".java");
|
|
final var isXml = notNull && file.getName().endsWith(".xml");
|
|
final var filesModified = notNull && mViewModel != null && mViewModel.areFilesModified();
|
|
final var isLayout =
|
|
isXml
|
|
&& file.getParentFile() != null
|
|
&& Pattern.compile(FileOptionsHandler.LAYOUT_RES_PATH_REGEX)
|
|
.matcher(file.getParentFile().getAbsolutePath())
|
|
.matches();
|
|
final var nullableAlpha = notNull ? 255 : 76;
|
|
final var javaFileAlpha = isJava ? 255 : 76;
|
|
final var layoutFileAlpha = isLayout ? 255 : 76;
|
|
final var saveAlpha = filesModified ? 255 : 76;
|
|
|
|
undo.setEnabled(notNull);
|
|
redo.setEnabled(notNull);
|
|
save.setEnabled(filesModified);
|
|
comment.setEnabled(notNull);
|
|
uncomment.setEnabled(notNull);
|
|
findFile.setEnabled(notNull);
|
|
def.setEnabled(isJava);
|
|
ref.setEnabled(isJava);
|
|
|
|
undo.getIcon().setAlpha(nullableAlpha);
|
|
redo.getIcon().setAlpha(nullableAlpha);
|
|
save.getIcon().setAlpha(saveAlpha);
|
|
comment.getIcon().setAlpha(nullableAlpha);
|
|
uncomment.getIcon().setAlpha(nullableAlpha);
|
|
findFile.getIcon().setAlpha(nullableAlpha);
|
|
def.getIcon().setAlpha(javaFileAlpha);
|
|
ref.getIcon().setAlpha(javaFileAlpha);
|
|
|
|
viewLayout.setEnabled(isLayout);
|
|
viewLayout.getIcon().setAlpha(layoutFileAlpha);
|
|
viewLayout.setShowAsActionFlags(
|
|
isLayout ? MenuItem.SHOW_AS_ACTION_ALWAYS : MenuItem.SHOW_AS_ACTION_NEVER);
|
|
|
|
return true;
|
|
}
|
|
|
|
@SuppressLint("RestrictedApi")
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu) {
|
|
if (menu instanceof MenuBuilder) {
|
|
MenuBuilder builder = (MenuBuilder) menu;
|
|
builder.setOptionalIconsVisible(true);
|
|
}
|
|
|
|
getMenuInflater().inflate(R.menu.menu_editor, menu);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
if (getBuildService() == null) {
|
|
LOG.error("Build service is null. Cannot perform option menu actions.");
|
|
return false;
|
|
}
|
|
|
|
int id = item.getItemId();
|
|
if (id == R.id.menuEditor_runDebug || id == R.id.menuEditor_quickRun) {
|
|
getBuildServiceHandler().assembleDebug(true);
|
|
} else if (id == R.id.menuEditor_runRelease) {
|
|
getBuildService().assembleRelease();
|
|
} else if (id == R.id.menuEditor_runClean) {
|
|
getBuildService().clean();
|
|
} else if (id == R.id.menuEditor_runCleanBuild) {
|
|
getBuildService().cleanAndRebuild();
|
|
} else if (id == R.id.menuEditor_runStopDaemons) {
|
|
getBuildService().stopAllDaemons();
|
|
} else if (id == R.id.menuEditor_runBuild) {
|
|
getBuildService().build();
|
|
} else if (id == R.id.menuEditor_runBundle) {
|
|
getBuildService().bundle();
|
|
} else if (id == R.id.menuEditor_lint) {
|
|
getBuildService().lint();
|
|
} else if (id == R.id.menuEditor_lintDebug) {
|
|
getBuildService().lintDebug();
|
|
} else if (id == R.id.menuEditor_lintRelease) {
|
|
getBuildService().lintRelease();
|
|
} else if (id == R.id.menuEditor_save) {
|
|
saveAll(true, true);
|
|
} else if (id == R.id.menuEditor_findProject) {
|
|
AlertDialog d = getFindInProjectDialog();
|
|
if (d != null) {
|
|
d.show();
|
|
}
|
|
} else if (id == R.id.menuEditor_viewLayout) {
|
|
previewLayout();
|
|
} else if (id == R.id.menuEditor_daemonStatus) {
|
|
showDaemonStatus();
|
|
} else if (id == R.id.menuEditor_files) {
|
|
if (!mBinding.editorDrawerLayout.isDrawerOpen(GravityCompat.END)) {
|
|
mBinding.editorDrawerLayout.openDrawer(GravityCompat.END);
|
|
}
|
|
} else if (getCurrentEditor() != null) { // Should be checked at last
|
|
if (id == R.id.menuEditor_undo) {
|
|
this.getCurrentEditor().undo();
|
|
} else if (id == R.id.menuEditor_redo) {
|
|
this.getCurrentEditor().redo();
|
|
} else if (id == R.id.menuEditor_gotoDefinition) {
|
|
this.getCurrentEditor().findDefinition();
|
|
} else if (id == R.id.menuEditor_findReferences) {
|
|
this.getCurrentEditor().findReferences();
|
|
} else if (id == R.id.menuEditor_commentLine) {
|
|
this.getCurrentEditor().commentLine();
|
|
} else if (id == R.id.menuEditor_uncommentLine) {
|
|
this.getCurrentEditor().uncommentLine();
|
|
} else if (id == R.id.menuEditor_findFile) {
|
|
this.getCurrentEditor().beginSearch();
|
|
} else if (id == R.id.menuEditor_formatCode) {
|
|
if (!this.getCurrentEditor().getEditor().formatCodeAsync()) {
|
|
LOG.error("Unable to start format thread to format code...");
|
|
}
|
|
}
|
|
}
|
|
|
|
invalidateOptionsMenu();
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public EditorActivity provide() {
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public EditorActivity provideEditorActivity() {
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public AndroidProject provideAndroidProject() {
|
|
return getAndroidProject();
|
|
}
|
|
|
|
@Override
|
|
public IDEProject provideIDEProject() {
|
|
return getIDEProject();
|
|
}
|
|
|
|
public void handleSearchResults(Map<File, List<SearchResult>> results) {
|
|
setSearchResultAdapter(
|
|
new com.itsaky.androidide.adapters.SearchListAdapter(
|
|
results,
|
|
file -> {
|
|
openFile(file);
|
|
hideViewOptions();
|
|
},
|
|
match -> {
|
|
openFileAndSelect(match.file, match);
|
|
hideViewOptions();
|
|
}));
|
|
|
|
showSearchResults();
|
|
|
|
if (mSearchingProgress != null && mSearchingProgress.isShowing()) {
|
|
mSearchingProgress.dismiss();
|
|
}
|
|
}
|
|
|
|
public void appendApkLog(LogLine line) {
|
|
final var logFragment = bottomSheetTabAdapter.getLogFragment();
|
|
if (logFragment != null) {
|
|
logFragment.appendLog(line);
|
|
}
|
|
}
|
|
|
|
public void appendBuildOut(final String str) {
|
|
final var frag = bottomSheetTabAdapter.getBuildOutputFragment();
|
|
|
|
if (frag != null) {
|
|
frag.appendOutput(str);
|
|
}
|
|
}
|
|
|
|
public void showDaemonStatus() {
|
|
ShellServer shell = getApp().newShell(t -> getDaemonStatusFragment().append(t));
|
|
shell.bgAppend(String.format("echo '%s'", getString(R.string.msg_getting_daemom_status)));
|
|
shell.bgAppend(
|
|
String.format(
|
|
"cd '%s' && sh gradlew --status",
|
|
Objects.requireNonNull(getAndroidProject()).getProjectPath()));
|
|
if (!getDaemonStatusFragment().isShowing()) {
|
|
getDaemonStatusFragment().show(getSupportFragmentManager(), "daemon_status");
|
|
}
|
|
}
|
|
|
|
public void hideViewOptions() {
|
|
if (mEditorBottomSheet.getState() != BottomSheetBehavior.STATE_COLLAPSED) {
|
|
mEditorBottomSheet.setState(BottomSheetBehavior.STATE_COLLAPSED);
|
|
}
|
|
}
|
|
|
|
public void showSearchResults() {
|
|
if (mEditorBottomSheet.getState() != BottomSheetBehavior.STATE_EXPANDED) {
|
|
mEditorBottomSheet.setState(BottomSheetBehavior.STATE_EXPANDED);
|
|
}
|
|
|
|
final int index =
|
|
bottomSheetTabAdapter.findIndexOfFragmentByClass(SearchResultFragment.class);
|
|
if (index >= 0 && index < mBinding.bottomSheet.tabs.getTabCount()) {
|
|
final var tab = mBinding.bottomSheet.tabs.getTabAt(index);
|
|
if (tab != null) {
|
|
tab.select();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void handleDiagnosticsResultVisibility(boolean errorVisible) {
|
|
runOnUiThread(
|
|
() -> {
|
|
final var diagnosticsFragment = bottomSheetTabAdapter.getDiagnosticsFragment();
|
|
if (diagnosticsFragment != null) {
|
|
diagnosticsFragment.handleResultVisibility(errorVisible);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void handleSearchResultVisibility(boolean errorVisible) {
|
|
runOnUiThread(
|
|
() -> {
|
|
final var searchResultFragment =
|
|
bottomSheetTabAdapter.getSearchResultFragment();
|
|
if (searchResultFragment != null) {
|
|
searchResultFragment.handleResultVisibility(errorVisible);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setStatus(final CharSequence text) {
|
|
try {
|
|
runOnUiThread(() -> mBinding.bottomSheet.statusText.setText(text));
|
|
} catch (Throwable th) {
|
|
LOG.error("Failed to update status text", th);
|
|
}
|
|
}
|
|
|
|
public void showFirstBuildNotice() {
|
|
DialogUtils.newMaterialDialogBuilder(this)
|
|
.setPositiveButton(android.R.string.ok, null)
|
|
.setTitle(R.string.title_first_build)
|
|
.setMessage(R.string.msg_first_build)
|
|
.setCancelable(false)
|
|
.create()
|
|
.show();
|
|
}
|
|
|
|
@Override
|
|
public void onGroupClick(DiagnosticGroup group) {
|
|
if (group != null
|
|
&& group.file != null
|
|
&& group.file.exists()
|
|
&& FileUtils.isUtf8(group.file)) {
|
|
openFile(group.file);
|
|
hideViewOptions();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDiagnosticClick(File file, @NonNull DiagnosticItem diagnostic) {
|
|
openFileAndSelect(file, diagnostic.getRange());
|
|
hideViewOptions();
|
|
}
|
|
|
|
public ActivityEditorBinding getBinding() {
|
|
return mBinding;
|
|
}
|
|
|
|
public LayoutDiagnosticInfoBinding getDiagnosticBinding() {
|
|
return mDiagnosticInfoBinding;
|
|
}
|
|
|
|
public void openFileAndSelect(File file, Range selection) {
|
|
openFile(file, selection);
|
|
final var opened = getEditorForFile(file);
|
|
if (opened != null && opened.getEditor() != null) {
|
|
final var editor = opened.getEditor();
|
|
final var range = editor.validateRange(selection);
|
|
editor.post(
|
|
() -> {
|
|
if (LSPUtils.isEqual(range.getStart(), range.getEnd())) {
|
|
editor.setSelection(
|
|
range.getStart().getLine(), range.getEnd().getColumn());
|
|
} else {
|
|
editor.setSelection(range);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTabSelected(@NonNull TabLayout.Tab tab) {
|
|
final var position = tab.getPosition();
|
|
mBinding.editorContainer.setDisplayedChild(position);
|
|
|
|
final var editorView = getEditorAtIndex(position);
|
|
Objects.requireNonNull(editorView);
|
|
|
|
editorView.onEditorSelected();
|
|
mViewModel.setCurrentFile(position, editorView.getFile());
|
|
refreshSymbolInput(editorView);
|
|
invalidateOptionsMenu();
|
|
}
|
|
|
|
@Override
|
|
public void onTabUnselected(@NonNull TabLayout.Tab tab) {
|
|
final var position = tab.getPosition();
|
|
final var editorView = getEditorAtIndex(position);
|
|
if (editorView != null) {
|
|
final var editor = editorView.getEditor();
|
|
if (editor != null) {
|
|
editor.ensureWindowsDismissed();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onTabReselected(@NonNull TabLayout.Tab tab) {
|
|
mTabCloseAction.show(tab.view);
|
|
}
|
|
|
|
@Override
|
|
public boolean onNavigationItemSelected(@NonNull MenuItem p1) {
|
|
final int id = p1.getItemId();
|
|
if (id == R.id.editornav_discuss) {
|
|
getApp().openTelegramGroup();
|
|
} else if (id == R.id.editornav_suggest) {
|
|
getApp().openGitHub();
|
|
} else if (id == R.id.editornav_needHelp) {
|
|
showNeedHelpDialog();
|
|
} else if (id == R.id.editornav_settings) {
|
|
startActivity(new Intent(this, PreferencesActivity.class));
|
|
} else if (id == R.id.editornav_share) {
|
|
startActivity(IntentUtils.getShareTextIntent(getString(R.string.msg_share_app)));
|
|
} else if (id == R.id.editornav_close_project) {
|
|
confirmProjectClose();
|
|
} else if (id == R.id.editornav_terminal) {
|
|
openTerminal();
|
|
}
|
|
mBinding.getRoot().closeDrawer(GravityCompat.START);
|
|
return false;
|
|
}
|
|
|
|
public void loadFragment(Fragment fragment) {
|
|
super.loadFragment(fragment, mBinding.editorFrameLayout.getId());
|
|
}
|
|
|
|
public FileTreeFragment getFileTreeFragment() {
|
|
return mFileTreeFragment;
|
|
}
|
|
|
|
public TreeNode getLastHoldTreeNode() {
|
|
return mLastHeld;
|
|
}
|
|
|
|
public OptionsListFragment getFileOptionsFragment(File file) {
|
|
mFileOptionsFragment = new OptionsListFragment();
|
|
mFileOptionsFragment.addOption(
|
|
new SheetOption(0, R.drawable.ic_file_copy_path, R.string.copy_path, file));
|
|
mFileOptionsFragment.addOption(
|
|
new SheetOption(1, R.drawable.ic_file_rename, R.string.rename_file, file));
|
|
mFileOptionsFragment.addOption(
|
|
new SheetOption(2, R.drawable.ic_delete, R.string.delete_file, file));
|
|
if (file.isDirectory()) {
|
|
mFileOptionsFragment.addOption(
|
|
new SheetOption(3, R.drawable.ic_new_file, R.string.new_file, file));
|
|
mFileOptionsFragment.addOption(
|
|
new SheetOption(4, R.drawable.ic_new_folder, R.string.new_folder, file));
|
|
}
|
|
|
|
return mFileOptionsFragment;
|
|
}
|
|
|
|
public ProgressSheet getProgressSheet(int msg) {
|
|
if (mSearchingProgress != null && mSearchingProgress.isShowing()) {
|
|
mSearchingProgress.dismiss();
|
|
}
|
|
mSearchingProgress = new ProgressSheet();
|
|
mSearchingProgress.setCancelable(false);
|
|
mSearchingProgress.setWelcomeTextEnabled(false);
|
|
mSearchingProgress.setMessage(getString(msg));
|
|
mSearchingProgress.setSubMessageEnabled(false);
|
|
return mSearchingProgress;
|
|
}
|
|
|
|
public MaterialBanner getSyncBanner() {
|
|
return mBinding.syncBanner
|
|
.setContentTextColor(ContextCompat.getColor(this, R.color.primaryTextColor))
|
|
.setBannerBackgroundColor(ContextCompat.getColor(this, R.color.primaryLightColor))
|
|
.setButtonTextColor(ContextCompat.getColor(this, R.color.secondaryColor))
|
|
.setIcon(R.drawable.ic_sync)
|
|
.setContentText(R.string.msg_sync_needed);
|
|
}
|
|
|
|
public TextSheetFragment getDaemonStatusFragment() {
|
|
return mDaemonStatusFragment == null
|
|
? mDaemonStatusFragment =
|
|
new TextSheetFragment()
|
|
.setTextSelectable(true)
|
|
.setTitleText(R.string.gradle_daemon_status)
|
|
: mDaemonStatusFragment;
|
|
}
|
|
|
|
public void setDiagnosticsAdapter(@NonNull final DiagnosticsAdapter adapter) {
|
|
runOnUiThread(
|
|
() -> {
|
|
final var diagnosticsFragment = bottomSheetTabAdapter.getDiagnosticsFragment();
|
|
if (diagnosticsFragment != null) {
|
|
diagnosticsFragment.setAdapter(adapter);
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setSearchResultAdapter(@NonNull final SearchListAdapter adapter) {
|
|
runOnUiThread(
|
|
() -> {
|
|
final var searchResultFragment =
|
|
bottomSheetTabAdapter.getSearchResultFragment();
|
|
if (searchResultFragment != null) {
|
|
searchResultFragment.setAdapter(adapter);
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void showFileOptions(File thisFile, TreeNode node) {
|
|
mLastHeld = node;
|
|
getFileOptionsFragment(thisFile)
|
|
.show(getSupportFragmentManager(), TAG_FILE_OPTIONS_FRAGMENT);
|
|
}
|
|
|
|
@SuppressWarnings("UnusedReturnValue")
|
|
public boolean saveAll() {
|
|
return saveAll(true);
|
|
}
|
|
|
|
public boolean saveAll(boolean notify) {
|
|
return saveAll(notify, false);
|
|
}
|
|
|
|
public boolean saveAll(boolean notify, boolean canProcessResources) {
|
|
SaveResult result = saveAllResult();
|
|
|
|
if (notify) {
|
|
getApp().toast(R.string.all_saved, Toaster.Type.SUCCESS);
|
|
}
|
|
|
|
if (result.gradleSaved) {
|
|
notifySyncNeeded();
|
|
}
|
|
|
|
if (result.xmlSaved && canProcessResources && getBuildService() != null) {
|
|
getBuildService().updateResourceClasses();
|
|
}
|
|
|
|
return result.gradleSaved;
|
|
}
|
|
|
|
public SaveResult saveAllResult() {
|
|
SaveResult result = new SaveResult();
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
saveResult(i, result);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public void saveResult(int index, SaveResult result) {
|
|
if (index >= 0 && index < mViewModel.getOpenedFileCount()) {
|
|
var frag = getEditorAtIndex(index);
|
|
if (frag == null || frag.getFile() == null) {
|
|
return;
|
|
}
|
|
|
|
// Must be called before frag.save()
|
|
// Otherwise, it'll always return false
|
|
final boolean modified = frag.isModified();
|
|
|
|
frag.save();
|
|
|
|
final boolean isGradle = frag.getFile().getName().endsWith(".gradle");
|
|
final boolean isXml = frag.getFile().getName().endsWith(".xml");
|
|
|
|
if (!result.gradleSaved) {
|
|
result.gradleSaved = modified && isGradle;
|
|
}
|
|
|
|
if (!result.xmlSaved) {
|
|
result.xmlSaved = modified && isXml;
|
|
}
|
|
}
|
|
|
|
var modified = false;
|
|
for (var file : mViewModel.getOpenedFiles()) {
|
|
var editor = getEditorForFile(file);
|
|
if (editor == null) {
|
|
continue;
|
|
}
|
|
modified = modified || editor.isModified();
|
|
}
|
|
|
|
mViewModel.setFilesModified(modified);
|
|
}
|
|
|
|
public void install(@NonNull File apk) {
|
|
if (apk.exists()) {
|
|
Intent i = IntentUtils.getInstallAppIntent(apk);
|
|
if (i != null) {
|
|
startActivity(i);
|
|
} else {
|
|
getApp().toast(R.string.msg_apk_install_intent_failed, Toaster.Type.ERROR);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void updateServices() {
|
|
new TaskExecutor()
|
|
.executeAsync(
|
|
() -> {
|
|
List<String> cps =
|
|
Objects.requireNonNull(getAndroidProject()).getClassPaths();
|
|
getApp().getJavaLanguageServer()
|
|
.configurationChanged(
|
|
new JavaServerConfiguration(
|
|
cps.stream()
|
|
.map(Paths::get)
|
|
.collect(Collectors.toSet())));
|
|
return null;
|
|
},
|
|
__ -> setStatus(getString(R.string.msg_service_started)));
|
|
}
|
|
|
|
@Override
|
|
public CodeEditorView openFile(File file) {
|
|
return openFile(file, null);
|
|
}
|
|
|
|
public CodeEditorView openFile(File file, com.itsaky.lsp.models.Range selection) {
|
|
if (selection == null) {
|
|
selection = com.itsaky.lsp.models.Range.NONE;
|
|
}
|
|
|
|
int index = openFileAndGetIndex(file, selection);
|
|
final var tab = mBinding.tabs.getTabAt(index);
|
|
if (tab != null && index >= 0 && !tab.isSelected()) {
|
|
tab.select();
|
|
}
|
|
|
|
if (mBinding.editorDrawerLayout.isDrawerOpen(GravityCompat.END)) {
|
|
mBinding.editorDrawerLayout.closeDrawer(GravityCompat.END);
|
|
}
|
|
|
|
mBinding.editorContainer.setDisplayedChild(index);
|
|
|
|
invalidateOptionsMenu();
|
|
try {
|
|
return getEditorAtIndex(index);
|
|
} catch (Throwable th) {
|
|
LOG.error("Unable to get editor fragment at opened file index", index);
|
|
LOG.error(th);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@SuppressLint("NotifyDataSetChanged")
|
|
public int openFileAndGetIndex(File file, com.itsaky.lsp.models.Range selection) {
|
|
final var openedFileIndex = findIndexOfEditorByFile(file);
|
|
|
|
if (openedFileIndex != -1) {
|
|
LOG.error("File is already opened. File: " + file);
|
|
return openedFileIndex;
|
|
}
|
|
|
|
final var position = mViewModel.getOpenedFileCount();
|
|
|
|
LOG.info("Opening file at index:", position, "file: ", file);
|
|
|
|
final var editor = new CodeEditorView(this, file, selection);
|
|
editor.getEditor().subscribeEvent(ContentChangeEvent.class, this::onEditorContentChanged);
|
|
editor.setLayoutParams(
|
|
new ViewGroup.LayoutParams(
|
|
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
|
|
|
|
mBinding.editorContainer.addView(editor);
|
|
mBinding.editorContainer.setDisplayedChild(position);
|
|
mBinding.tabs.addTab(mBinding.tabs.newTab().setText(file.getName()));
|
|
|
|
mViewModel.addFile(file);
|
|
mViewModel.setCurrentFile(position, file);
|
|
|
|
return position;
|
|
}
|
|
|
|
public void closeFile(int index) {
|
|
if (index >= 0 && index < mViewModel.getOpenedFileCount()) {
|
|
var opened = mViewModel.getOpenedFile(index);
|
|
LOG.info("Closing file:", opened);
|
|
final var editor = getEditorAtIndex(index);
|
|
|
|
if (editor != null && editor.isModified()) {
|
|
notifyFilesUnsaved(Collections.singletonList(editor), () -> closeFile(index));
|
|
return;
|
|
}
|
|
|
|
if (editor != null && editor.getEditor() != null) {
|
|
editor.getEditor().close();
|
|
} else {
|
|
LOG.error("Cannot save file before close. Editor instance is null");
|
|
}
|
|
|
|
mViewModel.removeFile(index);
|
|
mBinding.tabs.removeTabAt(index);
|
|
mBinding.editorContainer.removeViewAt(index);
|
|
} else {
|
|
LOG.error("Invalid file index. Cannot close.");
|
|
return;
|
|
}
|
|
|
|
mBinding.tabs.requestLayout();
|
|
invalidateOptionsMenu();
|
|
}
|
|
|
|
public void closeAll() {
|
|
closeAll(null);
|
|
}
|
|
|
|
/**
|
|
* Close all opened files. If all the files are saved successfully, then the provided {@link
|
|
* Runnable} will be called.
|
|
*
|
|
* @param onSaved The {@link Runnable} to run when all the files are saved.
|
|
*/
|
|
public void closeAll(Runnable onSaved) {
|
|
final var count = mViewModel.getOpenedFileCount();
|
|
final var unsavedFiles =
|
|
mViewModel.getOpenedFiles().stream()
|
|
.map(this::getEditorForFile)
|
|
.filter(editor -> editor != null && editor.isModified())
|
|
.collect(Collectors.toList());
|
|
|
|
if (unsavedFiles.isEmpty()) {
|
|
// Files were already saved, close all files one by one
|
|
for (int i = 0; i < count; i++) {
|
|
final var editor = getEditorAtIndex(i);
|
|
if (editor != null && editor.getEditor() != null) {
|
|
editor.getEditor().close();
|
|
} else {
|
|
LOG.error("Unable to close file at index:", i);
|
|
}
|
|
}
|
|
|
|
mViewModel.removeAllFiles();
|
|
mBinding.tabs.removeAllTabs();
|
|
mBinding.tabs.requestLayout();
|
|
mBinding.editorContainer.removeAllViews();
|
|
|
|
invalidateOptionsMenu();
|
|
|
|
if (onSaved != null) {
|
|
onSaved.run();
|
|
}
|
|
} else {
|
|
// There are unsaved files
|
|
notifyFilesUnsaved(unsavedFiles, () -> closeAll(onSaved));
|
|
}
|
|
}
|
|
|
|
private void notifyFilesUnsaved(List<CodeEditorView> unsavedEditors, Runnable invokeAfter) {
|
|
//noinspection ConstantConditions
|
|
final var mapped =
|
|
unsavedEditors.stream()
|
|
.map(CodeEditorView::getFile)
|
|
.filter(Objects::nonNull)
|
|
.map(File::getAbsolutePath)
|
|
.collect(Collectors.toList());
|
|
final var builder =
|
|
DialogUtils.newYesNoDialog(
|
|
this,
|
|
getString(R.string.title_files_unsaved), // title
|
|
getString(
|
|
R.string.msg_files_unsaved,
|
|
TextUtils.join("\n", mapped)), // message
|
|
(dialog, which) -> { // 'yes' click
|
|
dialog.dismiss();
|
|
saveAll(true);
|
|
invokeAfter.run();
|
|
},
|
|
(dialog, which) -> { // 'no' click
|
|
dialog.dismiss();
|
|
// Mark all the files as saved, then try to close them all
|
|
for (var editor : unsavedEditors) {
|
|
editor.markAsSaved();
|
|
}
|
|
|
|
invokeAfter.run();
|
|
});
|
|
builder.show();
|
|
}
|
|
|
|
public void closeOthers() {
|
|
final var unsavedFiles =
|
|
mViewModel.getOpenedFiles().stream()
|
|
.map(this::getEditorForFile)
|
|
.filter(editor -> editor != null && editor.isModified())
|
|
.collect(Collectors.toList());
|
|
|
|
if (unsavedFiles.isEmpty()) {
|
|
final var file = mViewModel.getCurrentFile();
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
final var editor = getEditorAtIndex(i);
|
|
|
|
// Index of files changes as we keep close files
|
|
// So we compare the files instead of index
|
|
if (editor != null) {
|
|
if (!file.equals(editor.getFile())) {
|
|
closeFile(i);
|
|
}
|
|
} else {
|
|
LOG.error("Unable to save file at index:", i);
|
|
}
|
|
}
|
|
} else {
|
|
notifyFilesUnsaved(unsavedFiles, this::closeOthers);
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public CodeEditorView getCurrentEditor() {
|
|
if (mViewModel.getCurrentFileIndex() != -1) {
|
|
return getEditorAtIndex(mViewModel.getCurrentFileIndex());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Nullable
|
|
public CodeEditorView getEditorAtIndex(final int index) {
|
|
return (CodeEditorView) mBinding.editorContainer.getChildAt(index);
|
|
}
|
|
|
|
@Nullable
|
|
public CodeEditorView getEditorForFile(@NonNull final File file) {
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
final CodeEditorView editor = (CodeEditorView) mBinding.editorContainer.getChildAt(i);
|
|
if (file.equals(editor.getFile())) {
|
|
return editor;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public int findIndexOfEditorByFile(File file) {
|
|
if (file == null) {
|
|
LOG.error("Cannot find index of a null file.");
|
|
return -1;
|
|
}
|
|
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
final var opened = mViewModel.getOpenedFile(i);
|
|
if (opened.equals(file)) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/////////////////////////////////////////////////
|
|
////////////// PRIVATE APIS /////////////////////
|
|
/////////////////////////////////////////////////
|
|
|
|
private void onEditorContentChanged(ContentChangeEvent event, Unsubscribe unsubscribe) {
|
|
if (event.getAction() != ContentChangeEvent.ACTION_SET_NEW_TEXT) {
|
|
mViewModel.setFilesModified(true);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("deprecation")
|
|
private void checkForCompilerModule() {
|
|
if (!Environment.isCompilerModuleInstalled()) {
|
|
final var pd =
|
|
ProgressDialog.show(
|
|
this,
|
|
getString(R.string.title_compiler_module_install),
|
|
getString(R.string.msg_compiler_module_install),
|
|
true,
|
|
false);
|
|
|
|
final CompletableFuture<Boolean> future =
|
|
CompletableFuture.supplyAsync(
|
|
() -> {
|
|
final var tmpModule =
|
|
new File(Environment.TMP_DIR, "compiler-module.zip");
|
|
if (!ResourceUtils.copyFileFromAssets(
|
|
ToolsManager.getCommonAsset("compiler-module.zip"),
|
|
tmpModule.getAbsolutePath())) {
|
|
throw new CompletionException(
|
|
new RuntimeException(
|
|
"Unable to copy compiler-module.zip"));
|
|
}
|
|
|
|
try {
|
|
ZipUtils.unzipFile(tmpModule, Environment.COMPILER_MODULE);
|
|
} catch (Throwable e) {
|
|
throw new CompletionException(e);
|
|
}
|
|
|
|
if (!Environment.isCompilerModuleInstalled()) {
|
|
throw new CompletionException(
|
|
new RuntimeException("Unknown error"));
|
|
}
|
|
|
|
try {
|
|
FileUtils.delete(tmpModule);
|
|
} catch (Exception e) {
|
|
// ignored
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
future.whenComplete(
|
|
(result, error) -> {
|
|
pd.dismiss();
|
|
|
|
if (error != null) {
|
|
showCompilerModuleInstallError(error);
|
|
return;
|
|
}
|
|
|
|
getApp().toast(
|
|
getString(R.string.msg_compiler_module_installed),
|
|
Toaster.Type.SUCCESS);
|
|
});
|
|
}
|
|
}
|
|
|
|
private void showCompilerModuleInstallError(Throwable error) {
|
|
final var stacktrace = ThrowableUtils.getFullStackTrace(error);
|
|
final var builder = DialogUtils.newMaterialDialogBuilder(this);
|
|
builder.setTitle(R.string.title_installation_failed);
|
|
builder.setMessage(getString(R.string.msg_compiler_module_install_failed, stacktrace));
|
|
builder.setCancelable(false);
|
|
builder.setPositiveButton(android.R.string.ok, (dialog, which) -> dialog.dismiss());
|
|
builder.setNegativeButton(
|
|
R.string.copy,
|
|
(dialog, which) -> {
|
|
ClipboardUtils.copyText(stacktrace);
|
|
dialog.dismiss();
|
|
});
|
|
builder.show();
|
|
}
|
|
|
|
private void dispatchOnPauseToEditors() {
|
|
CompletableFuture.runAsync(
|
|
() -> {
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
final var editor = getEditorAtIndex(i);
|
|
if (editor != null) {
|
|
editor.onPause();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
private void dispatchOnResumeToEditors() {
|
|
CompletableFuture.runAsync(
|
|
() -> {
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
final var editor = getEditorAtIndex(i);
|
|
if (editor != null) {
|
|
editor.onResume();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
@Contract(pure = true)
|
|
private void onGetUIDesignerResult(@NonNull ActivityResult result) {
|
|
final var index = mBinding.editorContainer.getDisplayedChild();
|
|
final var editor = getEditorAtIndex(index);
|
|
if (editor != null && result.getResultCode() == RESULT_OK) {
|
|
final var data = result.getData();
|
|
if (data != null && data.hasExtra(DesignerActivity.KEY_GENERATED_CODE)) {
|
|
final var code = data.getStringExtra(DesignerActivity.KEY_GENERATED_CODE);
|
|
editor.getEditor().setText(code);
|
|
saveAll();
|
|
} else {
|
|
final var msg = getString(R.string.msg_invalid_designer_result);
|
|
getApp().toast(msg, Toaster.Type.ERROR);
|
|
LOG.error(msg, "Data returned by UI Designer is null or is invalid.");
|
|
}
|
|
} else {
|
|
LOG.error(
|
|
"UI Designer returned an invalid result code.",
|
|
"Result code: " + result.getResultCode());
|
|
}
|
|
}
|
|
|
|
private void previewLayout() {
|
|
try {
|
|
|
|
if (getCurrentEditor() == null || getCurrentEditor().getFile() == null) {
|
|
LOG.error("No file is opened. Cannot preview layout.");
|
|
return;
|
|
}
|
|
|
|
saveAll(false);
|
|
|
|
final Intent intent = new Intent(this, DesignerActivity.class);
|
|
intent.putExtra(
|
|
DesignerActivity.KEY_LAYOUT_PATH,
|
|
getCurrentEditor().getFile().getAbsolutePath());
|
|
intent.putStringArrayListExtra(DesignerActivity.KEY_RES_DIRS, getResourceDirectories());
|
|
LOG.info("Launching UI Designer...");
|
|
mUIDesignerLauncher.launch(intent);
|
|
} catch (Throwable th) {
|
|
LOG.error(getString(R.string.err_cannot_preview_layout), th);
|
|
getApp().toast(R.string.msg_cannot_preview_layout, Toaster.Type.ERROR);
|
|
}
|
|
}
|
|
|
|
@NonNull
|
|
private ArrayList<String> getResourceDirectories() {
|
|
final var dirs = new ArrayList<String>();
|
|
if (getAndroidProject() != null
|
|
&& getAndroidProject().getModulePaths() != null
|
|
&& !getAndroidProject().getModulePaths().isEmpty()) {
|
|
for (String path : getAndroidProject().getModulePaths()) {
|
|
if (path != null && new File(path).exists()) {
|
|
File res = new File(path, "src/main/res");
|
|
if (res.exists()) {
|
|
dirs.add(res.getAbsolutePath());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return dirs;
|
|
}
|
|
|
|
private void openTerminal() {
|
|
final Intent intent = new Intent(this, TerminalActivity.class);
|
|
intent.putExtra(
|
|
TerminalActivity.KEY_WORKING_DIRECTORY,
|
|
Objects.requireNonNull(getAndroidProject()).getProjectPath());
|
|
startActivity(intent);
|
|
}
|
|
|
|
private void getProjectFromIntent() {
|
|
final var project = (AndroidProject) getIntent().getParcelableExtra(EXTRA_PROJECT);
|
|
if (mViewModel != null) {
|
|
mViewModel.setAndroidProject(project);
|
|
} else {
|
|
LOG.error("ViewModel is null. Cannot set project.");
|
|
}
|
|
getApp().getPrefManager()
|
|
.setOpenedProject(
|
|
Objects.requireNonNull(this.getAndroidProject()).getProjectPath());
|
|
|
|
try {
|
|
//noinspection ConstantConditions
|
|
getSupportActionBar()
|
|
.setSubtitle(new File(getAndroidProject().getProjectPath()).getName());
|
|
} catch (Throwable th) {
|
|
// ignored
|
|
}
|
|
|
|
CompletableFuture.runAsync(
|
|
() ->
|
|
ValuesTableFactory.setupWithResDirectories(
|
|
getResourceDirectories().stream()
|
|
.map(File::new)
|
|
.toArray(File[]::new)));
|
|
}
|
|
|
|
@Nullable
|
|
private AndroidProject getAndroidProject() {
|
|
if (mViewModel == null) {
|
|
return null;
|
|
}
|
|
|
|
return mViewModel.getAndroidProject();
|
|
}
|
|
|
|
@Nullable
|
|
private IDEProject getIDEProject() {
|
|
if (mViewModel == null) {
|
|
return null;
|
|
}
|
|
|
|
return mViewModel.getIDEProject();
|
|
}
|
|
|
|
public void setIDEProject(IDEProject project) {
|
|
if (mViewModel != null) {
|
|
mViewModel.setIDEProject(project);
|
|
}
|
|
}
|
|
|
|
private void setupDiagnosticInfo() {
|
|
GradientDrawable gd = new GradientDrawable();
|
|
gd.setShape(GradientDrawable.RECTANGLE);
|
|
gd.setColor(0xff212121);
|
|
gd.setStroke(1, 0xffffffff);
|
|
gd.setCornerRadius(8);
|
|
mDiagnosticInfoBinding.getRoot().setBackground(gd);
|
|
mDiagnosticInfoBinding.getRoot().setVisibility(View.GONE);
|
|
}
|
|
|
|
private void setupContainers() {
|
|
handleDiagnosticsResultVisibility(true);
|
|
handleSearchResultVisibility(true);
|
|
}
|
|
|
|
private void startServices() {
|
|
|
|
if (!IDELanguageClientImpl.isInitialized()) {
|
|
IDELanguageClientImpl.initialize(this);
|
|
}
|
|
|
|
initializeLanguageServers();
|
|
|
|
// Actually, we don't need to start FileOptionsHandler
|
|
// Because it would work anyway
|
|
// But still we do...
|
|
mFileOptionsHandler.start();
|
|
mBuildServiceHandler.start();
|
|
getBuildServiceHandler().assembleDebug(false);
|
|
}
|
|
|
|
private void initializeLanguageServers() {
|
|
final var client = IDELanguageClientImpl.getInstance();
|
|
final var javaLanguageServer = getApp().getJavaLanguageServer();
|
|
final var workspaceRoots = new HashSet<Path>();
|
|
workspaceRoots.add(
|
|
new File(Objects.requireNonNull(getAndroidProject()).getProjectPath()).toPath());
|
|
workspaceRoots.add(Environment.HOME.toPath().resolve("logsender"));
|
|
|
|
final var params = new InitializeParams(workspaceRoots);
|
|
|
|
javaLanguageServer.connectClient(client);
|
|
javaLanguageServer.applySettings(JavaServerSettings.getInstance());
|
|
javaLanguageServer.initialize(params);
|
|
}
|
|
|
|
private void stopServices() {
|
|
|
|
if (IDELanguageClientImpl.isInitialized()) {
|
|
IDELanguageClientImpl.shutdown();
|
|
}
|
|
|
|
shutdownLanguageServers();
|
|
|
|
if (getBuildService() != null) {
|
|
getBuildService().setListener(null);
|
|
if (mBuildServiceHandler != null) {
|
|
mBuildServiceHandler.stop();
|
|
} else {
|
|
getBuildService().exit();
|
|
}
|
|
}
|
|
|
|
if (mFileOptionsHandler != null) {
|
|
mFileOptionsHandler.stop();
|
|
}
|
|
}
|
|
|
|
private void shutdownLanguageServers() {
|
|
final var javaServer = getApp().getJavaLanguageServer();
|
|
javaServer.shutdown();
|
|
}
|
|
|
|
private void onSoftInputChanged() {
|
|
invalidateOptionsMenu();
|
|
if (KeyboardUtils.isSoftInputVisible(this)) {
|
|
TransitionManager.beginDelayedTransition(mBinding.getRoot(), new Slide(Gravity.TOP));
|
|
symbolInput.setVisibility(View.VISIBLE);
|
|
mBinding.bottomSheet.statusText.setVisibility(View.GONE);
|
|
mBinding.bottomSheet.swipeHint.setVisibility(View.GONE);
|
|
} else {
|
|
TransitionManager.beginDelayedTransition(mBinding.getRoot(), new Slide(Gravity.BOTTOM));
|
|
symbolInput.setVisibility(View.GONE);
|
|
mBinding.bottomSheet.statusText.setVisibility(View.VISIBLE);
|
|
mBinding.bottomSheet.swipeHint.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
|
|
private void refreshSymbolInput(@NonNull CodeEditorView frag) {
|
|
symbolInput.bindEditor(frag.getEditor());
|
|
symbolInput.setSymbols(Symbols.forFile(frag.getFile()));
|
|
}
|
|
|
|
private void notifySyncNeeded() {
|
|
if (getBuildService() != null && !getBuildService().isBuilding()) {
|
|
getSyncBanner()
|
|
.setNegative(android.R.string.cancel, null)
|
|
.setPositive(
|
|
android.R.string.ok, v -> getBuildServiceHandler().assembleDebug(false))
|
|
.show();
|
|
}
|
|
}
|
|
|
|
private void closeProject(boolean manualFinish) {
|
|
stopServices();
|
|
|
|
// Make sure we close files
|
|
// This fill further make sure that file contents are not erased.
|
|
closeAll(
|
|
() -> {
|
|
getApp().getPrefManager().setOpenedProject(PreferenceManager.NO_OPENED_PROJECT);
|
|
getApp().stopAllDaemons();
|
|
|
|
if (manualFinish) {
|
|
finish();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void confirmProjectClose() {
|
|
final MaterialAlertDialogBuilder builder = DialogUtils.newMaterialDialogBuilder(this);
|
|
builder.setTitle(R.string.title_confirm_project_close);
|
|
builder.setMessage(R.string.msg_confirm_project_close);
|
|
builder.setNegativeButton(R.string.no, null);
|
|
builder.setPositiveButton(
|
|
R.string.yes,
|
|
(d, w) -> {
|
|
d.dismiss();
|
|
closeProject(true);
|
|
});
|
|
builder.show();
|
|
}
|
|
|
|
private AlertDialog getFindInProjectDialog() {
|
|
return mFindInProjectDialog == null ? createFindInProjectDialog() : mFindInProjectDialog;
|
|
}
|
|
|
|
@Nullable
|
|
private AlertDialog createFindInProjectDialog() {
|
|
if (getAndroidProject() == null
|
|
|| getAndroidProject().getModulePaths() == null
|
|
|| getAndroidProject().getModulePaths().size() <= 0) {
|
|
getApp().toast(R.string.msg_no_modules, Toaster.Type.ERROR);
|
|
return null;
|
|
}
|
|
final List<String> modules = getAndroidProject().getModulePaths();
|
|
final List<File> srcDirs = new ArrayList<>();
|
|
final LayoutSearchProjectBinding binding =
|
|
LayoutSearchProjectBinding.inflate(getLayoutInflater());
|
|
binding.modulesContainer.removeAllViews();
|
|
for (int i = 0; i < modules.size(); i++) {
|
|
final File file = new File(modules.get(i));
|
|
final File src = new File(file, "src");
|
|
if (!file.exists() || !file.isDirectory() || !src.exists() || !src.isDirectory()) {
|
|
continue;
|
|
}
|
|
|
|
CheckBox check = new CheckBox(this);
|
|
check.setText(file.getName());
|
|
check.setChecked(true);
|
|
|
|
LinearLayout.MarginLayoutParams params = new LinearLayout.MarginLayoutParams(-2, -2);
|
|
params.bottomMargin = SizeUtils.dp2px(4);
|
|
binding.modulesContainer.addView(check, params);
|
|
|
|
srcDirs.add(src);
|
|
}
|
|
final MaterialAlertDialogBuilder builder = DialogUtils.newMaterialDialogBuilder(this);
|
|
builder.setTitle(R.string.menu_find_project);
|
|
builder.setView(binding.getRoot());
|
|
builder.setCancelable(false);
|
|
builder.setPositiveButton(
|
|
R.string.menu_find,
|
|
(dialog, which) -> {
|
|
final String text =
|
|
Objects.requireNonNull(binding.input.getEditText())
|
|
.getText()
|
|
.toString()
|
|
.trim();
|
|
if (text.isEmpty()) {
|
|
getApp().toast(R.string.msg_empty_search_query, Toaster.Type.ERROR);
|
|
return;
|
|
}
|
|
|
|
final List<File> searchDirs = new ArrayList<>();
|
|
for (int i = 0; i < mViewModel.getOpenedFileCount(); i++) {
|
|
CheckBox check = (CheckBox) binding.modulesContainer.getChildAt(i);
|
|
if (check.isChecked()) {
|
|
searchDirs.add(srcDirs.get(i));
|
|
}
|
|
}
|
|
|
|
final String extensions =
|
|
Objects.requireNonNull(binding.filter.getEditText())
|
|
.getText()
|
|
.toString()
|
|
.trim();
|
|
final List<String> extensionList = new ArrayList<>();
|
|
if (!extensions.isEmpty()) {
|
|
if (extensions.contains("|")) {
|
|
for (String str : extensions.split(Pattern.quote("|"))) {
|
|
if (str == null || str.trim().isEmpty()) {
|
|
continue;
|
|
}
|
|
|
|
extensionList.add(str);
|
|
}
|
|
} else {
|
|
extensionList.add(extensions);
|
|
}
|
|
}
|
|
|
|
if (searchDirs.isEmpty()) {
|
|
getApp().toast(R.string.msg_select_search_modules, Toaster.Type.ERROR);
|
|
} else {
|
|
dialog.dismiss();
|
|
getProgressSheet(R.string.msg_searching_project)
|
|
.show(getSupportFragmentManager(), "search_in_project_progress");
|
|
RecursiveFileSearcher.searchRecursiveAsync(
|
|
text, extensionList, searchDirs, this::handleSearchResults);
|
|
}
|
|
});
|
|
builder.setNegativeButton(android.R.string.cancel, (__, ___) -> __.dismiss());
|
|
mFindInProjectDialog = builder.create();
|
|
return mFindInProjectDialog;
|
|
}
|
|
|
|
private void registerLogReceiver() {
|
|
IntentFilter filter = new IntentFilter();
|
|
filter.addAction(LogReceiver.APPEND_LOG);
|
|
registerReceiver(mLogReceiver, filter);
|
|
}
|
|
|
|
private IDEService getBuildService() {
|
|
return mBuildServiceHandler.getService();
|
|
}
|
|
|
|
public BuildServiceHandler getBuildServiceHandler() {
|
|
return mBuildServiceHandler;
|
|
}
|
|
|
|
private void showNeedHelpDialog() {
|
|
MaterialAlertDialogBuilder builder = DialogUtils.newMaterialDialogBuilder(this);
|
|
builder.setTitle(R.string.need_help);
|
|
builder.setMessage(R.string.msg_need_help);
|
|
builder.setPositiveButton(android.R.string.ok, null);
|
|
builder.create().show();
|
|
}
|
|
|
|
private void createQuickActions() {
|
|
ActionItem closeThis =
|
|
new ActionItem(
|
|
ACTION_ID_CLOSE,
|
|
getString(R.string.action_closeThis),
|
|
R.drawable.ic_close_this);
|
|
ActionItem closeOthers =
|
|
new ActionItem(
|
|
ACTION_ID_OTHERS,
|
|
getString(R.string.action_closeOthers),
|
|
R.drawable.ic_close_others);
|
|
ActionItem closeAll =
|
|
new ActionItem(
|
|
ACTION_ID_ALL,
|
|
getString(R.string.action_closeAll),
|
|
R.drawable.ic_close_all);
|
|
mTabCloseAction = new QuickAction(this, QuickAction.HORIZONTAL);
|
|
mTabCloseAction.addActionItem(closeThis, closeOthers, closeAll);
|
|
mTabCloseAction.setColorRes(R.color.tabAction_background);
|
|
mTabCloseAction.setTextColorRes(R.color.tabAction_text);
|
|
|
|
mTabCloseAction.setOnActionItemClickListener(
|
|
(item) -> {
|
|
final int id = item.getActionId();
|
|
if (getApp().getPrefManager()
|
|
.getBoolean(PreferenceManager.KEY_EDITOR_AUTO_SAVE, false)) {
|
|
saveAll();
|
|
}
|
|
|
|
if (id == ACTION_ID_CLOSE) {
|
|
closeFile(mBinding.tabs.getSelectedTabPosition());
|
|
}
|
|
|
|
if (id == ACTION_ID_OTHERS) {
|
|
closeOthers();
|
|
}
|
|
|
|
if (id == ACTION_ID_ALL) {
|
|
closeAll();
|
|
}
|
|
});
|
|
}
|
|
|
|
@Override
|
|
public void onOptionsClick(SheetOption option) {
|
|
if (mFileOptionsHandler != null) {
|
|
mFileOptionsHandler.onOptionsClick(option);
|
|
}
|
|
}
|
|
}
|