Proyectos de Subversion Android Microlearning

Rev

Rev 4 | Rev 8 | Ir a la última revisión | | Comparar con el anterior | Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1
package com.cesams.twogetskills.activity;
2
 
3
import androidx.activity.result.ActivityResultLauncher;
4
import androidx.activity.result.contract.ActivityResultContracts;
5
import androidx.annotation.NonNull;
6
import androidx.appcompat.app.ActionBarDrawerToggle;
7
import androidx.appcompat.app.AlertDialog;
8
import androidx.appcompat.app.AppCompatActivity;
9
import androidx.core.app.NotificationCompat;
10
import androidx.core.view.GravityCompat;
11
import androidx.fragment.app.Fragment;
12
import androidx.fragment.app.FragmentTransaction;
13
 
14
import android.accounts.Account;
15
import android.accounts.AccountManager;
16
import android.app.NotificationChannel;
17
import android.app.NotificationManager;
18
import android.app.PendingIntent;
19
import android.content.ContentResolver;
20
import android.content.DialogInterface;
21
import android.net.ConnectivityManager;
22
import android.os.Build;
23
import android.text.TextUtils;
24
import android.util.Log;
25
import android.content.Context;
26
import android.content.Intent;
27
import android.content.IntentFilter;
28
import android.os.Bundle;
29
import android.view.Menu;
30
import android.view.MenuItem;
31
import android.view.View;
32
import android.widget.ImageView;
33
import android.widget.ProgressBar;
34
import android.widget.TextView;
35
 
36
 
37
import com.bumptech.glide.Glide;
38
import com.bumptech.glide.load.engine.DiskCacheStrategy;
39
import com.bumptech.glide.load.model.GlideUrl;
40
import com.bumptech.glide.load.model.LazyHeaders;
41
import com.bumptech.glide.request.RequestOptions;
42
import com.cesams.twogetskills.Configuration;
43
import com.cesams.twogetskills.dao.AnswerDao;
44
import com.cesams.twogetskills.dao.AppDatabase;
45
import com.cesams.twogetskills.dao.CapsuleDao;
46
import com.cesams.twogetskills.dao.CompanyDao;
47
import com.cesams.twogetskills.dao.DatabaseHelper;
48
import com.cesams.twogetskills.dao.ProgressDao;
49
import com.cesams.twogetskills.dao.QuestionDao;
50
import com.cesams.twogetskills.dao.QuizDao;
51
import com.cesams.twogetskills.dao.SlideDao;
52
import com.cesams.twogetskills.dao.SyncDao;
53
import com.cesams.twogetskills.dao.TopicDao;
54
import com.cesams.twogetskills.dao.UserExtendedDao;
55
import com.cesams.twogetskills.dao.UserLogDao;
56
import com.cesams.twogetskills.entity.UserExtended;
57
import com.cesams.twogetskills.fragment.CapsuleFragment;
58
import com.cesams.twogetskills.fragment.CompanyFragment;
59
import com.cesams.twogetskills.fragment.FinishCapsuleFragment;
60
import com.cesams.twogetskills.fragment.FinishTopicFragment;
61
import com.cesams.twogetskills.fragment.GalleryFragment;
62
import com.cesams.twogetskills.fragment.ProgressFragment;
63
import com.cesams.twogetskills.fragment.SlideFragment;
64
import com.cesams.twogetskills.fragment.TimelineFragment;
65
import com.cesams.twogetskills.fragment.TopicFragment;
66
import com.cesams.twogetskills.fragment.UserProfileFragment;
67
import com.cesams.twogetskills.library.Http;
68
import com.cesams.twogetskills.library.MD5;
69
import com.cesams.twogetskills.library.UniqueID;
70
import com.cesams.twogetskills.entity.Answer;
71
import com.cesams.twogetskills.entity.Capsule;
72
import com.cesams.twogetskills.entity.Company;
73
import com.cesams.twogetskills.entity.Progress;
74
import com.cesams.twogetskills.entity.Question;
75
import com.cesams.twogetskills.entity.Quiz;
76
import com.cesams.twogetskills.entity.Slide;
77
import com.cesams.twogetskills.entity.Sync;
78
import com.cesams.twogetskills.entity.Topic;
79
import com.cesams.twogetskills.entity.UserLog;
80
import com.cesams.twogetskills.preference.Preference;
81
import com.cesams.twogetskills.receiver.ConnectivityReceiver;
82
import com.cesams.twogetskills.receiver.InternalReceiver;
83
import com.cesams.twogetskills.room.ResultCount;
84
import com.google.android.material.snackbar.Snackbar;
85
import com.google.android.material.navigation.NavigationView;
86
 
87
import androidx.drawerlayout.widget.DrawerLayout;
88
import androidx.appcompat.widget.Toolbar;
89
import com.cesams.twogetskills.Constants;
90
import com.cesams.twogetskills.R;
91
 
92
import com.cesams.twogetskills.fragment.IntroFragment;
93
import com.cesams.twogetskills.fragment.SigninFragment;
94
import com.cesams.twogetskills.skeleton.ITwoGetSkills;
95
 
96
import org.json.JSONArray;
97
import org.json.JSONException;
98
import org.json.JSONObject;
99
 
100
import java.io.IOException;
101
import java.text.SimpleDateFormat;
102
import java.util.Calendar;
103
import java.util.Date;
104
import java.util.HashMap;
105
import java.util.List;
106
import java.util.Random;
107
import java.util.TimeZone;
108
 
109
//import de.hdodenhof.circleimageview.CircleImageView;
110
import okhttp3.Call;
111
import okhttp3.FormBody;
112
import okhttp3.OkHttpClient;
113
import okhttp3.Request;
114
import okhttp3.RequestBody;
115
import okhttp3.Response;
116
 
