Come faccio a gestire le eccezioni nella cartina() in un 'osservabile in RxJava

Question

Voglio fare questo:

Observable.just(bitmap) 
      .map(new Func1<Bitmap, File>() { 
       @Override 
       public File call(Bitmap photoBitmap) { 

        //File creation throws IOException, 
        //I just want it to hit the onError() inside subscribe() 

        File photoFile = new File(App.getAppContext().getCacheDir(), "userprofilepic_temp.jpg"); 
        if(photoFile.isFile()) {//delete the file first if it exists otherwise the new file won't be created 
         photoFile.delete(); 
        } 
        photoFile.createNewFile(); //saves the file in the cache dir 

        FileOutputStream fos = new FileOutputStream(photoFile); 
        photoBitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);//jpeg format 
        fos.close(); 

        return photoFile; 

       } 
      }) 
      .subscribe(//continue implementation...); 

In sostanza nel metodo call(), può generare eccezioni. Come posso far sì che l'Observer lo gestisca in onError(). O non è questo il modo giusto di pensarci?

Answer 1

rx rileva sempre errori, anche se si tratta di RuntimeException. Quindi puoi lanciare qualche tipo di eccezione di runtime nel blocco catch. Questo è il modo in cui dovrebbe funzionare.

Observable.just(bitmap) 
       .map(b -> { 
        try { 
         // do some work which throws IOException 
         throw new IOException("something went wrong"); 
        } catch (IOException e) { 
         throw new RXIOException(e); 
         // Or you can use 
         throw Exceptions.propagate(e); 
         // This helper method will wrap your exception with runtime one 
        } 
       }).subscribe(o -> { 
        // do something here 
       }, exception -> exception.printStackTrace()); 

public static class RXIOException extends RuntimeException { 
     public RXIOException(IOException throwable) { 
      super(throwable); 
     } 
} 

Answer 2

Con 1.0.15, c'è il metodo fromCallable fabbrica che ti permette di eseguire un'istanza Callable per ogni abbonato, dove si può buttare eccezioni controllate così:

Observable.fromCallable(() -> {  
    File photoFile = new File(App.getAppContext().getCacheDir(), 
     "userprofilepic_temp.jpg"); 
    if (photoFile.isFile()) { 
     //delete the file if it exists otherwise the new file won't be created 
     photoFile.delete(); 
    } 
    photoFile.createNewFile(); //saves the file in the cache dir 

    FileOutputStream fos = new FileOutputStream(photoFile); 
    photoBitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);//jpeg format 
    fos.close(); 

    return photoFile; 
}) 
.subscribe(...) 

Edit:

source.flatMap(v -> { 
    try { 
     //... 
     return Observable.just(result); 
    } catch (Exception e) { 
     return Observable.error(e); 
    } 
}) 
.subscribe(...); 

Answer 3

classe helper appena creato per estrarre questo boilerplate in un altro luogo:

public class RxRethrow { 
    public static <T, R> Func1<T, R> rethrow(Func1R<T, R> catchedFunc) { 
     return t -> { 
      try { 
       return catchedFunc.call(t); 
      } catch (Exception e) { 
       throw Exceptions.propagate(e); 
      } 
     }; 
    } 

    public interface Func1R<T, R> extends Function { 
     R call(T t) throws Exception; 
    } 
} 

si può chiamare in questo modo:

.map(RxRethrow.rethrow(products -> mapper.writer(schema).writeValueAsString(products))) 

Answer 4

non so come la situazione è stato quando questa domanda è stata prima chiesta e ha risposto, ma RxJava attualmente contiene un metodo di supporto per questo esatto scopo: Exceptions.propagate(Throwable t)

RxJava Javadoc

Metodo pratico per gettare un RuntimeException ed Error direttamente o avvolgere qualsiasi altro tipo di eccezione in un RuntimeException.