path: root/org.fox.ttcomics/src/main/java/org/fox/ttcomics2/MainActivity.java

package org.fox.ttcomics2;


import android.Manifest;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.ActionBar;
import android.support.v7.widget.Toolbar;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;

import org.fox.ttcomics2.sync.SyncClient;
import org.fox.ttcomics2.sync.SyncFolderService;

import java.io.File;
import java.util.Arrays;

import it.neokree.materialtabs.MaterialTab;
import it.neokree.materialtabs.MaterialTabHost;
import it.neokree.materialtabs.MaterialTabListener;

public class MainActivity extends CommonActivity implements MaterialTabListener, SharedPreferences.OnSharedPreferenceChangeListener {
	private final String TAG = this.getClass().getSimpleName();
    private final static int TRIAL_DAYS = 7;
	
	private int m_selectedTab;
    private MaterialTabHost tabHost;
	private ProgressDialog m_progressDialog;
	private boolean m_needRestart;

	private BroadcastReceiver m_serviceReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
			if (SyncFolderService.INTENT_ACTION_FILE_PROCESSED.equals(intent.getAction())) {

				int count = intent.getExtras().getInt("count");
				int index = intent.getExtras().getInt("index");

				m_progressDialog.setCancelable(false);
				m_progressDialog.setTitle("Synchronizing...");
				m_progressDialog.setMessage("File " + index + " of " + count);
				m_progressDialog.show();
			}