117
public class MainActivity extends  AppCompatActivity implements ITwoGetSkills,NavigationView.OnNavigationItemSelectedListener {
118
    private boolean isSyncDevice = false;
119
    private boolean isSyncToken = false;
120
    private boolean isSyncBatch = false;
121
    private boolean isForeground = false;
6 gabriel 122
    private boolean issmartlockloginrun = false;
1 efrain 123
 
124
    private final static String PREFIX_FRAG = "FRAG";
125
    private final static String TAG = "C2GS - MainActivity";
126
 
127
    private DrawerLayout mDrawer;
128
    private ActionBarDrawerToggle mDrawerToggle;
129
 
130
    private HashMap<String, Fragment> fragmentHashMap;
131
 
132
    private ImageView navHeaderUserImage;
133
 
134
    private TextView navHeaderUserName;
135
    private TextView navHeaderUserEmail;
136
    private TextView textViewMessageNotConnection;
137
 
138
 
139
 
140
    private Preference preference;
141
    private boolean connected = false;
142
    private ConnectivityReceiver mConnectivityReceiver;
143
    private InternalReceiver mInternalReceiver;
144
    private ProgressBar mProgressBar;
145
 
146
    private Account mAccount;
147
    private AppDatabase mAppDatabase;
148
 
149
 
150
 
151
    ActivityResultLauncher<Intent> mLauncher = registerForActivityResult(
152
            new ActivityResultContracts.StartActivityForResult(),
153
            result -> {
154
                if(result.getResultCode() == RESULT_OK) {
6 gabriel 155
                    boolean completed = result.getData().hasExtra("completed") && result.getData().getBooleanExtra("completed", false);
1 efrain 156
                    int requestCode = result.getData().hasExtra("requestCode") ? result.getData().getIntExtra("requestCode", 0) : 0;
157
                    if(requestCode == Constants.REQUEST_CODE_QUIZ) {
158
                        createProgressAndSyncRecord(preference.getSlideUuidActive(), completed, true, false);
159
                    } else  if(requestCode == Constants.REQUEST_CODE_AUDIO_VIDEO) {
160
                        createProgressAndSyncRecord(preference.getSlideUuidActive(), completed, false, true);
161
                    } else {
162
                        createProgressAndSyncRecord(preference.getSlideUuidActive(), completed, false, false);
163
                    }
164
                }
165
            }
166
    );
167
 
168
 
169
    @Override
170
    protected void onCreate(Bundle savedInstanceState) {
171
        super.onCreate(savedInstanceState);
172
        setContentView(R.layout.activity_main);
173
 
174
        Log.d(TAG, "MainActivity onCreate");
175
 
176
        /**** CANAL DE NOTIFICACIONES **/
177
        createNotificationChannel();
178
 
179
        /*** CUENTAS DE SINCRONIZACION **/
180
        mAccount =  CreateSyncAccount(this);
181
 
182
 
183
        // Get the content resolver for your app
184
        //mResolver = getContentResolver();
185
 
186
        mAppDatabase = DatabaseHelper.getInstance(this).getAppDatabase();
187
 
188
        preference = new Preference(this);
189
 
190
        if(TextUtils.isEmpty(preference.getDeviceUuid())) {
191
            String uuid = UniqueID.id(this);
192
            preference.setDeviceUuid(uuid);
193
            preference.save(this);
194
 
195
            Sync sync = new Sync(Constants.SYNC_ADAPTER_TYPE_DEVICE, uuid);
196
            mAppDatabase.getSyncDao().insert(sync);
197
 
198
            if(!TextUtils.isEmpty(preference.getDeviceToken())) {
199
                sync = new Sync(Constants.SYNC_ADAPTER_TYPE_FCM, preference.getDeviceToken());
200
                mAppDatabase.getSyncDao().insert(sync);
201
            }
202
        }
203
 
204
        fragmentHashMap = new HashMap<>();
205
 
206
        mProgressBar = findViewById(R.id.progressBar);
6 gabriel 207
        Toolbar mToolbar = findViewById(R.id.toolbar);
1 efrain 208
        setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
209
 
210
        mDrawer = findViewById(R.id.drawer_layout);
211
        mDrawerToggle = new ActionBarDrawerToggle(
212
                this, mDrawer, mToolbar, R.string.navigation_drawer_open,
213
                R.string.navigation_drawer_close);
214
 
215
        mDrawerToggle.setToolbarNavigationClickListener(v -> onBackPressed());
216
 
217
        mDrawer.addDrawerListener(mDrawerToggle);
218
        mDrawerToggle.syncState();
219
 
220
        NavigationView navigationView = findViewById(R.id.navigation_view);
221
        navigationView.setNavigationItemSelectedListener(this);
222
 
223
        View header = navigationView.getHeaderView(0);
224
        //navHeaderUserImage = (CircleImageView) header.findViewById(R.id.nav_header_user_image);
4 gabriel 225
        navHeaderUserImage = header.findViewById(R.id.nav_header_user_image);
226
        navHeaderUserName = header.findViewById(R.id.nav_header_user_name);
227
        navHeaderUserEmail =  header.findViewById(R.id.nav_header_user_email);
1 efrain 228
 
4 gabriel 229
        textViewMessageNotConnection = findViewById(R.id.main_activity_text_view_message_not_connection);
1 efrain 230
 
231
        mConnectivityReceiver = new ConnectivityReceiver();
232
        registerReceiver(mConnectivityReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
233
 
234
        IntentFilter intentFilterInternal = new IntentFilter();
235
        intentFilterInternal.addAction(Constants.BROADCAST_TYPE_NOTIFICATION);
236
        intentFilterInternal.addAction(Constants.BROADCAST_TYPE_TOKEN);
237
        intentFilterInternal.addAction(Constants.BROADCAST_TYPE_COMMAND);
238
        intentFilterInternal.addAction(Constants.BROADCAST_TYPE_SYNC_TO_SERVER_OR_CHECK_CHANGES);
239
 
240
        mInternalReceiver = new InternalReceiver();
241
        registerReceiver(mInternalReceiver, intentFilterInternal);
242
 
243
    }
244
 
245
    @Override
246
    protected void onDestroy() {
247
        super.onDestroy();
248
 
249
        try  {
250
            unregisterReceiver(mConnectivityReceiver);
251
            unregisterReceiver(mInternalReceiver);
252
        } catch (IllegalArgumentException e) {
253
            e.printStackTrace();
254
        }
255
    }
256
 
257
 
258
    @Override
259
    protected void onResume() {
260
        super.onResume();
261
        isForeground = true;
262
 
263
        if(preference == null) {
264
            preference = new Preference(this);
265
        }
266
 
267
        reloadNavHeader();
268
 
6 gabriel 269
        Log.e("Se ejecuta", "On resumen");
270
 
1 efrain 271
        if(TextUtils.isEmpty(preference.getUserUuid())) {
6 gabriel 272
 
273
            //Verifico que el teclado no vaya a relanzar el fragment de intro al usar Google Smartlock para traer
274
            //Informacion de inicio de sesion almacenada en su cuenta personal de Google
275
            if (!issmartlockloginrun) {
276
                invokeFragment(Constants.IDX_FRAGMENT_INTRO);
277
                issmartlockloginrun= true;
278
            }
279
 
280
 
1 efrain 281
        } else {
282
            if(preference.getFragmentIdxActive() == 0) {
283
                invokeFragment(Constants.IDX_FRAGMENT_TOPICS);
284
            } else {
285
                invokeFragment(preference.getFragmentIdxActive());
286
            }
287
        }
288
 
289
    }
290
 
291
    @Override
292
    protected void onPause() {
293
        super.onPause();
294
 
295
        isForeground = false;
296
        preference.save(this);
297
    }
298
 
299
    @Override
300
    public boolean onNavigationItemSelected(@NonNull MenuItem menuItem) {
301
        int title;
302
        mDrawer.closeDrawers();
303
 
304
        switch (menuItem.getItemId()) {
305
            case R.id.nav_topics :
306
                setTitleActionBar(getString(R.string.menu_topics));
307
                invokeFragment(Constants.IDX_FRAGMENT_TOPICS);
308
                break;
309
            case R.id.nav_timeline:
310
                setTitleActionBar(getString(R.string.menu_timeline));
311
                invokeFragment(Constants.IDX_FRAGMENT_TIMELINE);
312
 
313
                break;
314
            case R.id.nav_progress:
315
 
316
                if(preference.getCompanyCount() > 1) {
317
                    invokeFragment(Constants.IDX_FRAGMENT_COMPANIES);
318
                }  else {
319
                    setTitleActionBar(getString(R.string.menu_progress));
320
                    invokeFragment(Constants.IDX_FRAGMENT_PROGRESS);
321
                }
322
                break;
323
 
324
            case R.id.nav_userprofile:
325
                setTitleActionBar(getString(R.string.menu_user_profile));
326
                invokeFragment(Constants.IDX_FRAGMENT_USER_PROFILE);
327
                break;
328
 
329
            case R.id.nav_exit_app:
330
                setTitleActionBar(getString(R.string.menu_exit));
331
                AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
332
                builder.setTitle(R.string.alter_dialog_close_app_title);
333
                builder.setMessage(R.string.alter_dialog_close_app_message);
334
                builder.setNegativeButton(R.string.alter_dialog_button_no, new DialogInterface.OnClickListener() {
335
                    @Override
336
                    public void onClick(DialogInterface dialog, int which) {
337
 
338
                    }
339
                });
340
                builder.setPositiveButton(R.string.alter_dialog_button_yes, new DialogInterface.OnClickListener() {
341
                    @Override
342
                    public void onClick(DialogInterface dialog, int which) {
343
                        signout();
344
                    }
345
                });
346
 
347
                AlertDialog dialog = builder.create();
348
                dialog.show();
349
 
350
                break;
351
 
352
            default:
353
                throw new IllegalArgumentException("menu option not implemented!!");
354
        }
355
 
356
        mDrawer.closeDrawer(GravityCompat.START);
357
 
358
        return true;
359
    }
360
 
361
    private void createNotificationChannel() {
362
        // Create the NotificationChannel, but only on API 26+ because
363
        // the NotificationChannel class is new and not in the support library
4 gabriel 364
        CharSequence name = getString(R.string.channel_name);
365
        String description = getString(R.string.channel_description);
366
        int importance = NotificationManager.IMPORTANCE_DEFAULT;
367
        NotificationChannel channel = new NotificationChannel(Constants.NOTIFICATION_CHANNEL_ID, name, importance);
368
        channel.setDescription(description);
369
        channel.setShowBadge(true);
1 efrain 370
 
371
 
4 gabriel 372
        // Register the channel with the system; you can't change the importance
373
        // or other notification behaviors after this
374
        NotificationManager notificationManager = getSystemService(NotificationManager.class);
375
        notificationManager.createNotificationChannel(channel);
1 efrain 376
    }
377
 
378
 
379
    @Override
380
    public void showFcmNotification(String title, String body, int new_capsules)
381
    {
382
 
383
        NotificationCompat.Builder builder =
384
                new NotificationCompat.Builder(MainActivity.this, Constants.NOTIFICATION_CHANNEL_ID)
385
                        .setSmallIcon(R.drawable.ic_notificacion) //set icon for notification
386
                        .setContentTitle(title) //set title of notification
387
                        .setContentText(body)//this is notification message
388
                        .setAutoCancel(true) // makes auto cancel of notification
389
                        .setPriority(NotificationCompat.PRIORITY_DEFAULT); //set priority of notification
390
 
391
        if(new_capsules > 0) {
392
            builder.setBadgeIconType(NotificationCompat.BADGE_ICON_LARGE);
393
            builder.setNumber(new_capsules);
394
        }
395
 
396
        Intent notificationIntent = new Intent(this, MainActivity.class);
397
        notificationIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
398
        //notification message will get at NotificationView
399
        notificationIntent.putExtra(title, body);
400
 
401
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent,
402
                PendingIntent.FLAG_UPDATE_CURRENT);
403
        builder.setContentIntent(pendingIntent);
404
 
405
        // Add as notification
406
        NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
407
        manager.notify(0, builder.build());
408
 
409
 
410
        if(new_capsules > 0) {
411
 
412
            String message = new_capsules == 1
413
                    ? "Hay 1 cápsula nueva disponible"
414
                    : "Hay " + new_capsules + " cápsulas disponible";
415
 
416
            showMessageSnackBarWithClose(message);
417
        } else {
418
            showMessageSnackBarWithClose(body);
419
        }
420
 
421
 
422
    }
423
 
424
    @Override
425
    public void signout()
426
    {
427
        mAppDatabase.getAnswerDao().removeAll();
428
        mAppDatabase.getQuestionDao().removeAll();
429
        mAppDatabase.getQuizDao().removeAll();
430
        mAppDatabase.getSlideDao().removeAll();
431
        mAppDatabase.getCapsuleDao().removeAll();
432
        mAppDatabase.getTopicDao().removeAll();
433
        mAppDatabase.getUserExtendedDao().removeAll();
434
 
435
 
436
        preference.setUserUuid("");
437
        preference.setFirstName("");
438
        preference.setLastName("");
439
        preference.setEmail("");
440
        preference.setImage("");
441
        preference.setMaxDateChanges("");
442
        preference.setCompanyCount(0);
443
        preference.setCompanyUuidActive("");
444
        preference.setTopicUuidActive("");
445
        preference.setCapsuleUuidActive("");
446
        preference.setSlideUuidActive("");
447
        preference.save(this);
448
 
449
        invokeFragment(Constants.IDX_FRAGMENT_INTRO);
450
    }
451
 
452
    @Override
453
    public void onBackPressed() {
454
 
455
        //super.onBackPressed();
456
        switch (preference.getFragmentIdxActive())
457
        {
458
 
459
/*
460
            case Constants.IDX_FRAGMENT_INTRO :
461
            case Constants.IDX_FRAGMENT_SIGNIN  :
462
            case Constants.IDX_FRAGMENT_TOPICS  :
463
                finish();
464
                return;*/
465
 
466
            case Constants.IDX_FRAGMENT_PROGRESS :
467
               if(preference.getCompanyCount() > 1) {
468
                   invokeFragment(Constants.IDX_FRAGMENT_COMPANIES);
469
               } else {
470
                   invokeFragment(Constants.IDX_FRAGMENT_TOPICS);
471
               }
472
               break;
473
 
474
            case Constants.IDX_FRAGMENT_COMPANIES:
475
            case Constants.IDX_FRAGMENT_TIMELINE  :
476
            case Constants.IDX_FRAGMENT_CAPSULES :
477
            case Constants.IDX_FRAGMENT_FINISH_TOPIC :
478
 
479
                preference.setTopicUuidActive("");
480
                preference.setCapsuleUuidActive("");
481
                preference.setSlideUuidActive("");
482
                preference.save(this);
483
 
484
                invokeFragment(Constants.IDX_FRAGMENT_TOPICS);
485
                return;
486
 
487
            case Constants.IDX_FRAGMENT_SLIDES :
488
                invokeFragment(Constants.IDX_FRAGMENT_CAPSULES);
489
                return;
490
 
491
            case Constants.IDX_FRAGMENT_GALLERY :
492
                invokeFragment(Constants.IDX_FRAGMENT_SLIDES);
493
                return;
494
 
495
            case Constants.IDX_FRAGMENT_FINISH_CAPSULE :
496
                preference.setCapsuleUuidActive("");
497
                preference.setSlideUuidActive("");
498
                preference.save(this);
499
 
500
                invokeFragment(Constants.IDX_FRAGMENT_CAPSULES);
501
                return;
502
 
503
        }
504
    }
505
 
506
 
507
 
508
    @Override
509
    public void hideProgressBar() {
510
 
511
        //accessing it from ui-thread
512
        runOnUiThread(new Runnable() {
513
            @Override
514
            public void run() {
515
                mProgressBar.setVisibility(View.INVISIBLE);
516
            }
517
        });
518
 
519
    }
520
 
521
    @Override
522
    public void showProgressBar() {
523
        runOnUiThread(new Runnable() {
524
            @Override
525
            public void run() {
526
                mProgressBar.setVisibility(View.VISIBLE);
527
            }
528
        });
529
 
530
 
531
    }
532
 
533
 
534
 
535
 
536
 
537
    @Override
538
    public boolean onCreateOptionsMenu(Menu menu) {
539
        // Inflate the menu; this adds items to the action bar if it is present.
540
        getMenuInflater().inflate(R.menu.drawer, menu);
541
        return true;
542
    }
543
 
544
 
545
 
546
 
547
      /**
548
         * Create a new dummy account for the sync adapter
549
         *
550
         * @param context The application context
551
         */
552
    public static Account CreateSyncAccount(Context context) {
553
        // Create the account type and default account
554
        Account newAccount = new Account(
555
                Constants.ACCOUNT, Constants.ACCOUNT_TYPE);
556
        // Get an instance of the Android account manager
557
        AccountManager accountManager =
558
                (AccountManager) context.getSystemService(
559
                        ACCOUNT_SERVICE);
560
        /*
561
         * Add the account and account type, no password or user data
562
         * If successful, return the Account object, otherwise report an error.
563
         */
564
        if (accountManager.addAccountExplicitly(newAccount, null, null)) {
565
            /*
566
             * If you don't set android:syncable="true" in
567
             * in your <provider> element in the manifest,
568
             * then call context.setIsSyncable(account, AUTHORITY, 1)
569
             * here.
570
             */
571
 
572
            ContentResolver.setIsSyncable(newAccount, Constants.AUTHORITY, 1);
573
            ContentResolver.setSyncAutomatically(newAccount, Constants.AUTHORITY, true);
574
            ContentResolver.addPeriodicSync(newAccount,
575
                    Constants.AUTHORITY,  Bundle.EMPTY, Constants.SYNC_INTERVAL);
576
 
577
 
578
        } else {
579
            /*
580
             * The account exists or some other error occurred. Log this, report it,
581
             * or handle it internally.
582
             */
583
 
584
            Account[] accounts = accountManager.getAccounts();
585
            if(accounts != null && accounts.length > 0) {
586
 
587
                for(Account account : accounts)
588
                {
589
                    if(account.type.equals(Constants.ACCOUNT_TYPE)) {
590
                        return account;
591
                    }
592
                }
593
                return accounts[0];
594
            } else {
595
                return null;
596
            }
597
 
598
 
599
 
600
        }
601
 
602
        return newAccount;
603
 
604
 
605
    }
606
 
607
 
608
 
609
 
610
 
611
    @Override
612
    public void createSyncRecordNewToken(String token)
613
    {
614
 
615
        preference.setDeviceToken (token);
616
        preference.save(this);
617
 
618
        if(!TextUtils.isEmpty(preference.getDeviceUuid())) {
619
            Sync sync = new Sync(Constants.SYNC_ADAPTER_TYPE_FCM, token);
620
            mAppDatabase.getSyncDao().insert(sync);
621
        }
622
    }
623
 
624
 
625
 
626
 
627
    @Override
628
    public void executeFcmCommand(String command)
629
    {
630
 
631
        if (command.equals("signout")) {
632
            signout();
633
        }
634
    }
635
 
636
 
637
 
638
    @Override
639
    public void setConnectedInternet(Boolean isConnected)
640
    {
641
        connected = isConnected;
642
        textViewMessageNotConnection.setVisibility(isConnected ? View.INVISIBLE : View.VISIBLE);
643
    }
644
 
645
    @Override
646
    public boolean isConnectedInternet() {
647
        return connected;
648
    }
649
 
650
    @Override
651
    public void showMessageSnackBar(String message) {
652
        Snackbar.make(this.findViewById(R.id.fragment_container), message, Snackbar.LENGTH_LONG).show();
653
    }
654
 
655
 
656
    @Override
657
    public void showMessageSnackBarWithClose(String message) {
658
        final Snackbar snackBar = Snackbar.make(this.findViewById(R.id.fragment_container), message, Snackbar.LENGTH_INDEFINITE);
659
 
660
        snackBar.setAction(R.string.snackbar_close, new View.OnClickListener() {
661
            @Override
662
            public void onClick(View v) {
663
                // Call your action method here
664
                snackBar.dismiss();
665
            }
666
        });
667
        snackBar.show();
668
 
669
 
670
    }
671
 
672
    @Override
673
    public void onErrorFatal() {
674
 
675
 
676
        invokeFragment(Constants.IDX_FRAGMENT_SIGNIN);
677
    }
678
 
679
    @Override
680
    public void invokeFragment(int fragmentIdxActiveNuevo)
681
    {
682
        String fragmentKeyActual    = PREFIX_FRAG + preference.getFragmentIdxActive();
683
        String fragmentKeyNuevo 	= PREFIX_FRAG + fragmentIdxActiveNuevo;
684
        preference.setFragmentIdxActive(fragmentIdxActiveNuevo);
685
        preference.save(this);
686
 
687
        Fragment fragment;
688
        if(!fragmentKeyActual.equalsIgnoreCase(fragmentKeyNuevo)) {
689
            if(fragmentHashMap.containsKey(fragmentKeyActual)) {
690
                fragment = fragmentHashMap.get(fragmentKeyActual);
691
                if(fragment != null) {
692
                    FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
693
                    fragmentTransaction.hide(fragment);
694
                    fragmentTransaction.commit();
695
                }
696
            }
697
        }
698
 
699
        boolean add = false;
700
        fragment = null;
701
        getSupportActionBar().setDisplayHomeAsUpEnabled(false);
702
        mDrawerToggle.setDrawerIndicatorEnabled(false);
703
 
704
 
705
        switch(fragmentIdxActiveNuevo) {
706
            case Constants.IDX_FRAGMENT_SIGNIN :
707
                getSupportActionBar().hide();
708
                 if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
709
                     fragment = fragmentHashMap.get(fragmentKeyNuevo);
710
                 } else {
711
                     add = true;
712
                     fragment = new SigninFragment();
713
                 }
714
                break;
715
 
716
            case Constants.IDX_FRAGMENT_TOPICS :
717
 
718
 
719
                getSupportActionBar().show();
720
                mDrawerToggle.setDrawerIndicatorEnabled(true);
721
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
722
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
723
                } else {
724
                    add = true;
725
                    fragment = new TopicFragment();
726
                }
727
                break;
728
 
4 gabriel 729
 
1 efrain 730
            case Constants.IDX_FRAGMENT_CAPSULES :
731
                getSupportActionBar().show();
732
                getSupportActionBar().setDisplayHomeAsUpEnabled(true);
733
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
734
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
735
                } else {
736
                    add = true;
737
                    fragment = new CapsuleFragment();
738
                }
