Android：在CursorAdapter中使用微调文本

Question

我有一个用SimpleCursorAdapter填充的ListView。应该在此视图中显示的一个字段（TBTsqlHelperBudgets.KEY_INTERVAL）以int形式（用于输入的微调器的索引）存储在DB中。但我想在ListView中显示文本而不是索引。有什么建议么？

public class TBTTManageBudgetsActivity extends Activity { 
    // ... 
    // some stuff 
    // ... 

    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     // ... 
     // some stuff 
     // ... 
       cursor = getBudgets(); 
       String[] uiBindFrom = { TBTsqlHelperBudgets.KEY_NAME, TBTsqlHelperBudgets.KEY_BUDGET, TBTsqlHelperBudgets.KEY_INTERVAL };    
       int[] uiBindTo = { R.id.name, R.id.budget, R.id.interval}; 
       cursor.moveToFirst(); 
       CursorAdapter adapter = new SimpleCursorAdapter(this.getApplicationContext(), R.layout.list_budgets_item, cursor, uiBindFrom, uiBindTo);     
       listView.setAdapter(adapter); 
     // ... 
     // some stuff 
     // ... 
    } 
    // ... 
    // some stuff 
    // ... 
} 

顺便说一句：微调器设置使用XML数组：

ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this, R.array.intervals, android.R.layout.simple_spinner_item); 

与XML：

<resources> 
    <string-array name="intervals"> 
     <item>per day</item> 
     <item>per week</item> 
     <item>per month</item> 
     <item>per year</item> 
    </string-array> 
</resources> 

Answer 1

如果你只是想显示的文本（而不是为了能够编辑它），您可以使用类似的方式来即时进行转换或查找。它只是简单地包装你的光标，并且设置哪些列需要特殊处理。所有其他处理由底层的光标对象处理：

package com.awc.util; 

import java.text.DateFormat; 
import java.util.Date; 

import android.content.ContentResolver; 
import android.database.CharArrayBuffer; 
import android.database.ContentObserver; 
import android.database.Cursor; 
import android.database.DataSetObserver; 
import android.net.Uri; 
import android.os.Bundle; 
import android.util.Log; 

