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