739
                break;
740
 
741
            case Constants.IDX_FRAGMENT_SLIDES :
742
                getSupportActionBar().show();
743
                getSupportActionBar().setDisplayHomeAsUpEnabled(true);
744
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
745
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
746
                } else {
747
                    add = true;
748
                    fragment = new SlideFragment();
749
                }
750
                break;
751
 
752
            case Constants.IDX_FRAGMENT_GALLERY :
753
                getSupportActionBar().show();
754
                getSupportActionBar().setDisplayHomeAsUpEnabled(true);
755
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
756
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
757
                } else {
758
                    add = true;
759
                    fragment = new GalleryFragment();
760
                }
761
 
762
                break;
763
 
764
            case Constants.IDX_FRAGMENT_FINISH_CAPSULE :
765
                getSupportActionBar().hide();
766
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
767
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
768
                } else {
769
                    add = true;
770
                    fragment = new FinishCapsuleFragment();
771
                }
772
                break;
4 gabriel 773
 
1 efrain 774
            case Constants.IDX_FRAGMENT_FINISH_TOPIC :
775
                getSupportActionBar().hide();
776
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
777
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
778
                } else {
779
                    add = true;
780
                    fragment = new FinishTopicFragment();
781
                }
782
                break;
783
 
784
            case Constants.IDX_FRAGMENT_TIMELINE :
785
                getSupportActionBar().show();
786
                mDrawerToggle.setDrawerIndicatorEnabled(true);
787
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
788
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
789
                } else {
790
                    add = true;
791
                    fragment = new TimelineFragment();
792
                }
793
                break;
794
 
795
            case Constants.IDX_FRAGMENT_COMPANIES:
796
                getSupportActionBar().show();
797
                mDrawerToggle.setDrawerIndicatorEnabled(true);
798
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
799
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
800
                } else {
801
                    add = true;
802
                    fragment = new CompanyFragment();
803
                }
804
                break;
805
 
806
            case Constants.IDX_FRAGMENT_PROGRESS :
807
                getSupportActionBar().show();
808
                mDrawerToggle.setDrawerIndicatorEnabled(true);
809
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
810
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
811
                } else {
812
                    add = true;
813
                    fragment = new ProgressFragment();
814
                }
815
                break;
816
 
817
            case Constants.IDX_FRAGMENT_USER_PROFILE:
818
                getSupportActionBar().show();
819
                mDrawerToggle.setDrawerIndicatorEnabled(true);
820
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
821
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
822
                } else {
823
                    add = true;
824
                    fragment = new UserProfileFragment();
825
                }
826
                break;
827
 
828
            default :
829
                getSupportActionBar().hide();
830
                if(fragmentHashMap.containsKey(fragmentKeyNuevo)) {
831
                    fragment = fragmentHashMap.get(fragmentKeyNuevo);
832
                } else {
833
                    add = true;
834
                    fragment = new IntroFragment();
835
                }
836
                break;
837
 
838
 
839
        }
840
 
841
        if(add) {
842
            fragmentHashMap.put(fragmentKeyNuevo, fragment);
843
 
844
            FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
845
            fragmentTransaction.add(R.id.fragment_container, fragment, fragmentKeyNuevo);
846
            fragmentTransaction.commit();
847
        }
848
 
849
 
850
        if(fragment != null) {
851
            FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
852
            fragmentTransaction.show(fragment);
853
            fragmentTransaction.commit();
854
        }
855
 
856
    }
857
 
858
    @Override
859
    public void changeTopicActive(String topicUuid)
860
    {
861
        Log.d(TAG, "changeTopicActive : " + topicUuid);
862
 
863
        preference.setTopicUuidActive(topicUuid);
864
        preference.setCapsuleUuidActive("");
865
        preference.setSlideUuidActive("");
866
        preference.save(this);
867
 
868
        invokeFragment(Constants.IDX_FRAGMENT_CAPSULES);
869
    }
870
 
871
    @Override
872
    public void changeCapsuleActive(String capsuleUuid)
873
    {
874
        Log.d(TAG, "changeCapsuleActive : " + capsuleUuid);
875
 
876
 
877
        preference.setCapsuleUuidActive(capsuleUuid);
878
        preference.setSlideUuidActive("");
879
 
880
 
881
        preference.save(this);
882
 
883
        invokeFragment(Constants.IDX_FRAGMENT_SLIDES);
884
    }
885
 
886
    @Override
887
    public void changeCompanyActive(String companyUuid)
888
    {
889
        Log.d(TAG, "changeCompanyActive : " + companyUuid);
890
 
891
        preference.setCompanyUuidActive(companyUuid);
892
        preference.save(this);
893
    }
894
 
895
    @Override
896
    public void changeSlideActive(String slideUuid, String type, boolean showGallery)
897
    {
898
 
899
        Log.d(TAG, "changeSlideActive : " + slideUuid);
900
 
901
        if(!preference.getSlideUuidActive().equals(slideUuid) && type.equals(Constants.SLIDE_TYPE_IMAGE)) {
902
            Log.d(TAG, "registerOnPageChangeCallback - createProgressAndSyncRecord");
903
 
904
            createProgressAndSyncRecord(slideUuid, true, false, false);
905
        }
906
 
907
 
908
 
909
        preference.setSlideUuidActive(slideUuid);
910
        preference.save(this);
911
 
912
 
913
        if(showGallery) {
914
            invokeFragment(Constants.IDX_FRAGMENT_GALLERY);
915
        }
916
    }
917
 
918
    @Override
919
    public String getTopicUuidActive()
920
    {
921
        return preference.getTopicUuidActive();
922
    }
923
 
924
    @Override
925
    public String getCapsuleUuidActive()
926
    {
927
        return preference.getCapsuleUuidActive();
928
    }
929
 
930
    @Override
931
    public String getSlideUuidActive()
932
    {
933
        return preference.getSlideUuidActive();
934
    }
935
 
936
    @Override
937
    public String getCompanyUuidActive()
938
    {
939
        return preference.getCompanyUuidActive();
940
    }
941
 
942
    @Override
943
    public void setTitleActionBar(String title)
944
    {
945
        getSupportActionBar().setTitle(title);
946
    }
947
 
948
    @Override
949
    public synchronized void createProgressAndSyncRecord(String slideUuid, boolean completed, boolean isQuiz, boolean isAudioOrVideo)
