We Keep Coding

How to Show SQLite table in Logcat

Database Helper
public class DatabaseHelper extends SQLiteOpenHelper {
// Table Name
public static final String TABLE_NAME = "Contacts";
// Table columns
public static final String ID = "ID";
public static final String Contact_Name = "Contact_Name";
public static final String Phone_Number = "Phone_Number";
public static final String Favourites = "Favourites";
// Database Information
static final String DB_NAME = "MessagePlus_Contacts";
// database version
static final int DB_VERSION = 1;
// Creating table query
private static final String CREATE_TABLE = "Create Table " + TABLE_NAME + "(" + ID
+ " INTEGER PRIMARY KEY AUTOINCREMENT, " + Contact_Name + " TEXT NOT NULL, " + Phone_Number + " INT NOT NULL, " + Favourites + " Boolean NOT NULL);";
private static final String Show_Table = "Select * From " + TABLE_NAME;
public DatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_TABLE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
onCreate(db);
}
public void showData(SQLiteDatabase db){db.execSQL(Show_Table);}
public void insertData(String contactName, String phoneNumber,String favourites) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(DatabaseHelper.Contact_Name, contactName);
values.put(DatabaseHelper.Phone_Number, phoneNumber);
values.put(DatabaseHelper.Favourites, favourites);
db.insert(DatabaseHelper.TABLE_NAME, null, values);
// close db connection
db.close();
}
public int addToFavourites(String favourites) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(DatabaseHelper.Favourites, favourites);
// updating row
return db.update(DatabaseHelper.TABLE_NAME, values, DatabaseHelper.Phone_Number + " = ?", new String[]{favourites});
}
public int getCount() {
String countQuery = "SELECT * FROM " + DatabaseHelper.TABLE_NAME;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery(countQuery, null);
int count = cursor.getCount();
cursor.close();
// return count
return count;
}
Modal
public class FavouritesHelper {
public String Name;
public String PhoneNumber;
public boolean Favourites;
public FavouritesHelper() {
}
public FavouritesHelper(String Name, String PhoneNumber, Boolean Favourites) {
this.Name = Name;
this.PhoneNumber = PhoneNumber;
this.Favourites = Favourites;
}
public String getName() {
return Name;
}
public void setName(String Name) {
this.Name = Name;
}
public String getPhoneNumber() {
return PhoneNumber;
}
public void setPhoneNumber(String PhoneNumber) {
this.PhoneNumber = PhoneNumber;
}
public boolean getFavourites() {
return Favourites;
}
public void setFavourites(boolean Favourites) {
this.Favourites = Favourites;
}
}
This is my database helper and I'm trying to fetch the table in logcat but I don't know how to do that. I know the code is Select * from <tablename> but how do i implement that. I want to see all the data in my table.

Soltion:
Please follow the following steps:
First Step:
Make the below method in DatabaseHelper class:
public List<FavouritesHelper> getAllData() {
List<FavouritesHelper> data = new ArrayList<>();
// Select All Query
String selectQuery = "SELECT * FROM " + FavouritesHelper.TABLE_NAME;
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(selectQuery, null);
// looping through all rows and adding to list
if (cursor.moveToFirst()) {
do {
FavouritesHelper alldata = new FavouritesHelper();
alldata.setName(cursor.getString(cursor.getColumnIndex(FavouritesHelper.Name)));
alldata.setPhoneNumber(cursor.getString(cursor.getColumnIndex(FavouritesHelper.PhoneNumber)));
alldata.setFavourites(cursor.getBoolean(cursor.getColumnIndex(FavouritesHelper.Favourites)));
data.add(alldata);
} while (cursor.moveToNext());
}
// close db connection
db.close();
// return notes list
return data;
}
Second Step:
In your activity:
declare a global object: List<FavouritesHelper> AllData inside your class.
Third Step:
then, add this AllData = new List<FavouritesHelper>(); in your onCreate()
Fourth Step:
write this in your activity after inserting data: AllData = database.getAllData();
Fifth Step:
Print it in log using below statement:
for(FavouritesHelper helper : AllData) {
Log.e("values : ", helper.getName() + ", " + helper.getPhoneNumber() + ", " + helper.getFavourites());
}
That's it.
Try it out. Hope it Helps.

