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