950
    {
951
        Calendar calendar = Calendar.getInstance();
952
        Date date = calendar.getTime();
953
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(Constants.FORMAT_DATETIME_SERVICE);
954
        String  dateOn = simpleDateFormat.format(date);
955
 
956
        SlideDao slideDao = mAppDatabase.getSlideDao();
957
        Slide slide =  slideDao.selectByUuid(slideUuid);
958
 
959
        CapsuleDao capsuleDao = mAppDatabase.getCapsuleDao();
960
        Capsule capsule = capsuleDao.selectByUuid(slide.getCapsuleUuid());
961
 
962
        TopicDao topicDao = mAppDatabase.getTopicDao();
963
        Topic topic = topicDao.selectByUuid(capsule.getTopicUuid());
964
 
965
        UserLog userLog;
966
        UserLogDao userLogDao = mAppDatabase.getUserLogDao();
967
 
968
        SyncDao syncDao = mAppDatabase.getSyncDao();
969
        Sync sync;
970
 
971
        // Progreso y UserLog  del Slide
972
        ProgressDao progressDao = mAppDatabase.getProgressDao();
973
        Progress progressSlide = progressDao.selectBySlideUuid(slide.getUuid());
974
        Progress progressCapsule =  progressDao.selectByCapsuleUuid(slide.getCapsuleUuid());
975
        Progress progressTopic =  progressDao.selectByTopicUuid(slide.getTopicUuid());
976
 
977
        int totalSlides = 0;
978
        int viewSlides = 0;
979
        double percentaje = 0;
980
        boolean newRecord = false;
981
        boolean retakeQuiz = false;
982
 
983
        /*** INICIO PROCESO DIAPOSITIVA ***/
984
        if(progressSlide == null) {
985
 
986
            retakeQuiz = false;
987
 
988
 
989
            progressSlide = new Progress();
990
            progressSlide.setUserUuid(preference.getUserUuid());
991
            progressSlide.setCompanyUuid(topic.getCompanyUuid());
992
            progressSlide.setTopicUuid(topic.getUuid());
993
            progressSlide.setCapsuleUuid(capsule.getUuid());
994
            progressSlide.setSlideUuid(slide.getUuid());
995
            progressSlide.setType(Constants.PROGERSS_TYPE_SLIDE);
996
            progressSlide.setCompleted(completed ? 1 : 0);
997
            progressSlide.setAddedOn(dateOn);
998
            progressSlide.setUpdatedOn(dateOn);
999
            progressDao.insert(progressSlide);
1000
        } else {
1001
            retakeQuiz = true;
1002
 
1003
            if (progressSlide.getCompleted() == 1) {
1004
                progressSlide.setReturningAfterCompleted(progressSlide.getReturningAfterCompleted() + 1);
1005
            } else {
1006
                if (completed) {
4 gabriel 1007
                    //0 y 1 para Boolean
1 efrain 1008
                    progressSlide.setCompleted(completed  ? 1 : 0);
1009
                } else {
1010
                    progressSlide.setReturning(progressSlide.getReturning() + 1);
1011
                }
1012
            }
1013
 
1014
            progressSlide.setUpdatedOn(dateOn);
1015
            progressDao.update(progressSlide);
1016
        }
1017
 
1018
 
1019
        /*** FIN PROCESO DIAPOSITIVA ***/
1020
 
1021
 
1022
 
1023
        /*** INICIO PROCESO TOPICO ***/
1024
        ResultCount resultCount;
1025
 
1026
 
1027
        resultCount = slideDao.getCountByTopicUuid(slide.getTopicUuid());
1028
        totalSlides = resultCount.getCount();
1029
 
1030
        resultCount = progressDao.getCountSlidesCompletedByTopicUuid(slide.getTopicUuid());
1031
        viewSlides =  resultCount.getCount();
1032
        if(totalSlides == 0) {
1033
            percentaje = 0;
1034
        } else {
1035
            percentaje = (viewSlides * 100) / totalSlides;
1036
        }
1037
 
1038
        if(progressTopic == null) {
1039
            newRecord = true;
1040
            progressTopic = new Progress();
1041
            progressTopic.setUserUuid(preference.getUserUuid());
1042
            progressTopic.setCompanyUuid( topic.getCompanyUuid());
1043
            progressTopic.setTopicUuid (topic.getUuid());
1044
 
1045
            progressTopic.setViewSlides(viewSlides);
1046
            progressTopic.setTotalSlides(totalSlides);
1047
            progressTopic.setProgress (percentaje);
1048
            progressTopic.setType(Constants.PROGERSS_TYPE_TOPIC);
1049
 
1050
            progressTopic.setAddedOn(dateOn);
1051
            progressTopic.setUpdatedOn(dateOn);
1052
             progressDao.insert(progressTopic);
1053
        } else {
1054
            newRecord = false;
1055
            progressTopic.setViewSlides(viewSlides);
1056
            progressTopic.setTotalSlides(totalSlides);
1057
            progressTopic.setProgress (percentaje);
1058
            progressDao.update(progressTopic);
1059
        }
1060
 
1061
        try {
1062
            JSONObject json = progressTopic.toJson();
1063
            json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS);
1064
 
1065
            sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1066
            syncDao.insert(sync);
1067
        } catch (JSONException e) {
1068
        }
1069
 
1070
        if(newRecord) {
1071
            userLog = new UserLog();
1072
            userLog.setUserUuid(preference.getUserUuid());
1073
            userLog.setActivity(Constants.USER_LOG_ACTIVITY_START_TOPIC);
1074
            userLog.setCompanyUuid (topic.getCompanyUuid());
1075
            userLog.setTopicUuid (topic.getUuid());
1076
            userLog.setAddedOn(dateOn);
1077
 
1078
 
1079
            userLogDao.insert(userLog);
1080
            try {
1081
                JSONObject json = userLog.toJson();
1082
                json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1083
 
1084
                sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1085
                syncDao.insert(sync);
1086
            } catch (JSONException e) {
1087
            }
1088
        }
1089
        /*** FIN PROCESO TOPICO ***/
1090
 
1091
 
1092
 
1093
        /*** INICIO PROCESO CAPSULA ***/
1094
        resultCount = slideDao.getCountByCapsuleUuid(slide.getCapsuleUuid());
1095
        totalSlides = resultCount.getCount();
1096
        resultCount = progressDao.getCountSlidesCompletedByCapsuleUuid(slide.getCapsuleUuid());
1097
        viewSlides =  resultCount.getCount();
1098
        if(totalSlides == 0) {
1099
            percentaje = 0;
1100
        } else {
1101
            percentaje = (viewSlides * 100) / totalSlides;
1102
        }
1103
 
1104
        if(progressCapsule == null) {
1105
            newRecord = true;
1106
            progressCapsule = new Progress();
1107
            progressCapsule.setUserUuid(preference.getUserUuid());
1108
            progressCapsule.setCompanyUuid(topic.getCompanyUuid());
1109
            progressCapsule.setTopicUuid(topic.getUuid());
1110
            progressCapsule.setCapsuleUuid (capsule.getUuid());
1111
            progressCapsule.setViewSlides(viewSlides);
1112
            progressCapsule.setTotalSlides(totalSlides);
1113
            progressCapsule.setProgress(percentaje);
1114
            progressCapsule.setType(Constants.PROGERSS_TYPE_CAPSULE);
1115
            progressCapsule.setAddedOn(dateOn);
1116
            progressCapsule.setUpdatedOn(dateOn);
1117
            progressDao.insert(progressCapsule);
1118
 
1119
            Log.d(TAG, "Progress Capsule Nueva : setLastCapsuleActive : " + preference.getLastCapsuleUuidActive());
1120
            preference.setLastCapsuleUuidActive(capsule.getUuid());
1121
        } else {
1122
            newRecord = false;
1123
            progressCapsule.setViewSlides(viewSlides);
1124
            progressCapsule.setTotalSlides(totalSlides);
1125
            progressCapsule.setProgress(percentaje);
1126
 
1127
            Log.d(TAG, "Progress Capsule : getLastCapsuleActive : " + preference.getLastCapsuleUuidActive());
1128
            Log.d(TAG, "Progress Capsule : CapsuleActive : " + preference.getCapsuleUuidActive());
1129
 
1130
            if (!preference.getLastCapsuleUuidActive().equals(preference.getCapsuleUuidActive())) {
1131
 
1132
                Log.d(TAG, "Capsule Progress : " + progressCapsule.getProgress());
1133
                Log.d(TAG, "Capsule Completed : " + progressCapsule.getCompleted());
1134
                Log.d(TAG, "Capsule Total slides : " + progressCapsule.getTotalSlides());
1135
                Log.d(TAG, "Capsule View slides : " + progressCapsule.getViewSlides());
1136
 
1137
                if(progressCapsule.getCompleted() == 1) {
1138
                    Log.d(TAG, "Capsule OLD returningAfterCompleted = " + progressCapsule.getReturningAfterCompleted());
1139
 
1140
                    int returningAfterCompleted = progressCapsule.getReturningAfterCompleted() + 1;
1141
 
1142
                    Log.d(TAG, "Capsule NEW returningAfterCompleted = " + returningAfterCompleted);
1143
                    progressCapsule.setReturningAfterCompleted(returningAfterCompleted);
1144
                }
1145
 
1146
                preference.setLastCapsuleUuidActive(capsule.getUuid());
1147
                preference.save(this);
1148
 
1149
                Log.d(TAG, "Progress Capsule : setLastCapsuleActive : " + preference.getLastCapsuleUuidActive());
1150
            }
1151
 
1152
            progressDao.update(progressCapsule);
1153
        }
1154
        try {
1155
            JSONObject json = progressCapsule.toJson();
1156
            json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS);
1157
 
1158
            sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1159
            syncDao.insert(sync);
1160
        } catch (JSONException e) {
1161
 
1162
        }
1163
 
1164
        if(newRecord) {
1165
            userLog = new UserLog();
1166
            userLog.setUserUuid(preference.getUserUuid());
1167
            userLog.setActivity(Constants.USER_LOG_ACTIVITY_START_CAPSULE);
1168
            userLog.setCompanyUuid(topic.getCompanyUuid());
1169
            userLog.setTopicUuid(topic.getUuid());
1170
            userLog.setCapsuleUuid(capsule.getUuid());
1171
            userLog.setAddedOn(dateOn);
1172
 
1173
 
1174
            userLogDao.insert(userLog);
1175
            try {
1176
                JSONObject json = userLog.toJson();
1177
                json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1178
 
1179
                sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1180
                syncDao.insert(sync);
1181
            } catch (JSONException e) {
1182
            }
1183
        }
1184
 
1185
 
1186
        /*** FIN PROCESO CAPSULA ***/
1187
 
1188
        /*** INICIO USERLOG SLIDE ***/
1189
        userLog = new UserLog();
1190
        userLog.setUserUuid(preference.getUserUuid());
1191
        userLog.setActivity(Constants.USER_LOG_ACTIVITY_VIEW_SLIDE);
1192
        userLog.setCompanyUuid(topic.getCompanyUuid());
1193
        userLog.setTopicUuid(topic.getUuid());
1194
        userLog.setCapsuleUuid(capsule.getUuid());
1195
        userLog.setSlideUuid(slide.getUuid());
1196
        userLog.setAddedOn(dateOn);
1197
 
1198
 
1199
        userLogDao.insert(userLog);
1200
        try {
1201
            JSONObject json = userLog.toJson();
1202
            json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1203
 
1204
            sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1205
            syncDao.insert(sync);
1206
        } catch (JSONException e) {
1207
        }
1208
 
1209
        /*** FIN ***/
1210
 
1211
 
1212
        /*** PROGRESS SLIDE***/
1213
        try {
1214
            JSONObject json = progressSlide.toJson();
1215
            json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_PROGRESS);
1216
 
1217
            sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1218
            syncDao.insert(sync);
1219
        } catch (JSONException e) {
1220
        }
1221
 
1222
        /** IS SLIDE = QUIZ **/
