private void cadastrarUsuario() {

        //Cria objeto usuario
        ParseUser usuario = new ParseUser();
        usuario.setUsername(textoUsuario.getText().toString());
        usuario.setEmail(textoEmail.getText().toString());
        usuario.setPassword(textoSenha.getText().toString());

        //salva dados do usuario
        usuario.signUpInBackground(new SignUpCallback() {
            @Override
            public void done(ParseException e) {
                if (e == null) {//sucesso ao salvar
                    Toast.makeText(CadastroActivity.this,"Cadastro feito com sucesso!",Toast.LENGTH_LONG).show();
                    abrirLoginUsuario();
                } else {//erro ao salvar
                    ParseErros parseErros = new ParseErros();
                    String erro = parseErros.getErro(e.getCode());
                    Toast.makeText(CadastroActivity.this,erro,Toast.LENGTH_LONG).show();
                }
            }
        });

    }

private void verificarLogin(String usuario,String senha) {
    ParseUser.logInInBackground(usuario,senha,new LogInCallback() {
        @Override
        public void done(ParseUser user,ParseException e) {

            if (e == null) {//sucesso no login
                Toast.makeText(LoginActivity.this,"Login realizado com sucesso!!",Toast.LENGTH_LONG).show();
                abrirAreaPrincipal();
            } else {//erro ao logar
                ParseErros parseErros = new ParseErros();
                String erro = parseErros.getErro(e.getCode());
                Toast.makeText(LoginActivity.this,Toast.LENGTH_LONG).show();
            }

        }
    });
}

private void localQuery(){
    ParseQuery<Kid> lQuery = ParseQuery.getQuery(Kid.class).fromLocalDatastore();
    lQuery.orderByAscending("createdAt");
    lQuery.findInBackground(new FindCallback<Kid>() {
        @Override
        public void done(List<Kid> list,ParseException e) {
            if (e == null) {

                kidArrayList.clear();
                kidArrayList.addAll(list);
                fillHashMap();
                adapter = new AddAttendanceAdapter(AddAttendance.this,kidArrayList,activityMap);
                listView.setAdapter(adapter);
                listView.invalidate();
            }

        }
    });
}

private void saveMethod(){
        //will save the data
        if(dateText.getText().toString().equals("") || dateText.getText().toString().equals(" ") || dateText.getText() == null){  //but before saving we will make sure that date is there
            Toast.makeText(getApplicationContext(),"Attendance date is required",Toast.LENGTH_SHORT).show();
           // Snackbar.make(findViewById(R.id.activity_add_attendance),//  "Attendance date is required",Snackbar.LENGTH_SHORT).show();
        }else{
            List<String> kidsIds = new ArrayList<>();
            for (int i = 0; i < adapter.map.size() ; i++) {
                if (adapter.map.get(kidArrayList.get(i))){
                    kidsIds.add(kidArrayList.get(i).getobjectId());
                }
            }
            attendance.setDate(dateText.getText().toString());
            attendance.setKidsIds(kidsIds);
            attendance.saveInBackground(new SaveCallback() {
                @Override
                public void done(ParseException e) {
                    if (e == null){
                        Toast.makeText(getApplicationContext(),"Saved successfully.",Toast.LENGTH_LONG).show();
                        end();
                    }
                }
            });
        }
}

private void logIn() {
    prefs = getSharedPreferences("prefFile",0);
    String userName = prefs.getString("userName",null);
    String password = prefs.getString("password",null);
    user.logInInBackground(userName,password,new LogInCallback() {
        @Override
        public void done(ParseUser parseUser,@Nullable ParseException e) {
            if (e == null){
                toaster("Login successful!","l");

            }else {
                toaster("Failed to connect!","l");
            }
        }
    });
}

private void localQuery(){
    ParseQuery<Kid> query = ParseQuery.getQuery(Kid.class).fromLocalDatastore();
    query.orderByAscending("createdAt");
    query.findInBackground(new FindCallback<Kid>() {
        @Override
        public void done(List<Kid> list,@Nullable ParseException e) {
            if (e == null && list.size()!=0) {
                kidArrayList.clear();
                kidArrayList.addAll(list);
                applyAttendancetoKids();
                adapter.notifyDataSetChanged();
                listView.invalidate();
                   }
                    }
                });
}

