Notepad3 Tutorial Adding a ratingbar


  1. StefanKos

    StefanKos New Member

    I've completed the Notepad Tutorials from the Devs website and now I'm trying to figure it out how to add new things.This time I"m looking to define a rating bar that will be present in the edit/add notes section and will allow the user to rate the note/s.I've tried to define it in the code but the program will crash,you will see the attempt when I present the code.I have been unable to find any examples on the net, of how to take the RatingBar and add it as a value to theSQLite database.So obviously my question is how can I write the code for the rating bar's implementation?Thank you.

    Notepad3 class:



    Code (Text):
    1.  package com.android.demo.notepad3;
    2.    
    3.     import android.app.ListActivity;
    4.     import android.content.Intent;
    5.     import android.database.Cursor;
    6.     import android.os.Bundle;
    7.     import android.view.ContextMenu;
    8.     import android.view.Menu;
    9.     import android.view.MenuItem;
    10.     import android.view.View;
    11.     import android.view.ContextMenu.ContextMenuInfo;
    12.     import android.widget.ListView;
    13.    
    14.     import android.widget.SimpleCursorAdapter;
    15.     import android.widget.AdapterView.AdapterContextMenuInfo;
    16.    
    17.    
    18.     public class Notepadv3 extends ListActivity {
    19.         private static final int ACTIVITY_CREATE=0;
    20.         private static final int ACTIVITY_EDIT=1;
    21.    
    22.         private static final int INSERT_ID = Menu.FIRST;
    23.         private static final int DELETE_ID = Menu.FIRST + 1;
    24.    
    25.         private NotesDbAdapter mDbHelper;
    26.    
    27.         /** Called when the activity is first created. */
    28.         @Override
    29.         public void onCreate(Bundle savedInstanceState) {
    30.             super.onCreate(savedInstanceState);
    31.             setContentView(R.layout.notes_list);
    32.             mDbHelper = new NotesDbAdapter(this);
    33.             mDbHelper.open();
    34.             fillData();
    35.             registerForContextMenu(getListView());
    36.            
    37.         }
    38.    
    39.         private void fillData() {
    40.             Cursor notesCursor = mDbHelper.fetchAllNotes();
    41.             startManagingCursor(notesCursor);
    42.    
    43.             // Create an array to specify the fields we want to display in the list (only TITLE)
    44.             String[] from = new String[]{NotesDbAdapter.KEY_TITLE,NotesDbAdapter.KEY_BODY,NotesDbAdapter.KEY_RATING};
    45.    
    46.             // and an array of the fields we want to bind those fields to (in this case just text1)
    47.             int[] to = new int[]{R.id.text1,R.id.text2,R.id.ratingbar};
    48.    
    49.             // Now create a simple cursor adapter and set it to display
    50.             SimpleCursorAdapter notes =
    51.                 new SimpleCursorAdapter(this, R.layout.notes_row, notesCursor, from, to);
    52.             setListAdapter(notes);
    53.         }
    54.    
    55.         @Override
    56.         public boolean onCreateOptionsMenu(Menu menu) {
    57.             super.onCreateOptionsMenu(menu);
    58.             menu.add(0, INSERT_ID, 0, R.string.menu_insert);
    59.             return true;
    60.         }
    61.    
    62.         @Override
    63.         public boolean onMenuItemSelected(int featureId, MenuItem item) {
    64.             switch(item.getItemId()) {
    65.                 case INSERT_ID:
    66.                     createNote();
    67.                     return true;
    68.             }
    69.    
    70.             return super.onMenuItemSelected(featureId, item);
    71.         }
    72.    
    73.         @Override
    74.         public void onCreateContextMenu(ContextMenu menu, View v,
    75.                 ContextMenuInfo menuInfo) {
    76.             super.onCreateContextMenu(menu, v, menuInfo);
    77.             menu.add(0, DELETE_ID, 0, R.string.menu_delete);
    78.         }
    79.    
    80.         @Override
    81.         public boolean onContextItemSelected(MenuItem item) {
    82.             switch(item.getItemId()) {
    83.                 case DELETE_ID:
    84.                     AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
    85.                     mDbHelper.deleteNote(info.id);
    86.                     fillData();
    87.                     return true;
    88.             }
    89.             return super.onContextItemSelected(item);
    90.         }
    91.    
    92.         private void createNote() {
    93.             Intent i = new Intent(this, NoteEdit.class);
    94.             startActivityForResult(i, ACTIVITY_CREATE);
    95.         }
    96.    
    97.         @Override
    98.         protected void onListItemClick(ListView l, View v, int position, long id) {
    99.             super.onListItemClick(l, v, position, id);
    100.             Intent i = new Intent(this, NoteEdit.class);
    101.             i.putExtra(NotesDbAdapter.KEY_ROWID, id);
    102.             startActivityForResult(i, ACTIVITY_EDIT);
    103.         }
    104.    
    105.         @Override
    106.         protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    107.             super.onActivityResult(requestCode, resultCode, intent);
    108.             fillData();
    109.         }
    110.     }
    111.  
    NoteEdit class:

    Code (Text):
    1. package com.android.demo.notepad3;
    2.    
    3.     import android.app.Activity;
    4.     import android.database.Cursor;
    5.     import android.os.Bundle;
    6.     import android.view.View;
    7.     import android.widget.Button;
    8.     import android.widget.EditText;
    9.     import android.widget.RatingBar;
    10.    
    11.     public class NoteEdit extends Activity {
    12.    
    13.         private EditText mTitleText;
    14.         private EditText mBodyText;
    15.         private Long mRowId;
    16.         private NotesDbAdapter mDbHelper;
    17.         private RatingBar mRatingBar;
    18.    
    19.         @Override
    20.         protected void onCreate(Bundle savedInstanceState) {
    21.             super.onCreate(savedInstanceState);
    22.             mDbHelper = new NotesDbAdapter(this);
    23.             mDbHelper.open();
    24.    
    25.             setContentView(R.layout.note_edit);
    26.             setTitle(R.string.edit_note);
    27.    
    28.             mTitleText = (EditText) findViewById(R.id.title);
    29.             mBodyText = (EditText) findViewById(R.id.body);
    30.             mRatingBar= (RatingBar) findViewById(R.id.ratingbar);
    31.    
    32.             Button confirmButton = (Button) findViewById(R.id.confirm);
    33.    
    34.             mRowId = (savedInstanceState == null) ? null :
    35.                 (Long) savedInstanceState.getSerializable(NotesDbAdapter.KEY_ROWID);
    36.             if (mRowId == null) {
    37.                 Bundle extras = getIntent().getExtras();
    38.                 mRowId = extras != null ? extras.getLong(NotesDbAdapter.KEY_ROWID)
    39.                                         : null;
    40.             }
    41.    
    42.             populateFields();
    43.    
    44.             confirmButton.setOnClickListener(new View.OnClickListener() {
    45.    
    46.                 public void onClick(View view) {
    47.                     setResult(RESULT_OK);
    48.                     finish();
    49.                 }
    50.    
    51.             });
    52.         }
    53.    
    54.         private void populateFields() {
    55.             if (mRowId != null) {
    56.                 Cursor note = mDbHelper.fetchNote(mRowId);
    57.                 startManagingCursor(note);
    58.                 mTitleText.setText(note.getString(
    59.                         note.getColumnIndexOrThrow(NotesDbAdapter.KEY_TITLE)));
    60.                 mBodyText.setText(note.getString(
    61.                         note.getColumnIndexOrThrow(NotesDbAdapter.KEY_BODY)));
    62.                 mRatingBar.setRating(note.getFloat(
    63.                         note.getColumnIndexOrThrow(NotesDbAdapter.KEY_RATING)));
    64.                
    65.             }
    66.         }
    67.    
    68.         @Override
    69.         protected void onSaveInstanceState(Bundle outState) {
    70.             super.onSaveInstanceState(outState);
    71.             saveState();
    72.             outState.putSerializable(NotesDbAdapter.KEY_ROWID, mRowId);
    73.         }
    74.    
    75.         @Override
    76.         protected void onPause() {
    77.             super.onPause();
    78.             saveState();
    79.         }
    80.    
    81.         @Override
    82.         protected void onResume() {
    83.             super.onResume();
    84.             populateFields();
    85.         }
    86.    
    87.         private void saveState() {
    88.             String title = mTitleText.getText().toString();
    89.             String body = mBodyText.getText().toString();
    90.             Float rating = mRatingBar.getRating();
    91.    
    92.             if (mRowId == null) {
    93.                 long id = mDbHelper.createNote(title, body,rating);
    94.                 if (id > 0) {
    95.                     mRowId = id;
    96.                 }
    97.             } else {
    98.                 mDbHelper.updateNote(mRowId, title, body,rating);
    99.             }
    100.         }
    101.    
    102.     }
    103.  
    NotesDBAdabpter class:

    Code (Text):
    1. package com.android.demo.notepad3;
    2.    
    3.     import android.content.ContentValues;
    4.     import android.content.Context;
    5.     import android.database.Cursor;
    6.     import android.database.SQLException;
    7.     import android.database.sqlite.SQLiteDatabase;
    8.     import android.database.sqlite.SQLiteOpenHelper;
    9.     import android.util.Log;
    10.    
    11.    
    12.     public class NotesDbAdapter {
    13.    
    14.         public static final String KEY_TITLE = "title";
    15.         public static final String KEY_BODY = "body";
    16.         public static final String KEY_RATING = "rating";
    17.         public static final String KEY_ROWID = "_id";
    18.    
    19.         private static final String TAG = "NotesDbAdapter";
    20.         private DatabaseHelper mDbHelper;
    21.         private SQLiteDatabase mDb;
    22.    
    23.         /**
    24.          * Database creation sql statement
    25.          */
    26.         private static final String DATABASE_CREATE =
    27.             "create table notes (_id integer primary key autoincrement, "
    28.             + "title text not null, body text not null,rating not null);";
    29.    
    30.         private static final String DATABASE_NAME = "data";
    31.         private static final String DATABASE_TABLE = "notes";
    32.         private static final int DATABASE_VERSION = 5;
    33.    
    34.         private final Context mCtx;
    35.        
    36.    
    37.         private static class DatabaseHelper extends SQLiteOpenHelper {
    38.    
    39.             DatabaseHelper(Context context) {
    40.                 super(context, DATABASE_NAME, null, DATABASE_VERSION);
    41.             }
    42.    
    43.             @Override
    44.             public void onCreate(SQLiteDatabase db) {
    45.    
    46.                 db.execSQL(DATABASE_CREATE);
    47.                 insertNotes(db);
    48.             }
    49.    
    50.             @Override
    51.             public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    52.                 Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
    53.                         + newVersion + ", which will destroy all old data");
    54.                 db.execSQL("DROP TABLE IF EXISTS notes");
    55.                
    56.                 onCreate(db);
    57.             }
    58.         }
    59.    
    60.         /**
    61.          * Constructor - takes the context to allow the database to be
    62.          * opened/created
    63.          *
    64.          * @param ctx the Context within which to work
    65.          */
    66.         public NotesDbAdapter(Context ctx) {
    67.             this.mCtx = ctx;
    68.         }
    69.    
    70.         /**
    71.          * Open the notes database. If it cannot be opened, try to create a new
    72.          * instance of the database. If it cannot be created, throw an exception to
    73.          * signal the failure
    74.          *
    75.          * @return this (self reference, allowing this to be chained in an
    76.          *         initialization call)
    77.          * @throws SQLException if the database could be neither opened or created
    78.          */
    79.         public NotesDbAdapter open() throws SQLException {
    80.             mDbHelper = new DatabaseHelper(mCtx);
    81.             mDb = mDbHelper.getWritableDatabase();
    82.             return this;
    83.         }
    84.    
    85.         public void close() {
    86.             mDbHelper.close();
    87.         }
    88.    
    89.    
    90.         /**
    91.          * Create a new note using the title and body provided. If the note is
    92.          * successfully created return the new rowId for that note, otherwise return
    93.          * a -1 to indicate failure.
    94.          *
    95.          * @param title the title of the note
    96.          * @param body the body of the note
    97.          * @return rowId or -1 if failed
    98.          */
    99.         public long createNote(String title, String body,Float rating) {
    100.             ContentValues initialValues = new ContentValues();
    101.             initialValues.put(KEY_TITLE, title);
    102.             initialValues.put(KEY_BODY, body);
    103.             initialValues.put(KEY_RATING, rating);
    104.            
    105.    
    106.             return mDb.insert(DATABASE_TABLE, null, initialValues);
    107.         }
    108.    
    109.         /**
    110.          * Delete the note with the given rowId
    111.          *
    112.          * @param rowId id of note to delete
    113.          * @return true if deleted, false otherwise
    114.          */
    115.         public boolean deleteNote(long rowId) {
    116.    
    117.             return mDb.delete(DATABASE_TABLE, KEY_ROWID + "=" + rowId, null) > 0;
    118.         }
    119.    
    120.         /**
    121.          * Return a Cursor over the list of all notes in the database
    122.          *
    123.          * @return Cursor over all notes
    124.          */
    125.         public Cursor fetchAllNotes() {
    126.    
    127.             return mDb.query(DATABASE_TABLE, new String[] {KEY_ROWID, KEY_TITLE,
    128.                     KEY_BODY,KEY_RATING}, null, null, null, null, null);
    129.         }
    130.    
    131.         /**
    132.          * Return a Cursor positioned at the note that matches the given rowId
    133.          *
    134.          * @param rowId id of note to retrieve
    135.          * @return Cursor positioned to matching note, if found
    136.          * @throws SQLException if note could not be found/retrieved
    137.          */
    138.         public Cursor fetchNote(long rowId) throws SQLException {
    139.    
    140.             Cursor mCursor =
    141.    
    142.                 mDb.query(true, DATABASE_TABLE, new String[] {KEY_ROWID,
    143.                         KEY_TITLE, KEY_BODY,KEY_RATING}, KEY_ROWID + "=" + rowId, null,
    144.                         null, null, null, null);
    145.             if (mCursor != null) {
    146.                 mCursor.moveToFirst();
    147.             }
    148.             return mCursor;
    149.    
    150.         }
    151.    
    152.         /**
    153.          * Update the note using the details provided. The note to be updated is
    154.          * specified using the rowId, and it is altered to use the title and body
    155.          * values passed in
    156.          *
    157.          * @param rowId id of note to update
    158.          * @param title value to set note title to
    159.          * @param body value to set note body to
    160.          * @return true if the note was successfully updated, false otherwise
    161.          */
    162.         public boolean updateNote(long rowId, String title, String body,Float rating) {
    163.             ContentValues args = new ContentValues();
    164.             args.put(KEY_TITLE, title);
    165.             args.put(KEY_BODY, body);
    166.             args.put(KEY_RATING, rating);
    167.    
    168.             return mDb.update(DATABASE_TABLE, args, KEY_ROWID + "=" + rowId, null) > 0;
    169.         }
    170.         private static void insertNotes(SQLiteDatabase db){
    171.            
    172.         }
    173.    
    174.     }

    Advertisement

Share This Page