Bonjour,

Je débute tout juste avec RxJava, utilisé avec Retrofit c'est absolument génial, mais maintenant que j'essaie d'utiliser cela avec ma base de donnée SQLite, je commence à avoir des doutes sur ma manière de l'implémenter et j'apprécierais beaucoup un retour, des avis ou des suggestions concernant cela.

La méthode suivante me permet de loader la DB au chargement de mon application, pour cella je créer un nouvel Observable et utilise un Callable pour éxecuter mes tâches Dans le Schedulers.io() puis j'observe dans la MainThread pour mettre la vue à jour une fois toutes les données chargées.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
public void loadDB(){
        rx.Observable.fromCallable(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                dbManager.openForRead();
                dbManager.printTables();
                List<FormationModel> formations = dbManager.getAllFormationModels();
                ArrayList<ExperienceModel> experiences = dbManager.getAllExperienceModels();
                ProfileModel profile = dbManager.getProfileModel();
                ResumeModel resumeModel = new ResumeModel(null, null,experiences,formations, profile);
                return resumeModel;
            }})
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Object>() {
                    @Override
                    public void onCompleted() {
                        dbManager.close();
                        unsubscribe();
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.i(TAG, "onError - LoadDB : " + e.getMessage());
 
                    }
 
                    @Override
                    public void onNext(Object o) {
                        resume = (ResumeModel) o;
                        Log.i(TAG, "LoadDB - Resume loaded from DB!");
                        FormationModel formation = resume.getFormations().get(0);
                        for (String s : formation.getCompetence()) {
                            Log.d(TAG, "LoadDB - formation : " + formation.getName() + " competence : " + s);
                        }
                    }
                });
 
    }
Même méthode pour enregistrer des données dans ma DB, ici le OnNext m'est inutile.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
private void populateDB(final ResumeModel resume) {
        rx.Observable.fromCallable(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                dbManager.openForWrite();
                Log.i(TAG, "populateDB : profileID : " + resume.getProfile().getNom());
                Log.i(TAG, "populateDB : profile ID : "  +  dbManager.insertProfileModel(resume.getProfile()) + " added!");
                ArrayList<ExperienceModel> exps = resume.getExperiences();
                for (ExperienceModel exp : exps){
                    Log.i(TAG, "populateDB : experience ID : "  + dbManager.insertExperienceModel(exp) +  " added!");
                }
                ArrayList<FormationModel> forms = resume.getFormations();
                for (FormationModel form : forms){
                    Log.i(TAG, "populateDB : formation ID : "  + dbManager.insertFormationModel(form) + " added!");
                }
 
                SharedPreferences.Editor editor = sharedPreferences.edit();
                editor.putBoolean(DBCREATED, true);
                editor.commit();
 
                dbManager.close();
                return null;
            }
        }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<Void>() {
            @Override
            public void onCompleted() {
                //UpdateView
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onNext(Void aVoid) {
 
            }
        });
 
    }
Dans cette méthode utilisé par mon Service pour Firebase Cloud Messaging, j'enregistre/édite/supprime la donnée reçus dans la table correspondante grâce à la réflectivité.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
    /**
     * Called when message is received.
     *
     * @param remoteMessage Object representing the message received from Firebase Cloud Messaging.
     */
    @Override
    public void onMessageReceived(final RemoteMessage remoteMessage) {
        ((ResumeApplication) getApplication())
                .getComponent()
                .inject(this);
 
 
 
        Log.d(TAG, "From: " + remoteMessage.getFrom());
        // Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
            Log.d(TAG, "Message data payload: " + remoteMessage.getData());
 
                Observable.fromCallable(new Callable<Void>() {
                    @Override
                    public Void call() throws Exception {
                        String table = remoteMessage.getData().get("to");
                        String action = remoteMessage.getData().get("action");
                        String content = remoteMessage.getData().get("content");
                            Method method = dbManager.getClass().getDeclaredMethod(action.toLowerCase() + table + "Model", String.class);
                            method.invoke(dbManager, content);
                            return null;
                    }
                }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Void>() {
                    @Override
                    public void onCompleted() {
 
                    }
 
                    @Override
                    public void onError(Throwable e) {
                            FirebaseCrash.log(remoteMessage.getData().get("content"));
                            FirebaseCrash.report(e);
                    }
 
                    @Override
                    public void onNext(Void aVoid) {
 
                    }
                });
        }
 
        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            createNotification(remoteMessage.getNotification());
        }
    }
Dans les 3 cas j'utilise donc le même schéma d'exécution, ça fonctionne, mais il y à peut être plus fonctionnel et je serais ravis d'avoir vos retours concernant l'utilisation de RxJava.