private void serverQuery() {
ParseQuery<Kid> query = ParseQuery.getQuery(Kid.class);
query.orderByAscending("createdAt");
query.findInBackground(new FindCallback<Kid>() {
    @Override
    public void done(List<Kid> list,@Nullable ParseException e) {
        if (e == null){
            kidArrayList.clear();
            kidArrayList.addAll(list);
            Kid.pinAllInBackground(kidArrayList);
            applyAttendancetoKids();
            adapter.notifyDataSetChanged();
            listView.invalidate();
        }else if(checkConnection()){
            toaster("Error getting data from Server\nWorking offline!","l");
        }
    }
});
        }

public void autoLogin(){
    if (checkConnection()){
    String userName = prefs.getString("userName",@Nullable ParseException e) {
            if (e == null){
                isLoggedIn = true;
                splash(1500);
                Snackbar.make(findViewById(R.id.activity_splash),"Login successful..",Snackbar.LENGTH_LONG).show();
            }
        }
        });
    }else {
        isLoggedIn = false;
        splash(4000);
        Snackbar.make(findViewById(R.id.activity_splash),"You are offline,Working on local data",Snackbar.LENGTH_LONG).show();}
}

private void incrementNumberOfVisits(){
    int i;
    if(myKid.getNumberOfVisits() == null){
        i = 0;
    }else{
        i = Integer.parseInt(myKid.getNumberOfVisits());}
    i++;
    myKid.setNumberOfVisits(String.valueOf(i));
    myKid.saveInBackground(new SaveCallback() {
        @Override
        public void done(ParseException e) {
        if (e ==  null){
            Toast.makeText(getApplicationContext(),"Saved successfully",Toast.LENGTH_LONG).show();
        }else {
            Toast.makeText(getApplicationContext(),"Error calculating the number of visits!",Toast.LENGTH_LONG).show();
        }
        }
    });
}

@Kroll.method
public void start()
{
    setState(STATE_RUNNING);
    // App opens analytics
    ParseAnalytics.trackAppOpenedInBackground(TiApplication.getAppRootOrCurrentActivity().getIntent());
    ParseInstallation.getCurrentInstallation().put("androidId",getAndroidId());
    ParseInstallation.getCurrentInstallation().saveInBackground(new SaveCallback() {
        public void done(ParseException e) {
            if (e != null) {
                Log.e(TAG,"Installation initialization Failed: " + e.getMessage());
            }
            // fire event
            try {
                JSONObject pnData = new JSONObject();
    pnData.put("objectId",getobjectId());
    pnData.put("installationId",getCurrentInstallationId());
    KrollDict data = new KrollDict(pnData);
             module.fireEvent("installationId",data);
} catch (JSONException e1) {
    Log.e(TAG,"InstallationId event Failed: " + e1.getMessage());
}
        }
    });
}

@Override
public List<Anime> getAnimeListByUrl(String url) {
    ArrayList<Anime> animeList = new ArrayList<>();
    ParseQuery<AnimeRecord> query = AnimeRecord.getQuery();
    try {
        List<AnimeRecord> animeRecords = query.whereContains("url",url).find();
        for (AnimeRecord record : animeRecords) {
            Anime anime = AnimeRecord.toAnime(record);
            if (anime != null)
                animeList.add(anime);
        }
    } catch (ParseException e) {
        WriteLog.appendLogException(TAG,"getAnimeListByUrl(" + url + ") Failed",e);
    }
    return animeList;
}

@Override
public List<Anime> getAnimeListByTitle(String title) {
    ArrayList<Anime> animeList = new ArrayList<>();
    ParseQuery<AnimeRecord> query = AnimeRecord.getQuery();
    try {
        List<AnimeRecord> animeRecords = query.whereContains("title",title).find();
        for (AnimeRecord record : animeRecords) {
            Anime anime = AnimeRecord.toAnime(record);
            if (anime != null)
                animeList.add(anime);
        }
    } catch (ParseException e) {
        WriteLog.appendLogException(TAG,"getAnimeListByTitle(" + title + ") Failed",e);
    }
    return animeList;
}