As #pskink suggested you can use dumpCursor like this
create this method inside your DatabaseHelper class
public void dumpCursorInLogCat() {
//here first getting the readable database
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery(Show_Table, null);
//here is how you can Dump cursor
DatabaseUtils.dumpCursor(cursor);
cursor.close();
}
and call this method in your activity whenever you want to show data in logcat
call it inside your activity like
new DatabaseHelper(your_activity_name.this).dumpCursorInLogCat();

Android SQLite Database : Cannot resolve constructor

I am trying to create a simple SQLite database in android. I am following this tutorial. But the code gives this error "Cannot resolve constructor Contact()". Below is the code for DatabaseHandler.java. I have pointed out the line where the error occurs so it's easy to understand.
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
import java.util.List;
/**
* Created by Usama on 10/7/2017.
*/
public class DatabaseHandler extends SQLiteOpenHelper {
// Database Version
private static final int DATABASE_VERSION = 1;
// Database Name
private static final String DATABASE_NAME = "favouritesmanager";
// Contacts table name
private static final String TABLE_CONTACTS = "favourites";
// Contacts Table Columns names
private static final String KEY_ID = "id";
private static final String KEY_NAME = "name";
private static final String KEY_PH_NO = "phone_number";
private static final String KEY_ADRESS = "adress";
public DatabaseHandler(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
// Creating Tables
#Override
public void onCreate(SQLiteDatabase db) {
String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_CONTACTS + "("
+ KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT,"
+ KEY_PH_NO + " TEXT" + KEY_ADRESS + " TEXT" + ")";
db.execSQL(CREATE_CONTACTS_TABLE);
}
// Upgrading database
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// Drop older table if existed
db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACTS);
// Create tables again
onCreate(db);
}
// Adding new contact
public void addContact(Contact contact) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(KEY_NAME, contact.getName()); // Contact Name
values.put(KEY_PH_NO, contact.getPhoneNumber()); // Contact Phone Number
values.put(KEY_ADRESS, contact.getAdress()); //address
// Inserting Row
db.insert(TABLE_CONTACTS, null, values);
db.close(); // Closing database connection
}
// Getting All Contacts
public List<Contact> getAllContacts() {
List<Contact> contactList = new ArrayList<Contact>();
// Select All Query
String selectQuery = "SELECT * FROM " + TABLE_CONTACTS;
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.rawQuery(selectQuery, null);
// looping through all rows and adding to list
if (cursor.moveToFirst()) {
do {
Contact contact = new Contact(); <<<< HERE IS THE ERROR
contact.setID(Integer.parseInt(cursor.getString(0)));
contact.setName(cursor.getString(1));
contact.setPhoneNumber(cursor.getString(2));
contact.setAdress(cursor.getString(3));
// Adding contact to list
contactList.add(contact);
} while (cursor.moveToNext());
}
// return contact list
return contactList;
}
}
and here is the contact.java class
public class Contact {
int _id;
String _name;
String _phone_number;
String _adress;
// constructor
public Contact(int id, String name, String _phone_number, String adress){
this._id = id;
this._name = name;
this._phone_number = _phone_number;
this._adress = adress;
}
// constructor
public Contact(String name, String _phone_number, String adress){
this._name = name;
this._phone_number = _phone_number;
this._adress = adress;
}
// getting ID
public int getID(){
return this._id;
}
// setting id
public void setID(int id){
this._id = id;
}
// getting name
public String getName(){
return this._name;
}
// setting name
public void setName(String name){
this._name = name;
}
// getting phone number
public String getPhoneNumber(){
return this._phone_number;
}
// setting phone number
public void setPhoneNumber(String phone_number){
this._phone_number = phone_number;
}
//getting adress
public String getAdress(){
return this._adress;
}
//setting adress
public void setAdress(String adresstowrite){
this._adress = adresstowrite;
}
}
Any fixes for this error please?

