app/src/main/java/de/dhbwloe/campusapp/fragments/SplashScreen.java

   1 package de.dhbwloe.campusapp.fragments;
   2
   3
   4 import android.graphics.Bitmap;
   5 import android.graphics.BitmapFactory;
   6 import android.graphics.Point;
   7 import android.os.Bundle;
   8 import android.os.Handler;
   9 import android.support.v4.app.Fragment;
  10 import android.view.Display;
  11 import android.view.LayoutInflater;
  12 import android.view.View;
  13 import android.view.ViewGroup;
  14 import android.widget.ImageView;
  15 import android.widget.ProgressBar;
  16 import android.widget.TextView;
  17
  18 import java.util.Date;
  19
  20 import de.dhbwloe.campusapp.CampusApp;
  21 import de.dhbwloe.campusapp.CampusAppContext;
  22 import de.dhbwloe.campusapp.CampusAppFragment;
  23 import de.dhbwloe.campusapp.R;
  24 import de.dhbwloe.campusapp.mensaplan.MensaplanManager;
  25 import de.dhbwloe.campusapp.mensaplan.MensaplanManagerInterface;
  26 import de.dhbwloe.campusapp.news.NewsManager;
  27 import de.dhbwloe.campusapp.news.NewsManagerInterface;
  28 import de.dhbwloe.campusapp.search.SearchIndices;
  29 import de.dhbwloe.campusapp.vorlesungen.CalendarManager;
  30 import de.dhbwloe.campusapp.vorlesungen.CalendarManagerInterface;
  31 import de.dhbwloe.campusapp.vorlesungen.CourseEvent;
  32 import de.dhbwloe.campusapp.vorlesungen.CourseGroup;
  33
  34 /**
  35  * A simple {@link Fragment} subclass.
  36  */
  37 public class SplashScreen extends CampusAppFragment {
  38     private ProgressBar splashProgress;
  39     private int progressCounter;
  40     private Handler timerHandler = new Handler();
  41     private Runnable timerRunnable;
  42
  43     @Override
  44     public void onCreate(Bundle savedInstanceState) {
  45         super.onCreate(savedInstanceState);
  46
  47
  48     }
  49
  50     @Override
  51     public void onSaveInstanceState(Bundle savedInstanceState) {
  52         timerHandler.removeCallbacksAndMessages(null);
  53         super.onSaveInstanceState(savedInstanceState);
  54     }
  55
  56     @Override
  57     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  58                              Bundle savedInstanceState) {
  59         View view = inflater.inflate(R.layout.fragment_splashscreen, container, false);
  60
  61         TextView versionView = (TextView) view.findViewById(R.id.version);
  62         versionView.setText(CampusAppContext.APPVERSION);
  63
  64         splashProgress = (ProgressBar)view.findViewById(R.id.splashProgress);
  65         splashProgress.setMax(20);
  66         splashProgress.setProgress(0);
  67         progressCounter = 0;
  68
  69         AppContext.setTitle("DHBW Lörrach");
  70
  71         ImageView splashImage = (ImageView)view.findViewById(R.id.splashImage);
  72         BitmapFactory.Options dimensions = new BitmapFactory.Options();
  73         Bitmap mBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.dhbw_campus_hd, dimensions);
  74         int height = dimensions.outHeight;
  75         int width =  dimensions.outWidth;
  76         Display display = AppContext.getMainActivity().getWindowManager().getDefaultDisplay();
  77         Point size = new Point();
  78         display.getSize(size);
  79         float scaleX = (float)size.x / (float)width;
  80         float scaleY = (float)size.y / (float)height;
  81         float scale = Math.max(scaleX, scaleY);
  82         int newWidth = (int)(width*scale);
  83         int newHeight = (int)(height*scale);
  84         Bitmap newBitmap = Bitmap.createScaledBitmap(mBitmap, newWidth, newHeight, true);
  85         splashImage.setImageBitmap(newBitmap);
  86
  87         timerRunnable = new Runnable() {
  88             @Override
  89             public void run() {
  90                 progressCounter++;
  91                 splashProgress.setProgress(progressCounter);
  92                 long now = (new Date()).getTime()/1000;
  93                 switch(progressCounter) {
  94                     case 1:
  95                         AppContext.getDatabaseManager().initializeDatabase();
  96                         break;
  97                     case 2:
  98                         AppContext.addDefaultSearchIndexes();
  99                         break;
 100                     case 3:
 101                         String startCounter = AppContext.getDatabaseManager().getRuntimeCache("AppStartCounter");
 102                         if(startCounter == null || Integer.parseInt(startCounter) == 0) {
 103                             AppContext.getNavigationManager().navigatePage("FirstRun", null, false);
 104                             return;
 105                         }
 106                         AppContext.getDatabaseManager().setRuntimeCache("AppStartCounter", Integer.toString(Integer.parseInt(startCounter) + 1));
 107                         break;
 108                     case 4:
 109                         String lastVLMFullSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastVLMFullSync");
 110                         String lastVLMPartialSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastVLMPartialSync");
 111                         long lastVLMFullSync, lastVLMPartialSync;
 112                         if(lastVLMFullSyncStr != null)
 113                             lastVLMFullSync = Long.parseLong(lastVLMFullSyncStr);
 114                         else
 115                             lastVLMFullSync = 0;
 116                         if(lastVLMPartialSyncStr != null)
 117                             lastVLMPartialSync = Long.parseLong(lastVLMPartialSyncStr);
 118                         else
 119                             lastVLMPartialSync = 0;
 120
 121                         String kursTag = AppContext.getDatabaseManager().getRuntimeCache("CourseName");
 122                         if(kursTag == null || kursTag.isEmpty())
 123                             break;
 124                         CalendarManager vpm = new CalendarManager(AppContext, kursTag);
 125
 126                         if(lastVLMFullSync == 0 || now - lastVLMFullSync > (86400 * 14)) { // full sync every 14 days
 127                             vpm.performFullSynchronisation(new CalendarManagerInterface() {
 128                                 @Override
 129                                 public void onCalendarUpdateDone() {
 130                                     long now = (new Date()).getTime() / 1000;
 131                                     AppContext.getDatabaseManager().setRuntimeCache("LastVLMFullSync", Long.toString(now));
 132                                     AppContext.getDatabaseManager().setRuntimeCache("LastVLMPartialSync", Long.toString(now));
 133                                     timerHandler.postDelayed(timerRunnable, 100);
 134                                 }
 135
 136                                 @Override
 137                                 public void onCalendarUpdateFail(String errorMessage) {
 138                                     timerHandler.postDelayed(timerRunnable, 100);
 139                                 }
 140                                 @Override
 141                                 public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
 142                                     CourseGroup group = event.getCourseGroup();
 143                                     SearchIndices indices = new SearchIndices("Vorlesungsplan#Group"+group.getGroupId(), false);
 144                                     indices.setUpdateTime(event.getEventFrom());
 145                                     indices.setTarget("#Vorlesungsplan#groupid=" + group.getGroupId());
 146                                     indices.setTitle("Vorlesungsplan " + event.getCourseName());
 147                                     indices.setDescription("Vorlesung " + event.getEventTitle());
 148                                     indices.addKeyWord(event.getGroupTitle());
 149                                     indices.addKeyWord(event.getEventLocation());
 150                                     return indices;
 151                                 }
 152                             });
 153                         }
 154                         else if(lastVLMPartialSync == 0 || now - lastVLMPartialSync > (86400)) { // partial sync every day
 155                             vpm.performFastSynchronisation(new CalendarManagerInterface() {
 156                                 @Override
 157                                 public void onCalendarUpdateDone() {
 158                                     long now = (new Date()).getTime()/1000;
 159                                     AppContext.getDatabaseManager().setRuntimeCache("LastVLMPartialSync", Long.toString(now));
 160                                     timerHandler.postDelayed(timerRunnable, 100);
 161                                 }
 162                                 @Override
 163                                 public void onCalendarUpdateFail(String errorMessage) {
 164                                     timerHandler.postDelayed(timerRunnable, 100);
 165                                 }
 166                                 @Override
 167                                 public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
 168                                     CourseGroup group = event.getCourseGroup();
 169                                     SearchIndices indices = new SearchIndices("Vorlesungsplan#Group"+group.getGroupId(), false);
 170                                     indices.setUpdateTime(event.getEventFrom());
 171                                     indices.setTarget("#Vorlesungsplan#groupid=" + group.getGroupId());
 172                                     indices.setTitle(AppContext.getResString(R.string.search_vorlesungsplan_group_title, event.getCourseName()));
 173                                     indices.setDescription(event.getEventTitle());
 174                                     indices.addKeyWord(event.getGroupTitle());
 175                                     indices.addKeyWord(event.getEventLocation());
 176                                     return indices;
 177                                 }
 178                             });
 179                         }
 180                         else
 181                             break;
 182                         return;
 183                     case 5:
 184                         String lastMPMSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastMPSync");
 185                         long lastMPMSync;
 186                         if(lastMPMSyncStr != null)
 187                             lastMPMSync = Long.parseLong(lastMPMSyncStr);
 188                         else
 189                             lastMPMSync = 0;
 190
 191                         MensaplanManager mpm = new MensaplanManager(AppContext);
 192
 193                         if(lastMPMSync == 0 || now - lastMPMSync > (86400 * 2)) { //sync every 2 days
 194                             mpm.performSynchronisation(new MensaplanManagerInterface() {
 195                                 @Override
 196                                 public void onMensaplanUpdateDone() {
 197                                     long now = (new Date()).getTime() / 1000;
 198                                     AppContext.getDatabaseManager().setRuntimeCache("LastMPSync", Long.toString(now));
 199                                     timerHandler.postDelayed(timerRunnable, 100);
 200                                 }
 201
 202                                 @Override
 203                                 public void onMensaplanUpdateFail(String errorMessage) {
 204                                     timerHandler.postDelayed(timerRunnable, 100);
 205                                 }
 206                             });
 207                         }
 208                         else
 209                             break;
 210                         return;
 211                     case 6:
 212                     case 7:
 213                         final String syncSource = (progressCounter == 6 ? "DHBW" : "STUV");
 214                         String lastNewsSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastNewsSync_"+syncSource);
 215                         long lastNewsSync;
 216                         if(lastNewsSyncStr != null)
 217                             lastNewsSync = Long.parseLong(lastNewsSyncStr);
 218                         else
 219                             lastNewsSync = 0;
 220
 221                         NewsManager nm = new NewsManager(AppContext, syncSource);
 222
 223                         if(lastNewsSync == 0 || now - lastNewsSync > (86400 * 1)) { //sync every day
 224                             nm.performSynchronisation(new NewsManagerInterface() {
 225                                 @Override
 226                                 public void onNewsUpdateDone() {
 227                                     long now = (new Date()).getTime() / 1000;
 228                                     AppContext.getDatabaseManager().setRuntimeCache("LastNewsSync_"+syncSource, Long.toString(now));
 229                                     timerHandler.postDelayed(timerRunnable, 100);
 230                                 }
 231
 232                                 @Override
 233                                 public void onNewsUpdateFail(String errorMessage) {
 234                                     timerHandler.postDelayed(timerRunnable, 100);
 235                                 }
 236                             });
 237                         }
 238                         else
 239                             break;
 240                         return;
 241                     case 8:
 242                         String lastStuvSyncStr = AppContext.getDatabaseManager().getRuntimeCache("LastStuvSync");
 243                         long lastStuvSync;
 244                         if(lastStuvSyncStr != null)
 245                             lastStuvSync = Long.parseLong(lastStuvSyncStr);
 246                         else
 247                             lastStuvSync = 0;
 248
 249                         final String calendarName = "STUV";
 250                         CalendarManager stuvsyncmgr = new CalendarManager(AppContext, calendarName);
 251
 252                         if(lastStuvSync == 0 || now - lastStuvSync > (86400 * 3)) { // full sync every 3 days
 253                             stuvsyncmgr.performFullSynchronisation(new CalendarManagerInterface() {
 254                                 @Override
 255                                 public void onCalendarUpdateDone() {
 256                                     long now = (new Date()).getTime() / 1000;
 257                                     AppContext.getDatabaseManager().setRuntimeCache("LastStuvSync", Long.toString(now));
 258                                     timerHandler.postDelayed(timerRunnable, 100);
 259                                 }
 260
 261                                 @Override
 262                                 public void onCalendarUpdateFail(String errorMessage) {
 263                                     timerHandler.postDelayed(timerRunnable, 100);
 264                                 }
 265
 266                                 @Override
 267                                 public SearchIndices onGenerateCalendarSearchIndices(CourseEvent event) {
 268                                     CourseGroup group = event.getCourseGroup();
 269                                     SearchIndices indices = new SearchIndices("Vorlesungsplan#Group"+group.getGroupId(), false);
 270                                     indices.setUpdateTime(event.getEventFrom());
 271                                     indices.setTarget("#News#showevent=" + group.getGroupId() + "&course=" + calendarName);
 272                                     indices.setTitle(calendarName+" Event: " + event.getCourseName());
 273                                     indices.setDescription(event.getEventTitle());
 274                                     indices.addKeyWord(event.getGroupTitle());
 275                                     indices.addKeyWord(event.getEventLocation());
 276
 277                                     return null;
 278                                 }
 279                             });
 280                         }
 281                         else
 282                             break;
 283                         return;
 284
 285                     // some more tasks to do here?
 286
 287                     case 20:
 288                         ((CampusApp)AppContext.getMainActivity()).loadMainUi();
 289                         AppContext.getNavigationManager().navigatePage("Dashboard", null, false);
 290                         return;
 291                 }
 292                 timerHandler.postDelayed(timerRunnable, 100);
 293             }
 294         };
 295
 296         return view;
 297     }
 298
 299     @Override
 300     public void onResume() {
 301         super.onResume();
 302         timerHandler.postDelayed(timerRunnable, 500);
 303     }
 304
 305 }