public void getContactInfos(List<String> usernames,final EMValueCallBack<List<EaseUser>> callback) {
    ParseQuery<ParSEObject> pQuery = ParseQuery.getQuery(CONfig_TABLE_NAME);
    pQuery.whereContainedIn(CONfig_USERNAME,usernames);
    pQuery.findInBackground(new FindCallback<ParSEObject>() {

        @Override
        public void done(List<ParSEObject> arg0,ParseException arg1) {
            if (arg0 != null) {
                List<EaseUser> mList = new ArrayList<EaseUser>();
                for (ParSEObject pObject : arg0) {
                    EaseUser user = new EaseUser(pObject.getString(CONfig_USERNAME));
                    ParseFile parseFile = pObject.getParseFile(CONfig_AVATAR);
                    if (parseFile != null) {
                        user.setAvatar(parseFile.getUrl());
                    }
                    user.setNick(pObject.getString(CONfig_NICK));
                    EaseCommonUtils.setUserInitialLetter(user);
                    mList.add(user);
                }
                callback.onSuccess(mList);
            } else {
                callback.onError(arg1.getCode(),arg1.getMessage());
            }
        }
    });
}

private void signUp(){
    ParseUser user = new ParseUser();
    user.setUsername(USER_NAME);
    user.setPassword(PASSWORD);
    user.setEmail(EMAIL);
    user.signUpInBackground(new SignUpCallback() {
        public void done(ParseException e) {
            if (e == null) {
                login();
                Toast.makeText(getApplicationContext(),"Login cadasTrado com sucesso",Toast.LENGTH_SHORT).show();
            }else{
                Toast.makeText(getApplicationContext(),"Erro ao cadastrar login",Toast.LENGTH_SHORT).show();
            }
        }
    });
}

public static void setUpParse(Context context) {

        Parse.enableLocalDatastore(context);
        Parse.initialize(context,"SUA_APPLICATION_ID","SUA CLIENT_KEY");
        ParseInstallation.getCurrentInstallation().saveInBackground();

        ParseUser.enableAutomaticUser();
        ParseACL defaultACL = new ParseACL();
        defaultACL.setPublicReadAccess(true);
        defaultACL.setPublicWriteAccess(true);

        ParsePush.subscribeInBackground(Constants.CHANNEL,new SaveCallback() {
            @Override
            public void done(ParseException error) {
                if (error == null) {
                    Log.i(Constants.TAG,"Successfully subscribed to Parse!");
                }else{
                    Log.i(Constants.TAG,"Error subscribed to Parse!");
                }
            }
        });
    }

public static void retreiveprofile(String username,final Context context) {
    ParseQuery<ParSEObject> query= ParseQuery.getQuery("Profile");
    query.whereEqualTo("user",username);
    query.getFirstInBackground(new GetCallback<ParSEObject>() {
        @Override
        public void done(ParSEObject parSEObject,ParseException e) {

            if(parSEObject!=null && e==null) {

                ParseFile file = (ParseFile) parSEObject.get("image");
                String url = "http://wwww.webianks.com";

                if (file != null) {
                    url = file.getUrl().toString();
                }

                MainActivity.retriveProfileCallback(context,url);

            }else{
                //canntretrivee file
            }
        }
    });

}

public static void retreivetimelineprofile(String username,ParseException e) {

            if(parSEObject!=null && e==null) {

                ParseFile file = (ParseFile) parSEObject.get("image");
                String url = "http://wwww.webianks.com";
                if (file != null) {

                    url = file.getUrl().toString();
                }

                Profile.retriveTimelineProfileCallback(context,url);

            }else{
                //canntretrivee file
            }
        }
    });

}

private void runUpdate(final Event event,ArrayList<String> locations,String tag) {
    Log.d("FAC",tag);
    for (String location : locations) {
        String venue = event.getVenue();
        venue = venue.replaceAll("\n"," ");
        event.setVenue(venue);

        if (venue.toLowerCase().contains(location)) {
            event.setFacultyTag(tag);
            event.saveInBackground(new SaveCallback() {
                @Override
                public void done(ParseException e) {
                    Log.e("Saved:",event.getType());
                }
            });
            break;
        }
    }
}

@Override
public void login(String username,String password) {

    //Make sure parse is initialized in the Application class of the main app
    ParseUser.logInInBackground(username,new LogInCallback() {
                @Override
                public void done(ParseUser user,ParseException e) {
                    if (e == null){
                        //User exist and authenticated,send user to Welcome.class
                        EventBus.getDefault().post(new LoginCallbackEvent(true,null));
                    } else {
                        EventBus.getDefault().post(new LoginCallbackEvent(false,e.getMessage()));
                    }

                }
            });

}