Create empty constructor.
// Empty constructor
public Contact(){
}

Retrieve data from SQLite on android

I am trying to read data from SQLite in android using three parameters, id, name and date. For example, id="number" and name="something" and date between ("first date", "second date"). the problem is that, i cannot figure out what to do with the last function. There are two more parameters left and i dont know what to do or where to place it. So does anyone have any experience and familiar with this code style and can share or help me? (I take this code from book too and there was not any solution for related to this at all in the book.)
//Table person; It contain the same attribute as Person class
public static final class PersonTable
{
public static final String NAME = "Persons";
public static final class Cols
{
static final String ID = "id";
static final String NAME = "name";
static final String DATE = "date";
}
}
public class PersonCursorWrapper extends CursorWrapper
{
public PersonCursorWrapper(Cursor cursor)
{
super(cursor);
}
public Person getPerson()
{
int id = geIntI(getColumnIndex(PersonTable.Cols.ID));
String name = getString(getColumnIndex(PersonTable.Cols.NAME));
long date = getLong(getColumnIndex(PersonTable.Cols.DATE));
Person Person = new Person();
Person.id(id);
Person.setDate(new Date(date));
Person.setName(name);
return Person;
}
}
}
private PersonCursorWrapper queryPersons(String whereClause, String[] whereArgs)
{
Cursor cursor = mDatabase.query
(
PersonTable.NAME,
null,
whereClause,
whereArgs,
null,
null,
null
);
return new PersonCursorWrapper(cursor);
}
public Person getPerson(int id, String name, String date)
{
PersonCursorWrapper cursor = queryPersons(
PersonTable.Cols.ID + " = ?"+" "+
PersonTable.Cols.NAME + " = ?"+" "+
PersonTable.Cols.DATE + " = ?",
new String[] { id.toString() }
);
try
{
if (cursor.getCount() == 0)
{
return null;
}
cursor.moveToFirst();
return cursor.getPerson();
}
finally
{
cursor.close();
}
}

You have three parameter markers (?), so you have to give it three parameters:
cursor = queryPersons(
...,
new String[] { id.toString(), name, date }
);