1223
        if (isQuiz) {
1224
            userLog = new UserLog();
1225
            userLog.setUserUuid(preference.getUserUuid());
1226
            userLog.setActivity(retakeQuiz ? Constants.USER_LOG_ACTIVITY_RETAKE_A_TEST : Constants.USER_LOG_ACTIVITY_TAKE_A_TEST);
1227
            userLog.setCompanyUuid (topic.getCompanyUuid());
1228
            userLog.setTopicUuid(slide.getTopicUuid());
1229
            userLog.setCapsuleUuid(slide.getCapsuleUuid());
1230
            userLog.setSlideUuid(slide.getUuid());
1231
            userLog.setAddedOn(dateOn);
1232
 
1233
            userLogDao.insert(userLog);
1234
            try {
1235
                JSONObject json = userLog.toJson();
1236
                json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1237
 
1238
                sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1239
                syncDao.insert(sync);
1240
            } catch (JSONException e) {
1241
            }
1242
 
1243
 
1244
            if(progressSlide.getCompleted() == 1) {
1245
                userLog = new UserLog();
1246
                userLog.setUserUuid(preference.getUserUuid());
1247
                userLog.setActivity(Constants.USER_LOG_ACTIVITY_APPROVED_TEST);
1248
                userLog.setCompanyUuid(topic.getCompanyUuid());
1249
                userLog.setTopicUuid(slide.getTopicUuid());
1250
                userLog.setCapsuleUuid(slide.getCapsuleUuid());
1251
                userLog.setSlideUuid(slide.getUuid());
1252
                userLog.setAddedOn(dateOn);
1253
 
1254
                userLogDao.insert(userLog);
1255
                try {
1256
                    JSONObject json = userLog.toJson();
1257
                    json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1258
 
1259
                    sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1260
                    syncDao.insert(sync);
1261
                } catch (JSONException e) {
1262
                }
1263
 
1264
            } else {
1265
                if(progressSlide.getCompleted() == 1) {
1266
                    userLog = new UserLog();
1267
                    userLog.setUserUuid(preference.getUserUuid());
1268
                    userLog.setActivity( Constants.USER_LOG_ACTIVITY_VIEW_SLIDE);
1269
                    userLog.setCompanyUuid(topic.getCompanyUuid());
1270
                    userLog.setTopicUuid(slide.getTopicUuid());
1271
                    userLog.setCapsuleUuid(slide.getCapsuleUuid());
1272
                    userLog.setSlideUuid(slide.getUuid());
1273
                    userLog.setAddedOn(dateOn);
1274
 
1275
                    userLogDao.insert(userLog);
1276
                    try {
1277
                        JSONObject json = userLog.toJson();
1278
                        json.put(Constants.SYNC_ADAPTER_DATA_TYPE_FIELD_NAME, Constants.SYNC_ADAPTER_DATA_TYPE_MICROLEARNING_USER_LOG);
1279
 
1280
                        sync = new Sync(Constants.SYNC_ADAPTER_TYPE_SYNC, json.toString());
1281
                        syncDao.insert(sync);
1282
                    } catch (JSONException e) {
1283
                    }
1284
                }
1285
            }
1286
        }
1287
 
1288
        requestExecuteSyncAdapter();
1289
    }
1290
 
1291
    @Override
1292
    public void launchVideoViewer(String videoAudioUrl)
1293
    {
1294
 
1295
        Intent intent = new Intent(this, VideoAudioActivity.class);
1296
        intent.putExtra("videoAudioUrl",videoAudioUrl);
1297
        intent.putExtra("deviceId", preference.getDeviceUuid());
1298
        intent.putExtra("password", preference.getPassword());
1299
        //startActivityForResult(intent, Constants.REQUEST_CODE_VIDEO);
1300
 
1301
        mLauncher.launch(intent);
1302
 
1303
    }
1304
 
1305
    @Override
1306
    public void launchAudioViewer(String videoAudioUrl)
1307
    {
1308
 
1309
        Intent intent = new Intent(this, VideoAudioActivity.class);
1310
        intent.putExtra("videoAudioUrl",videoAudioUrl);
1311
        intent.putExtra("deviceId", preference.getDeviceUuid());
1312
        intent.putExtra("password", preference.getPassword());
1313
        //startActivityForResult(intent, Constants.REQUEST_CODE_AUDIO);
1314
 
1315
 
1316
        mLauncher.launch(intent);
1317
    }
1318
 
1319
    @Override
1320
    public void launchTextViewer(String description)
1321
    {
1322
        Intent intent = new Intent(this,TextActivity.class);
1323
        intent.putExtra("description",description);
1324
 
1325
        //startActivityForResult(intent, Constants.REQUEST_CODE_TEXT);
1326
 
1327
        mLauncher.launch(intent);
1328
    }
1329
 
1330
 
1331
    @Override
1332
    public void launchDocumentViewer(String file)
1333
    {
1334
 
1335
        Intent intent = new Intent(this,PdfActivity.class);
1336
        intent.putExtra("documentUrl",file);
1337
        intent.putExtra("deviceId", preference.getDeviceUuid());
1338
        intent.putExtra("password", preference.getPassword());
1339
 
1340
        //startActivityForResult(intent, Constants.REQUEST_CODE_PDF);
1341
 
1342
        mLauncher.launch(intent);
1343
    }
1344
 
1345
    @Override
1346
    public void launchQuizViewer(String quizUuid)
1347
    {
1348
        ProgressDao progressDao = mAppDatabase.getProgressDao();
1349
        Progress progress = progressDao.selectBySlideUuid(preference.getSlideUuidActive());
1350
 
1351
        boolean launch = false;
1352
        if(progress != null && progress.getCompleted() == 0) {
1353
 
1354
            Calendar calendar = Calendar.getInstance();
1355
            Date date = calendar.getTime();
1356
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(Constants.FORMAT_DATETIME_SERVICE);
1357
            try {
1358
                Long updateOn = simpleDateFormat.parse(progress.getUpdatedOn()).getTime();
1359
 
1360
                //30 minutes
1361
                long mintime = 30 * 60 * 1000;
1362
                if(date.getTime() - updateOn >  mintime ) {
1363
                    launch = true;
1364
                }
1365
 
1366
                launch = true;
1367
 
1368
            } catch(Exception e) {
1369
 
1370
            }
1371
 
1372
 
1373
        } else {
1374
            launch = true;
1375
        }
1376
 
1377
        if(launch) {
1378
 
1379
            QuizDao quizDao = mAppDatabase.getQuizDao();
1380
            Quiz quiz = quizDao.selectByUuid(quizUuid);
1381
 
1382
            TopicDao topicDao = mAppDatabase.getTopicDao();
1383
            Topic topic = topicDao.selectByUuid(preference.getTopicUuidActive());
1384
 
1385
            CapsuleDao capsuleDao = mAppDatabase.getCapsuleDao();
1386
            Capsule capsule = capsuleDao.selectByUuid(preference.getCapsuleUuidActive());
1387
 
1388
            SlideDao slideDao = mAppDatabase.getSlideDao();
1389
            Slide slide = slideDao.selectByUuid(preference.getSlideUuidActive());
1390
 
1391
            QuestionDao questionDao = mAppDatabase.getQuestionDao();
1392
            List<Question> questions = questionDao.selectAllByQuizUuid(quiz.getUuid());
1393
 
1394
 
1395
            List<Answer> answers;
1396
            AnswerDao answerDao = mAppDatabase.getAnswerDao();
1397
 
1398
            Intent intent = new Intent(this, QuizActivity.class);
1399
           // intent.putExtra("companyUuid", topic.getCompanyUuid());
1400
           // intent.putExtra("topicUuid", topic.getUuid());
1401
            //intent.putExtra("capsuleUuid", capsule.getUuid());
1402
            //intent.putExtra("slideUuid", slide.getUuid());
1403
            //intent.putExtra("userUuid", preference.getUserUuid());
1404
            //intent.putExtra("quizUuid", quizUuid);
1405
 
1406
 
1407
            intent.putExtra("quiz_uuid", quiz.getUuid());
1408
            intent.putExtra("quiz_company_uuid", quiz.getCompanyUuid());
1409
            intent.putExtra("quiz_name", quiz.getName());
1410
            intent.putExtra("quiz_points", quiz.getPoints());
1411
            intent.putExtra("quiz_max_time", quiz.getMaxTime());
1412
            intent.putExtra("quiz_minimum_points_required", quiz.getMinimumPointsRequired());
1413
            intent.putExtra("quiz_failed", quiz.getFailed());
1414
            intent.putExtra("quiz_text", quiz.getText());
1415
 
1416
            intent.putExtra("questions", questions.size());
1417
            int i = 1;
1418
            int j = 1;
1419
            for(Question question : questions) {
1420
                intent.putExtra("question" + i + "_uuid", question.getUuid());
1421
                intent.putExtra("question" + i + "_text", question.getText());
1422
                intent.putExtra("question" + i + "_max_length", question.getMaxlength());
1423
                intent.putExtra("question" + i + "_position", question.getPosition());
1424
                intent.putExtra("question" + i + "_points", question.getPoints());
1425
                intent.putExtra("question" + i + "_type", question.getType());
1426
 
1427
                answers = answerDao.selectAllByQuestionUuid(question.getUuid());
1428
                intent.putExtra("question" + i + "_answers", answers.size());
1429
 
1430
                j = 1;
1431
                for(Answer answer : answers) {
1432
                    intent.putExtra("question" + i + "_answer_uuid" + j, answer.getUuid());
1433
                    intent.putExtra("question" + i + "_answer_text" + j, answer.getText());
1434
                    intent.putExtra("question" + i + "_answer_points" + j, answer.getPoints());
1435
                    intent.putExtra("question" + i + "_answer_correct" + j, answer.getCorrect());
1436
                    j++;
1437
                }
1438
 
1439
                i++;
1440
            }
1441
 
1442
 
1443
 
1444
            //startActivityForResult(intent, Constants.REQUEST_CODE_QUIZ);
1445
 
1446
            mLauncher.launch(intent);
1447
        } else {
1448
            showMessageSnackBar(getString(R.string.error_retry_quiz_min_time));
1449
        }
1450
    }
1451
 
1452
 
1453
    @Override
1454
    public Preference getPreference() {
1455
        return preference;
1456
    }
1457
 
1458
    @Override
1459
    public Preference reloadPreference()
1460
    {
1461
        preference = new Preference(this);
1462
        return preference;
1463
    }
1464
 
1465
    @Override
1466
    public void reloadNavHeader() {
1467
        Log.d(TAG, "User Image = " + preference.getImage());
1468
        navHeaderUserName.setText((preference.getFirstName() + " " + preference.getLastName()).trim());
1469
        navHeaderUserEmail.setText(preference.getEmail());
1470
 
1471
 
1472
 
1473
        Log.d(TAG, preference.getImage());
1474
        if(!TextUtils.isEmpty(preference.getImage())) {
1475
 
1476
            TimeZone timeZone = TimeZone.getTimeZone("UTC");
1477
            Calendar calendar = Calendar.getInstance(timeZone);
1478
            TimeZone tz = calendar.getTimeZone();
1479
            int created =  (int) (calendar.getTimeInMillis() / 1000);
1480
 
1481
            Random random = new Random(created);
1482
            int rand = 1000 + random.nextInt(8999);
1483
 
1484
 
1485
 
1486
 
1487
            Log.d(TAG, "token = " + preference.getDeviceUuid());
1488
            Log.d(TAG, "created = " + created);
1489
            Log.d(TAG, "rand = " + rand);
1490
            Log.d(TAG, "calc = " + preference.getPassword() + ':' +  created + ':' + rand);
1491
 
1492
            String secret = MD5.generar(preference.getPassword() + ':' +  created + ':' + rand);
1493
 
1494
            GlideUrl url = new GlideUrl(preference.getImage(), new LazyHeaders.Builder()
1495
                    .addHeader(Constants.HTTP_HEADER_ACCEPT, Constants.HTTP_HEADER_ACCEPT_VALUE)
1496
                    .addHeader(Constants.HTTP_HEADER_SECURITY_TOKEN, preference.getDeviceUuid())
1497
                    .addHeader(Constants.HTTP_HEADER_SECURITY_SECRET, secret)
1498
                    .addHeader(Constants.HTTP_HEADER_SECURITY_CREATED, String.valueOf(created))
1499
                    .addHeader(Constants.HTTP_HEADER_SECURITY_RAND, String.valueOf(rand))
1500
                    .build());
1501
 
1502
            RequestOptions options = new RequestOptions()
1503
                    .diskCacheStrategy(DiskCacheStrategy.ALL);
1504
 
1505
            Glide.with(this).load(url)
1506
                    .thumbnail()
1507
                    .apply(options)
1508
                    .into(navHeaderUserImage);
1509
        }
1510
    }
1511
 
1512
    public void requestCheckChanges()
