Trying to add plugin support for mobile app

ReactNativeClient/Root.tsx

@@ -0,0 +1,876 @@
+import setUpQuickActions from './setUpQuickActions';
+import PluginAssetsLoader from './PluginAssetsLoader';
+import reducer, { defaultState, State } from 'lib/reducer';
+import AlarmService from 'lib/services/AlarmService';
+import AlarmServiceDriver from 'lib/services/AlarmServiceDriver.ios';
+import Alarm from 'lib/models/Alarm';
+import Logger, { TargetType } from 'lib/Logger';
+import BaseService from 'lib/services/BaseService';
+import NoteScreen from 'lib/components/screens/Note';
+import UpgradeSyncTargetScreen from 'lib/components/screens/UpgradeSyncTargetScreen';
+import Setting from 'lib/models/Setting';
+import PoorManIntervals from 'lib/PoorManIntervals';
+import ShareExtension from 'lib/ShareExtension';
+import handleShared from 'lib/shareHandler';
+import uuid from 'lib/uuid';
+import KeychainServiceDriverMobile from 'lib/services/keychain/KeychainServiceDriver.mobile';
+import shim from 'lib/shim';
+import PluginService from 'lib/services/plugins/PluginService';
+import PluginRunner from './services/plugins/PluginRunner';
+
+const React = require('react');
+const { AppState, Keyboard, NativeModules, BackHandler, Animated, View, StatusBar } = require('react-native');
+const SafeAreaView = require('lib/components/SafeAreaView');
+const { connect, Provider } = require('react-redux');
+const { BackButtonService } = require('lib/services/back-button.js');
+const NavService = require('lib/services/NavService.js');
+const { createStore, applyMiddleware } = require('redux');
+const reduxSharedMiddleware = require('lib/components/shared/reduxSharedMiddleware');
+const { shimInit } = require('lib/shim-init-react.js');
+const { time } = require('lib/time-utils.js');
+const { AppNav } = require('lib/components/app-nav.js');
+const Note = require('lib/models/Note.js');
+const Folder = require('lib/models/Folder.js');
+const BaseSyncTarget = require('lib/BaseSyncTarget.js');
+const { FoldersScreenUtils } = require('lib/folders-screen-utils.js');
+const Resource = require('lib/models/Resource.js');
+const Tag = require('lib/models/Tag.js');
+const NoteTag = require('lib/models/NoteTag.js');
+const BaseItem = require('lib/models/BaseItem.js');
+const MasterKey = require('lib/models/MasterKey.js');
+const Revision = require('lib/models/Revision.js');
+const BaseModel = require('lib/BaseModel.js');
+const ResourceService = require('lib/services/ResourceService');
+const RevisionService = require('lib/services/RevisionService');
+const KvStore = require('lib/services/KvStore');
+const { JoplinDatabase } = require('lib/joplin-database.js');
+const { Database } = require('lib/database.js');
+const { NotesScreen } = require('lib/components/screens/notes.js');
+const { TagsScreen } = require('lib/components/screens/tags.js');
+const { ConfigScreen } = require('lib/components/screens/config.js');
+const { FolderScreen } = require('lib/components/screens/folder.js');
+const { LogScreen } = require('lib/components/screens/log.js');
+const { StatusScreen } = require('lib/components/screens/status.js');
+const { SearchScreen } = require('lib/components/screens/search.js');
+const { OneDriveLoginScreen } = require('lib/components/screens/onedrive-login.js');
+const { EncryptionConfigScreen } = require('lib/components/screens/encryption-config.js');
+const { DropboxLoginScreen } = require('lib/components/screens/dropbox-login.js');
+const { MenuContext } = require('react-native-popup-menu');
+const { SideMenu } = require('lib/components/side-menu.js');
+const { SideMenuContent } = require('lib/components/side-menu-content.js');
+const { SideMenuContentNote } = require('lib/components/side-menu-content-note.js');
+const { DatabaseDriverReactNative } = require('lib/database-driver-react-native');
+const { reg } = require('lib/registry.js');
+const { setLocale, closestSupportedLocale, defaultLocale } = require('lib/locale');
+const { FileApiDriverLocal } = require('lib/file-api-driver-local.js');
+const RNFetchBlob = require('rn-fetch-blob').default;
+const DropdownAlert = require('react-native-dropdownalert').default;
+const ResourceFetcher = require('lib/services/ResourceFetcher');
+const SearchEngine = require('lib/services/searchengine/SearchEngine');
+const WelcomeUtils = require('lib/WelcomeUtils');
+const { themeStyle } = require('lib/components/global-style.js');
+
+const { loadKeychainServiceAndSettings } = require('lib/services/SettingUtils');
+
+const SyncTargetRegistry = require('lib/SyncTargetRegistry.js');
+const SyncTargetOneDrive = require('lib/SyncTargetOneDrive.js');
+const SyncTargetFilesystem = require('lib/SyncTargetFilesystem.js');
+const SyncTargetNextcloud = require('lib/SyncTargetNextcloud.js');
+const SyncTargetWebDAV = require('lib/SyncTargetWebDAV.js');
+const SyncTargetDropbox = require('lib/SyncTargetDropbox.js');
+const SyncTargetAmazonS3 = require('lib/SyncTargetAmazonS3.js');
+
+SyncTargetRegistry.addClass(SyncTargetOneDrive);
+SyncTargetRegistry.addClass(SyncTargetNextcloud);
+SyncTargetRegistry.addClass(SyncTargetWebDAV);
+SyncTargetRegistry.addClass(SyncTargetDropbox);
+SyncTargetRegistry.addClass(SyncTargetFilesystem);
+SyncTargetRegistry.addClass(SyncTargetAmazonS3);
+
+const FsDriverRN = require('lib/fs-driver-rn.js').FsDriverRN;
+const DecryptionWorker = require('lib/services/DecryptionWorker');
+const EncryptionService = require('lib/services/EncryptionService');
+const MigrationService = require('lib/services/MigrationService');
+
+const DEFAULT_ROUTE = {
+	type: 'NAV_GO',
+	routeName: 'Notes',
+	smartFilterId: 'c3176726992c11e9ac940492261af972',
+};
+
+export interface AppState extends State {
+	sideMenuOpenPercent: number,
+	route: any,
+	noteSelectionEnabled: boolean,
+	noteSideMenuOptions: any,
+}
+
+const appDefaultState:AppState = {
+	...defaultState,
+	sideMenuOpenPercent: 0,
+	route: DEFAULT_ROUTE,
+	noteSelectionEnabled: false,
+	noteSideMenuOptions: null,
+}
+
+let storeDispatch = function(_action:any) {};
+
+const logReducerAction = function(action:any) {
+	if (['SIDE_MENU_OPEN_PERCENT', 'SYNC_REPORT_UPDATE'].indexOf(action.type) >= 0) return;
+
+	const msg = [action.type];
+	if (action.routeName) msg.push(action.routeName);
+
+	// reg.logger().debug('Reducer action', msg.join(', '));
+};
+
+const generalMiddleware = (store:any) => (next:any) => async (action:any) => {
+	logReducerAction(action);
+	PoorManIntervals.update(); // This function needs to be called regularly so put it here
+
+	const result = next(action);
+	const newState:AppState = store.getState();
+
+	await reduxSharedMiddleware(store, next, action);
+
+	if (action.type == 'NAV_GO') Keyboard.dismiss();
+
+	if (['NOTE_UPDATE_ONE', 'NOTE_DELETE', 'FOLDER_UPDATE_ONE', 'FOLDER_DELETE'].indexOf(action.type) >= 0) {
+		if (!await reg.syncTarget().syncStarted()) reg.scheduleSync(5 * 1000, { syncSteps: ['update_remote', 'delete_remote'] });
+		SearchEngine.instance().scheduleSyncTables();
+	}
+
+	if (['EVENT_NOTE_ALARM_FIELD_CHANGE', 'NOTE_DELETE'].indexOf(action.type) >= 0) {
+		await AlarmService.updateNoteNotification(action.id, action.type === 'NOTE_DELETE');
+	}
+
+	if (action.type == 'SETTING_UPDATE_ONE' && action.key == 'sync.interval' || action.type == 'SETTING_UPDATE_ALL') {
+		reg.setupRecurrentSync();
+	}
+
+	if ((action.type == 'SETTING_UPDATE_ONE' && (action.key == 'dateFormat' || action.key == 'timeFormat')) || (action.type == 'SETTING_UPDATE_ALL')) {
+		time.setDateFormat(Setting.value('dateFormat'));
+		time.setTimeFormat(Setting.value('timeFormat'));
+	}
+
+	if (action.type == 'SETTING_UPDATE_ONE' && action.key == 'locale' || action.type == 'SETTING_UPDATE_ALL') {
+		setLocale(Setting.value('locale'));
+	}
+
+	if ((action.type == 'SETTING_UPDATE_ONE' && (action.key.indexOf('encryption.') === 0)) || (action.type == 'SETTING_UPDATE_ALL')) {
+		await EncryptionService.instance().loadMasterKeysFromSettings();
+		DecryptionWorker.instance().scheduleStart();
+		const loadedMasterKeyIds = EncryptionService.instance().loadedMasterKeyIds();
+
+		storeDispatch({
+			type: 'MASTERKEY_REMOVE_NOT_LOADED',
+			ids: loadedMasterKeyIds,
+		});
+
+		// Schedule a sync operation so that items that need to be encrypted
+		// are sent to sync target.
+		reg.scheduleSync();
+	}
+
+	if (action.type == 'NAV_GO' && action.routeName == 'Notes') {
+		Setting.setValue('activeFolderId', newState.selectedFolderId);
+	}
+
+	if (action.type === 'SYNC_GOT_ENCRYPTED_ITEM') {
+		DecryptionWorker.instance().scheduleStart();
+	}
+
+	if (action.type === 'SYNC_CREATED_OR_UPDATED_RESOURCE') {
+		ResourceFetcher.instance().autoAddResources();
+	}
+
+	return result;
+};
+
+const navHistory:any[] = [];
+
+function historyCanGoBackTo(route:any) {
+	if (route.routeName === 'Note') return false;
+	if (route.routeName === 'Folder') return false;
+
+	// There's no point going back to these screens in general and, at least in OneDrive case,
+	// it can be buggy to do so, due to incorrectly relying on global state (reg.syncTarget...)
+	if (route.routeName === 'OneDriveLogin') return false;
+	if (route.routeName === 'DropboxLogin') return false;
+
+	return true;
+}
+
+const appReducer = (state:AppState = appDefaultState, action:any) => {
+	let newState = state;
+	let historyGoingBack = false;
+
+	try {
+		switch (action.type) {
+
+		// @ts-ignore
+		case 'NAV_BACK':
+
+		{
+			if (!navHistory.length) break;
+
+			let newAction = null;
+			while (navHistory.length) {
+				newAction = navHistory.pop();
+				if (newAction.routeName != state.route.routeName) break;
+			}
+
+			action = newAction ? newAction : navHistory.pop();
+
+			historyGoingBack = true;
+		}
+
+		// Fall throught
+
+		case 'NAV_GO':
+
+			{
+				const currentRoute = state.route;
+
+				if (!historyGoingBack && historyCanGoBackTo(currentRoute)) {
+				// If the route *name* is the same (even if the other parameters are different), we
+				// overwrite the last route in the history with the current one. If the route name
+				// is different, we push a new history entry.
+					if (currentRoute.routeName == action.routeName) {
+					// nothing
+					} else {
+						navHistory.push(currentRoute);
+					}
+				}
+
+				// HACK: whenever a new screen is loaded, all the previous screens of that type
+				// are overwritten with the new screen parameters. This is because the way notes
+				// are currently loaded is not optimal (doesn't retain history properly) so
+				// this is a simple fix without doing a big refactoring to change the way notes
+				// are loaded. Might be good enough since going back to different folders
+				// is probably not a common workflow.
+				for (let i = 0; i < navHistory.length; i++) {
+					const n = navHistory[i];
+					if (n.routeName == action.routeName) {
+						navHistory[i] = Object.assign({}, action);
+					}
+				}
+
+				newState = Object.assign({}, state);
+
+				newState.selectedNoteHash = '';
+
+				if ('noteId' in action) {
+					newState.selectedNoteIds = action.noteId ? [action.noteId] : [];
+				}
+
+				if ('folderId' in action) {
+					newState.selectedFolderId = action.folderId;
+					newState.notesParentType = 'Folder';
+				}
+
+				if ('tagId' in action) {
+					newState.selectedTagId = action.tagId;
+					newState.notesParentType = 'Tag';
+				}
+
+				if ('smartFilterId' in action) {
+					newState.selectedSmartFilterId = action.smartFilterId;
+					newState.notesParentType = 'SmartFilter';
+				}
+
+				if ('itemType' in action) {
+					newState.selectedItemType = action.itemType;
+				}
+
+				if ('noteHash' in action) {
+					newState.selectedNoteHash = action.noteHash;
+				}
+
+				if ('sharedData' in action) {
+					newState.sharedData = action.sharedData;
+				} else {
+					newState.sharedData = null;
+				}
+
+				newState.route = action;
+				newState.historyCanGoBack = !!navHistory.length;
+			}
+			break;
+
+		case 'SIDE_MENU_TOGGLE':
+
+			newState = Object.assign({}, state);
+			newState.showSideMenu = !newState.showSideMenu;
+			break;
+
+		case 'SIDE_MENU_OPEN':
+
+			newState = Object.assign({}, state);
+			newState.showSideMenu = true;
+			break;
+
+		case 'SIDE_MENU_CLOSE':
+
+			newState = Object.assign({}, state);
+			newState.showSideMenu = false;
+			break;
+
+		case 'SIDE_MENU_OPEN_PERCENT':
+
+			newState = Object.assign({}, state);
+			newState.sideMenuOpenPercent = action.value;
+			break;
+
+		case 'NOTE_SELECTION_TOGGLE':
+
+			{
+				newState = Object.assign({}, state);
+
+				const noteId = action.id;
+				const newSelectedNoteIds = state.selectedNoteIds.slice();
+				const existingIndex = state.selectedNoteIds.indexOf(noteId);
+
+				if (existingIndex >= 0) {
+					newSelectedNoteIds.splice(existingIndex, 1);
+				} else {
+					newSelectedNoteIds.push(noteId);
+				}
+
+				newState.selectedNoteIds = newSelectedNoteIds;
+				newState.noteSelectionEnabled = !!newSelectedNoteIds.length;
+			}
+			break;
+
+		case 'NOTE_SELECTION_START':
+
+			if (!state.noteSelectionEnabled) {
+				newState = Object.assign({}, state);
+				newState.noteSelectionEnabled = true;
+				newState.selectedNoteIds = [action.id];
+			}
+			break;
+
+		case 'NOTE_SELECTION_END':
+
+			newState = Object.assign({}, state);
+			newState.noteSelectionEnabled = false;
+			newState.selectedNoteIds = [];
+			break;
+
+		case 'NOTE_SIDE_MENU_OPTIONS_SET':
+
+			newState = Object.assign({}, state);
+			newState.noteSideMenuOptions = action.options;
+			break;
+
+		}
+	} catch (error) {
+		error.message = `In reducer: ${error.message} Action: ${JSON.stringify(action)}`;
+		throw error;
+	}
+
+	return reducer(newState, action);
+};
+
+const store = createStore(appReducer, applyMiddleware(generalMiddleware));
+storeDispatch = store.dispatch;
+
+function resourceFetcher_downloadComplete(event:any) {
+	if (event.encrypted) {
+		DecryptionWorker.instance().scheduleStart();
+	}
+}
+
+function decryptionWorker_resourceMetadataButNotBlobDecrypted() {
+	ResourceFetcher.instance().scheduleAutoAddResources();
+}
+
+async function initialize(dispatch:Function) {
+	shimInit();
+
+	Setting.setConstant('env', __DEV__ ? 'dev' : 'prod');
+	Setting.setConstant('appId', 'net.cozic.joplin-mobile');
+	Setting.setConstant('appType', 'mobile');
+	Setting.setConstant('resourceDir', RNFetchBlob.fs.dirs.DocumentDir);
+	Setting.setConstant('pluginDir', Setting.value('resourceDir') + '/plugins');
+
+	const logDatabase = new Database(new DatabaseDriverReactNative());
+	await logDatabase.open({ name: 'log.sqlite' });
+	await logDatabase.exec(Logger.databaseCreateTableSql());
+
+	const mainLogger = new Logger();
+	mainLogger.addTarget(TargetType.Database, { database: logDatabase, source: 'm' });
+	mainLogger.setLevel(Logger.LEVEL_INFO);
+
+	if (Setting.value('env') == 'dev') {
+		mainLogger.addTarget(TargetType.Console);
+		mainLogger.setLevel(Logger.LEVEL_DEBUG);
+	}
+
+	reg.setLogger(mainLogger);
+	reg.setShowErrorMessageBoxHandler((message:string) => { alert(message); });
+
+	BaseService.logger_ = mainLogger;
+	// require('lib/ntpDate').setLogger(reg.logger());
+
+	reg.logger().info('====================================');
+	reg.logger().info(`Starting application ${Setting.value('appId')} (${Setting.value('env')})`);
+
+	const dbLogger = new Logger();
+	dbLogger.addTarget(TargetType.Database, { database: logDatabase, source: 'm' });
+	if (Setting.value('env') == 'dev') {
+		dbLogger.addTarget(TargetType.Console);
+		dbLogger.setLevel(Logger.LEVEL_INFO); // Set to LEVEL_DEBUG for full SQL queries
+	} else {
+		dbLogger.setLevel(Logger.LEVEL_INFO);
+	}
+
+	const db = new JoplinDatabase(new DatabaseDriverReactNative());
+	db.setLogger(dbLogger);
+	reg.setDb(db);
+
+	reg.dispatch = dispatch;
+	BaseModel.dispatch = dispatch;
+	FoldersScreenUtils.dispatch = dispatch;
+	BaseSyncTarget.dispatch = dispatch;
+	NavService.dispatch = dispatch;
+	BaseModel.setDb(db);
+
+	KvStore.instance().setDb(reg.db());
+
+	BaseItem.loadClass('Note', Note);
+	BaseItem.loadClass('Folder', Folder);
+	BaseItem.loadClass('Resource', Resource);
+	BaseItem.loadClass('Tag', Tag);
+	BaseItem.loadClass('NoteTag', NoteTag);
+	BaseItem.loadClass('MasterKey', MasterKey);
+	BaseItem.loadClass('Revision', Revision);
+
+	const fsDriver = new FsDriverRN();
+
+	Resource.fsDriver_ = fsDriver;
+	FileApiDriverLocal.fsDriver_ = fsDriver;
+
+	AlarmService.setDriver(new AlarmServiceDriver(mainLogger));
+	AlarmService.setLogger(mainLogger);
+
+	try {
+		if (Setting.value('env') == 'prod') {
+			await db.open({ name: 'joplin.sqlite' });
+		} else {
+			await db.open({ name: 'joplin-76.sqlite' });
+
+			// await db.clearForTesting();
+		}
+
+		reg.logger().info('Database is ready.');
+		reg.logger().info('Loading settings...');
+
+		await loadKeychainServiceAndSettings(KeychainServiceDriverMobile);
+
+		if (!Setting.value('clientId')) Setting.setValue('clientId', uuid.create());
+
+		if (Setting.value('firstStart')) {
+			let locale = NativeModules.I18nManager.localeIdentifier;
+			if (!locale) locale = defaultLocale();
+			Setting.setValue('locale', closestSupportedLocale(locale));
+			Setting.setValue('firstStart', 0);
+		}
+
+		if (Setting.value('db.ftsEnabled') === -1) {
+			const ftsEnabled = await db.ftsEnabled();
+			Setting.setValue('db.ftsEnabled', ftsEnabled ? 1 : 0);
+			reg.logger().info('db.ftsEnabled = ', Setting.value('db.ftsEnabled'));
+		}
+
+		if (Setting.value('env') === 'dev') {
+			Setting.setValue('welcome.enabled', false);
+		}
+
+		PluginAssetsLoader.instance().setLogger(mainLogger);
+		await PluginAssetsLoader.instance().importAssets();
+
+		// eslint-disable-next-line require-atomic-updates
+		BaseItem.revisionService_ = RevisionService.instance();
+
+		// Note: for now we hard-code the folder sort order as we need to
+		// create a UI to allow customisation (started in branch mobile_add_sidebar_buttons)
+		Setting.setValue('folders.sortOrder.field', 'title');
+		Setting.setValue('folders.sortOrder.reverse', false);
+
+		reg.logger().info(`Sync target: ${Setting.value('sync.target')}`);
+
+		setLocale(Setting.value('locale'));
+
+		// ----------------------------------------------------------------
+		// E2EE SETUP
+		// ----------------------------------------------------------------
+
+		EncryptionService.fsDriver_ = fsDriver;
+		EncryptionService.instance().setLogger(mainLogger);
+		// eslint-disable-next-line require-atomic-updates
+		BaseItem.encryptionService_ = EncryptionService.instance();
+		DecryptionWorker.instance().dispatch = dispatch;
+		DecryptionWorker.instance().setLogger(mainLogger);
+		DecryptionWorker.instance().setKvStore(KvStore.instance());
+		DecryptionWorker.instance().setEncryptionService(EncryptionService.instance());
+		await EncryptionService.instance().loadMasterKeysFromSettings();
+		DecryptionWorker.instance().on('resourceMetadataButNotBlobDecrypted', decryptionWorker_resourceMetadataButNotBlobDecrypted);
+
+		// ----------------------------------------------------------------
+		// / E2EE SETUP
+		// ----------------------------------------------------------------
+
+		reg.logger().info('Loading folders...');
+
+		await FoldersScreenUtils.refreshFolders();
+
+		const tags = await Tag.allWithNotes();
+
+		dispatch({
+			type: 'TAG_UPDATE_ALL',
+			items: tags,
+		});
+
+		const masterKeys = await MasterKey.all();
+
+		dispatch({
+			type: 'MASTERKEY_UPDATE_ALL',
+			items: masterKeys,
+		});
+
+		const folderId = Setting.value('activeFolderId');
+		let folder = await Folder.load(folderId);
+
+		if (!folder) folder = await Folder.defaultFolder();
+
+		dispatch({
+			type: 'FOLDER_SET_COLLAPSED_ALL',
+			ids: Setting.value('collapsedFolderIds'),
+		});
+
+		if (!folder) {
+			dispatch(DEFAULT_ROUTE);
+		} else {
+			dispatch({
+				type: 'NAV_GO',
+				routeName: 'Notes',
+				folderId: folder.id,
+			});
+		}
+
+		setUpQuickActions(dispatch, folderId);
+	} catch (error) {
+		alert(`Initialization error: ${error.message}`);
+		reg.logger().error('Initialization error:', error);
+	}
+
+	reg.setupRecurrentSync();
+
+	PoorManIntervals.setTimeout(() => {
+		AlarmService.garbageCollect();
+	}, 1000 * 60 * 60);
+
+	ResourceService.runInBackground();
+
+	ResourceFetcher.instance().setFileApi(() => { return reg.syncTarget().fileApi(); });
+	ResourceFetcher.instance().setLogger(reg.logger());
+	ResourceFetcher.instance().dispatch = dispatch;
+	ResourceFetcher.instance().on('downloadComplete', resourceFetcher_downloadComplete);
+	ResourceFetcher.instance().start();
+
+	SearchEngine.instance().setDb(reg.db());
+	SearchEngine.instance().setLogger(reg.logger());
+	SearchEngine.instance().scheduleSyncTables();
+
+	await MigrationService.instance().run();
+
+	// When the app starts we want the full sync to
+	// start almost immediately to get the latest data.
+	reg.scheduleSync(1000).then(() => {
+		// Wait for the first sync before updating the notifications, since synchronisation
+		// might change the notifications.
+		AlarmService.updateAllNotifications();
+
+		DecryptionWorker.instance().scheduleStart();
+	});
+
+	await WelcomeUtils.install(dispatch);
+
+	// Collect revisions more frequently on mobile because it doesn't auto-save
+	// and it cannot collect anything when the app is not active.
+	RevisionService.instance().runInBackground(1000 * 30);
+
+
+
+
+	const pluginRunner = new PluginRunner();
+	PluginService.instance().setLogger(reg.logger());
+	PluginService.instance().initialize({
+		joplin: {
+			workspace: {},
+		},
+	}, pluginRunner, store);
+
+	try {
+		if (await shim.fsDriver().exists(Setting.value('pluginDir'))) await PluginService.instance().loadAndRunPlugins(Setting.value('pluginDir'));
+	} catch (error) {
+		this.logger().error(`There was an error loading plugins from ${Setting.value('pluginDir')}:`, error);
+	}
+
+	try {
+		if (Setting.value('plugins.devPluginPaths')) {
+			const paths = Setting.value('plugins.devPluginPaths').split(',').map((p:string) => p.trim());
+			await PluginService.instance().loadAndRunPlugins(paths);
+		}
+
+		// Also load dev plugins that have passed via command line arguments
+		if (Setting.value('startupDevPlugins')) {
+			await PluginService.instance().loadAndRunPlugins(Setting.value('startupDevPlugins'));
+		}
+	} catch (error) {
+		this.logger().error(`There was an error loading plugins from ${Setting.value('plugins.devPluginPaths')}:`, error);
+	}
+
+
+	
+
+
+	// const pluginString = `
+	// 	/* joplin-manifest:
+	// 	{
+	// 		"manifest_version": 1,
+	// 		"name": "JS Bundle test",
+	// 		"description": "JS Bundle Test plugin",
+	// 		"version": "1.0.0",
+	// 		"author": "Laurent Cozic",
+	// 		"homepage_url": "https://joplinapp.org"
+	// 	}
+	// 	*/
+
+	// 	joplin.plugins.register({
+	// 		onStart: async function() {
+	// 			const folder = await joplin.data.post(['folders'], null, { title: "my plugin folder" });
+	// 			await joplin.data.post(['notes'], null, { parent_id: folder.id, title: "testing plugin!" });
+	// 		},
+	// 	});
+	// `;
+
+	// await shim.fsDriver().writeFile(Setting.value('pluginDir') + '/simple.js', pluginString, 'utf8');
+
+	// console.info(await shim.fsDriver().readFile(Setting.value('pluginDir') + '/simple.js', 'utf8'));
+
+	reg.logger().info('Application initialized');
+}
+
+class AppComponent extends React.Component {
+
+	constructor() {
+		super();
+
+		this.state = {
+			sideMenuContentOpacity: new Animated.Value(0),
+		};
+
+		this.lastSyncStarted_ = defaultState.syncStarted;
+
+		this.backButtonHandler_ = () => {
+			return this.backButtonHandler();
+		};
+
+		this.onAppStateChange_ = () => {
+			PoorManIntervals.update();
+		};
+	}
+
+	// 2020-10-08: It seems the initialisation code is quite fragile in general and should be kept simple.
+	// For example, adding a loading screen as was done in this commit: https://github.com/laurent22/joplin/commit/569355a3182bc12e50a54249882e3d68a72c2b28.
+	// had for effect that sharing with the app would create multiple instances of the app, thus breaking
+	// database access and so on. It's unclear why it happens and how to fix it but reverting that commit
+	// fixed the issue for now.
+	//
+	// Changing app launch mode doesn't help.
+	//
+	// It's possible that it's a bug in React Native, or perhaps the framework expects that the whole app can be
+	// mounted/unmounted or multiple ones can be running at the same time, but the app was not designed in this
+	// way.
+	//
+	// More reports and info about the multiple instance bug:
+	//
+	// https://github.com/laurent22/joplin/issues/3800
+	// https://github.com/laurent22/joplin/issues/3804
+	// https://github.com/laurent22/joplin/issues/3807
+	// https://discourse.joplinapp.org/t/webdav-config-encryption-config-randomly-lost-on-android/11364
+	// https://discourse.joplinapp.org/t/android-keeps-on-resetting-my-sync-and-theme/11443
+	async componentDidMount() {
+		if (this.props.appState == 'starting') {
+			this.props.dispatch({
+				type: 'APP_STATE_SET',
+				state: 'initializing',
+			});
+
+			await initialize(this.props.dispatch);
+
+			this.props.dispatch({
+				type: 'APP_STATE_SET',
+				state: 'ready',
+			});
+		}
+
+		BackButtonService.initialize(this.backButtonHandler_);
+
+		AlarmService.setInAppNotificationHandler(async (alarmId:string) => {
+			const alarm = await Alarm.load(alarmId);
+			const notification = await Alarm.makeNotification(alarm);
+			this.dropdownAlert_.alertWithType('info', notification.title, notification.body ? notification.body : '');
+		});
+
+		AppState.addEventListener('change', this.onAppStateChange_);
+
+		const sharedData = await ShareExtension.data();
+		if (sharedData) {
+			reg.logger().info('Received shared data');
+			if (this.props.selectedFolderId) {
+				handleShared(sharedData, this.props.selectedFolderId, this.props.dispatch);
+			} else {
+				reg.logger.info('Cannot handle share - default folder id is not set');
+			}
+		}
+	}
+
+	componentWillUnmount() {
+		AppState.removeEventListener('change', this.onAppStateChange_);
+	}
+
+	componentDidUpdate(prevProps:any) {
+		if (this.props.showSideMenu !== prevProps.showSideMenu) {
+			Animated.timing(this.state.sideMenuContentOpacity, {
+				toValue: this.props.showSideMenu ? 0.5 : 0,
+				duration: 600,
+			}).start();
+		}
+	}
+
+	async backButtonHandler() {
+		if (this.props.noteSelectionEnabled) {
+			this.props.dispatch({ type: 'NOTE_SELECTION_END' });
+			return true;
+		}
+
+		if (this.props.showSideMenu) {
+			this.props.dispatch({ type: 'SIDE_MENU_CLOSE' });
+			return true;
+		}
+
+		if (this.props.historyCanGoBack) {
+			this.props.dispatch({ type: 'NAV_BACK' });
+			return true;
+		}
+
+		BackHandler.exitApp();
+
+		return false;
+	}
+
+	UNSAFE_componentWillReceiveProps(newProps:any) {
+		if (newProps.syncStarted != this.lastSyncStarted_) {
+			if (!newProps.syncStarted) FoldersScreenUtils.refreshFolders();
+			this.lastSyncStarted_ = newProps.syncStarted;
+		}
+	}
+
+	sideMenu_change(isOpen:boolean) {
+		// Make sure showSideMenu property of state is updated
+		// when the menu is open/closed.
+		this.props.dispatch({
+			type: isOpen ? 'SIDE_MENU_OPEN' : 'SIDE_MENU_CLOSE',
+		});
+	}
+
+	render() {
+		if (this.props.appState != 'ready') return null;
+		const theme = themeStyle(this.props.themeId);
+
+		let sideMenuContent = null;
+		let menuPosition = 'left';
+
+		if (this.props.routeName === 'Note') {
+			sideMenuContent = <SafeAreaView style={{ flex: 1, backgroundColor: theme.backgroundColor }}><SideMenuContentNote options={this.props.noteSideMenuOptions}/></SafeAreaView>;
+			menuPosition = 'right';
+		} else {
+			sideMenuContent = <SafeAreaView style={{ flex: 1, backgroundColor: theme.backgroundColor }}><SideMenuContent/></SafeAreaView>;
+		}
+
+		const appNavInit = {
+			Notes: { screen: NotesScreen },
+			Note: { screen: NoteScreen },
+			Tags: { screen: TagsScreen },
+			Folder: { screen: FolderScreen },
+			OneDriveLogin: { screen: OneDriveLoginScreen },
+			DropboxLogin: { screen: DropboxLoginScreen },
+			EncryptionConfig: { screen: EncryptionConfigScreen },
+			UpgradeSyncTarget: { screen: UpgradeSyncTargetScreen },
+			Log: { screen: LogScreen },
+			Status: { screen: StatusScreen },
+			Search: { screen: SearchScreen },
+			Config: { screen: ConfigScreen },
+		};
+
+		const statusBarStyle = theme.appearance === 'light' ? 'dark-content' : 'light-content';
+
+		return (
+			<View style={{ flex: 1, backgroundColor: theme.backgroundColor }}>
+				<SideMenu
+					menu={sideMenuContent}
+					edgeHitWidth={5}
+					menuPosition={menuPosition}
+					onChange={(isOpen:boolean) => this.sideMenu_change(isOpen)}
+					onSliding={(percent:number) => {
+						this.props.dispatch({
+							type: 'SIDE_MENU_OPEN_PERCENT',
+							value: percent,
+						});
+					}}
+				>
+					<StatusBar barStyle={statusBarStyle} />
+					<MenuContext style={{ flex: 1, backgroundColor: theme.backgroundColor }}>
+						<SafeAreaView style={{ flex: 1 }}>
+							<View style={{ flex: 1, backgroundColor: theme.backgroundColor }}>
+								<AppNav screens={appNavInit} />
+							</View>
+							<DropdownAlert ref={(ref:any) => this.dropdownAlert_ = ref} tapToCloseEnabled={true} />
+							<Animated.View pointerEvents='none' style={{ position: 'absolute', backgroundColor: 'black', opacity: this.state.sideMenuContentOpacity, width: '100%', height: '120%' }}/>
+						</SafeAreaView>
+					</MenuContext>
+				</SideMenu>
+			</View>
+		);
+	}
+}
+
+const mapStateToProps = (state:AppState) => {
+	return {
+		historyCanGoBack: state.historyCanGoBack,
+		showSideMenu: state.showSideMenu,
+		syncStarted: state.syncStarted,
+		appState: state.appState,
+		noteSelectionEnabled: state.noteSelectionEnabled,
+		selectedFolderId: state.selectedFolderId,
+		routeName: state.route.routeName,
+		themeId: state.settings.theme,
+		noteSideMenuOptions: state.noteSideMenuOptions,
+	};
+};
+
+const App = connect(mapStateToProps)(AppComponent);
+
+export default class Root extends React.Component {
+	render() {
+		return (
+			<Provider store={store}>
+				<App/>
+			</Provider>
+		);
+	}
+}