For android sqlite database operations you can simply use SQLiteOpenHelper class provided with android.
This is a complete implementation for your case with SQLiteOpenHelper.
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import java.util.ArrayList;
import java.util.List;
public class DatabaseHandler2 extends SQLiteOpenHelper {
// Database details
private static final int DATABASE_VERSION = 1;
private static String DATABASE_NAME = "dbname.db";
// Table names
private static String TABLE_PERSON = "person";
// Table Columns name
private static final String COLUMN_ID = "workout_id";
private static final String COLUMN_NAME = "exercise_id";
// Create queries
private static final String CREATE_TABLE_PERSON = "CREATE TABLE " + TABLE_PERSON + "(" + COLUMN_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + COLUMN_NAME + " TEXT NOT NULL)";
public DatabaseHandler2(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_TABLE_PERSON);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS " + CREATE_TABLE_PERSON);
}
public Person getPerson(int id) {
Person person = new Person();
String selectQuery = "SELECT * FROM " + TABLE_PERSON + " WHERE " + COLUMN_ID + "=" + id;
SQLiteDatabase rdb;
rdb = this.getReadableDatabase();
Cursor cursor = rdb.rawQuery(selectQuery, null);
if (cursor.moveToFirst()) {
do {
person.setId(cursor.getInt(0));
person.setName(cursor.getString(1));
} while (cursor.moveToNext());
}
cursor.close();
rdb.close();
return person;
}
public List<Person> getAllPersons() {
List<Person> personList = new ArrayList<Person>();
String selectQuery = "SELECT * FROM " + TABLE_PERSON;
SQLiteDatabase rdb;
rdb = this.getReadableDatabase();
Cursor cursor = rdb.rawQuery(selectQuery, null);
if (cursor.moveToFirst()) {
do {
Person person = new Person();
person.setId(cursor.getInt(0));
person.setName(cursor.getString(1));
personList.add(person);
} while (cursor.moveToNext());
}
cursor.close();
rdb.close();
return personList;
}
public void savePerson(Person person) {
SQLiteDatabase wdb;
ContentValues values = new ContentValues();
values.put(COLUMN_ID, person.getId());
values.put(COLUMN_NAME, person.getName());
wdb = this.getWritableDatabase();
long rowId = wdb.insert(TABLE_PERSON, null, values);
wdb.close();
}
public void deletePerson(int id) {
SQLiteDatabase db = this.getWritableDatabase();
db.delete(TABLE_PERSON, COLUMN_ID + "='" + id + "'", null);
db.close();
}
public boolean renamePerson(int id, String newName) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(COLUMN_NAME, newName);
int numOfRowsEffected = db.update(TABLE_PERSON, values, COLUMN_ID + "='" + id + "'", null);
db.close();
return numOfRowsEffected > 0 ? true : false;
}
}
Here is the Person class
public class Person {
private int id;
private String name;
public Person() {
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

java.lang.NumberFormatException: Invalid int: "null"

The method getAllActivities() must return all activities from database in array list format
But I got: java.lang.NumberFormatException: Invalid int: "null",
at activity.setActivityType(Integer.parseInt(cursor.getString(1)));
I don't know what is wrong
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteStatement;
import com.yast.util.Constants;
import com.yast.util.Utils;
import java.util.ArrayList;
import java.util.List;
public class DatabaseHandler extends SQLiteOpenHelper {
private static final int DATABASE_VERSION = 1;
private static final String DATABASE_NAME = "YastDB.db";
// Activities table name
private static final String TABLE_ACTIVITIES = "Activities";
// Activities Table Columns names
private static final String KEY_ID = "id";
private static final String KEY_ACTIVITYTYPE = "ActivityType";
private static final String KEY_HARTRATE = "HartRate";
private static final String KEY_HARTBATNO = "HartBatNo";
private static final String KEY_DISTANCE = "Distance";
private static final String KEY_SPEED = "Speed";
private static final String KEY_STRIDES = "Strides";
private static final String KEY_STARTDATETIME = "StartDateTime";
private static final String KEY_ENDDATETIME = "EndDateTime";
public static final String KEY_CURRENTDATETIME = "CurrentDateTime";
private String[] PROJECTION = new String[]{ KEY_ID,
KEY_ACTIVITYTYPE, KEY_HARTRATE,KEY_HARTBATNO, KEY_DISTANCE,
KEY_SPEED,KEY_STRIDES,KEY_STARTDATETIME,KEY_ENDDATETIME
,KEY_CURRENTDATETIME};
public DatabaseHandler(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
// Creating Tables
#Override
public void onCreate(SQLiteDatabase db) {
String CREATE_Activitys_TABLE = "CREATE TABLE " + TABLE_ACTIVITIES + "("
+ KEY_ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
KEY_ACTIVITYTYPE + " INTEGER,"+
KEY_HARTRATE + " INTEGER, "+
KEY_HARTBATNO + " INTEGER,"+
KEY_DISTANCE + " INTEGER," +
KEY_SPEED + " INTEGER," +
KEY_STRIDES + " INTEGER," +
KEY_STARTDATETIME + " TEXT," +
KEY_ENDDATETIME + " TEXT," +
KEY_CURRENTDATETIME + " TEXT" +
")";
db.execSQL(CREATE_Activitys_TABLE);
}
// Upgrading database
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// Drop older table if existed
db.execSQL("DROP TABLE IF EXISTS " + TABLE_ACTIVITIES);
// Create tables again
onCreate(db);
}
//CRUD operations (Create, Read, Update and Delete)
// Adding new activity
public void addActivity(ActivityEntity activity) {
SQLiteDatabase db = this.getWritableDatabase();
ContentValues values = new ContentValues();
values.put(KEY_ACTIVITYTYPE, activity.getActivityType()); // Activity type
values.put(KEY_HARTRATE, activity.getHartRate());
values.put(KEY_HARTBATNO, activity.getHartBatNo());
values.put(KEY_DISTANCE, activity.getDistance());
values.put(KEY_SPEED, activity.getSpeed());
values.put(KEY_STRIDES, activity.getStrides());
values.put(KEY_STARTDATETIME,activity.getStartDateTime().toString());
values.put(KEY_ENDDATETIME, activity.getEndDateTime().toString());
values.put(KEY_CURRENTDATETIME, activity.getCurrentDateTime().toString());
// Inserting Row
db.insert(TABLE_ACTIVITIES, null, values);
db.close(); // Closing database connection
}
// Getting single Activity
/*
The following method getActivity() will read single contact row.
It accepts id as parameter and will return the matched row from the database.
*/
public ActivityEntity getActivity(int id) {
ActivityEntity activity = null;
SQLiteDatabase db = this.getReadableDatabase();
String where = KEY_ID + "=?";
String[] selectionArg = new String[]{String.valueOf(id)};
Cursor cursor = db.query(TABLE_ACTIVITIES, PROJECTION, where, selectionArg,
null, null, null, null);
if (cursor != null) {
cursor.moveToFirst();
activity = new ActivityEntity(Integer.parseInt(cursor.getString(0)),
Integer.parseInt(cursor.getString(1)),
Integer.parseInt(cursor.getString(2)),
Integer.parseInt(cursor.getString(3)),
Integer.parseInt(cursor.getString(4)),
Integer.parseInt(cursor.getString(5)),
Integer.parseInt(cursor.getString(6)),
cursor.getString(7),
cursor.getString(8),
cursor.getString(9));
}
return activity;
}
// Getting All Activities
public ArrayList<ActivityEntity> getAllActivitys() {
ArrayList<ActivityEntity> activitiesList = new ArrayList<ActivityEntity>();
SQLiteDatabase db = this.getWritableDatabase();
Cursor cursor = db.query(TABLE_ACTIVITIES, PROJECTION, null, null, null, null, null, null);
// looping through all rows and adding to list
if (cursor.moveToFirst()) {
do {
ActivityEntity activity = new ActivityEntity();
activity.setID(Integer.parseInt(cursor.getString(0)));
activity.setActivityType(Integer.parseInt(cursor.getString(1)));
activity.setHartRate(Integer.parseInt(cursor.getString(2)));
activity.setHartBatNo(Integer.parseInt(cursor.getString(3)));
activity.setDistance(Integer.parseInt(cursor.getString(4)));
activity.setSpeed(Integer.parseInt(cursor.getString(5)));
activity.setStrides(Integer.parseInt(cursor.getString(6)));
activity.setStartDateTime(cursor.getString(7));
activity.setEndDateTime(cursor.getString(8));
activity.set_currentDateTime(cursor.getString(9));
// Adding activity to list
activitiesList.add(activity);
} while (cursor.moveToNext());
}
return activitiesList;
}
public int getActivitiesCount() {
String countQuery = "SELECT * FROM " + TABLE_ACTIVITIES;
SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.rawQuery(countQuery, null);
cursor.close();
// return count
return cursor.getCount();
}
// Updating single Activity
public int updateActivity(ActivityEntity activity) {
SQLiteDatabase db = this.getWritableDatabase();
String where = KEY_ID + "=?";
ContentValues values = new ContentValues();
values.put(PROJECTION[1], activity.getActivityType());
values.put(PROJECTION[2], activity.getHartRate());
values.put(PROJECTION[3], activity.getHartBatNo());
values.put(PROJECTION[4], activity.getDistance());
values.put(PROJECTION[5], activity.getSpeed());
values.put(PROJECTION[6], activity.getStrides());
values.put(PROJECTION[7], activity.getStartDateTime().toString());
values.put(PROJECTION[8], activity.getEndDateTime().toString());
values.put(PROJECTION[9], activity.getCurrentDateTime().toString());
// updating row
return db.update(TABLE_ACTIVITIES, values, where, new String[] { String.valueOf(activity.getID()) });
}
public void deleteActivity(ActivityEntity activity)
{
String where = KEY_ID + "=?";
SQLiteDatabase db = this.getWritableDatabase();
db.delete(TABLE_ACTIVITIES, where,
new String[] { String.valueOf(activity.getID()) });
db.close();
}
public void bulkInsert(ArrayList<ActivityEntity> arrayOfActivities) {
SQLiteDatabase db = this.getWritableDatabase();
String sql = "INSERT INTO "+ TABLE_ACTIVITIES +" VALUES (?,?,?,?,?,?,?,?,?,?);";
SQLiteStatement statement = db.compileStatement(sql);
db.beginTransaction();
for (ActivityEntity a : arrayOfActivities ) {
statement.clearBindings();
statement.bindLong(1, (long) a.getID());
statement.bindLong(2, (long) a.getActivityType());
statement.bindLong(3, (long) a.getHartRate());
statement.bindLong(4, (long) a.getHartBatNo());
statement.bindLong(5, (long) a.getDistance());
statement.bindLong(6, (long) a.getSpeed());
statement.bindLong(7, (long) a.getStrides());
statement.bindString(8, a.getStartDateTime());
statement.bindString(9, a.getEndDateTime());
statement.bindString(10,a.getCurrentDateTime());
statement.clearBindings();
statement.execute();
}
db.setTransactionSuccessful();
db.endTransaction();
}
}
ActivityEntity.java calss:
import com.yast.util.Constants;
import com.yast.util.Utils;
import java.util.Date;
public class ActivityEntity {
int id;
int activityType;
int hartRate;
int hartBatNo;
int distance;
int speed;
int strides;
String startDateTime;
String endDateTime;
String currentDateTime;
public ActivityEntity(){
}
// constructor
public ActivityEntity(int Id, int activityType, int hartRate, int _hartBatNo, int distance, int speed, int strides, String startDateTime, String endDateTime, String currentDateTime){
this.id = Id;
this.activityType = activityType;
this.hartRate = hartRate;
this.hartBatNo = _hartBatNo;
this.distance = distance;
this.speed = speed;
this.strides = strides;
this.startDateTime = startDateTime;
this.endDateTime = endDateTime;
this.currentDateTime = currentDateTime;
}
public void setID(int id){
this.id = id;
}
public int getID(){
return this.id;
}
public void setActivityType(int activityType){
this.activityType = activityType;
}
public int getActivityType(){
return this.activityType;
}
public void setHartRate(int hartRate){
this.hartRate = hartRate;
}
public int getHartRate(){
return this.hartRate;
}
public void setHartBatNo(int hartBatNo){
this.hartBatNo = hartBatNo;
}
public int getHartBatNo(){
return this.hartBatNo;
}
public void setDistance(int distance){
this.distance = distance;
}
public int getDistance(){
return this.distance;
}
public void setSpeed(int speed){
this.speed = speed;
}
public int getSpeed(){
return this.speed;
}
public void setStrides(int strides){
this.strides = strides;
}
public int getStrides(){
return this.strides;
}
public void setStartDateTime(String startDateTime){
this.startDateTime = startDateTime;
}
public String getStartDateTime(){
return this.startDateTime;
}
public void setEndDateTime(String endDateTime){
this.endDateTime = endDateTime;
}
public String getEndDateTime(){
return this.endDateTime;
}
public void set_currentDateTime(String currentDateTime){
this.currentDateTime = currentDateTime;
}
public String getCurrentDateTime(){
return this.currentDateTime;
}
#Override
public String toString() {
return "ActivityEntity{" +
"id=" + id +
", activityType=" + activityType +
", hartRate=" + hartRate +
", hartBatNo=" + hartBatNo +
", distance=" + distance +
", speed=" + speed +
", strides=" + strides +
", startDateTime='" + startDateTime + '\'' +
", endDateTime='" + endDateTime + '\'' +
", currentDateTime='" + currentDateTime + '\'' +
'}';
}
}

in your code, if cursor.getString(int num) returns null, then Integer.parseInt(String str) will throw NumberFormatException.
To avoid this, you should have check for what the cursor.getString(int num) returns.
OR, you can use try-catch and print the appropriate message in catch if you'll get NumberFormatException.

You should check your cursor value is null or not.
if(cursor.isNull(column))
{
//Value is null
}else{
return cursor.getString(column);
}

Before you convert the value to Integer, you have to check whether the value is integer or not. If it is not an integer then replace it to default integer.
activity.setActivityType(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(1))));
activity.setActivityType(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(1))));
activity.setHartRate(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(2))));
activity.setHartBatNo(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(3))));
activity.setDistance(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(4))));
activity.setSpeed(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(5))));
activity.setStrides(Integer.parseInt(nulltoIntegerDefalt(cursor.getString(6))));
String nulltoIntegerDefalt(String value){
if(!isIntValue(value)) value="0";
return value;
}
boolean isIntValue(String val)
{
try {
val=val.replace(" ","");
Integer.parseInt(val);
} catch (Exception e) {return false;}
return true;
}