private void verifyOrganization(){
    final String enteredText = orgName.getText().toString().trim();

    final RefreshingDialog rd = new RefreshingDialog(this);
    rd.createRefreshingDialog();
    ParseQuery<Organization> query = ParseQuery.getQuery(Organization.class);
    query.whereEqualTo("name",enteredText);
    query.findInBackground(new FindCallback<Organization>() {
        @Override
        public void done(List<Organization> objects,ParseException e) {
           if(objects.isEmpty()){//new group
               createGroupAlert(enteredText);
               rd.stop();
           }else{
               joinGroupAlert(objects.get(0));
               rd.stop();
           }
        }
    });

}

private void userAcceptedGroup(Object org){
    if(org instanceof String){
        final Organization newOrg = new Organization((String)org);
        newOrg.saveInBackground(new SaveCallback() {
            @Override
            public void done(ParseException e) {
                if(e == null){
                    //save worked
                    saveAndContinue(newOrg);
                }else{
                    Toast.makeText(CreateOrganization.this,"Error creating organization,please try again",Toast.LENGTH_SHORT).show();
                }
            }
        });
    }else{
        saveAndContinue((Organization)org);
    }

}

private void loadData() {
    ParseQuery<UserInfo> query = ParseQuery.getQuery(UserInfo.class);
    query.orderByDescending("score").setLimit(10);
    query.findInBackground(new FindCallback<UserInfo>() {
        @Override
        public void done(List<UserInfo> objects,ParseException e) {
            list.addAll(objects);
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    adapter.notifyDataSetChanged();
                }
            });
        }
    });

}

private void requestSessionToken(String authorizationCode) {
    HashMap<String,Object> params = new HashMap<>();
    params.put("authorizationCode",authorizationCode);
    ParseCloud.callFunctionInBackground("requestSessionToken",params,new FunctionCallback<String>() {
        @Override
        public void done(String sessionToken,ParseException e) {
            if (e == null) {
                Log.d("cloud","Got back: " + sessionToken);
                becomeUser(sessionToken);
            } else {
                Toast.makeText(LoginActivity.this,"Login Failed",Toast.LENGTH_LONG).show();
                Log.d("error",e.toString());
            }
        }
    });
}

public <T> Observable<T> callFunctionForList(@NonNull String functionName,@NonNull Map<String,?> params) {
    Log.d(TAG,"Calling function: " + functionName + ",with params: " + params);
    return Observable.create(new ParseRequest<List<T>,T>("Exception while calling method " + functionName) {

        @NonNull
        @Override
        protected List<T> networkCall() throws ParseException {
            return ParseCloud.callFunction(functionName,params);
        }

        @Override
        protected void publishResult(@NonNull Subscriber<? super T> subscriber,@NonNull List<T> results) {
            for (T result : results) {
                subscriber.onNext(result);
            }
        }
    });
}

public Observable<ParseUser> signUp(@NonNull String userName,@NonNull String password,"Running sign up");
    return Observable.create(new SimpleParseRequest<ParseUser>("Exception while calling signUp") {

        @NonNull
        @Override
        protected ParseUser networkCall() throws ParseException {
            final ParseUser user = new ParseUser();
            user.setUsername(userName);
            user.setPassword(password);
            for (Map.Entry<String,?> param : params.entrySet()) {
                user.put(param.getKey(),param.getValue());
            }
            user.signUp();
            return user;
        }
    });
}

@Override
public void call(Subscriber<? super T> subscriber) {
    if (!mCallCompleted) {
        synchronized (this) {
            if (!mCallCompleted) {
                try {
                    mResult = networkCall();
                }
                catch (ParseException e) {
                    mParseException = e;
                }
                mCallCompleted = true;
            }
        }
    }
    if (mResult != null) {
        publishResult(subscriber,mResult);
    }
    else if (mParseException != null) {
        publishError(subscriber,mParseException);
        return;
    }
    // As we might not have a result for example where the return type is void,onCompleted needs to occur outside of the result
    // if statement.
    subscriber.onCompleted();
}

@Override
public void onCreate() {
    super.onCreate();

    Parse.enableLocalDatastore(this);
    Parse.initialize(this,"b6M7rAxtdYoUgGMgGkzmYmpDWiN2T6M8c2RTJ5Zg","Xsqyd44kUtgiOMMvwP8gyVjmdZLvXLxuynmGqqNX");
    ParsePush.subscribeInBackground("Apro_2016",new SaveCallback() {
        @Override
        public void done(ParseException e) {
            Log.e(TAG,"Successfully subscribed to Parse!");
        }


    });
    Log.d(TAG,"not rgtd.");
}

