+ @Override
+ public void onResume() {
+ super.onResume();
+ timerHandler.postDelayed(timerRunnable, 500);
+ }
+
+ private void runSplashTasks() {
+ /*
+ Dieser Taskhandler, bestehend aus den Methoden runSplashTasks, runSplashTask, onSplashTaskComplete, onSplashTasksFinished
+ soll möglichst effizient alle durchzuführenden Aufgaben (Tasks) beim Ladevorgang der App durchführen.
+
+ Die Tasks werden innerhalb der Methode runSplashTask definiert.
+ Es können beliebig tasks parallel durchgeführt werden, solange diese Asnychron arbeiten. Siehe PARALLELIZE_SPLASHTASKS
+ */
+ progressCounter = 0;
+ lastTaskId = 0;
+ pendingSplashTasks = 1; // 1 (Timer Task)
+ splashProgress.setMax(SPLASHTASK_COUNT+1);
+ splashProgress.setProgress(0);
+ pendingSplashTask[0] = true;
+ for(int i = 0; i < PARALLELIZE_SPLASHTASKS; i++) {
+ if(lastTaskId >= SPLASHTASK_COUNT)
+ break;
+ pendingSplashTasks++;
+ lastTaskId++;
+ pendingSplashTask[lastTaskId] = true;
+ runSplashTask(lastTaskId);
+ }
+ timerRunnable = new Runnable() {
+ @Override
+ public void run() {
+ onSplashTaskComplete(0, true);
+ }
+ };
+ timerHandler.postDelayed(timerRunnable, 3000); // Show Splashscreen at least 3 seconds
+ }
+
+ private void onSplashTaskComplete(int taskId, boolean success) {
+ if(!pendingSplashTask[taskId])
+ return; // double callback call?
+ pendingSplashTask[taskId] = false;
+ pendingSplashTasks--;
+ progressCounter++;
+ splashProgress.setProgress(progressCounter);
+
+ if(lastTaskId < SPLASHTASK_COUNT) {
+ pendingSplashTasks++;
+ lastTaskId++;
+ pendingSplashTask[lastTaskId] = true;
+ runSplashTask(lastTaskId);
+ } else if(pendingSplashTasks == 0) {
+ onSplashTasksFinished();
+ }
+ }
+
+ private void onSplashTasksFinished() {
+ ((CampusApp) AppContext.getMainActivity()).loadMainUi();
+ AppContext.getNavigationManager().navigatePage("Dashboard", null, false);
+ }
+
+ private void runSplashTask(int taskId) {
+ long now = (new Date()).getTime() / 1000;
+ switch (taskId) {
+ case 1:
+ AppContext.getDatabaseManager().initializeDatabase();
+ onSplashTaskComplete(1, true);
+ break;
+ case 2:
+ AppContext.addDefaultSearchIndexes();
+ onSplashTaskComplete(2, true);
+ break;
+ case 3:
+ String lastCNSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastCNSync");
+ long lastCNSync;
+ if (lastCNSyncStr != null)
+ lastCNSync = Long.parseLong(lastCNSyncStr);
+ else
+ lastCNSync = 0;
+
+ CourseNameManager cnm = new CourseNameManager();
+
+ if (lastCNSync == 0 || now - lastCNSync > (86400 * 7)) { //sync every 7 days
+ cnm.synchronizeCourseNames(new CourseNameManagerInterface() {
+ @Override
+ public void onCourseNamesSynchronized() {
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastCNSync", Long.toString(now));
+ onSplashTaskComplete(3, true);
+
+ }
+
+ @Override
+ public void onCourseNamesFailed(String errorMessage) {
+ onSplashTaskComplete(3, false);
+ }
+ });
+ } else
+ onSplashTaskComplete(3, true);
+ break;
+ case 4:
+ String startCounter = AppContext.getDatabaseManager().getRuntimeCache("AppStartCounter");
+ if (startCounter == null || Integer.parseInt(startCounter) == 0) {
+ AppContext.getNavigationManager().navigatePage("FirstRun", null, false);
+ return;
+ }
+ AppContext.getDatabaseManager().setRuntimeCache("AppStartCounter", Integer.toString(Integer.parseInt(startCounter) + 1));
+ onSplashTaskComplete(4, true);
+ break;
+ case 5:
+ String lastVLMFullSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastVLMFullSync");
+ String lastVLMPartialSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastVLMPartialSync");
+ long lastVLMFullSync, lastVLMPartialSync;
+ if (lastVLMFullSyncStr != null)
+ lastVLMFullSync = Long.parseLong(lastVLMFullSyncStr);
+ else
+ lastVLMFullSync = 0;
+ if (lastVLMPartialSyncStr != null)
+ lastVLMPartialSync = Long.parseLong(lastVLMPartialSyncStr);
+ else
+ lastVLMPartialSync = 0;
+
+ final String kursTag = AppContext.getDatabaseManager().getRuntimeCache("CourseName");
+ if (kursTag == null || kursTag.isEmpty()) {
+ onSplashTaskComplete(5, true);
+ break;
+ }
+ CalendarManager vpm = new CalendarManager(AppContext, kursTag);
+
+ if (lastVLMFullSync == 0 || now - lastVLMFullSync > (86400 * 14)) { // full sync every 14 days
+ vpm.performFullSynchronisation(new CalendarManagerInterface() {
+ @Override
+ public void onCalendarUpdateDone() {
+ if (!AppContext.getDatabaseManager().haveCourseName(kursTag)) {
+ CourseNameManager cnm = new CourseNameManager();
+ cnm.addCourseName(kursTag);
+ }
+
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastVLMFullSync", Long.toString(now));
+ AppContext.getDatabaseManager().setRuntimeCache("LastVLMPartialSync", Long.toString(now));
+ onSplashTaskComplete(5, true);
+ }
+
+ @Override
+ public void onCalendarUpdateFail(String errorMessage) {
+ onSplashTaskComplete(5, false);
+ }
+
+ @Override
+ public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
+ CourseGroup group = event.getCourseGroup();
+ SearchIndices indices = new SearchIndices("Vorlesungsplan#Group" + group.getGroupId(), false);
+ indices.setUpdateTime(event.getEventFrom());
+ indices.setTarget("#Vorlesungsplan#groupid=" + group.getGroupId());
+ indices.setTitle("Vorlesungsplan " + event.getCourseName());
+ indices.setDescription("Vorlesung " + event.getEventTitle());
+ indices.addKeyWord(event.getGroupTitle());
+ indices.addKeyWord(event.getEventLocation());
+ return indices;
+ }
+ });
+ } else if (lastVLMPartialSync == 0 || now - lastVLMPartialSync > (86400)) { // partial sync every day
+ vpm.performFastSynchronisation(new CalendarManagerInterface() {
+ @Override
+ public void onCalendarUpdateDone() {
+ if (!AppContext.getDatabaseManager().haveCourseName(kursTag)) {
+ CourseNameManager cnm = new CourseNameManager();
+ cnm.addCourseName(kursTag);
+ }
+
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastVLMPartialSync", Long.toString(now));
+ onSplashTaskComplete(5, true);
+ }
+
+ @Override
+ public void onCalendarUpdateFail(String errorMessage) {
+ onSplashTaskComplete(5, false);
+ }
+
+ @Override
+ public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
+ CourseGroup group = event.getCourseGroup();
+ SearchIndices indices = new SearchIndices("Vorlesungsplan#Group" + group.getGroupId(), false);
+ indices.setUpdateTime(event.getEventFrom());
+ indices.setTarget("#Vorlesungsplan#groupid=" + group.getGroupId());
+ indices.setTitle(AppContext.getResString(R.string.search_vorlesungsplan_group_title, event.getCourseName()));
+ indices.setDescription(event.getEventTitle());
+ indices.addKeyWord(event.getGroupTitle());
+ indices.addKeyWord(event.getEventLocation());
+ return indices;
+ }
+ });
+ } else
+ onSplashTaskComplete(5, true);
+ break;
+ case 6:
+ String lastMPMSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastMPSync");
+ long lastMPMSync;
+ if (lastMPMSyncStr != null)
+ lastMPMSync = Long.parseLong(lastMPMSyncStr);
+ else
+ lastMPMSync = 0;
+
+ MensaplanManager mpm = new MensaplanManager(AppContext);
+
+ if (lastMPMSync == 0 || now - lastMPMSync > (86400 * 2)) { //sync every 2 days
+ mpm.performSynchronisation(new MensaplanManagerInterface() {
+ @Override
+ public void onMensaplanUpdateDone() {
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastMPSync", Long.toString(now));
+ onSplashTaskComplete(6, true);
+ }
+
+ @Override
+ public void onMensaplanUpdateFail(String errorMessage) {
+ onSplashTaskComplete(6, false);
+ }
+ });
+ } else
+ onSplashTaskComplete(6, true);
+ break;
+ case 7:
+ final String syncSource = "DHBW";
+ String lastNewsSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastNewsSync_" + syncSource);
+ long lastNewsSync;
+ if (lastNewsSyncStr != null)
+ lastNewsSync = Long.parseLong(lastNewsSyncStr);
+ else
+ lastNewsSync = 0;
+
+ NewsManager nm = new NewsManager(AppContext, syncSource);
+
+ if (lastNewsSync == 0 || now - lastNewsSync > (86400 * 1)) { //sync every day
+ nm.performSynchronisation(new NewsManagerInterface() {
+ @Override
+ public void onNewsUpdateDone() {
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastNewsSync_" + syncSource, Long.toString(now));
+ onSplashTaskComplete(7, true);
+ }
+
+ @Override
+ public void onNewsUpdateFail(String errorMessage) {
+ onSplashTaskComplete(7, false);
+ }
+ });
+ } else
+ onSplashTaskComplete(7, true);
+ break;
+ case 8:
+ final String syncSource2 = "STUV";
+ String lastNewsSyncStr2 = AppContext.getDatabaseManager().getRuntimeCache("LastNewsSync_" + syncSource2);
+ long lastNewsSync2;
+ if (lastNewsSyncStr2 != null)
+ lastNewsSync2 = Long.parseLong(lastNewsSyncStr2);
+ else
+ lastNewsSync2 = 0;
+
+ NewsManager nm2 = new NewsManager(AppContext, syncSource2);
+
+ if (lastNewsSync2 == 0 || now - lastNewsSync2 > (86400 * 1)) { //sync every day
+ nm2.performSynchronisation(new NewsManagerInterface() {
+ @Override
+ public void onNewsUpdateDone() {
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastNewsSync_" + syncSource2, Long.toString(now));
+ onSplashTaskComplete(8, true);
+ }
+
+ @Override
+ public void onNewsUpdateFail(String errorMessage) {
+ onSplashTaskComplete(8, false);
+ }
+ });
+ } else
+ onSplashTaskComplete(8, true);
+ break;
+ case 9:
+ String lastStuvSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastStuvSync");
+ long lastStuvSync;
+ if (lastStuvSyncStr != null)
+ lastStuvSync = Long.parseLong(lastStuvSyncStr);
+ else
+ lastStuvSync = 0;
+
+ final String calendarName = "STUV";
+ CalendarManager stuvsyncmgr = new CalendarManager(AppContext, calendarName);
+
+ if (lastStuvSync == 0 || now - lastStuvSync > (86400 * 3)) { // full sync every 3 days
+ stuvsyncmgr.performFullSynchronisation(new CalendarManagerInterface() {
+ @Override
+ public void onCalendarUpdateDone() {
+ long now = (new Date()).getTime() / 1000;
+ AppContext.getDatabaseManager().setRuntimeCache("LastStuvSync", Long.toString(now));
+ onSplashTaskComplete(9, true);
+ }
+
+ @Override
+ public void onCalendarUpdateFail(String errorMessage) {
+ onSplashTaskComplete(9, false);
+ }
+
+ @Override
+ public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
+ CourseGroup group = event.getCourseGroup();
+ SearchIndices indices = new SearchIndices("Vorlesungsplan#Group" + group.getGroupId(), false);
+ indices.setUpdateTime(event.getEventFrom());
+ indices.setTarget("#News#showevent=" + group.getGroupId() + "&course=" + calendarName);
+ indices.setTitle(calendarName + " Event: " + event.getCourseName());
+ indices.setDescription(event.getEventTitle());
+ indices.addKeyWord(event.getGroupTitle());
+ indices.addKeyWord(event.getEventLocation());
+
+ return null;
+ }
+ });
+ } else
+ onSplashTaskComplete(9, true);
+ break;
+
+ default:
+ onSplashTaskComplete(taskId, true);
+ break;
+ }
+ }
+