1513
    {
1514
        Log.d(TAG, "requestCheckChanges");
1515
        try {
1516
 
1517
            CapsuleDao capsuleDao = mAppDatabase.getCapsuleDao();
1518
            List<Capsule> capsules = capsuleDao.selectAll();
1519
 
1520
            if(capsules.size() > 0) {
1521
                //ArrayList<String> ids = new ArrayList<>();
1522
 
1523
                TimeZone timeZone = TimeZone.getTimeZone("UTC");
1524
                Calendar calendar = Calendar.getInstance(timeZone);
1525
                TimeZone tz = calendar.getTimeZone();
1526
                int created =  (int) (calendar.getTimeInMillis() / 1000);
1527
 
1528
                Random random = new Random(created);
1529
                int rand = 1000 + random.nextInt(8999);
1530
 
1531
 
1532
                //Log.d("requestCheckChanges", "token = " + preference.getDeviceUuid());
1533
                //Log.d("requestCheckChanges", "created = " + created);
1534
               // Log.d("requestCheckChanges", "rand = " + rand);
1535
                //Log.d("requestCheckChanges", "calc = " + preference.password + ':' +  created + ':' + rand);
1536
 
1537
                String secret = MD5.generar(preference.getPassword() + ':' +  created + ':' + rand);
1538
 
1539
                //Log.d("requestCheckChanges", "secret = " + secret);
1540
 
1541
 
1542
                FormBody.Builder formBodyCheckChangeBuilder = new FormBody.Builder();
1543
                formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_DEVICE_UUID, preference.getDeviceUuid());
1544
                formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_MAX_DATE_CHANGES, preference.getMaxDateChanges());
1545
                formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_IS_FOREGROUND, String.valueOf(isForeground ? 1 : 0));
1546
                Http http = new Http(this.getCacheDir(), preference.getDeviceUuid(), secret, created, rand);
1547
                OkHttpClient client = http.getHttpClient(false);
1548
 
1549
 
1550
 
1551
                formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_MAX_IDS, String.valueOf(capsules.size()));
1552
                //formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_MAX_IDS, String.valueOf(0));
1553
 
1554
              int i = 1;
1555
                for(Capsule capsule : capsules)
1556
                {
1557
                    Log.d("requestCheckChanges", "id" + i + " = " + capsule.getTopicUuid() + "|" + capsule.getUuid());
1558
 
1559
 
1560
                    formBodyCheckChangeBuilder.add(Constants.POST_MICROLEARNING_CHECK_CHANGES_ID + i, capsule.getTopicUuid() + "|" + capsule.getUuid());
1561
                    i++;
1562
                }
1563
 
1564
 
1565
 
1566
                RequestBody formBody = formBodyCheckChangeBuilder.build();
1567
 
1568
                Log.d(TAG, "URL = " + Configuration.URL_CHECK_CHANGES);
1569
                Request request = new Request.Builder()
1570
                        .url(Configuration.URL_CHECK_CHANGES)
1571
                        .post(formBody)
1572
                        .build();
1573
 
1574
                Call call = client.newCall(request);
1575
                call.enqueue(new okhttp3.Callback() {
1576
                    public void onResponse(Call call, Response response)
1577
                            throws IOException {
1578
 
1579
 
1580
 
1581
                        processResponseServerChanges(response.body().string());
1582
                    }
1583
 
1584
                    public void onFailure(Call call, IOException e) {
1585
                        Log.d(TAG, "Error :  " +  e.getMessage());
1586
                    }
1587
                });
1588
            }
1589
 
1590
 
1591
 
1592
        } catch(Exception e) {
1593
 
1594
        }
1595
    }
1596
 
1597
 
1598
    public void syncFromServer(JSONObject data)
1599
    {
1600
        try {
1601
            JSONObject objUser = data.getJSONObject("user");
1602
            String userUuid = objUser.getString("uuid");
1603
 
1604
 
1605
            AnswerDao answerDao = mAppDatabase.getAnswerDao();
1606
            QuestionDao questionDao = mAppDatabase.getQuestionDao();
1607
            QuizDao quizDao = mAppDatabase.getQuizDao();
1608
            SlideDao slideDao = mAppDatabase.getSlideDao();
1609
            CapsuleDao capsuleDao = mAppDatabase.getCapsuleDao();
1610
            TopicDao topicDao = mAppDatabase.getTopicDao();
1611
            CompanyDao companyDao = mAppDatabase.getCompanyDao();
1612
            UserExtendedDao userExtendedDao = mAppDatabase.getUserExtendedDao();
1613
 
1614
 
1615
 
1616
            ProgressDao progressDao = mAppDatabase.getProgressDao();
1617
            progressDao.removeAllUserUuidNotEqual(userUuid);
1618
 
1619
 
1620
            UserLogDao userLogDao = mAppDatabase.getUserLogDao();
1621
            userLogDao.removeAllUserUuidNotEqual(userUuid);
1622
 
1623
            JSONArray arrayCapsules;
1624
            JSONArray arraySlides;
1625
            JSONArray arrayAnswers;
1626
            JSONArray arrayQuestions;
1627
            JSONArray arrayProgress;
1628
            JSONArray arrayQuizzes;
1629
            JSONArray arrayUserLog;
1630
 
1631
            JSONObject objTopic;
1632
            JSONObject objCapsule;
1633
            JSONObject objSlide;
1634
            JSONObject objAnswer;
1635
            JSONObject objQuestion;
1636
            JSONObject objQuiz;
1637
            JSONObject objProgress;
1638
            JSONObject objUserLog;
1639
            int i,j,x;
1640
 
1641
            if(data.has("progress")) {
1642
 
1643
                arrayProgress = data.getJSONArray("progress");
1644
                for (i = 0; i < arrayProgress.length(); i++) {
1645
                    objProgress = arrayProgress.getJSONObject(i);
1646
 
1647
 
1648
                    Progress progress = null;
1649
 
1650
 
1651
                    userUuid = objProgress.getString("user_uuid");
1652
                    String type = objProgress.getString("type");
1653
                    String topicUuid = objProgress.getString("topic_uuid");
1654
                    String capsuleUuid = objProgress.getString("capsule_uuid");
1655
                    String slideUuid = objProgress.getString("slide_uuid");
1656
 
1657
                    if(type == Constants.PROGERSS_TYPE_SLIDE) {
1658
                        progress = progressDao.selectBySlideUuidAndUserUuid(slideUuid, userUuid);
1659
                    } else if(type == Constants.PROGERSS_TYPE_CAPSULE) {
1660
                        progress = progressDao.selectByCapsuleUuidAndUserUuid(capsuleUuid, userUuid);
1661
                    } else if(type == Constants.PROGERSS_TYPE_TOPIC) {
1662
                        progress = progressDao.selectByTopicUuidAndUserUuid(topicUuid, userUuid);
1663
                    }
1664
 
1665
 
1666
                    if(progress == null) {
1667
                        progress = new Progress();
1668
                        progress.setUserUuid(userUuid);
1669
                        progress.setCompanyUuid(objProgress.getString("company_uuid"));
1670
                        progress.setTopicUuid(topicUuid);
1671
                        progress.setCapsuleUuid(capsuleUuid);
1672
                        progress.setSlideUuid(slideUuid);
1673
                        progress.setProgress(objProgress.getDouble("progress"));
1674
                        progress.setTotalSlides(objProgress.getInt("total_slides"));
1675
                        progress.setViewSlides(objProgress.getInt("view_slides"));
1676
                        progress.setType(type);
1677
                        progress.setReturning(objProgress.getInt("returning"));
1678
                        progress.setReturningAfterCompleted(objProgress.getInt("returning_after_completed"));
1679
                        progress.setCompleted(objProgress.getInt("completed"));
1680
                        progress.setAddedOn(objProgress.getString("added_on"));
1681
                        progress.setUpdatedOn(objProgress.getString("updated_on"));
1682
 
1683
                        progressDao.insert(progress);
1684
                    }
1685
 
1686
 
1687
                }
1688
            }
1689
 
1690
            if(data.has("userlog")) {
1691
                arrayUserLog = data.getJSONArray("userlog");
1692
                for (i = 0; i < arrayUserLog.length(); i++) {
1693
                    objUserLog = arrayUserLog.getJSONObject(i);
1694
 
1695
                    userUuid = objUserLog.getString("user_uuid");
1696
                    String activity = objUserLog.getString("activity");
1697
                    String added_on = objUserLog.getString("added_on");
1698
 
1699
                    UserLog userLog = userLogDao.selectOneByUserUuidAndActivityAndAddedOn(userUuid, activity, added_on);
1700
                    if(userLog == null) {
1701
                        userLog = new UserLog();
1702
                        userLog.setUserUuid(objUserLog.getString("user_uuid"));
1703
                        userLog.setCompanyUuid(objUserLog.getString("company_uuid"));
1704
                        userLog.setTopicUuid(objUserLog.getString("topic_uuid"));
1705
                        userLog.setCapsuleUuid(objUserLog.getString("capsule_uuid"));
1706
                        userLog.setSlideUuid(objUserLog.getString("slide_uuid"));
1707
                        userLog.setActivity(objUserLog.getString("activity"));
1708
                        userLog.setAddedOn(objUserLog.getString("added_on"));
1709
                        userLogDao.insert(userLog);
1710
                    }
1711
                }
1712
            }
1713
 
1714
            if(data.has("quizzes")) {
1715
                arrayQuizzes = data.getJSONArray("quizzes");
1716
                for (i = 0; i < arrayQuizzes.length(); i++) {
1717
                    objQuiz = arrayQuizzes.getJSONObject(i);
1718
                    Quiz quiz = new Quiz();
1719
                    quiz.setUuid(  objQuiz.getString("uuid"));
1720
                    quiz.setCompanyUuid(  objQuiz.getString("company_uuid"));
1721
                    quiz.setFailed(  objQuiz.getString("failed"));
1722
                    quiz.setName(  objQuiz.getString("name"));
1723
                    quiz.setText(  objQuiz.getString("text"));
1724
                    quiz.setPoints(  objQuiz.getInt("points"));
1725
                    quiz.setMinimumPointsRequired(objQuiz.getInt("minimum_points_required"));
1726
                    quiz.setMaxTime( objQuiz.getInt("max_time"));
1727
 
1728
                    Company company = companyDao.selectByUuid(quiz.getCompanyUuid());
1729
                    if (company == null) {
1730
                        company = new Company();
1731
                        company.setUuid(objQuiz.getString("company_uuid"));
1732
                        company.setName(objQuiz.getString("company_name"));
1733
                        company.setImage(objQuiz.getString("company_image"));
1734
 
1735
                        companyDao.insert(company);
1736
                    }
1737
 
1738
                    quizDao.insert(quiz);
1739
 
1740
                    arrayQuestions = objQuiz.getJSONArray("questions");
1741
                    for (j = 0; j < arrayQuestions.length(); j++) {
1742
                        objQuestion = arrayQuestions.getJSONObject(j);
1743
                        Question question = new Question();
1744
                        question.setQuizUuid( quiz.getUuid());
1745
                        question.setUuid( objQuestion.getString("uuid"));
1746
                        question.setText( objQuestion.getString("text"));
1747
                        question.setType( objQuestion.getString("type"));
1748
                        question.setPoints( objQuestion.getInt("points"));
1749
                        question.setMaxlength( objQuestion.getInt("maxlength"));
1750
 
1751
                        questionDao.insert(question);
1752
 
1753
                        arrayAnswers = objQuestion.getJSONArray("answers");
1754
                        for (x = 0; x < arrayAnswers.length(); x++) {
1755
                            objAnswer = arrayAnswers.getJSONObject(x);
1756
                            Answer answer = new Answer();
1757
                            answer.setQuestionUuid(question.getUuid());
1758
                            answer.setUuid(objAnswer.getString("uuid"));
1759
                            answer.setText(objAnswer.getString("text"));
1760
                            answer.setPoints( objAnswer.getInt("points"));
1761
                            answer.setCorrect(objAnswer.getString("correct"));
1762
 
1763
                            answerDao.insert(answer);
1764
                        }
1765
 
1766
 
1767
                    }
1768
                }
1769
            }
1770
 
1771
 
1772
 
1773
 
1774
 
1775
            if(data.has("topics")) {
1776
 
1777
                JSONArray arrayTopics = data.getJSONArray("topics");
1778
                for (i = 0; i < arrayTopics.length(); i++) {
1779
                    objTopic = arrayTopics.getJSONObject(i);
1780
                    Topic topic = new Topic();
1781
                    topic.setUuid(objTopic.getString("uuid"));
1782
                    topic.setCompanyUuid(objTopic.getString("company_uuid"));
1783
                    topic.setName(objTopic.getString("name"));
1784
                    topic.setDescription(objTopic.getString("description"));
1785
                    topic.setImage(objTopic.getString("image"));
1786
                    topic.setPosition(objTopic.getInt("position"));
1787
 
1788
                    Company company = companyDao.selectByUuid(topic.getCompanyUuid());
1789
                    if (company == null) {
1790
                        company = new Company();
1791
                        company.setUuid(objTopic.getString("company_uuid"));
1792
                        company.setName(objTopic.getString("company_name"));
1793
                        company.setImage(objTopic.getString("company_image"));
1794
 
1795
                        companyDao.insert(company);
1796
                    }
1797
 
1798
                    topicDao.insert(topic);
1799
 
1800
                    arrayCapsules = objTopic.getJSONArray("capsules");
1801
                    for (j = 0; j < arrayCapsules.length(); j++) {
1802
                        objCapsule = arrayCapsules.getJSONObject(j);
1803
                        Capsule capsule = new Capsule();
1804
                        capsule.setTopicUuid(topic.getUuid());
1805
                        capsule.setUuid(objCapsule.getString("uuid"));
1806
                        capsule.setName(objCapsule.getString("name"));
1807
                        capsule.setDescription(objCapsule.getString("description"));
1808
                        capsule.setImage(objCapsule.getString("image"));
1809
                        capsule.setPosition(objCapsule.getInt("position"));
1810
                        capsuleDao.insert(capsule);
1811
 
1812
                        arraySlides = objCapsule.getJSONArray("slides");
1813
                        for (x = 0; x < arraySlides.length(); x++) {
1814
                            objSlide = arraySlides.getJSONObject(x);
1815
                            Slide slide = new Slide();
1816
                            slide.setUuid(objSlide.getString("uuid"));
1817
                            slide.setTopicUuid(capsule.getTopicUuid());
1818
                            slide.setCapsuleUuid(capsule.getUuid());
1819
                            slide.setQuizUuid(objSlide.getString("quiz_uuid"));
1820
                            slide.setName(objSlide.getString("name"));
1821
                            slide.setDescription(objSlide.getString("description"));
1822
                            slide.setPosition(objSlide.getInt("position"));
1823
                            slide.setType(objSlide.getString("type"));
1824
                            slide.setFile(objSlide.getString("file"));
1825
                            slide.setBackground(objSlide.getString("background"));
1826
 
1827
                            slideDao.insert(slide);
1828
                        }
1829
 
1830
                    }
1831
 
1832
 
1833
                }
1834
            }
1835
 
1836
 
1837
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat(Constants.FORMAT_DATETIME_SERVICE);
1838
            if(data.has("max_date_changes")) {
1839
                String max_date_changes = data.getString("max_date_changes");
1840
                Log.d("syncFromServer", "max_date_changes : " + max_date_changes);
1841
 
1842
                if(!TextUtils.isEmpty(max_date_changes)) {
1843
                    preference.setMaxDateChanges(max_date_changes);
1844
                }
1845
            } else {
1846
                Log.d("syncFromServer", "No max_date_changes");
1847
            }
1848
 
1849
            Calendar calendar = Calendar.getInstance();
1850
            Date date = calendar.getTime();
1851
 
1852
            String  addedOn = simpleDateFormat.format(date);
1853
 
1854
            List<Company> companies = mAppDatabase.getCompanyDao().selectAll();
1855
            int companySize = companies.size();
1856
 
1857
            if(companySize > 0) {
1858
 
1859
                if(TextUtils.isEmpty(preference.getCompanyUuidActive())) {
1860
 
1861
                    preference.setCompanyUuidActive(companies.get(0).getUuid());
1862
 
1863
                } else {
1864
 
1865
                    boolean companyExist = false;
1866
                    for (Company company : companies) {
1867
                        if (company.getUuid().equals(preference.getCompanyUuidActive())) {
1868
                            companyExist = true;
1869
                        }
1870
                    }
1871
 
1872
                    if(!companyExist) {
1873
                        preference.setCompanyUuidActive(companies.get(0).getUuid());
1874
                    }
1875
                }
1876
 
1877
            } else {
1878
                preference.setCompanyUuidActive("");
1879
            }
1880
 
1881
            if(data.has( "extended")) {
1882
 
1883
                JSONObject objExtended;
1884
                JSONObject objItem;
1885
                JSONArray objItems;
1886
 
1887
                String company_uuid;
1888
 
1889
                UserExtended userExtended;
1890
 
1891
                JSONArray extendedCompanies = data.getJSONArray("extended");
1892
                for(i = 0 ; i < extendedCompanies.length(); i++)
1893
                {
1894
                    objExtended = extendedCompanies.getJSONObject(i);
1895
                    if(objExtended.has("details")) {
1896
                        company_uuid = objExtended.getString("company_uuid");
1897
 
1898
                        objItems = objExtended.getJSONArray("details");
1899
                        for(j = 0 ; j < objItems.length(); j++) {
1900
                            objItem = objItems.getJSONObject(j);
1901
                            userExtended = new UserExtended();
1902
                            userExtended.setCompanyUuid(company_uuid);
1903
                            userExtended.setUuid(objItem.getString("uuid"));
1904
                            userExtended.setLabel(objItem.getString("label"));
1905
                            userExtended.setValue(objItem.getString("value"));
1906
                            userExtendedDao.insert(userExtended);
1907
 
1908
                        }
1909
                    }
1910
                }
1911
 
1912
            }
1913
 
1914
            preference.setLastDataRefresh(addedOn);
1915
            preference.setCompanyCount(companySize);
1916
            preference.save(this);
1917
 
1918
        } catch (JSONException e) {
1919
            Log.d(TAG, e.getMessage());
1920
        }
1921
    }