"null" isn't a valid int. Check for null first.

You need to be more careful checking for nullness:
1) cursor itself could be null
2) cursor.getString(1) could be null
Putting this together:
if (cursor != null && cursor.getString(1) != null){
/*your parse will be safe here*/
}
Note that I'm exploiting the fact that an if will evaluate from left to right and will stop evaluation once the result is known.
As an optimisation, you might want to store the result of cursor.getString(1) to prevent your having to evaluate this twice. But get the code working first.

Cursor cursor = db.query(TABLE_ACTIVITIES, PROJECTION, null, null, null, null, null, null);
Your SQL query string, the first null input in the query method, is null. You have not provided a query. I am assuming you want all columns from the table, so perhaps fill the query like:
String SQLSTATEMENT = "SELECT " + KEY_ID + "," + KEY_ACTIVITYTYPE + "," KEY_HARTRATE + "," KEY_HARTBATNO + "," KEY_DISTANCE + "," KEY_SPEED,KEY_STRIDES + "," KEY_STARTDATETIME + "," KEY_ENDDATETIM + "," KEY_CURRENTDATETIME;
Cursor cursor = db.query(TABLE_ACTIVITIES, PROJECTION, SQLSTATEMENT, null, null, null, null, null);

activity.setActivityType(Integer.parseInt(cursor.getString(1)));
in this cursor.getString(1) is getting null and That is why you are getting null pointer exception. Check for that String value.