public void getContactInfos(List<String> usernames,arg1.getMessage());
            }
        }
    });
}

public void localTeamList() {
    // Query backend
    ParseQuery<ParSEObject> query = ParseQuery.getQuery("T" + teamNumber);
    query.fromLocalDatastore().findInBackground(new FindCallback<ParSEObject>() {
        @Override
        public void done(List<ParSEObject> list,ParseException e) {
            // No exception,query successful
            if (e == null) {
                teams.clear();
                Collections.reverse(list);
                for (ParSEObject object : list) {
                    if (object.getString("team").equals("")) continue;
                    Team team = new Team(object.getString("team"),object.getString("region"),object.getString("school"),object.getString("teamName"),object.getobjectId());
                    teams.add(team);
                }
            }
            adapter.notifyDataSetChanged();
            refresh.setRefreshing(false);
        }
    });
}

public void getNodes(final Callback<List<Node>> cb)
{
    if (nodes == null)
    {
        getNodeRelation()
                .getQuery()
                .orderByAscending(KEY_ORDER)
                .findInBackground(new FindCallback<Node>() {
                    @Override
                    public void done(List<Node> objects,ParseException e) {
                        if (e != null) {
                            cb.error(new Error(e.getMessage(),e.getCode()));
                            e.printstacktrace();
                        } else {
                            nodes = objects;
                            cb.done(nodes);
                        }
                    }
                });
    } else {
        cb.done(nodes);
    }
}

public Bitmap getPic(){
    ParseFile picFile=null;
    if(parseEntry!=null){
        if(parseEntry.getParseFile("ProfilePic")!=null){
            picFile = parseEntry.getParseFile("ProfilePic");
        };
    }

    if(picFile == null){
        return null;
    }
    try {
        byte[] image = picFile.getData();
        Bitmap pic = BitmapFactory.decodeByteArray(image,image.length);
        return pic;
    } catch (ParseException e) {
        e.printstacktrace();
        return null;
    }
}

public void showFavorites() {
    ParseQuery<Trainer> query = ParseQuery.getQuery("Trainer");
    query.include("favorited_by");
    query.whereEqualTo("favorited_by",SimpleUser.currentUserObject);
    query.findInBackground(new FindCallback<Trainer>() {
        public void done(List<Trainer> trainers,ParseException e) {
            hideProgressWheel();
            if (e == null) {
                Log.d("DEBUG","Retrieved " + trainers.size() + " trainers");
                refreshFragment(trainers);
            } else {
                Log.d("DEBUG","Error: " + e.getMessage());
            }
        }
    });
}

public void autorization(){



        ParseUser.logInInBackground(entLogin.getText().toString(),entPassword.getText().toString(),new LogInCallback(){
        public void done(ParseUser user,ParseException e) {
            if (user != null) {
               loginok();
            } else {
                Toast toast = Toast.makeText(getApplicationContext(),"Incorect login or password",duration);
                toast.show();
                // Signup Failed. Look at the ParseException to see what happened.
            }
        }
    });
    }

public void addCommentTask(){
    ParseQuery<ParSEObject> query = ParseQuery.getQuery("BullshITBankDB");
    query.whereEqualTo("phone",Phone);
    query.getFirstInBackground(new GetCallback<ParSEObject>() {
        @Override
        public void done(ParSEObject parSEObject,ParseException e) {
            Log.d("TAG","Done Loading Detail!");
            String NewComment = AddComment.getText().toString();
            List<String> CommentsList = parSEObject.getList("comments");
            if(CommentsList==null){
                CommentsList = new ArrayList<String>();
            }
            CommentsList.add(NewComment+"["+GUID+"]");
            parSEObject.put("comments",CommentsList);
            parSEObject.saveInBackground();
            loadDetail();
        }
    });
}

public void addCommentTask(String Number,final String Comment,final String GUID){
    ParseQuery<ParSEObject> query = ParseQuery.getQuery("BullshITBankDB");
    query.whereEqualTo("phone",Number);
    query.getFirstInBackground(new GetCallback<ParSEObject>() {
        @Override
        public void done(ParSEObject parSEObject,"Done Loading Detail!");
            List<String> CommentsList = parSEObject.getList("comments");
            if(CommentsList==null){
                CommentsList = new ArrayList<String>();
            }
            CommentsList.add(Comment+"["+GUID+"]");
            parSEObject.put("comments",CommentsList);
            parSEObject.saveInBackground();
        }
    });
}