			if (SyncFolderService.INTENT_ACTION_SCAN_COMPLETE.equals(intent.getAction())) {
				m_progressDialog.dismiss();
				updateComicsList();
			}

		}
	};

	@SuppressLint("NewApi")
	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

		m_prefs.registerOnSharedPreferenceChangeListener(this);

        setContentView(R.layout.activity_main);
		setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
        setTitle(R.string.app_name);

		m_progressDialog = new ProgressDialog(this);

		tabHost = (MaterialTabHost) this.findViewById(R.id.materialTabHost);

    	if (savedInstanceState == null) {
			m_selectedTab = getIntent().getIntExtra("selectedTab", 0);

			//Log.d(TAG, "selTab=" + m_selectedTab);

			ComicListFragment frag = new ComicListFragment();
			frag.setMode(m_selectedTab);

            if (getIntent().getStringExtra("baseDir") != null) {
            	frag.setBaseDirectory(getIntent().getStringExtra("baseDir"));
            } else {
				frag.setBaseDirectory(m_prefs.getString("comics_directory", ""));
			}

			FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
			ft.replace(R.id.comics_list, frag, FRAG_COMICS_LIST);
			ft.commit();
		} else {
        	//m_baseDirectory = savedInstanceState.getString("baseDir");
    	}

		m_selectedTab = -1;

    	tabHost.addTab(tabHost.newTab()
                .setText(getString(R.string.tab_all_comics))
                .setTabListener(this));

        tabHost.addTab(tabHost.newTab()
    			.setText(getString(R.string.tab_unread))
    			.setTabListener(this));

        tabHost.addTab(tabHost.newTab()
                .setText(getString(R.string.tab_unfinished))
                .setTabListener(this));

        tabHost.addTab(tabHost.newTab()
    			.setText(getString(R.string.tab_read))
    			.setTabListener(this));

    	if (savedInstanceState != null) {
    		m_selectedTab = savedInstanceState.getInt("selectedTab");
    	} else {
    		m_selectedTab = getIntent().getIntExtra("selectedTab", 0);
    	}

        if (m_selectedTab != -1)
   		    tabHost.setSelectedNavigationItem(m_selectedTab);

		if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {

			ActivityCompat.requestPermissions(this,
					new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
					REQUEST_PERMISSION_READ_EXTERNAL_STORAGE);

		} else {
			setupDefaultDirectory();
		}
	}

	private void setupDefaultDirectory() {
		if (m_prefs.getString("comics_directory", null) == null) {
			AlertDialog.Builder builder = new AlertDialog.Builder(this);
			builder.setMessage(R.string.dialog_need_prefs_message)
					.setCancelable(false)
					.setPositiveButton(R.string.dialog_need_prefs_preferences, new DialogInterface.OnClickListener() {
						public void onClick(DialogInterface dialog, int id) {
							Intent intent = new Intent(MainActivity.this,
									PreferencesActivity.class);
							startActivityForResult(intent, 0);
						}
					})
					.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
						public void onClick(DialogInterface dialog, int id) {
							dialog.cancel();
						}
					});
			AlertDialog alert = builder.create();
			alert.show();
		}
	}

	@Override
	public void onRequestPermissionsResult(int requestCode,
										   String permissions[], int[] grantResults) {
		switch (requestCode) {
			case REQUEST_PERMISSION_READ_EXTERNAL_STORAGE: {
				// If request is cancelled, the result arrays are empty.
				if (grantResults.length > 0
						&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {

					// TODO workaround for android 6.0 bug, maybe needs to be removed in the future

					android.os.Process.killProcess(android.os.Process.myPid());

				} else {
					toast("Storage permission denied, the app might not be able to access your comic archives.");
				}

				return;
			}
		}
	}

	@Override
	public void onResume() {
		super.onResume();

		IntentFilter filter = new IntentFilter();
		filter.addAction(SyncFolderService.INTENT_ACTION_FILE_PROCESSED);
		filter.addAction(SyncFolderService.INTENT_ACTION_SCAN_COMPLETE);
		filter.addCategory(Intent.CATEGORY_DEFAULT);

		registerReceiver(m_serviceReceiver, filter);

		//if (m_enableFab != m_prefs.getBoolean("enable_fab", true)) {

		if (m_needRestart) {
			Log.d(TAG, "shared preferences changed, restarting");

			finish();
			startActivity(getIntent());
		}
	}

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);

		menu.findItem(R.id.menu_sync_directory).setVisible(m_prefs.getBoolean("use_position_sync", false) && m_syncClient.hasOwner());

        return true;
    }

    @Override
	public void onSaveInstanceState(Bundle out) {
		super.onSaveInstanceState(out);

		out.putInt("selectedTab", m_selectedTab);
	}

	public int getMode() {
		return m_selectedTab;
	}

    public boolean onOptionsItemSelected(MenuItem item) {
		switch (item.getItemId()) {
		case R.id.menu_sync_directory:
			if (true) {
				AlertDialog.Builder builder = new AlertDialog.Builder(this);
				builder.setMessage("Get synchronized last read page for listed files?")
						.setCancelable(true)
						.setPositiveButton("Continue", new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, int id) {
								ComicListFragment frag = (ComicListFragment) getSupportFragmentManager().findFragmentByTag(FRAG_COMICS_LIST);

								if (frag != null && frag.isAdded()) {
									String baseDir = frag.getBaseDirectory();

									updateLastRead(baseDir);
								}

							}
						})
						.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, int id) {
								dialog.cancel();
							}
						});
				AlertDialog alert = builder.create();
				alert.show();

			}
			return true;
		case android.R.id.home:
			onBackPressed();
			return true;
		default:
			Log.d(TAG,
					"onOptionsItemSelected, unhandled id=" + item.getItemId());
			return super.onOptionsItemSelected(item);
		}
	}

	private void updateLastRead(String baseDir) {
		Intent serviceIntent = new Intent(MainActivity.this, SyncFolderService.class);
		serviceIntent.putExtra("baseDir", baseDir);
		startService(serviceIntent);
	}

	@Override
	public void onComicArchiveSelected(String fileName) {
		super.onComicArchiveSelected(fileName);
		
		File file = new File(fileName);
		
		if (file.isDirectory()) {

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

			intent.putExtra("selectedTab", m_selectedTab);
			intent.putExtra("baseDir", fileName);

			startActivity(intent);

		} else if (file.canRead()) {
			Intent intent = new Intent(MainActivity.this,
					ViewComicActivity.class);

			intent.putExtra("fileName", fileName);

			startActivityForResult(intent, REQUEST_VIEWCOMIC); 
		} else {
			toast(getString(R.string.error_cant_open_file, fileName));

			ComicListFragment frag = (ComicListFragment) getSupportFragmentManager().findFragmentByTag(FRAG_COMICS_LIST);

			if (frag != null && frag.isAdded()) {
				frag.rescan();
			}
		}
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
	    if (requestCode == REQUEST_VIEWCOMIC && resultCode == Activity.RESULT_OK) {
			String fileName = intent.getStringExtra("fileName");
	    	Log.d(TAG, "finished viewing comic: " + fileName);
	    	
	    	if (m_prefs.getBoolean("use_position_sync", false) && m_syncClient.hasOwner()) {
	    		toast(R.string.sync_uploading);
	    		m_syncClient.setPosition(sha1(new File(fileName).getName()), m_databaseHelper.getLastPosition(fileName));
	    	}

			updateComicsList();
	    }
	    
	    System.gc();
	    
	    super.onActivityResult(requestCode, resultCode, intent);
	}

    @Override
    public void onTabSelected(MaterialTab tab) {

        tabHost.setSelectedNavigationItem(tab.getPosition());

        FragmentTransaction sft = getSupportFragmentManager().beginTransaction();

        if (m_selectedTab != tab.getPosition() && m_selectedTab != -1) {

			ComicListFragment frag = (ComicListFragment) getSupportFragmentManager().findFragmentByTag(FRAG_COMICS_LIST);

			if (frag != null && frag.isAdded()) {
				frag.setMode(tab.getPosition());
				frag.refresh();
			}
        }

        m_selectedTab = tab.getPosition();

        sft.commit();
    }

    @Override
    public void onTabReselected(MaterialTab materialTab) {

    }

    @Override
    public void onTabUnselected(MaterialTab materialTab) {

    }

	private void updateComicsList() {
		ComicListFragment frag = (ComicListFragment) getSupportFragmentManager().findFragmentByTag(FRAG_COMICS_LIST);

		if (frag != null && frag.isAdded()) {
			frag.refresh();
		}
	}

	public void resetProgress(final String fileName) {

		if (m_prefs.getBoolean("use_position_sync", false) && m_syncClient.hasOwner()) {
			m_databaseHelper.setLastPosition(fileName, 0);
			m_databaseHelper.setLastMaxPosition(fileName, 0);
			updateComicsList();

			if (m_prefs.getBoolean("use_position_sync", false) && m_syncClient.hasOwner()) {
				AlertDialog.Builder builder = new AlertDialog.Builder(this);
				builder.setMessage(R.string.reset_remove_synced_progress)
						.setCancelable(true)
						.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, int id) {
								m_syncClient.clearData(sha1(new File(fileName).getName()), new SyncClient.DataClearedListener() {
									@Override
									public void onDataCleared(boolean result) {
										updateComicsList();
									}
								});
							}
						})
						.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
							public void onClick(DialogInterface dialog, int id) {
								dialog.cancel();
							}
						});
				AlertDialog alert = builder.create();
				alert.show();
			}

		}

	}

	@Override
	public void onPause() {
		super.onPause();

		unregisterReceiver(m_serviceReceiver);
	}

	@Override
	public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
		String[] filter = new String[] { "enable_fab", "comics_directory", "use_position_sync" };

		m_needRestart = Arrays.asList(filter).indexOf(key) != -1;
	}
}