Page MenuHomeGitPull.it

ActivityPrincipal.java
No OneTemporary

Authored By
Unknown
Size
36 KB
Referenced Files
None
Subscribers
None

ActivityPrincipal.java

/*
BusTO - Arrival times for Turin public transport.
Copyright (C) 2021 Fabio Mazza
This program 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.
This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
package it.reyboz.bustorino;
import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.*;
import android.widget.Toast;
import androidx.activity.OnBackPressedCallback;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.ActionBarDrawerToggle;
import androidx.appcompat.app.AppCompatDelegate;
import androidx.appcompat.widget.Toolbar;
import androidx.core.graphics.Insets;
import androidx.core.view.*;
import androidx.drawerlayout.widget.DrawerLayout;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import androidx.lifecycle.ViewModelProvider;
import androidx.preference.PreferenceManager;
import androidx.work.WorkInfo;
import com.google.android.material.navigation.NavigationView;
import com.google.android.material.snackbar.Snackbar;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.function.Consumer;
import it.reyboz.bustorino.backend.Stop;
import it.reyboz.bustorino.data.DBUpdateCheckWorker;
import it.reyboz.bustorino.data.DBUpdateWorker;
import it.reyboz.bustorino.data.PreferencesHolder;
import it.reyboz.bustorino.fragments.*;
import it.reyboz.bustorino.middleware.GeneralActivity;
import it.reyboz.bustorino.viewmodels.ServiceAlertsViewModel;
import static it.reyboz.bustorino.backend.utils.getBusStopIDFromUri;
import static it.reyboz.bustorino.backend.utils.openIceweasel;
public class ActivityPrincipal extends GeneralActivity implements FragmentListenerMain {
private DrawerLayout mDrawer;
private NavigationView mNavView;
private ActionBarDrawerToggle drawerToggle;
private final static String DEBUG_TAG="BusTO Act Principal";
private final static String TAG_FAVORITES="favorites_frag";
private Snackbar snackbar;
private boolean startedFromIntent = false;
private ServiceAlertsViewModel serviceAlertsViewModel;
private final DrawerLayout.DrawerListener drawerListener = new DrawerLayout.DrawerListener() {
@Override
public void onDrawerSlide(@NonNull View drawerView, float slideOffset) {
}
@Override
public void onDrawerOpened(@NonNull View drawerView) {
hideKeyboard();
}
@Override
public void onDrawerClosed(@NonNull View drawerView) {
}
@Override
public void onDrawerStateChanged(int newState) {
}
};
//private FragmentKind showingFragmentKind;
private final Map<Integer, Runnable> menuActions = Map.of(
R.id.drawer_action_settings, () -> {
Log.d("MAINBusTO", "Pressed button preferences");
startActivity(new Intent(this, ActivitySettings.class));
},
R.id.nav_favorites_item, () ->
checkAndShowFavoritesFragment(getSupportFragmentManager(), true),
R.id.nav_home, this::showHomeMainFragmentFromClick,
R.id.nav_map_item, () ->
requestMapFragment(true),
R.id.nav_lines_item, () ->
showLinesFragment(getSupportFragmentManager(), true, null),
R.id.drawer_action_info, () ->
startActivity(new Intent(this, ActivityAbout.class)),
R.id.nav_nearby, this::openNearbyStopsFragment
);
private long lastClosingAttempt = -1L;
private final OnBackPressedCallback backPressedCallback = new OnBackPressedCallback(false) {
@Override
public void handleOnBackPressed() {
boolean isResolved = activityCustomBackPressed();
Log.d(DEBUG_TAG, "backpress resolved: " + isResolved);
if(!isResolved){
//if(startedFromIntent){
// finish();
//} else{
long currentTime = System.currentTimeMillis();
if (currentTime - lastClosingAttempt < 2000)
finish();
else {
lastClosingAttempt = currentTime;
Toast.makeText(getApplicationContext(), R.string.back_again_to_close, Toast.LENGTH_SHORT).show();
}
//}
}
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(DEBUG_TAG, "onCreate, savedInstanceState is: "+savedInstanceState);
setContentView(R.layout.activity_principal);
serviceAlertsViewModel = new ViewModelProvider(this).get(ServiceAlertsViewModel.class);
//Use LiveModel to sync fragment state
//onBackPressed solution required from Android 16
backPressedCallback.setEnabled(true);
this.getOnBackPressedDispatcher().addCallback(backPressedCallback);
final Toolbar mToolbar = findViewById(R.id.default_toolbar);
setSupportActionBar(mToolbar);
if (getSupportActionBar()!=null)
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
else Log.w(DEBUG_TAG, "NO ACTION BAR");
mToolbar.setOnMenuItemClickListener(new ToolbarItemClickListener(this));
mDrawer = findViewById(R.id.drawer_layout);
drawerToggle = setupDrawerToggle(mToolbar);
// Setup toggle to display hamburger icon with nice animation
drawerToggle.setDrawerIndicatorEnabled(true);
drawerToggle.syncState();
mDrawer.addDrawerListener(drawerToggle);
mDrawer.addDrawerListener(drawerListener);
mNavView = findViewById(R.id.nvView);
setupDrawerContent(mNavView);
/*View header = mNavView.getHeaderView(0);
*/
//mNavView.getMenu().findItem(R.id.versionFooter).
/// LEGACY CODE
//---------------------------- START INTENT CHECK QUEUE ------------------------------------
// Intercept calls from URL intent
boolean tryedFromIntent = false;
String initialBusStopID = null;
var intent = getIntent();
if(intent != null){
var data = intent.getData();
if(data != null){
//var rest = data.getSchemeSpecificPart();
//Log.d(DEBUG_TAG, "the rest is: "+rest);
initialBusStopID = getBusStopIDFromUri(data);
tryedFromIntent = true;
Log.d(DEBUG_TAG, "Opening Intent: initialBusStopID: "+initialBusStopID);
}
// Intercept calls from other activities
if(!tryedFromIntent){
Bundle b =intent.getExtras();
if (b != null) {
initialBusStopID = b.getString("bus-stop-ID");
/*
* I'm not very sure if you are coming from an Intent.
* Some launchers work in strange ways.
*/
tryedFromIntent = initialBusStopID != null;
}
}
}
//---------------------------- END INTENT CHECK QUEUE --------------------------------------
if (initialBusStopID == null) {
// Show keyboard if can't start from intent
// JUST DON'T
// showKeyboard();
// You haven't obtained anything... from an intent?
if (tryedFromIntent) {
// This shows a luser warning
Toast.makeText(getApplicationContext(),
R.string.insert_bus_stop_number_error, Toast.LENGTH_SHORT).show();
}
}
//save whether we started from intent
startedFromIntent = tryedFromIntent;
//period database check
DBUpdateCheckWorker.Companion.schedulePeriodicCheck(this,false);
//Watch for database update
DBUpdateWorker.getWorkInfoLiveData(this)
.observe(this, workInfoList -> {
// If there are no matching work info, do nothing
if (workInfoList == null || workInfoList.isEmpty()) {
return;
}
Log.d(DEBUG_TAG, "WorkerInfo: "+workInfoList);
boolean showProgress = false;
for (WorkInfo workInfo : workInfoList) {
if (workInfo.getState() == WorkInfo.State.RUNNING) {
showProgress = true;
break;
}
}
if (showProgress) {
createDatabaseUpdateSnackbar();
} else {
if(snackbar!=null) {
snackbar.dismiss();
snackbar = null;
}
}
});
// show the main fragment
Fragment f = getSupportFragmentManager().findFragmentById(R.id.mainActContentFrame);
Log.d(DEBUG_TAG, "OnCreate the fragment is "+f);
String vl = PreferenceManager.getDefaultSharedPreferences(this).getString(SettingsFragment.PREF_KEY_STARTUP_SCREEN, "");
Log.d(DEBUG_TAG, "The default screen to open is: "+vl);
var framan = getSupportFragmentManager();
if (initialBusStopID!=null) {
Log.d(DEBUG_TAG, "Opening Main Fragment on arrivals, bus Stop: "+initialBusStopID);
createShowMainFragment(framan, MainScreenFragment.makeArgsArrivals(initialBusStopID), false);
}else if (savedInstanceState==null) {
//we are not restarting the activity from nothing
switch (vl){
case "map" -> {requestMapFragment(false);}
case "favorites" -> checkAndShowFavoritesFragment(framan, false);
case "lines" -> showLinesFragment(framan, false, null);
case "nearby" -> createShowMainFragment(framan, MainScreenFragment.makeArgsNearby(), false);
default -> createShowMainFragment(framan, MainScreenFragment.makeArgsButtonsScreen(), false);
}
}
//boolean onCreateComplete = true;
//default values are set in the BustoApp
//checkApplyDefaultSettingsValues();
// handle the device "insets"
/*
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.rootRelativeLayout), (v, windowInsets) -> {
Insets insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars());
// Apply the insets as a margin to the view. This solution sets only the
// bottom, left, and right dimensions, but you can apply whichever insets are
// appropriate to your layout. You can also update the view padding if that's
// more appropriate.
ViewGroup.MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams) v.getLayoutParams();
mlp.leftMargin = insets.left;
mlp.bottomMargin = insets.bottom;
mlp.rightMargin = insets.right;
v.setLayoutParams(mlp);
//set for toolbar
//mlp = (ViewGroup.MarginLayoutParams) mToolbar.getLayoutParams();
//mlp.topMargin = insets.top;
//mToolbar.setLayoutParams(mlp);
mToolbar.setPadding(0, insets.top, 0, 0);
// Return CONSUMED if you don't want the window insets to keep passing
// down to descendant views.
return WindowInsetsCompat.CONSUMED;
});
//to properly handle IME
WindowInsetsControllerCompat insetsController =
WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView());
if (insetsController != null) {
insetsController.setSystemBarsBehavior(
WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
);
}
*/
// Toolbar: solo inset superiore (status bar)
ViewCompat.setOnApplyWindowInsetsListener(mToolbar, (v, windowInsets) -> {
Insets statusBar = windowInsets.getInsets(WindowInsetsCompat.Type.statusBars());
v.setPadding(0, statusBar.top, 0, 0);
return windowInsets; // NON consumare: passa gli insets ai figli
});
// Content frame: insets laterali e inferiori (navigation bar)
// I fragment figli riceveranno gli insets e potranno gestirli a loro volta
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.mainActContentFrame), (v, windowInsets) -> {
Insets systemBars = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars());
// Solo left/right, bottom lo gestisce ogni fragment
v.setPadding(systemBars.left, 0, systemBars.right, 0);
return windowInsets; //WindowInsetsCompat.CONSUMED; // NON consumare: passa ai fragment
});
//check if first run activity (IntroActivity) has been started once or not
final SharedPreferences theShPr = getMainSharedPreferences();
boolean hasIntroRun = theShPr.getBoolean(PreferencesHolder.PREF_INTRO_ACTIVITY_RUN,false);
if(!hasIntroRun){
startIntroductionActivity();
}
serviceAlertsViewModel.getLastTimeRunningDownload().observe(this, (timeRunning) -> {
if (timeRunning != null) {
Log.d(DEBUG_TAG, "requested alerts download at time: "+timeRunning);
}
});
serviceAlertsViewModel.launchAlertsPeriodCheck();
}
private ActionBarDrawerToggle setupDrawerToggle(Toolbar toolbar) {
// NOTE: Make sure you pass in a valid toolbar reference. ActionBarDrawToggle() does not require it
// and will not render the hamburger icon without it.
return new ActionBarDrawerToggle(this, mDrawer, toolbar, R.string.drawer_open, R.string.drawer_close);
}
/**
* Setup drawer actions
* @param navigationView the navigation view on which to set the callbacks
*/
private void setupDrawerContent(NavigationView navigationView) {
navigationView.setNavigationItemSelectedListener(
menuItem -> {
int menuId = menuItem.getItemId();
if( menuActions.containsKey(menuId)){
closeDrawerIfOpen();
var runnable = menuActions.get(menuId);
if(runnable!=null) runnable.run();
return true;
} else{
return false;
}
});
}
private void closeDrawerIfOpen(){
if (mDrawer.isDrawerOpen(GravityCompat.START))
mDrawer.closeDrawer(GravityCompat.START);
}
// `onPostCreate` called when activity start-up is complete after `onStart()`
// NOTE 1: Make sure to override the method with only a single `Bundle` argument
// Note 2: Make sure you implement the correct `onPostCreate(Bundle savedInstanceState)` method.
// There are 2 signatures and only `onPostCreate(Bundle state)` shows the hamburger icon.
@Override
protected void onPostCreate(Bundle savedInstanceState) {
super.onPostCreate(savedInstanceState);
// Sync the toggle state after onRestoreInstanceState has occurred.
drawerToggle.syncState();
}
@Override
public void onConfigurationChanged(@NonNull Configuration newConfig) {
super.onConfigurationChanged(newConfig);
// Pass any configuration change to the drawer toggles
drawerToggle.onConfigurationChanged(newConfig);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.principal_menu, menu);
MenuItem experimentsMenuItem = menu.findItem(R.id.action_experiments);
SharedPreferences shPr = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
boolean exper_On = shPr.getBoolean(getString(R.string.pref_key_experimental), false);
experimentsMenuItem.setVisible(exper_On);
return super.onCreateOptionsMenu(menu);
}
//requesting permissions
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode==STORAGE_PERMISSION_REQ){
final String storagePerm = Manifest.permission.WRITE_EXTERNAL_STORAGE;
if (permissionDoneRunnables.containsKey(storagePerm)) {
Runnable toRun = permissionDoneRunnables.get(storagePerm);
if (toRun != null)
toRun.run();
permissionDoneRunnables.remove(storagePerm);
}
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
Log.d(DEBUG_TAG, "Permissions check: " + Arrays.toString(permissions));
if (permissionDoneRunnables.containsKey(storagePerm)) {
Runnable toRun = permissionDoneRunnables.get(storagePerm);
if (toRun != null)
toRun.run();
permissionDoneRunnables.remove(storagePerm);
}
} else {
//permission denied
showToastMessage(R.string.permission_storage_maps_msg, false);
}
}
}
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {
Log.d(DEBUG_TAG, "Item pressed");
if (item.getItemId() == android.R.id.home) {
mDrawer.openDrawer(GravityCompat.START);
return true;
}
if (drawerToggle.onOptionsItemSelected(item)) {
return true;
}
return super.onOptionsItemSelected(item);
}
/*@Override
public void onBackPressed() {
if (!activityCustomBackPressed())
super.onBackPressed();
}
*/
private boolean activityCustomBackPressed(){
var mainFragManager = getSupportFragmentManager();
boolean resolved = mainFragManager.getBackStackEntryCount() > 0;
Fragment shownFrag = mainFragManager.findFragmentById(R.id.mainActContentFrame);
if (mDrawer.isDrawerOpen(GravityCompat.START)) {
mDrawer.closeDrawer(GravityCompat.START);
resolved = true;
}
else if (shownFrag instanceof MainScreenFragment mainFrag) { //the only case when we have to pop both stacks
mainFrag.cancelReloadArrivalsIfNeeded();
var chManager = mainFrag.getChildFragmentManager();
if(chManager.getBackStackEntryCount() > 0){
chManager.popBackStack();
Log.d(DEBUG_TAG, "Child back stack popped");
resolved = true;
} else{
Log.d(DEBUG_TAG, "No back stack on child fragment manager");
}
boolean haveToPopMainFromFragment = mainFrag.needToPopMainStackOnBack();
//mainFrag.getChildFragmentManager().popBackStack();
if(haveToPopMainFromFragment){ // pops the stack
mainFragManager.popBackStack();
}
}
else if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
mainFragManager.popBackStack();
var newFrag = mainFragManager.findFragmentById(R.id.mainActContentFrame);
if(newFrag != null) {
int backStackCount = newFrag.getChildFragmentManager().getBackStackEntryCount();
Log.d(DEBUG_TAG, "new fragment is "+newFrag.getClass().getSimpleName() +", count of the backstack: "+backStackCount);
}
Log.d(DEBUG_TAG, "Popping main backstack");
}
else{
resolved = false;
}
return resolved;
}
/**
* Create and show the SnackBar with the message
* The fragment shown points to which view to attach the snackbar
*/
private void createDatabaseUpdateSnackbar() {
View baseView = null;
boolean showSnackbar = true;
final Fragment frag = getSupportFragmentManager().findFragmentById(R.id.mainActContentFrame);
if (frag instanceof ScreenBaseFragment){
baseView = ((ScreenBaseFragment) frag).getBaseViewForSnackBar();
showSnackbar = ((ScreenBaseFragment) frag).showSnackbarOnDBUpdate();
}
if (baseView == null) baseView = findViewById(R.id.mainActContentFrame);
//if (baseView == null) Log.e(DEBUG_TAG, "baseView null for default snackbar, probably exploding now");
if (baseView !=null && showSnackbar) {
snackbar = Snackbar.make(baseView, R.string.database_update_msg_inapp, Snackbar.LENGTH_INDEFINITE);
snackbar.setTextColor(getColor(android.R.color.white));
snackbar.setBackgroundTint(getColor(R.color.grey_800));
if (frag instanceof ScreenBaseFragment){
((ScreenBaseFragment) frag).setSnackbarPropertiesBeforeShowing(snackbar);
}
snackbar.show();
} else{
Log.e(DEBUG_TAG, "Asked to show the snackbar but the baseView is null");
}
}
/*
private void updateShowingFragmentKindInternal(@NonNull FragmentKind newKind){
if(BuildConfig.DEBUG)
Log.d(DEBUG_TAG, "Updating fragment kind, new: "+newKind+", current: "+showingFragmentKind);
boolean showingMainFragmentFromOther = false;
if(showingFragmentKind == null){
showingFragmentKind = newKind;
showingMainFragmentFromOther = false;
} else if(newKind != showingFragmentKind) {
showingMainFragmentFromOther = (
FragmentKind.getSuperKind(newKind) != FragmentKind.getSuperKind(showingFragmentKind));
showingFragmentKind = newKind;
}
}
*/
/**
* Show the actual fragment by adding it to the backstack
* @param fraMan the fragmentManager
* @param fragment the fragment
*/
private static void showMainFragment(FragmentManager fraMan, MainScreenFragment fragment, boolean addToBackStack){
FragmentTransaction ft = fraMan.beginTransaction()
.replace(R.id.mainActContentFrame, fragment, MainScreenFragment.FRAGMENT_TAG)
.setReorderingAllowed(false)
/*.setCustomAnimations(
R.anim.slide_in, // enter
R.anim.fade_out, // exit
R.anim.fade_in, // popEnter
R.anim.slide_out // popExit
)*/
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
if (addToBackStack) {
ft.addToBackStack(null);
}
ft.commit();
}
/**
* Create a new MainFragment for the arguments provided and show it in the layout
* @param fraMan the fragmentManager
* @param arguments args for the fragment
*/
private static void createShowMainFragment(FragmentManager fraMan,@Nullable Bundle arguments, boolean addToBackStack){
FragmentTransaction ft = fraMan.beginTransaction()
.replace(R.id.mainActContentFrame, MainScreenFragment.class, arguments, MainScreenFragment.FRAGMENT_TAG)
.setReorderingAllowed(false)
/*.setCustomAnimations(
R.anim.slide_in, // enter
R.anim.fade_out, // exit
R.anim.fade_in, // popEnter
R.anim.slide_out // popExit
)*/
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
if (addToBackStack) ft.addToBackStack(null);
ft.commit();
}
private void showHomeMainFragmentFromClick(){
FragmentManager fraMan = getSupportFragmentManager();
var fragment = fraMan.findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if(fragment instanceof MainScreenFragment mainFrag){
var visible = mainFrag.isVisible();
if(!mainFrag.isVisible()){
showMainFragment(fraMan, mainFrag, true);
}
mainFrag.showButtonsFragmentIfNotNearby(true);
} else{
createShowMainFragment(fraMan, MainScreenFragment.makeArgsButtonsScreen(), true);
}
}
private void requestMapFragment(final boolean allowReturn){
// starting from Android 11, we don't need to have the STORAGE permission anymore for the map cache
FragmentManager fm = getSupportFragmentManager();
Fragment fragment = fm.findFragmentById(R.id.mainActContentFrame);
if(fragment instanceof MapLibreFragment){
Log.d(DEBUG_TAG, "Requested map fragment, but it is already open");
} else {
fragment = fm.findFragmentByTag(MapLibreFragment.FRAGMENT_TAG);
if(fragment != null){
Log.d(DEBUG_TAG, "Found map fragment, reopening it");
var ft = fm.beginTransaction();
ft.replace(R.id.mainActContentFrame,fragment, MapLibreFragment.FRAGMENT_TAG);
if(allowReturn) ft.addToBackStack(null);
ft.commit();
} else {
//create from scratch
//The permissions are handled in the MapLibreFragment instead
createAndShowMapFragment(null, allowReturn);
}
}
}
private void checkAndShowFavoritesFragment(FragmentManager fragmentManager, boolean addToBackStack){
if(getSupportFragmentManager().findFragmentById(R.id.mainActContentFrame) instanceof FavoritesFragment){
Log.d(DEBUG_TAG, "Requested favorites fragment, but it is already open");
return;
}
FragmentTransaction ft = fragmentManager.beginTransaction();
Fragment fragment = fragmentManager.findFragmentByTag(TAG_FAVORITES);
if(fragment!=null){
ft.replace(R.id.mainActContentFrame, fragment, TAG_FAVORITES);
}else{
//use new method
ft.replace(R.id.mainActContentFrame,FavoritesFragment.class,null,TAG_FAVORITES);
}
if (addToBackStack)
ft.addToBackStack("favorites_main");
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.setReorderingAllowed(false);
ft.commit();
}
private void showLinesFragment(@NonNull FragmentManager fragmentManager, boolean addToBackStack, @Nullable Bundle fragArgs){
if(getSupportFragmentManager().findFragmentById(R.id.mainActContentFrame) instanceof LinesGridShowingFragment){
Log.d(DEBUG_TAG, "Requested lines grid fragment, but it is already open");
return;
}
FragmentTransaction ft = fragmentManager.beginTransaction();
Fragment f = fragmentManager.findFragmentByTag(LinesGridShowingFragment.FRAGMENT_TAG);
if(f!=null){
ft.replace(R.id.mainActContentFrame, f, LinesGridShowingFragment.FRAGMENT_TAG);
}else{
//use new method
ft.replace(R.id.mainActContentFrame,LinesGridShowingFragment.class,fragArgs,
LinesGridShowingFragment.FRAGMENT_TAG);
}
if (addToBackStack)
ft.addToBackStack("linesGrid");
ft.setReorderingAllowed(true)
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.commit();
}
/*
@Nullable
private MainScreenFragment getMainFragmentIfVisible(){
FragmentManager fraMan = getSupportFragmentManager();
Fragment fragment = fraMan.findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if (fragment!= null && fragment.isVisible()) return (MainScreenFragment) fragment;
else return null;
}
*/
@Override
public void showFloatingActionButton(boolean yes) {
var framan = getSupportFragmentManager();
var frag = framan.findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if(frag instanceof MainScreenFragment mainFrag){
mainFrag.showFloatingActionButton(yes);
} else{
Log.d(DEBUG_TAG, "No main screen fragment found to set showFloatingActionButton");
}
}
/*
public void setDrawerSelectedItem(String fragmentTag){
switch (fragmentTag){
case MainScreenFragment.FRAGMENT_TAG:
mNavView.setCheckedItem(R.id.nav_arrivals);
break;
case MapFragment.FRAGMENT_TAG:
break;
case FavoritesFragment.FRAGMENT_TAG:
mNavView.setCheckedItem(R.id.nav_favorites_item);
break;
}
}*/
@Override
public void readyGUIfor(FragmentKind fragmentType) {
//updateShowingFragmentKindInternal(fragmentType);
if(BuildConfig.DEBUG) Log.d(DEBUG_TAG, "readyGUIfor fragment kind: " + fragmentType);
Integer titleResId = null;
switch (fragmentType){
case MAP:
mNavView.setCheckedItem(R.id.nav_map_item);
titleResId = R.string.map;
break;
case FAVORITES:
mNavView.setCheckedItem(R.id.nav_favorites_item);
titleResId = R.string.nav_favorites_text;
break;
case ARRIVALS:
titleResId = R.string.nav_arrivals_text;
mNavView.setCheckedItem(R.id.nav_home);
//TODO: Figure out way to change title
//mNavView.getCheckedItem().setTitle(R.string.nav_arrivals_text);
break;
case STOPS:
titleResId = R.string.stop_search_view_title;
mNavView.setCheckedItem(R.id.nav_home);
break;
case MAIN_SCREEN_FRAGMENT:
case HOME_BUTTONS:
titleResId=R.string.app_name_full;
mNavView.setCheckedItem(R.id.nav_home);
//mNavView.getCheckedItem().setTitle(R.string.nav_home_text);
break;
case NEARBY_STOPS:
case NEARBY_ARRIVALS:
titleResId=R.string.app_name_full;
mNavView.setCheckedItem(R.id.nav_nearby);
break;
case LINES:
titleResId=R.string.lines;
mNavView.setCheckedItem(R.id.nav_lines_item);
break;
}
if(getSupportActionBar()!=null && titleResId!=null)
getSupportActionBar().setTitle(titleResId);
//MainScreenFragment mainFragmentIfVisible = getMainFragmentIfVisible();
var frag = getSupportFragmentManager().findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if (frag instanceof MainScreenFragment mainFrag){
mainFrag.readyGUIfor(fragmentType);
}
}
@Override
public void requestArrivalsForStopID(String ID) {
Consumer<MainScreenFragment> consumer = fragment -> {
fragment.setSuppressArrivalsReload(true);
fragment.requestArrivalsForStopID(ID);
};
boolean done = getMainFragmentAndDoStuff(consumer);
if(!done){
//create the fragment
final Bundle args = MainScreenFragment.makeArgsArrivals(ID);
createShowMainFragment(getSupportFragmentManager(), args ,true);
}
}
@Override
public void openLineFromStop(String routeGtfsId, @Nullable String stopIDFrom){
FragmentTransaction tr = getSupportFragmentManager().beginTransaction();
tr.replace(R.id.mainActContentFrame, LinesDetailFragment.class,
LinesDetailFragment.Companion.makeArgs(routeGtfsId, stopIDFrom));
tr.addToBackStack("LineFromStop-"+routeGtfsId);
tr.commit();
}
private boolean getMainFragmentAndDoStuff(Consumer<MainScreenFragment> consumer){
FragmentManager fraMan = getSupportFragmentManager();
var frag = fraMan.findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if( frag instanceof MainScreenFragment mainFrag){
if(!mainFrag.isVisible()) {
showMainFragment(fraMan, mainFrag, true);
mainFrag.setMainFragmentManagerTransition(true);
} else{
mainFrag.setMainFragmentManagerTransition(false);
}
consumer.accept(mainFrag);
return true;
} else{
return false;
}
}
@Override
public void openLineFromVehicle(String routeGtfsId, @Nullable String optionalPatternId, @Nullable Bundle args) {
FragmentTransaction tr = getSupportFragmentManager().beginTransaction();
tr.replace(R.id.mainActContentFrame, LinesDetailFragment.class,
LinesDetailFragment.Companion.makeArgsPattern(routeGtfsId, optionalPatternId, args));
tr.addToBackStack("LineFromOther-"+routeGtfsId);
tr.commit();
}
@Override
public void openNearbyStopsFragment() {
boolean done = getMainFragmentAndDoStuff(MainScreenFragment::openNearbyStopsFragment);
if(!done){
createShowMainFragment(getSupportFragmentManager(), MainScreenFragment.makeArgsNearby(), true);
}
}
@Override
public void openLinesFragment() {
showLinesFragment(getSupportFragmentManager(), true, null);
}
@Override
public void openFavoritesFragment() {
checkAndShowFavoritesFragment(getSupportFragmentManager(), true);
}
@Override
public void toggleSpinner(boolean state) {
var frag = getSupportFragmentManager().findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if (frag instanceof MainScreenFragment mainFrag) {
mainFrag.toggleSpinner(state);
}
}
@Override
public void enableRefreshLayout(boolean yes) {
Log.d(DEBUG_TAG, "enableRefreshLayout: "+yes);
var framan = getSupportFragmentManager();
var frag = framan.findFragmentByTag(MainScreenFragment.FRAGMENT_TAG);
if (frag instanceof MainScreenFragment mainFrag){
mainFrag.enableRefreshLayout(yes);
}
}
@Override
public void showMapCenteredOnStop(@Nullable Stop stop) {
createAndShowMapFragment(stop, true);
}
//Map Fragment stuff
void createAndShowMapFragment(@Nullable Stop stop, boolean addToBackStack){
final FragmentManager fm = getSupportFragmentManager();
final FragmentTransaction ft = fm.beginTransaction();
final MapLibreFragment fragment = MapLibreFragment.newInstance(stop);
ft.replace(R.id.mainActContentFrame, fragment, MapLibreFragment.FRAGMENT_TAG);
if (addToBackStack) ft.addToBackStack(null);
ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
ft.commit();
}
void startIntroductionActivity(){
Intent intent = new Intent(ActivityPrincipal.this, ActivityIntro.class);
intent.putExtra(ActivityIntro.RESTART_MAIN, false);
startActivity(intent);
}
class ToolbarItemClickListener implements Toolbar.OnMenuItemClickListener{
private final Context activityContext;
public ToolbarItemClickListener(Context activityContext) {
this.activityContext = activityContext;
}
@Override
public boolean onMenuItemClick(MenuItem item) {
final int id = item.getItemId();
if(id == R.id.action_about){
startActivity(new Intent(ActivityPrincipal.this, ActivityAbout.class));
return true;
} else if (id == R.id.action_hack) {
openIceweasel(getString(R.string.hack_url), activityContext);
return true;
} else if (id == R.id.action_source){
openIceweasel("https://gitpull.it/source/libre-busto/", activityContext);
return true;
} else if (id == R.id.action_licence){
openIceweasel("https://www.gnu.org/licenses/gpl-3.0.html", activityContext);
return true;
} else if (id == R.id.action_experiments) {
startActivity(new Intent(ActivityPrincipal.this, ActivityExperiments.class));
return true;
} else if (id == R.id.action_tutorial) {
startIntroductionActivity();
return true;
}
return false;
}
}
@Override
protected void onPause() {
super.onPause();
// stop updating the alerts
serviceAlertsViewModel.setRunningDownloadRequests(false);
}
@Override
protected void onResume() {
super.onResume();
serviceAlertsViewModel.launchAlertsPeriodCheck();
}
}

File Metadata

Mime Type
text/x-java
Expires
Thu, Nov 19, 09:53 (2 m, 8 s)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
2265710
Default Alt Text
ActivityPrincipal.java (36 KB)

Event Timeline