1922
 
1923
    @Override
1924
    public void requestExecuteSyncAdapter() {
1925
            // Pass the settings flags by inserting them in a bundle
1926
            Bundle settingsBundle = new Bundle();
1927
            settingsBundle.putBoolean(
1928
                    ContentResolver.SYNC_EXTRAS_MANUAL, true);
1929
            settingsBundle.putBoolean(
1930
                    ContentResolver.SYNC_EXTRAS_EXPEDITED, true);
1931
 
1932
            ContentResolver.requestSync(mAccount, Constants.AUTHORITY, settingsBundle);
1933
    }
1934
 
1935
 
1936
    private void processResponseServerChanges(String dataString)
1937
    {
1938
 
1939
        Log.d(TAG, "processResponseServerChanges = " + dataString);
1940
 
1941
        try {
1942
            JSONObject objJSON = new JSONObject(dataString);
1943
            boolean success = objJSON.has("success") ? objJSON.getBoolean("success")  : false;
1944
 
1945
 
1946
            if(success) {
1947
                Calendar calendar = Calendar.getInstance();
1948
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(Constants.FORMAT_DATETIME_SERVICE);
1949
                preference.setLastDataRefresh(simpleDateFormat.format(calendar.getTime()));
1950
                preference.save(this);
1951
 
1952
                String max_date_changes = "";
1953
                boolean processChanges = false;
1954
 
1955
                JSONObject data = objJSON.getJSONObject("data");
1956
                if(data.has("max_date_changes") && data.has("new_capsules")) {
1957
                    int new_capsules = data.getInt("new_capsules");
1958
                    max_date_changes = data.getString("max_date_changes");
1959
 
1960
 
1961
 
1962
 
1963
                    processChanges = new_capsules > 0 && !max_date_changes.equals(preference.getMaxDateChanges());
1964
                } else {
1965
                    processChanges = false;
1966
                }
1967
 
1968
                if(processChanges && !max_date_changes.isEmpty()) {
1969
                    int new_capsules = data.getInt("new_capsules");
1970
                    String message = new_capsules == 1
1971
                            ? "Hay 1 cápsula nueva disponible"
1972
                            : "Hay " + new_capsules + " cápsulas disponible";
1973
 
1974
 
1975
                    showMessageSnackBarWithClose(message);
1976
 
1977
 
1978
                    preference.setMaxDateChanges(max_date_changes);
1979
 
1980
                    if(!isForeground) {
1981
                        String body = new_capsules == 1
1982
                                ? "Hay 1 cápsula nueva disponible"
1983
                                : "Hay " + new_capsules + " cápsulas disponible";
1984
                        showFcmNotification("Nuevo contenido", body, new_capsules);
1985
                    }
1986
 
1987
                    /*
1988
                    if(!isForeground) {
1989
                        String body = new_capsules == 1
1990
                                ? "Hay 1 cápsula nueva disponible"
1991
                                : "Hay " + new_capsules + " cápsulas disponible";
1992
                        showFcmNotification("Nuevo contenido", body, new_capsules);
1993
 
1994
 
1995
                        AnswerDao answerDao = mAppDatabase.getAnswerDao();
1996
                        answerDao.removeAll();
1997
 
1998
                        QuestionDao questionDao = mAppDatabase.getQuestionDao();
1999
                        questionDao.removeAll();
2000
 
2001
                        QuizDao quizDao = mAppDatabase.getQuizDao();
2002
                        quizDao.removeAll();
2003
 
2004
                        SlideDao slideDao = mAppDatabase.getSlideDao();
2005
                        slideDao.removeAll();
2006
 
2007
                        CapsuleDao capsuleDao = mAppDatabase.getCapsuleDao();
2008
                        capsuleDao.removeAll();
2009
 
2010
                        TopicDao topicDao = mAppDatabase.getTopicDao();
2011
                        topicDao.removeAll();
2012
 
2013
                        CompanyDao companyDao = mAppDatabase.getCompanyDao();
2014
                        companyDao.removeAll();
2015
 
2016
                        UserExtendedDao userExtendedDao = mAppDatabase.getUserExtendedDao();
2017
                        userExtendedDao.removeAll();
2018
 
2019
 
2020
                        this.syncFromServer(data);
2021
 
2022
 
2023
                        if(!TextUtils.isEmpty(preference.getSlideUuidActive())) {
2024
 
2025
                            Slide slide = mAppDatabase.getSlideDao().selectByUuid(preference.getSlideUuidActive());
2026
                            if(slide == null) {
2027
                                preference.setFragmentIdxActive(Constants.IDX_FRAGMENT_TOPICS);
2028
                                preference.save(this);
2029
                            }
2030
 
2031
                        }
2032
                    }*/
2033
                }
2034
            }
2035
        } catch (JSONException e) {
2036
            Log.d(TAG, e.getMessage());
2037
        }
2038
    }
2039
 
2040
    @Override
2041
    public AppDatabase getDatabase() {
2042
        return mAppDatabase;
2043
    }
2044
 
2045
    @Override
2046
    public void syncToServerOrCheckChanges()
2047
    {
2048
        if(TextUtils.isEmpty(preference.getDeviceUuid())) {
2049
            return;
2050
        }
2051
 
2052
        SyncDao syncDao = mAppDatabase.getSyncDao();
2053
        List<Sync> records = syncDao.selectBatch();
2054
 
2055
        if(records.size() > 0) {
2056
            syncToServer(records);
2057
        } else {
2058
 
2059
                long timeLast = 0;
2060
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(Constants.FORMAT_DATETIME_SERVICE);
2061
                if (!TextUtils.isEmpty(preference.getLastDataRefresh())) {
2062
                    try {
2063
                        timeLast = simpleDateFormat.parse(preference.getLastDataRefresh()).getTime();
2064
                    } catch (Exception e) {
2065
 
2066
                    }
2067
 
2068
                }
2069
 
2070
 
2071
                Calendar calendar = Calendar.getInstance();
2072
                long timeNow = calendar.getTime().getTime();
2073
                 if (timeNow > (timeLast + Constants.CHECK_CHANGES_INTERVAL)) {
2074
                    requestCheckChanges();
2075
                }
2076
        }
2077
    }
2078
 
2079
 
2080
 
2081
    public void syncToServer(List<Sync> records)