public void addBullshITBank(final String NewNumber){
    if(NewNumber.length()<6){
        Toast.makeText(mContext,getResources().getString(R.string.too_short),Toast.LENGTH_LONG).show();
    }else{

        ParseQuery<ParSEObject> query = ParseQuery.getQuery("BullshITBankDB");
        query.whereStartsWith("phone",NewNumber);
        query.findInBackground(new FindCallback<ParSEObject>() {
            @Override
            public void done(List<ParSEObject> parSEObjects,ParseException e) {
                if (parSEObjects.size() > 0) {
                    Toast.makeText(mContext,getResources().getString(R.string.duplicate),Toast.LENGTH_LONG).show();
                } else {
                    FragmentManager fragmentManager = getSupportFragmentManager();
                    DialogFragment ConfirmDialog = AddNewConfirmDialog.newInstance(NewNumber,GUID);
                    ConfirmDialog.show(fragmentManager,"confirmdialog");
                }
            }
        });

    }
}

public void setUsersImagetoParse(String username,final File image){
    ParseQuery<ParseUser> query = ParseUser.getQuery();
    query.whereEqualTo("username",username);

    query.getFirstInBackground(new GetCallback<ParseUser>() {
        public void done(ParseUser UsersClass,ParseException e) {
            if (UsersClass == null) {
                Log.d("score","no success setUsersImagetoParse");
            } else {
                //success
                UsersClass.put("ProfilePic",image);
                UsersClass.saveInBackground();

                pullParseAndSetotherUsersDatainBackground();

            }
        }
    });
}

public static void getMatches(final ActionDataCallbacks callbacks) {
    ParseQuery<ParSEObject> query = new ParseQuery<ParSEObject>(TABLE_NAME);
    query.whereEqualTo(COLUMN_BY_USER,ParseUser.getCurrentUser().getobjectId());
    query.whereEqualTo(COLUMN_TYPE,TYPE_MATCHED);
    query.orderByDescending(COLUMN_UPDATED_AT);
    query.findInBackground(new FindCallback<ParSEObject>() {
        @Override
        public void done(List<ParSEObject> list,ParseException e) {
            if(e == null) {
                List<String> ids = new ArrayList<String>();
                for(ParSEObject object : list) {
                    ids.add(object.getString(COLUMN_TO_USER));
                }

                if(callbacks != null) {
                    callbacks.onFetchedMatches(ids);
                }
            }
        }
    });
}

private void getFacebookInfo() {
    Bundle parameters = new Bundle();
    parameters.putString("fields","picture,first_name,id");
    new GraphRequest(Accesstoken.getCurrentAccesstoken(),"/me",parameters,HttpMethod.GET,new GraphRequest.Callback() {
        @Override
        public void onCompleted(GraphResponse graphResponse) {
            JSONObject user = graphResponse.getJSONObject();
            ParseUser currentUser = ParseUser.getCurrentUser();
            currentUser.put("firstName",user.optString("first_name"));
            currentUser.put("facebookId",user.optString("id"));
            currentUser.put("pictureURL",user.optJSONObject("picture").optJSONObject("data").optString("url"));
            currentUser.saveInBackground(new SaveCallback() {
                @Override
                public void done(ParseException e) {
                    if(e == null) {
                        Log.i(TAG,"User saved");
                        setResult(RESULT_OK);
                        finish();
                    }
                }
            });
        }
    }).executeAsync();
}

/**
 * This is where the bulk of our work is done. This function is
 * called in a background thread and should generate a new set of
 * data to be published by the loader.
 */
@Override
@SuppressWarnings("unchecked")
public List<T> loadInBackground() {
    if (mParseQuery == null) {
        return Collections.emptyList();
    }

    try {
        return mForceLoadEverything ? findAll(mParseQuery) : loadobjects(mPagetoLoad);
    } catch (ParseException e) {
        if (BuildConfig.DEBUG) {
            Log.w(TAG,"Load interrupted with ParseException " + e.getCode()
                    + ": " + e.getMessage());
        }

        return Collections.emptyList();
    }
}