no controlada tipo de excepción de error

Question

nunca he conseguido este error antes, así que no estoy seguro de qué hacer o lo que significa

no controlada tipo de excepción OperationApplicationException

Se produce en este código:

public void putSettings(SharedPreferences pref){ 
    ArrayList<ContentProviderOperation> ops = 
      new ArrayList<ContentProviderOperation>(); 

    ops.add(ContentProviderOperation.newUpdate(Data.CONTENT_URI) 
    .withSelection(Data.RAW_CONTACT_ID + "=?", new String[]{String.valueOf(pref.getString(SmsPrefs.ID, ""))}) 
    .withValue(Data.MIMETYPE,"vnd.android.cursor.item/color") 
    .withValue("data1",nColor).build()); 
    getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops); //error 


    ops.add(ContentProviderOperation.newUpdate(Data.CONTENT_URI) 
    .withSelection(Data.RAW_CONTACT_ID + "=?", new String[]{String.valueOf(pref.getString(SmsPrefs.ID, ""))}) 
    .withValue(Data.MIMETYPE,"vnd.android.cursor.item/vibrate") 
    .withValue("data1", nVibrate).build()); 
    getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops); //error 

    ops.add(ContentProviderOperation.newUpdate(Data.CONTENT_URI) 
    .withSelection(Data.RAW_CONTACT_ID + "=?", new String[]{String.valueOf(pref.getString(SmsPrefs.ID, ""))}) 
    .withValue(Data.MIMETYPE, "vnd.android.cursor.item/sound") 
    .withValue("data1", ringTonePath).build()); 
    getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);//error 
} 

Me da 2 opciones "agregar declaración de lanzamientos" y "envolvente con try/catch".

¿Qué debo hacer y por qué?

Answer 1

Significa que un método que está llamando se declara con la directiva throws para una excepción derivada de la clase Exception. Cuando se declara un método de esta manera, se le obliga a tratar con la excepción usando un bloque try/catch o agregar una declaración throws (para la misma excepción o un tipo estupendo) a su declaración de método.

Un ejemplo.

Quiero llamar a algún método foo dentro de mi método bar.

Aquí es foo 's definición:

public static void foo(String a) throws Exception { 
    // foo does something interesting here. 
} 

Quiero llamar foo. Si simplemente hago esto:

private void bar() { 
    foo("test"); 
} 

... entonces obtendré el error que está experimentando. foo declara al mundo que realmente podría decidir lanzar un Exception y será mejor que esté listo para enfrentarlo.

Tengo dos opciones. Puedo cambiar la definición bar 's de la siguiente manera:

private void bar() throws Exception { 
    foo("test"); 
} 

Ahora he publicitado mi propia advertencia de que mi método o algún método que llamo podrían lanzar una Exception que el usuario de mi método debe tratar. Como he diferido la responsabilidad de la persona que llama a mi método, mi método no tiene que lidiar con la excepción en sí.

A menudo es mejor tratar con la excepción usted mismo, si puede. Esto nos lleva a la segunda opción, la try/catch:

private void bar() { 
    try { 
     foo("test"); 
    } catch(Exception e) { 
     Log.wtf("MyApp", "Something went wrong with foo!", e); 
    } 
} 

Ahora he tratado con el potencial Exception lanzada por foo que el compilador se quejaba. Dado que se ha tratado, no es necesario que agregue una directiva throws a mi método bar.