The problem should be solved now, so I'm just solving the exception
An easier way is to change if(){}else{}" by "try{}catch(Exception e){}
Example :
try {
//Avoid/Éviter (FATAL EXCEPTION: main java.lang.NumberFormatException: Invalid int: "")
//exemple / Exemple d'action
int userWeight = Integer.parseInteger(userData);
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
intent.putExtra("weight", userWeight);
// control Toast/Toast de contrôle
Toast.makeText(MainActivity.this, "OK", Toast.LENGTH_LONG).show();
}
catch (Exception e) {
Toast.makeText(MainActivity.this, "not OK", Toast.LENGTH_LONG).show();
}

Thanks to #user3091530 answer. I have used my own ParsInt method.
Create a class named Math.
public class Math {
//Checking the value if null return zero
public int ParsIntOrDefalt(String value){
return Integer.parseInt(NullIntegerDefalt(value));
}
private String NullIntegerDefalt(String value) {
if (!isIntValue(value)) value = "0";
return value;
}
private boolean isIntValue(String val){
try {
val=val.replace(" ","");
Integer.parseInt(val);
} catch (Exception e) {return false;}
return true;
}
}
So, we can use it instead of the main Integer.parseInt() method:
Math math = new Math();
activity.setActivityType(math.ParsIntOrDefalt(cursor.getString(1)));