2082
    {
2083
 
2084
 
2085
 
2086
        int maxRecordsSyncBatch = 0;
2087
        FormBody.Builder formBodyBatchBuilder = new FormBody.Builder();
2088
        formBodyBatchBuilder.add(Constants.POST_SYNC_BATCH_FIELD_DEVICE_UUID, preference.getDeviceUuid());
2089
 
2090
        for(Sync record : records)
2091
        {
2092
            Log.d(TAG, "SyncRecord ID = " + record.getId() + " Data : "  + record.getData() + " Type= " + record.getType());
2093
 
2094
            if(record.getType() == Constants.SYNC_ADAPTER_TYPE_DEVICE && !isSyncDevice) {
2095
                Log.d(TAG, "Device");
2096
                isSyncDevice = true;
2097
 
2098
                try {
2099
                    Http http = new Http(this.getCacheDir());
2100
                    OkHttpClient client = http.getHttpClient(false);
2101
 
2102
                    RequestBody formBody = new FormBody.Builder()
2103
                            .add(Constants.POST_DEVICE_FIELD_APPLICATION_ID,  String.valueOf(Configuration.APPLICATION_ID))
2104
                            .add(Constants.POST_DEVICE_FIELD_DEVICE_UUID, preference.getDeviceUuid())
2105
                            .add(Constants.POST_DEVICE_FIELD_MANUFACTURER, Build.MANUFACTURER)
2106
                            .add(Constants.POST_DEVICE_FIELD_BRAND, Build.BRAND)
2107
                            .add(Constants.POST_DEVICE_FIELD_VERSION, Build.VERSION.RELEASE  + " " + Build.VERSION_CODES.class.getFields()[android.os.Build.VERSION.SDK_INT].getName())
2108
                            .add(Constants.POST_DEVICE_FIELD_MODEL, Build.MODEL)
2109
                            .add(Constants.POST_DEVICE_FIELD_PLATFORM, "android")
2110
                            .add(Constants.POST_DEVICE_FIELD_SYNC_ID, String.valueOf(record.getId()))
2111
                            .build();
2112
 
2113
                    Log.d(TAG, "URL = " + Configuration.URL_DEVICE);
2114
                    Request request = new Request.Builder()
2115
                            .url(Configuration.URL_DEVICE)
2116
                            .post(formBody)
2117
                            .build();
2118
 
2119
                    Call call = client.newCall(request);
2120
                    call.enqueue(new okhttp3.Callback() {
2121
                        public void onResponse(Call call, Response response)
2122
                                throws IOException {
2123
                            isSyncDevice = false;
2124
                            Log.d(TAG, "Response Device :  " +  response.body().toString());
2125
 
2126
                            processResponseSyncToServer(response.body().string());
2127
                        }
2128
 
2129
                        public void onFailure(Call call, IOException e) {
2130
                            isSyncDevice = false;
2131
                            Log.d(TAG, "Error :  " +  e.getMessage());
2132
                        }
2133
                    });
2134
                } catch (Exception e) {
2135
                }
2136
            }
2137
 
2138
            if(record.getType() == Constants.SYNC_ADAPTER_TYPE_FCM && !isSyncToken) {
2139
                isSyncToken = true;
2140
                Log.d(TAG, "FCM");
2141
 
2142
                try {
2143
                    Http http = new Http(this.getCacheDir());
2144
                    OkHttpClient client = http.getHttpClient(false);
2145
 
2146
                    RequestBody formBody = new FormBody.Builder()
2147
                            .add(Constants.POST_FCM_FIELD_DEVICE_UUID,preference.getDeviceUuid())
2148
                            .add(Constants.POST_FCM_FIELD_TOKEN, record.getData())
2149
                            .add(Constants.POST_FCM_FIELD_SYNC_ID, String.valueOf(record.getId()))
2150
                            .build();
2151
 
2152
                    Log.d(TAG, "URL = " + Configuration.URL_FCM);
2153
                    Request request = new Request.Builder()
2154
                            .url(Configuration.URL_FCM)
2155
                            .post(formBody)
2156
                            .build();
2157
 
2158
                    Call call = client.newCall(request);
2159
                    call.enqueue(new okhttp3.Callback() {
2160
                        public void onResponse(Call call, Response response)
2161
                                throws IOException {
2162
                            isSyncToken = false;
2163
                            processResponseSyncToServer(response.body().string());
2164
                        }
2165
 
2166
                        public void onFailure(Call call, IOException e) {
2167
                            Log.d(TAG, "Error :  " +  e.getMessage());
2168
                            isSyncToken = false;
2169
                        }
2170
                    });
2171
                } catch (Exception e) {
2172
 
2173
 
2174
                }
2175
            }
2176
 
2177
            if(record.getType() == Constants.SYNC_ADAPTER_TYPE_SYNC ) {
2178
                Log.d(TAG, "SYNC BATCH");
2179
                maxRecordsSyncBatch++;
2180
                formBodyBatchBuilder.add(Constants.POST_SYNC_BATCH_FIELD_RECORD_DATA + maxRecordsSyncBatch, record.getData());
2181
                formBodyBatchBuilder.add(Constants.POST_SYNC_BATCH_FIELD_RECORD_SYNC_ID + maxRecordsSyncBatch, String.valueOf(record.getId()));
2182
            }
2183
        }
2184
 
2185
 
2186
        if(maxRecordsSyncBatch > 0 && !isSyncBatch) {
2187
            Log.d(TAG, "Sync Batch");
2188
            isSyncBatch = true;
2189
 
2190
            try {
2191
                Http http = new Http(this.getCacheDir());
2192
                OkHttpClient client = http.getHttpClient(false);
2193
 
2194
                formBodyBatchBuilder.add(Constants.POST_SYNC_BATCH_FIELD_MAX_RECORDS, String.valueOf(maxRecordsSyncBatch));
2195
                RequestBody formBody = formBodyBatchBuilder.build();
2196
 
2197
                Log.d(TAG, "URL = " + Configuration.URL_SYNC_BATCH);
2198
                Request request = new Request.Builder()
2199
                    .url(Configuration.URL_SYNC_BATCH)
2200
                    .post(formBody)
2201
                    .build();
2202
 
2203
                Call call = client.newCall(request);
2204
                call.enqueue(new okhttp3.Callback() {
2205
                    public void onResponse(Call call, Response response) throws IOException {
2206
                        isSyncBatch = false;
2207
                        processResponseServerBatch(response.body().string());
2208
                    }
2209
 
2210
                    public void onFailure(Call call, IOException e) {
2211
                        Log.d(TAG, "Error :  " +  e.getMessage());
2212
                        isSyncBatch = false;
2213
                    }
2214
                });
2215
            } catch (Exception e) {
2216
 
2217
 
2218
            }
2219
        }
2220
 
2221
 
2222
    }
2223
 
2224
    private void processResponseServerBatch(String dataString)
2225
    {
2226
        boolean success = false;
2227
        long sync_id = 0;
2228
 
2229
        Log.d(TAG, "processResponseServer = " + dataString);
2230
        try {
2231
            JSONObject objJSON = new JSONObject(dataString);
2232
            success = objJSON.has("success") ? objJSON.getBoolean("success")  : false;
2233
            if(success  && objJSON.has("data")) {
2234
                JSONArray jsonArrayData = objJSON.getJSONArray("data");
2235
 
2236
 
2237
                JSONObject jsonObjectData;
2238
                int max = jsonArrayData.length();
2239
                for(int i = 0; i < max; i++) {
2240
                    jsonObjectData = jsonArrayData.getJSONObject(i);
2241
 
2242
                    if(jsonObjectData.has("success") && jsonObjectData.getBoolean("success")) {
2243
                        sync_id = jsonObjectData.getLong("sync_id");
2244
 
2245
                        mAppDatabase.getSyncDao().remove(sync_id);
2246
 
2247
                    }
2248
 
2249
 
2250
                }
2251
 
2252
 
2253
 
2254
                /*
2255
                if(jsonObjectData.has("message")) {
2256
                    message = jsonObjectData.getString("message");
2257
                }
2258
 
2259
                if(jsonObjectData.has("aes")) {
2260
                    preference.setAes(jsonObjectData.getString("aes"));
2261
                    preference.save(this);
2262
                }
2263
 
2264
                if(jsonObjectData.has("password")) {
2265
                    preference.setPassword(jsonObjectData.getString("password"));
2266
                    preference.save(this);
2267
                }
2268
                */
2269
            }
2270
            Log.d(TAG, "SyncID = " + sync_id);
2271
            if(success && sync_id > 0) {
2272
                Log.d(TAG, "DELETE SYNC RECORD : " + sync_id);
2273
                mAppDatabase.getSyncDao().remove(sync_id);
2274
            }
2275
        } catch (JSONException e) {
2276
            e.printStackTrace();
2277
        }
2278
    }
2279
 
2280
    private void processResponseSyncToServer(String dataString)
2281
    {
2282
        boolean success = false;
2283
        long sync_id = 0;
2284
 
2285
        Log.d(TAG, "processResponseServer = " + dataString);
2286
        try {
2287
            JSONObject objJSON = new JSONObject(dataString);
2288
            success = objJSON.has("success") ? objJSON.getBoolean("success")  : false;
2289
            if(success  && objJSON.has("data")) {
2290
                JSONObject jsonObjectData = objJSON.getJSONObject("data");
2291
 
2292
                if(jsonObjectData.has("sync_id")) {
2293
                    sync_id = jsonObjectData.getLong("sync_id");
2294
                }
2295
 
2296
                /*
2297
                if(jsonObjectData.has("message")) {
2298
                    message = jsonObjectData.getString("message");
2299
                }
2300
 
2301
                if(jsonObjectData.has("aes")) {
2302
                    preference.setAes(jsonObjectData.getString("aes"));
2303
                    preference.save(this);
2304
                }
2305
 
2306
                if(jsonObjectData.has("password")) {
2307
                    preference.setPassword(jsonObjectData.getString("password"));
2308
                    preference.save(this);
2309
                }
2310
                */
2311
            }
2312
            Log.d(TAG, "SyncID = " + sync_id);
2313
            if(success && sync_id > 0) {
2314
                Log.d(TAG, "DELETE SYNC RECORD : " + sync_id);
2315
                mAppDatabase.getSyncDao().remove(sync_id);
2316
            }
2317
        } catch (JSONException e) {
2318
            e.printStackTrace();
2319
        }
2320
    }
2321
 
2322
    /*
2323
    private void processResponseServerCheckChanges(String dataString) {
2324
 
2325
        Log.d(TAG, "processResponseServerCheckChanges = " + dataString);
2326
 
2327
        runOnUiThread(new Runnable() {
2328
 
2329
            @Override
2330
            public void run() {
2331
 
2332
                try {
2333
                    JSONObject objJSON = new JSONObject(dataString);
2334
                    boolean success = objJSON.has("success") ? objJSON.getBoolean("success") : false;
2335
                    String message = "";
2336
                    if (objJSON.has("data")) {
2337
                        Object item = objJSON.get("data");
2338
                        if (item instanceof String) {
2339
                            message = item.toString();
2340
                        }
2341
                    }
2342
 
2343
                    if (success) {
2344
                        mAppDatabase.getAnswerDao().removeAll();
2345
                        mAppDatabase.getQuestionDao().removeAll();
2346
                        mAppDatabase.getQuizDao().removeAll();
2347
                        mAppDatabase.getSlideDao().removeAll();
2348
                        mAppDatabase.getCapsuleDao().removeAll();
2349
                        mAppDatabase.getTopicDao().removeAll();
2350
 
2351
 
2352
                        JSONObject data = objJSON.getJSONObject("data");
2353
                        syncFromServer(data);
2354
 
2355
 
2356
                    }
2357
 
2358
 
2359
                } catch (JSONException e) {
2360
                    Log.d(TAG, e.getMessage());
2361
                }
2362
 
2363
                reloadNavHeader();
2364
 
2365
 
2366
            }
2367
        });
2368
    }
2369
     */
2370
 
2371
 
2372
 
2373
}