Notepad3 Tutorial Adding a ratingbar


Last Updated:

  1. StefanKos

    StefanKos New Member This Topic's Starter

    Joined:
    Dec 3, 2011
    Messages:
    1
    Likes Received:
    0
    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

Loading...