Adding a new field in SQLite in android

As I said before, im very much new to android and now i faced a very troubling poblem.
I have a database and i need to add a new field in the table. I don't know much of android and java..
So please guys, a little help will be appreciated...
Here's my code for the database:
public class MySQLiteHelper extends SQLiteOpenHelper {
public static final String TABLE_COMMENTS = "comments";
public static final String COLUMN_ID = "_id";
public static final String COLUMN_COMMENT = "comment";
private static final String DATABASE_NAME = "commments.db";
private static final int DATABASE_VERSION = 1;
// Database creation sql statement
private static final String DATABASE_CREATE = "create table "
+ TABLE_COMMENTS + "(" + COLUMN_ID
+ " integer primary key autoincrement, " + COLUMN_COMMENT
+ " text not null);";
public MySQLiteHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
#Override
public void onCreate(SQLiteDatabase database) {
database.execSQL(DATABASE_CREATE);
}
#Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(MySQLiteHelper.class.getName(),
"Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS " + TABLE_COMMENTS);
onCreate(db);
}
}
This is for the functions for the database:
public class CommentsDataSource {
// Database fields
private SQLiteDatabase database;
private MySQLiteHelper dbHelper;
private String[] allColumns = { MySQLiteHelper.COLUMN_ID,
MySQLiteHelper.COLUMN_COMMENT };
public CommentsDataSource(Context context) {
dbHelper = new MySQLiteHelper(context);
}
public void open() throws SQLException {
database = dbHelper.getWritableDatabase();
}
public void close() {
dbHelper.close();
}
public Comment createComment(String comment) {
ContentValues values = new ContentValues();
values.put(MySQLiteHelper.COLUMN_COMMENT, comment);
long insertId = database.insert(MySQLiteHelper.TABLE_COMMENTS, null,
values);
Cursor cursor = database.query(MySQLiteHelper.TABLE_COMMENTS,
allColumns, MySQLiteHelper.COLUMN_ID + " = " + insertId, null,
null, null, null);
cursor.moveToFirst();
Comment newComment = cursorToComment(cursor);
cursor.close();
return newComment;
}
public void deleteComment(Comment comment) {
long id = comment.getId();
System.out.println("Comment deleted with id: " + id);
database.delete(MySQLiteHelper.TABLE_COMMENTS, MySQLiteHelper.COLUMN_ID
+ " = " + id, null);
}
public List<Comment> getAllComments() {
List<Comment> comments = new ArrayList<Comment>();
Cursor cursor = database.query(MySQLiteHelper.TABLE_COMMENTS,
allColumns, null, null, null, null, null);
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Comment comment = cursorToComment(cursor);
comments.add(comment);
cursor.moveToNext();
}
// Make sure to close the cursor
cursor.close();
return comments;
}
private Comment cursorToComment(Cursor cursor) {
Comment comment = new Comment();
comment.setId(cursor.getLong(0));
comment.setComment(cursor.getString(1));
return comment;
}
}
and this is the other class which the above class uses:
public class Comment {
private long id;
private String comment;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getComment() {
return comment;
}
public void setComment(String comment) {
this.comment = comment;
}
// Will be used by the ArrayAdapter in the ListView
#Override
public String toString() {
return comment;
}
}
All this code works fine when I'm working with only one field(i.e. the comment) but
I want to add three new fields named: "Address", "Age", "Gender" and if possible change the DB name and i just can't seem to be able to alter it in the right way to get what i want.
Please tell me the right alterations needed.
PLEASE Help me on this!
Thanks in advance,
Waiting for your reply...

if possible change the DB name and i just can't seem to be able to
alter it in the right way to get what i want. Please tell me the right
alterations needed.
There are two ways:
implement correctly onUpgrade() method of SQLiteOpenHelper class (if you need update)
Just update your database class (modify DDL statement e.q. add new columns and change db
name if you want) and before install updated application to your device, delete
application's data (in device it's in settings under applications
manager). That will delete all data connected to your application
(databases, preferences, etc.)
Look at
Android: upgrading DB version and adding new table

Create new columns in table like this:
String Comment_table = String.format("CREATE TABLE %s " +
"(%s INTEGER PRIMARY KEY AUTOINCREMENT ," +
" %s TEXT , %s TEXT , %s TEXT ," +
" %s TEXT )",
Comment_Table,
Comment_ID ,
Comment , Address , Age ,
Gender );
(Here, Column names are Static String Declared as Class Variables).