ReactNativeClient/index.js

@@ -7,7 +7,7 @@
 // So there's basically still a one way flux: React => SQLite => Redux => React
 
 import { LogBox, AppRegistry } from 'react-native';
-const { Root } = require('./root.js');
+const Root = require('./Root').default;
 
 // Seems JavaScript developers love adding warnings everywhere, even when these warnings can't be fixed
 // or don't really matter. Because we want important warnings to actually be fixed, we disable

ReactNativeClient/lib/services/interop/InteropService.ts

@@ -198,7 +198,7 @@ export default class InteropService {
 		if (moduleMetadata.isCustom) {
 			output = this.newModuleFromCustomFactory(moduleMetadata);
 		} else {
-			const ModuleClass = require(this.modulePath(moduleMetadata)).default;
+			const ModuleClass = shim.require(this.modulePath(moduleMetadata)).default;
 			output = new ModuleClass();
 		}
 
@@ -231,7 +231,7 @@ export default class InteropService {
 		if (moduleMetadata.isCustom) {
 			output = this.newModuleFromCustomFactory(moduleMetadata);
 		} else {
-			const ModuleClass = require(modulePath).default;
+			const ModuleClass = shim.require(modulePath).default;
 			output = new ModuleClass();
 		}
 

ReactNativeClient/lib/services/interop/InteropService_Importer_Base.ts

@@ -1,5 +1,6 @@
 /* eslint @typescript-eslint/no-unused-vars: 0, no-unused-vars: 0 */
 
+import shim from 'lib/shim';
 import { ImportExportResult } from './types';
 
 const Setting = require('lib/models/Setting').default;
@@ -28,7 +29,7 @@ export default class InteropService_Importer_Base {
 	async temporaryDirectory_(createIt:boolean) {
 		const md5 = require('md5');
 		const tempDir = `${Setting.value('tempDir')}/${md5(Math.random() + Date.now())}`;
-		if (createIt) await require('fs-extra').mkdirp(tempDir);
+		if (createIt) await shim.fsDriver().mkdir(tempDir);
 		return tempDir;
 	}
 }

ReactNativeClient/lib/services/interop/InteropService_Importer_Jex.ts

@@ -1,9 +1,9 @@
+import shim from 'lib/shim';
 import { ImportExportResult } from './types';
 
 const InteropService_Importer_Base = require('lib/services/interop/InteropService_Importer_Base').default;
 const InteropService_Importer_Raw = require('lib/services/interop/InteropService_Importer_Raw').default;
 const { filename } = require('lib/path-utils');
-const fs = require('fs-extra');
 
 export default class InteropService_Importer_Jex extends InteropService_Importer_Base {
 	async exec(result:ImportExportResult) {
@@ -29,7 +29,7 @@ export default class InteropService_Importer_Jex extends InteropService_Importer
 		await importer.init(tempDir, this.options_);
 		result = await importer.exec(result);
 
-		await fs.remove(tempDir);
+		await shim.fsDriver().remove(tempDir);
 
 		return result;
 	}

ReactNativeClient/lib/services/plugins/api/Global.ts

@@ -1,11 +1,7 @@
 import Plugin from '../Plugin';
 import Joplin from './Joplin';
 import Logger from 'lib/Logger';
-
-/**
- * @ignore
- */
-const builtinModules = require('builtin-modules');
+import shim from 'lib/shim';
 
 /**
  * @ignore
@@ -43,7 +39,7 @@ export default class Global {
 
 	private requireWhiteList():string[] {
 		if (!this.requireWhiteList_) {
-			this.requireWhiteList_ = builtinModules.slice();
+			this.requireWhiteList_ = shim.builtinModules().slice();
 			this.requireWhiteList_.push('fs-extra');
 		}
 		return this.requireWhiteList_;
@@ -55,7 +51,7 @@ export default class Global {
 
 	require(filePath:string):any {
 		if (!this.requireWhiteList().includes(filePath)) throw new Error(`Path not allowed: ${filePath}`);
-		return require(filePath);
+		return shim.require(filePath);
 	}
 
 	// To get webpack to work with Node module we need to set the parameter `target: "node"`, however

ReactNativeClient/lib/services/plugins/api/JoplinInterop.ts

@@ -1,6 +1,6 @@
-import InteropService from 'lib/services/interop/InteropService';
-import { Module, ModuleType } from 'lib/services/interop/types';
-import { ExportModule, ImportModule } from './types';
+// import InteropService from 'lib/services/interop/InteropService';
+// import { Module, ModuleType } from 'lib/services/interop/types';
+// import { ExportModule, ImportModule } from './types';
 
 /**
  * Provides a way to create modules to import external data into Joplin or to export notes into any arbitrary format.
@@ -16,26 +16,26 @@ import { ExportModule, ImportModule } from './types';
  */
 export default class JoplinInterop {
 
-	async registerExportModule(module:ExportModule) {
-		const internalModule:Module = {
-			...module,
-			type: ModuleType.Exporter,
-			isCustom: true,
-			fileExtensions: module.fileExtensions ? module.fileExtensions : [],
-		};
+	async registerExportModule(_module:ExportModule) {
+		// const internalModule:Module = {
+		// 	...module,
+		// 	type: ModuleType.Exporter,
+		// 	isCustom: true,
+		// 	fileExtensions: module.fileExtensions ? module.fileExtensions : [],
+		// };
 
-		return InteropService.instance().registerModule(internalModule);
+		// return InteropService.instance().registerModule(internalModule);
 	}
 
-	async registerImportModule(module:ImportModule) {
-		const internalModule:Module = {
-			...module,
-			type: ModuleType.Importer,
-			isCustom: true,
-			fileExtensions: module.fileExtensions ? module.fileExtensions : [],
-		};
+	async registerImportModule(_module:ImportModule) {
+		// const internalModule:Module = {
+		// 	...module,
+		// 	type: ModuleType.Importer,
+		// 	isCustom: true,
+		// 	fileExtensions: module.fileExtensions ? module.fileExtensions : [],
+		// };
 
-		return InteropService.instance().registerModule(internalModule);
+		// return InteropService.instance().registerModule(internalModule);
 	}
 
 }

ReactNativeClient/lib/services/rest/Api.ts

@@ -19,15 +19,22 @@ const md5 = require('md5');
 const HtmlToMd = require('lib/HtmlToMd');
 const urlUtils = require('lib/urlUtils.js');
 const ArrayUtils = require('lib/ArrayUtils.js');
-const { netUtils } = require('lib/net-utils');
+// const { netUtils } = require('lib/net-utils');
 const { fileExtension, safeFileExtension, safeFilename, filename } = require('lib/path-utils');
 const ApiResponse = require('lib/services/rest/ApiResponse');
 const SearchEngineUtils = require('lib/services/searchengine/SearchEngineUtils');
 const { FoldersScreenUtils } = require('lib/folders-screen-utils.js');
-const uri2path = require('file-uri-to-path');
+// const uri2path = require('file-uri-to-path');
 const { MarkupToHtml } = require('lib/joplin-renderer');
 const { ErrorMethodNotAllowed, ErrorForbidden, ErrorBadRequest, ErrorNotFound } = require('./errors');
 
+function mimeTypeFromHeaders(headers:any) {
+	if (!headers || !headers['content-type']) return null;
+
+	const splitted = headers['content-type'].split(';');
+	return splitted[0].trim().toLowerCase();
+};
+
 export default class Api {
 
 	private token_:string | Function;
@@ -510,38 +517,40 @@ export default class Api {
 
 		if (requestNote.body_html) {
 			if (requestNote.convert_to === 'html') {
-				const style = await this.buildNoteStyleSheet_(requestNote.stylesheets);
-				const minify = require('html-minifier').minify;
+				// const style = await this.buildNoteStyleSheet_(requestNote.stylesheets);
+				// const minify = require('html-minifier').minify;
 
-				const minifyOptions = {
-					// Remove all spaces and, especially, newlines from tag attributes, as that would
-					// break the rendering.
-					customAttrCollapse: /.*/,
-					// Need to remove all whitespaces because whitespace at a beginning of a line
-					// means a code block in Markdown.
-					collapseWhitespace: true,
-					minifyCSS: true,
-					maxLineLength: 300,
-				};
+				// const minifyOptions = {
+				// 	// Remove all spaces and, especially, newlines from tag attributes, as that would
+				// 	// break the rendering.
+				// 	customAttrCollapse: /.*/,
+				// 	// Need to remove all whitespaces because whitespace at a beginning of a line
+				// 	// means a code block in Markdown.
+				// 	collapseWhitespace: true,
+				// 	minifyCSS: true,
+				// 	maxLineLength: 300,
+				// };
 
-				const uglifycss = require('uglifycss');
-				const styleString = uglifycss.processString(style.join('\n'), {
-					// Need to set a max length because Ace Editor takes forever
-					// to display notes with long lines.
-					maxLineLen: 200,
-				});
+				// // const uglifycss = require('uglifycss');
+				// // const styleString = uglifycss.processString(style.join('\n'), {
+				// // 	// Need to set a max length because Ace Editor takes forever
+				// // 	// to display notes with long lines.
+				// // 	maxLineLen: 200,
+				// // });
 
-				const styleTag = style.length ? `<style>${styleString}</style>` + '\n' : '';
-				let minifiedHtml = '';
-				try {
-					minifiedHtml = minify(requestNote.body_html, minifyOptions);
-				} catch (error) {
-					console.warn('Could not minify HTML - using non-minified HTML instead', error);
-					minifiedHtml = requestNote.body_html;
-				}
-				output.body = styleTag + minifiedHtml;
-				output.body = htmlUtils.prependBaseUrl(output.body, baseUrl);
-				output.markup_language = MarkupToHtml.MARKUP_LANGUAGE_HTML;
+				// const styleString = style.join('\n'); // TODO
+
+				// const styleTag = style.length ? `<style>${styleString}</style>` + '\n' : '';
+				// let minifiedHtml = '';
+				// try {
+				// 	minifiedHtml = minify(requestNote.body_html, minifyOptions);
+				// } catch (error) {
+				// 	console.warn('Could not minify HTML - using non-minified HTML instead', error);
+				// 	minifiedHtml = requestNote.body_html;
+				// }
+				// output.body = styleTag + minifiedHtml;
+				// output.body = htmlUtils.prependBaseUrl(output.body, baseUrl);
+				// output.markup_language = MarkupToHtml.MARKUP_LANGUAGE_HTML;
 			} else {
 				// Convert to Markdown
 				// Parsing will not work if the HTML is not wrapped in a top level tag, which is not guaranteed
@@ -592,7 +601,7 @@ export default class Api {
 	}
 
 	async tryToGuessImageExtFromMimeType_(response:any, imagePath:string) {
-		const mimeType = netUtils.mimeTypeFromHeaders(response.headers);
+		const mimeType = mimeTypeFromHeaders(response.headers);
 		if (!mimeType) return imagePath;
 
 		const newExt = mimeUtils.toFileExtension(mimeType);
@@ -652,7 +661,7 @@ export default class Api {
 			} else if (urlUtils.urlProtocol(url).toLowerCase() === 'file:') {
 				// Can't think of any reason to disallow this at this point
 				// if (!allowFileProtocolImages) throw new Error('For security reasons, this URL with file:// protocol cannot be downloaded');
-				const localPath = uri2path(url);
+				const localPath = url; // TODO: uri2path(url);
 				await shim.fsDriver().copy(localPath, imagePath);
 			} else {
 				const response = await shim.fetchBlob(url, { path: imagePath, maxRetry: 1 });

ReactNativeClient/lib/shim-init-node.js

@@ -524,6 +524,14 @@ function shimInit() {
 		return timers.clearInterval(id);
 	};
 
+	shim.require = (filePath) => {
+		return require(filePath);
+	};
+
+	shim.builtinModules = () => {
+		return require('builtin-modules');
+	};
+
 }
 
 module.exports = { shimInit };

ReactNativeClient/lib/shim.ts

@@ -273,6 +273,15 @@ const shim = {
 	clearInterval: (_id:any) => {
 		throw new Error('Not implemented');
 	},
+
+	require: (_filePath:string):any => {
+		// NOOP by default
+		return {};
+	},
+
+	builtinModules: ():string[] => {
+		return [];
+	},
 };
 
 export default shim;

ReactNativeClient/package.json

@@ -22,13 +22,17 @@
     "color": "^3.1.2",
     "diacritics": "^1.3.0",
     "diff-match-patch": "^1.0.4",
+    "es6-promise-pool": "^2.5.0",
     "events": "^1.1.1",
+    "file-uri-to-path": "^1.0.0",
     "font-awesome-filetypes": "^2.1.0",
     "form-data": "^2.1.4",
     "highlight.js": "^10.2.1",
     "html-entities": "^1.2.1",
     "htmlparser2": "^4.1.0",
     "immer": "^7.0.9",
+    "joplin-turndown": "^4.0.30",
+    "joplin-turndown-plugin-gfm": "^1.0.12",
     "jsc-android": "241213.1.0",
     "json-stringify-safe": "^5.0.1",
     "katex": "^0.12.0",
@@ -85,6 +89,7 @@
     "string-natural-compare": "^2.0.2",
     "string-padding": "^1.0.2",
     "timers": "^0.1.1",
+    "uglifycss": "0.0.29",
     "url": "^0.11.0",
     "url-parse": "^1.4.7",
     "uslug": "git+https://github.com/laurent22/uslug.git#emoji-support",

ReactNativeClient/services/plugins/PluginRunner.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BasePluginRunner_1 = require("lib/services/plugins/BasePluginRunner");
+var PluginMessageTarget;
+(function (PluginMessageTarget) {
+    PluginMessageTarget["MainWindow"] = "mainWindow";
+    PluginMessageTarget["Plugin"] = "plugin";
+})(PluginMessageTarget || (PluginMessageTarget = {}));
+let callbackIndex = 1;
+const callbackPromises = {};
+function mapEventIdsToHandlers(pluginId, arg) {
+    if (Array.isArray(arg)) {
+        for (let i = 0; i < arg.length; i++) {
+            arg[i] = mapEventIdsToHandlers(pluginId, arg[i]);
+        }
+        return arg;
+    }
+    else if (typeof arg === 'string' && arg.indexOf('___plugin_event_') === 0) {
+        const eventId = arg;
+        return (...args) => __awaiter(this, void 0, void 0, function* () {
+            const callbackId = `cb_${pluginId}_${Date.now()}_${callbackIndex++}`;
+            const promise = new Promise((resolve, reject) => {
+                callbackPromises[callbackId] = { resolve, reject };
+            });
+            // ipcRenderer.send('pluginMessage', {
+            // 	callbackId: callbackId,
+            // 	target: PluginMessageTarget.Plugin,
+            // 	pluginId: pluginId,
+            // 	eventId: eventId,
+            // 	args: args,
+            // });
+            return promise;
+        });
+    }
+    else if (arg === null) {
+        return null;
+    }
+    else if (arg === undefined) {
+        return undefined;
+    }
+    else if (typeof arg === 'object') {
+        for (const n in arg) {
+            arg[n] = mapEventIdsToHandlers(pluginId, arg[n]);
+        }
+    }
+    return arg;
+}
+class PluginRunner extends BasePluginRunner_1.default {
+    constructor() {
+        super();
+        this.eventHandlers_ = {};
+        this.eventHandler = this.eventHandler.bind(this);
+    }
+    eventHandler(eventHandlerId, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cb = this.eventHandlers_[eventHandlerId];
+            return cb(...args);
+        });
+    }
+    run(plugin, _pluginApi) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.info('RUNNING', plugin);
+            // const scriptPath = `${Setting.value('tempDir')}/plugin_${plugin.id}.js`;
+            // await shim.fsDriver().writeFile(scriptPath, plugin.scriptText, 'utf8');
+            // const pluginWindow = bridge().newBrowserWindow({
+            // 	show: false,
+            // 	webPreferences: {
+            // 		nodeIntegration: true,
+            // 	},
+            // });
+            // bridge().electronApp().registerPluginWindow(plugin.id, pluginWindow);
+            // pluginWindow.loadURL(`${require('url').format({
+            // 	pathname: require('path').join(__dirname, 'plugin_index.html'),
+            // 	protocol: 'file:',
+            // 	slashes: true,
+            // })}?pluginId=${encodeURIComponent(plugin.id)}&pluginScript=${encodeURIComponent(`file://${scriptPath}`)}`);
+            // pluginWindow.webContents.once('dom-ready', () => {
+            // 	pluginWindow.webContents.openDevTools();
+            // });
+            // ipcRenderer.on('pluginMessage', async (_event:any, message:PluginMessage) => {
+            // 	if (message.target !== PluginMessageTarget.MainWindow) return;
+            // 	if (message.pluginId !== plugin.id) return;
+            // 	if (message.mainWindowCallbackId) {
+            // 		const promise = callbackPromises[message.mainWindowCallbackId];
+            // 		if (!promise) {
+            // 			console.error('Got a callback without matching promise: ', message);
+            // 			return;
+            // 		}
+            // 		if (message.error) {
+            // 			promise.reject(message.error);
+            // 		} else {
+            // 			promise.resolve(message.result);
+            // 		}
+            // 	} else {
+            // 		const mappedArgs = mapEventIdsToHandlers(plugin.id, message.args);
+            // 		const fullPath = `joplin.${message.path}`;
+            // 		this.logger().debug(`PluginRunner: execute call: ${fullPath}: ${mappedArgs}`);
+            // 		let result:any = null;
+            // 		let error:any = null;
+            // 		try {
+            // 			result = await executeSandboxCall(plugin.id, pluginApi, fullPath, mappedArgs, this.eventHandler);
+            // 		} catch (e) {
+            // 			error = e ? e : new Error('Unknown error');
+            // 		}
+            // 		ipcRenderer.send('pluginMessage', {
+            // 			target: PluginMessageTarget.Plugin,
+            // 			pluginId: plugin.id,
+            // 			pluginCallbackId: message.callbackId,
+            // 			result: result,
+            // 			error: error,
+            // 		});
+            // 	}
+            // });
+        });
+    }
+}
+exports.default = PluginRunner;
+//# sourceMappingURL=data:application/json;base64,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

ReactNativeClient/services/plugins/PluginRunner.ts

@@ -0,0 +1,149 @@
+import Plugin from 'lib/services/plugins/Plugin';
+import BasePluginRunner from 'lib/services/plugins/BasePluginRunner';
+import executeSandboxCall from 'lib/services/plugins/utils/executeSandboxCall';
+import Global from 'lib/services/plugins/api/Global';
+import Setting from 'lib/models/Setting';
+import { EventHandlers } from 'lib/services/plugins/utils/mapEventHandlersToIds';
+import shim from 'lib/shim';
+
+enum PluginMessageTarget {
+	MainWindow = 'mainWindow',
+	Plugin = 'plugin',
+}
+
+export interface PluginMessage {
+	target: PluginMessageTarget,
+	pluginId: string,
+	callbackId?: string,
+	path?: string,
+	args?: any[],
+	result?: any,
+	error?: any,
+	mainWindowCallbackId?: string,
+}
+
+let callbackIndex = 1;
+const callbackPromises:any = {};
+
+function mapEventIdsToHandlers(pluginId:string, arg:any) {
+	if (Array.isArray(arg)) {
+		for (let i = 0; i < arg.length; i++) {
+			arg[i] = mapEventIdsToHandlers(pluginId, arg[i]);
+		}
+		return arg;
+	} else if (typeof arg === 'string' && arg.indexOf('___plugin_event_') === 0) {
+		const eventId = arg;
+
+		return async (...args:any[]) => {
+			const callbackId = `cb_${pluginId}_${Date.now()}_${callbackIndex++}`;
+
+			const promise = new Promise((resolve, reject) => {
+				callbackPromises[callbackId] = { resolve, reject };
+			});
+
+			// ipcRenderer.send('pluginMessage', {
+			// 	callbackId: callbackId,
+			// 	target: PluginMessageTarget.Plugin,
+			// 	pluginId: pluginId,
+			// 	eventId: eventId,
+			// 	args: args,
+			// });
+
+			return promise;
+		};
+	} else if (arg === null) {
+		return null;
+	} else if (arg === undefined) {
+		return undefined;
+	} else if (typeof arg === 'object') {
+		for (const n in arg) {
+			arg[n] = mapEventIdsToHandlers(pluginId, arg[n]);
+		}
+	}
+
+	return arg;
+}
+
+export default class PluginRunner extends BasePluginRunner {
+
+	protected eventHandlers_:EventHandlers = {};
+
+	constructor() {
+		super();
+
+		this.eventHandler = this.eventHandler.bind(this);
+	}
+
+	private async eventHandler(eventHandlerId:string, args:any[]) {
+		const cb = this.eventHandlers_[eventHandlerId];
+		return cb(...args);
+	}
+
+	async run(plugin:Plugin, _pluginApi:Global) {
+		console.info('RUNNING', plugin);
+
+		// const scriptPath = `${Setting.value('tempDir')}/plugin_${plugin.id}.js`;
+		// await shim.fsDriver().writeFile(scriptPath, plugin.scriptText, 'utf8');
+
+		// const pluginWindow = bridge().newBrowserWindow({
+		// 	show: false,
+		// 	webPreferences: {
+		// 		nodeIntegration: true,
+		// 	},
+		// });
+
+		// bridge().electronApp().registerPluginWindow(plugin.id, pluginWindow);
+
+		// pluginWindow.loadURL(`${require('url').format({
+		// 	pathname: require('path').join(__dirname, 'plugin_index.html'),
+		// 	protocol: 'file:',
+		// 	slashes: true,
+		// })}?pluginId=${encodeURIComponent(plugin.id)}&pluginScript=${encodeURIComponent(`file://${scriptPath}`)}`);
+
+		// pluginWindow.webContents.once('dom-ready', () => {
+		// 	pluginWindow.webContents.openDevTools();
+		// });
+
+		// ipcRenderer.on('pluginMessage', async (_event:any, message:PluginMessage) => {
+		// 	if (message.target !== PluginMessageTarget.MainWindow) return;
+		// 	if (message.pluginId !== plugin.id) return;
+
+		// 	if (message.mainWindowCallbackId) {
+		// 		const promise = callbackPromises[message.mainWindowCallbackId];
+
+		// 		if (!promise) {
+		// 			console.error('Got a callback without matching promise: ', message);
+		// 			return;
+		// 		}
+
+		// 		if (message.error) {
+		// 			promise.reject(message.error);
+		// 		} else {
+		// 			promise.resolve(message.result);
+		// 		}
+		// 	} else {
+		// 		const mappedArgs = mapEventIdsToHandlers(plugin.id, message.args);
+		// 		const fullPath = `joplin.${message.path}`;
+
+		// 		this.logger().debug(`PluginRunner: execute call: ${fullPath}: ${mappedArgs}`);
+
+		// 		let result:any = null;
+		// 		let error:any = null;
+		// 		try {
+		// 			result = await executeSandboxCall(plugin.id, pluginApi, fullPath, mappedArgs, this.eventHandler);
+		// 		} catch (e) {
+		// 			error = e ? e : new Error('Unknown error');
+		// 		}
+
+		// 		ipcRenderer.send('pluginMessage', {
+		// 			target: PluginMessageTarget.Plugin,
+		// 			pluginId: plugin.id,
+		// 			pluginCallbackId: message.callbackId,
+		// 			result: result,
+		// 			error: error,
+		// 		});
+		// 	}
+		// });
+	}
+
+}

package.json

@@ -18,11 +18,6 @@
     "clean": "gulp clean",
     "postinstall": "cd Tools && npm i && cd .. && npm run clean && cd ReactNativeClient && npm i && cd .. && cd ElectronClient && npm i && cd .. && cd CliClient && npm i && cd .. && gulp build"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/laurent22/joplin.git"