public class ConversionAndLookupCursor implements Cursor { 
private static final String TAG = ConversionAndLookupCursor.class.getSimpleName(); 


private Cursor wrapped; 
private Converter converters[]; 


public ConversionAndLookupCursor(Cursor wrapped) { 
    if(wrapped == null) { 
     throw new NullPointerException("wrapped"); 
    } 

    this.wrapped = wrapped; 
    this.converters = new Converter[wrapped.getColumnCount()]; 
} 


@Override 
public void close() { 
    wrapped.close(); 
} 

@Override 
public void copyStringToBuffer(int columnIndex, CharArrayBuffer buffer) { 
    Converter c; 
    String s; 


    Log.d(TAG, "Converting " + columnIndex); 
    c = converters[columnIndex]; 
    if(c != null) { 
     s = c.convertFrom(wrapped.getLong(columnIndex)); 
     buffer.data = s.toCharArray(); 
    } else { 
     wrapped.copyStringToBuffer(columnIndex, buffer); 
    } 
} 

@Override 
public void deactivate() { 
    wrapped.deactivate(); 
} 

@Override 
public byte[] getBlob(int columnIndex) { 
    return wrapped.getBlob(columnIndex); 
} 

@Override 
public int getColumnCount() { 
    return wrapped.getColumnCount(); 
} 

@Override 
public int getColumnIndex(String columnName) { 
    return wrapped.getColumnIndex(columnName); 
} 

@Override 
public int getColumnIndexOrThrow(String columnName) 
     throws IllegalArgumentException { 
    return wrapped.getColumnIndexOrThrow(columnName); 
} 

@Override 
public String getColumnName(int columnIndex) { 
    return wrapped.getColumnName(columnIndex); 
} 

@Override 
public String[] getColumnNames() { 
    return wrapped.getColumnNames(); 
} 

@Override 
public int getCount() { 
    return wrapped.getCount(); 
} 

@Override 
public double getDouble(int columnIndex) { 
    return wrapped.getDouble(columnIndex); 
} 

@Override 
public Bundle getExtras() { 
    return wrapped.getExtras(); 
} 

@Override 
public float getFloat(int columnIndex) { 
    return wrapped.getFloat(columnIndex); 
} 

@Override 
public int getInt(int columnIndex) { 
    return wrapped.getInt(columnIndex); 
} 

@Override 
public long getLong(int columnIndex) { 
    return wrapped.getLong(columnIndex); 
} 

@Override 
public int getPosition() { 
    return wrapped.getPosition(); 
} 

@Override 
public short getShort(int columnIndex) { 
    return wrapped.getShort(columnIndex); 
} 

@Override 
public String getString(int columnIndex) { 
    Converter c; 
    Long value = null; 
    String s; 


    c = converters[columnIndex]; 
    if(c != null) { 
     Log.d(TAG, "Converting in getString(" + columnIndex + ")"); 
     if(!wrapped.isNull(columnIndex)) { 
      value = wrapped.getLong(columnIndex); 
     } 
     s = c.convertFrom(value); 
    } else { 
     s = wrapped.getString(columnIndex); 
    } 

    return s; 
} 

@Override 
public boolean getWantsAllOnMoveCalls() { 
    return wrapped.getWantsAllOnMoveCalls(); 
} 

@Override 
public boolean isAfterLast() { 
    return wrapped.isAfterLast(); 
} 

@Override 
public boolean isBeforeFirst() { 
    return wrapped.isBeforeFirst(); 
} 

@Override 
public boolean isClosed() { 
    return wrapped.isClosed(); 
} 

@Override 
public boolean isFirst() { 
    return wrapped.isFirst(); 
} 

@Override 
public boolean isLast() { 
    return wrapped.isLast(); 
} 

@Override 
public boolean isNull(int columnIndex) { 
    return wrapped.isNull(columnIndex); 
} 

@Override 
public boolean move(int offset) { 
    return wrapped.move(offset); 
} 

@Override 
public boolean moveToFirst() { 
    return wrapped.moveToFirst(); 
} 

@Override 
public boolean moveToLast() { 
    return wrapped.moveToLast(); 
} 

@Override 
public boolean moveToNext() { 
    return wrapped.moveToNext(); 
} 

@Override 
public boolean moveToPosition(int position) { 
    return wrapped.moveToPosition(position); 
} 

@Override 
public boolean moveToPrevious() { 
    return wrapped.moveToPrevious(); 
} 

@Override 
public void registerContentObserver(ContentObserver observer) { 
    wrapped.registerContentObserver(observer); 
} 

@Override 
public void registerDataSetObserver(DataSetObserver observer) { 
    wrapped.registerDataSetObserver(observer); 
} 

@Override 
public boolean requery() { 
    return wrapped.requery(); 
} 

@Override 
public Bundle respond(Bundle extras) { 
    return wrapped.respond(extras); 
} 

@Override 
public void setNotificationUri(ContentResolver cr, Uri uri) { 
    wrapped.setNotificationUri(cr, uri); 
} 

@Override 
public void unregisterContentObserver(ContentObserver observer) { 
    wrapped.unregisterContentObserver(observer); 
} 

@Override 
public void unregisterDataSetObserver(DataSetObserver observer) { 
    wrapped.unregisterDataSetObserver(observer); 
} 


//////////////////////////////////// 
// DATA CONVERSION STUFF 
//////////////////////////////////// 
public void setDateConversion(int column) { 
    converters[column] = new DateConverter(); 
} 

public void setLookupConversion(int column, Cursor lookup, int lookupColumn) { 
    converters[column] = new LookupConverter(lookup, lookupColumn); 
} 

public void clearConversion(int column) { 
    converters[column] = null; 
} 

private interface Converter { 
    public String convertFrom(Object value); 
} 

private class DateConverter implements Converter { 
    private DateFormat fmt; 


    public DateConverter() { 
     fmt = DateFormat.getDateInstance(DateFormat.SHORT); 
    } 

    public String convertFrom(Object value) { 
     String s = null; 


     if(value != null && value instanceof Long) { 
      s = fmt.format(new Date((Long)value)); 
     } 

     return s; 
    } 
} 

private class LookupConverter implements Converter { 
    private Cursor lookup; 
    private int lookupColumn; 

    public LookupConverter(Cursor lookup, int column) { 
     if(lookup == null) throw new NullPointerException("lookup"); 

     this.lookup = lookup; 
     this.lookupColumn = column; 
    } 

    public String convertFrom(Object id) { 
     String s = null; 


     if(id != null && id instanceof Long) { 
      lookup.moveToPosition(((Long)id).intValue()); 
      s = lookup.getString(lookupColumn); 
     } 

     return s; 
    } 
} 
}