Pull To Refresh

make layout main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical">

    <!--
      The PullToRefresh-ListView replaces a standard ListView widget,
      and has all the features android.widget.ListView has.
    -->
    <"your package name".sample.PullToRefreshListView
        android:id="@+id/pull_to_refresh_listview"
        android:layout_height="fill_parent"
        android:layout_width="fill_parent"
       
        android:background="@android:color/white"
        android:cacheColorHint="@android:color/white" />

</LinearLayout>


create layout name pull_to_refresh_header.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    style="@style/ptr_headerContainer" >
    <RelativeLayout
        android:id="@+id/header"
        style="@style/ptr_header" >
        <ImageView
            android:id="@+id/image"
            style="@style/ptr_arrow" />
        <ProgressBar
            android:id="@+id/spinner"
            style="@style/ptr_spinner" />
        <TextView
            android:id="@+id/text"
            style="@style/ptr_text" />
    </RelativeLayout>
</LinearLayout>

create layout name list_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/tv"
    android:layout_width="wrap_content"
    android:layout_height="fill_parent"
    android:textColor="@android:color/black"
    android:textSize="10pt"
    android:padding="5dp"
    android:background="@android:color/white"
    android:singleLine="true" />

create file under values folder name default_style.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <style name="ptr_headerContainer">
        <item name="android:layout_width">fill_parent</item>
        <item name="android:layout_height">0px</item>
        <item name="android:gravity">bottom</item>
    </style>
   
    <style name="ptr_header">
        <item name="android:layout_width">fill_parent</item>
        <item name="android:layout_height">wrap_content</item>
        <item name="android:padding">5dp</item>
    </style>
   
    <style name="ptr_arrow">
        <item name="android:layout_width">wrap_content</item>
        <item name="android:layout_height">wrap_content</item>
        <item name="android:layout_centerVertical">true</item>
        <item name="android:src">@drawable/ic_pulltorefresh_arrow</item>
        <item name="android:paddingLeft">25dp</item>
        <item name="android:paddingRight">25dp</item>
    </style>
   
    <style name="ptr_spinner" parent="@android:style/Widget.ProgressBar.Small">
        <item name="android:layout_width">wrap_content</item>
        <item name="android:layout_height">wrap_content</item>
        <item name="android:layout_centerVertical">true</item>
        <item name="android:indeterminate">true</item>
        <item name="android:paddingLeft">25dp</item>
        <item name="android:paddingRight">25dp</item>
    </style>
   
    <style name="ptr_text">
        <item name="android:layout_width">wrap_content</item>
        <item name="android:layout_height">wrap_content</item>
        <item name="android:layout_centerHorizontal">true</item>
        <item name="android:layout_centerVertical">true</item>
        <item name="android:textAppearance">?android:attr/textAppearanceMedium</item>
        <item name="android:textStyle">bold</item>
        <item name="android:textColor">@android:color/black</item>
    </style>
   
</resources>

put this below string in strings folder

<string name="ptr_pull_to_refresh">Pull to refresh</string>
    <string name="ptr_release_to_refresh">Release to refresh</string>
    <string name="ptr_refreshing">Refreshing</string>

create class name PullToRefreshListView.java

import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.ViewTreeObserver.OnGlobalLayoutListener;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.LinearInterpolator;
import android.view.animation.OvershootInterpolator;
import android.view.animation.RotateAnimation;
import android.view.animation.TranslateAnimation;
import android.widget.AdapterView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
import android.widget.RelativeLayout;
import android.widget.TextView;

/**
 * A generic, customizable Android ListView implementation that has 'Pull to Refresh' functionality.
 *
 * This ListView can be used in place of the normal Android android.widget.ListView class.
 *
 * Users of this class should implement OnRefreshListener and call setOnRefreshListener(..)
 * to get notified on refresh events. The using class should call onRefreshComplete() when
 * refreshing is finished.
 *
 * The using class can call setRefreshing() to set the state explicitly to refreshing. This
 * is useful when you want to show the spinner and 'Refreshing' text when the
 * refresh was not triggered by 'Pull to Refresh', for example on start.
 *
 * For more information, visit the project page:
 * https://github.com/erikwt/PullToRefresh-ListView
 *
 * @author Erik Wallentinsen <dev+ptr@erikw.eu>
 * @version 1.0.0
 */
public class PullToRefreshListView extends ListView{

    private static final float    PULL_RESISTANCE                    = 1.7f;
    private static final int    BOUNCE_ANIMATION_DURATION        = 700;
    private static final int    BOUNCE_ANIMATION_DELAY            = 100;
    private static final float    BOUNCE_OVERSHOOT_TENSION        = 1.4f;
    private static final int    ROTATE_ARROW_ANIMATION_DURATION    = 250;

    private static enum State{
        PULL_TO_REFRESH,
        RELEASE_TO_REFRESH,
        REFRESHING
    }

    /**
     * Interface to implement when you want to get notified of 'pull to refresh'
     * events.
     * Call setOnRefreshListener(..) to activate an OnRefreshListener.
     */
    public interface OnRefreshListener{
       
        /**
         * Method to be called when a refresh is requested
         */
        public void onRefresh();
    }

    private static int             measuredHeaderHeight;

    private float                previousY;
    private int                    headerPadding;
    private boolean                scrollbarEnabled;
    private boolean                bounceBackHeader;
    private boolean                lockScrollWhileRefreshing;
    private boolean             hasResetHeader;
    private String              pullToRefreshText;
    private String              releaseToRefreshText;
    private String              refreshingText;

    private State                state;
    private LinearLayout        headerContainer;
    private RelativeLayout        header;
    private RotateAnimation        flipAnimation;
    private RotateAnimation        reverseFlipAnimation;
    private ImageView            image;
    private ProgressBar            spinner;
    private TextView            text;
    private OnItemClickListener onItemClickListener;
    private OnRefreshListener    onRefreshListener;

   
    public PullToRefreshListView(Context context){
        super(context);
        init();
    }

    public PullToRefreshListView(Context context, AttributeSet attrs){
        super(context, attrs);
        init();
    }

    public PullToRefreshListView(Context context, AttributeSet attrs, int defStyle){
        super(context, attrs, defStyle);
        init();
    }
   
    @Override
    public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
        this.onItemClickListener = onItemClickListener;
    }

    /**
     * Activate an OnRefreshListener to get notified on 'pull to refresh'
     * events.
     *
     * @param onRefreshListener The OnRefreshListener to get notified
     */
    public void setOnRefreshListener(OnRefreshListener onRefreshListener){
        this.onRefreshListener = onRefreshListener;
    }

    /**
     * @return If the list is in 'Refreshing' state
     */
    public boolean isRefreshing(){
        return state == State.REFRESHING;
    }

    /**
     * Default is false. When lockScrollWhileRefreshing is set to true, the list
     * cannot scroll when in 'refreshing' mode. It's 'locked' on refreshing.
     *
     * @param lockScrollWhileRefreshing
     */
    public void setLockScrollWhileRefreshing(boolean lockScrollWhileRefreshing){
        this.lockScrollWhileRefreshing = lockScrollWhileRefreshing;
    }
   
    /**
     * Explicitly set the state to refreshing. This
     * is useful when you want to show the spinner and 'Refreshing' text when
     * the refresh was not triggered by 'pull to refresh', for example on start.
     */
    public void setRefreshing(){
        state = State.REFRESHING;
        scrollTo(0, 0);
        setUiRefreshing();
        setHeaderPadding(0);
    }

    /**
     * Set the state back to 'pull to refresh'. Call this method when refreshing
     * the data is finished.
     */
    public void onRefreshComplete(){
        state = State.PULL_TO_REFRESH;
        resetHeader();
    }

    /**
     * Change the label text on state 'Pull to Refresh'
     * @param pullToRefreshText Text
     */
    public void setTextPullToRefresh(String pullToRefreshText){
        this.pullToRefreshText = pullToRefreshText;
        if(state == State.PULL_TO_REFRESH){
            text.setText(pullToRefreshText);
        }
    }

    /**
     * Change the label text on state 'Release to Refresh'
     * @param releaseToRefreshText Text
     */
    public void setTextReleaseToRefresh(String releaseToRefreshText){
        this.releaseToRefreshText = releaseToRefreshText;
        if(state == State.RELEASE_TO_REFRESH){
            text.setText(releaseToRefreshText);
        }
    }

    /**
     * Change the label text on state 'Refreshing'
     * @param refreshingText Text
     */
    public void setTextRefreshing(String refreshingText){
        this.refreshingText = refreshingText;
        if(state == State.REFRESHING){
            text.setText(refreshingText);
        }
    }
   
    private void init(){
        setVerticalFadingEdgeEnabled(false);

        headerContainer = (LinearLayout) LayoutInflater.from(getContext()).inflate(R.layout.pull_to_refresh_header, null);
        header = (RelativeLayout) headerContainer.findViewById(R.id.header);
        text = (TextView) header.findViewById(R.id.text);
        image = (ImageView) header.findViewById(R.id.image);
        spinner = (ProgressBar) header.findViewById(R.id.spinner);

        pullToRefreshText = getContext().getString(R.string.ptr_pull_to_refresh);
        releaseToRefreshText = getContext().getString(R.string.ptr_release_to_refresh);
        refreshingText = getContext().getString(R.string.ptr_refreshing);

        flipAnimation = new RotateAnimation(0, -180, RotateAnimation.RELATIVE_TO_SELF, 0.5f, RotateAnimation.RELATIVE_TO_SELF, 0.5f);
        flipAnimation.setInterpolator(new LinearInterpolator());
        flipAnimation.setDuration(ROTATE_ARROW_ANIMATION_DURATION);
        flipAnimation.setFillAfter(true);

        reverseFlipAnimation = new RotateAnimation(-180, 0, RotateAnimation.RELATIVE_TO_SELF, 0.5f, RotateAnimation.RELATIVE_TO_SELF, 0.5f);
        reverseFlipAnimation.setInterpolator(new LinearInterpolator());
        reverseFlipAnimation.setDuration(ROTATE_ARROW_ANIMATION_DURATION);
        reverseFlipAnimation.setFillAfter(true);

        addHeaderView(headerContainer);
        setState(State.PULL_TO_REFRESH);
        scrollbarEnabled = isVerticalScrollBarEnabled();
       
        ViewTreeObserver vto = header.getViewTreeObserver();
        vto.addOnGlobalLayoutListener(new PTROnGlobalLayoutListener());

        super.setOnItemClickListener(new PTROnItemClickListener());
    }

    private void setHeaderPadding(int padding){
        headerPadding = padding;

        MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams) header.getLayoutParams();
        mlp.setMargins(0, padding, 0, 0);
        header.setLayoutParams(mlp);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event){
        if(lockScrollWhileRefreshing && state == State.REFRESHING){
            return true;
        }

        switch(event.getAction()){
            case MotionEvent.ACTION_DOWN:
                if(getFirstVisiblePosition() == 0) previousY = event.getY();
                else previousY = -1;
                break;

            case MotionEvent.ACTION_UP:
                if(previousY != -1 && (state == State.RELEASE_TO_REFRESH || getFirstVisiblePosition() == 0)){
                    switch(state){
                        case RELEASE_TO_REFRESH:
                            setState(State.REFRESHING);
                            bounceBackHeader();

                            break;

                        case PULL_TO_REFRESH:
                            resetHeader();
                            break;
                    }
                }
                break;

            case MotionEvent.ACTION_MOVE:
                if(previousY != -1){
                    float y = event.getY();
                    float diff = y - previousY;
                    if(diff > 0) diff /= PULL_RESISTANCE;
                    previousY = y;

                    int newHeaderPadding = Math.max(headerPadding + Math.round(diff), -header.getHeight());
                    if(!lockScrollWhileRefreshing && state == State.REFRESHING && newHeaderPadding > 0){
                        newHeaderPadding = 0;
                    }
                   
                    setHeaderPadding(newHeaderPadding);

                    if(state == State.PULL_TO_REFRESH && headerPadding > 0){
                        setState(State.RELEASE_TO_REFRESH);

                        image.clearAnimation();
                        image.startAnimation(flipAnimation);
                    }else if(state == State.RELEASE_TO_REFRESH && headerPadding < 0){
                        setState(State.PULL_TO_REFRESH);

                        image.clearAnimation();
                        image.startAnimation(reverseFlipAnimation);
                    }
                }

                break;
        }

        return super.onTouchEvent(event);
    }

    private void bounceBackHeader(){
        int yTranslate = state == State.REFRESHING ? -(headerContainer.getHeight() - header.getHeight()) : -headerContainer.getHeight();

        TranslateAnimation bounceAnimation = new TranslateAnimation(
                TranslateAnimation.ABSOLUTE, 0,
                TranslateAnimation.ABSOLUTE, 0,
                TranslateAnimation.ABSOLUTE, 0,
                TranslateAnimation.ABSOLUTE, yTranslate);

        bounceAnimation.setDuration(BOUNCE_ANIMATION_DURATION);
        bounceAnimation.setFillEnabled(true);
        bounceAnimation.setFillAfter(false);
        bounceAnimation.setFillBefore(true);
        bounceAnimation.setInterpolator(new OvershootInterpolator(BOUNCE_OVERSHOOT_TENSION));
        bounceAnimation.setAnimationListener(new HeaderAnimationListener());

        startAnimation(bounceAnimation);
    }

    private void resetHeader(){
        if(headerPadding == -header.getHeight() || getFirstVisiblePosition() > 0){
            setState(State.PULL_TO_REFRESH);
            return;
        }

        if(getAnimation() != null && !getAnimation().hasEnded()){
            bounceBackHeader = true;
        }else{
            bounceBackHeader();
        }
    }
   
    private void setUiRefreshing(){
        spinner.setVisibility(View.VISIBLE);
        image.clearAnimation();
        image.setVisibility(View.INVISIBLE);
        text.setText(refreshingText);
    }

    private void setState(State state){
        this.state = state;
        switch(state){
            case PULL_TO_REFRESH:
                spinner.setVisibility(View.INVISIBLE);
                image.setVisibility(View.VISIBLE);
                text.setText(pullToRefreshText);
                break;

            case RELEASE_TO_REFRESH:
                spinner.setVisibility(View.INVISIBLE);
                image.setVisibility(View.VISIBLE);
                text.setText(releaseToRefreshText);
                break;

            case REFRESHING:
                setUiRefreshing();

                if(onRefreshListener == null){
                    setState(State.PULL_TO_REFRESH);
                }else{
                    onRefreshListener.onRefresh();
                }

                break;
        }
    }
   
    @Override
    protected void onScrollChanged(int l, int t, int oldl, int oldt) {
        super.onScrollChanged(l, t, oldl, oldt);
       
        if(!hasResetHeader){
            if(measuredHeaderHeight > 0 && state != State.REFRESHING){
                setHeaderPadding(-measuredHeaderHeight);
            }
           
            hasResetHeader = true;
        }
    }

    private class HeaderAnimationListener implements AnimationListener{

        private int        height;
        private State    stateAtAnimationStart;

        @Override
        public void onAnimationStart(Animation animation){
            stateAtAnimationStart = state;

            android.view.ViewGroup.LayoutParams lp = getLayoutParams();
            height = lp.height;
            lp.height = getHeight() + headerContainer.getHeight();
            setLayoutParams(lp);

            if(scrollbarEnabled){
                setVerticalScrollBarEnabled(false);
            }
        }

        @Override
        public void onAnimationEnd(Animation animation){
            setHeaderPadding(stateAtAnimationStart == State.REFRESHING ? 0 : -header.getHeight());

            android.view.ViewGroup.LayoutParams lp = getLayoutParams();
            lp.height = height;
            setLayoutParams(lp);

            if(scrollbarEnabled){
                setVerticalScrollBarEnabled(true);
            }

            if(bounceBackHeader){
                bounceBackHeader = false;

                postDelayed(new Runnable(){

                    @Override
                    public void run(){
                        bounceBackHeader();
                    }
                }, BOUNCE_ANIMATION_DELAY);
            }else if(stateAtAnimationStart != State.REFRESHING){
                setState(State.PULL_TO_REFRESH);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation){}
    }
   
    private class PTROnGlobalLayoutListener implements OnGlobalLayoutListener{

        @Override
        public void onGlobalLayout() {
            int initialHeaderHeight = header.getHeight();
           
            if(initialHeaderHeight > 0){
                measuredHeaderHeight = initialHeaderHeight;
               
                if(measuredHeaderHeight > 0 && state != State.REFRESHING){
                    setHeaderPadding(-measuredHeaderHeight);
                    requestLayout();
                }
            }
           
            getViewTreeObserver().removeGlobalOnLayoutListener(this);
        }
    }
   
    private class PTROnItemClickListener implements OnItemClickListener{

        @Override
        public void onItemClick(AdapterView<?> adapterView, View view, int position, long id) {
            hasResetHeader = false;
           
            if(onItemClickListener != null){
                onItemClickListener.onItemClick(adapterView, view, position, id);
            }
        }
    }
}
 

 create other new class name PullToRefreshListViewSampleActivity.java

import java.util.ArrayList;

import android.app.Activity;
import android.os.Bundle;
import android.widget.ArrayAdapter;
import eu.erikw.pulltorefresh.sample.PullToRefreshListView;
import eu.erikw.pulltorefresh.sample.PullToRefreshListView.OnRefreshListener;

public class PullToRefreshListViewSampleActivity extends Activity {
   
    private static ArrayList<String> items;
    static
    {
        items = new ArrayList<String>();
      
        items.add("Android");
        items.add("Blackberry");
        items.add("I-phone");
        items.add("Samsung");
        items.add("Nokia");
        items.add("Micromax");
        items.add("Sony");
        items.add("Relience");
    }
   
    private PullToRefreshListView listView;
   
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
       
        listView = (PullToRefreshListView) findViewById(R.id.pull_to_refresh_listview);
       
        // Set the onRefreshListener on the list. You could also use
        // listView.setOnRefreshListener(this); and let this Activity
        // implement OnRefreshListener.
        listView.setOnRefreshListener(new OnRefreshListener() {
          
            @Override
            public void onRefresh()
            {
                // Your code to refresh the list contents goes here

                // Make sure you call listView.onRefreshComplete()
                // when the loading is done. This can be done from here or any
                // other place, like on a broadcast receive from your loading
                // service or the onPostExecute of your AsyncTask.

                // For the sake of this sample, the code will pause here to
                // force a delay when invoking the refresh
                listView.postDelayed(new Runnable() {
                  
                    @Override
                    public void run() {
                        listView.onRefreshComplete();
                    }
                }, 2000);
            }
        });
       
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, R.layout.list_item, items);
        listView.setAdapter(adapter);
    }
}
 

Create Alarm Service for before time

At your main activity

Intent intent = new Intent(context, AlaramService.class);
                        intent.putExtra("startdate", strmysdate);
                        intent.putExtra("rem_hr", setreminderhrs);
                        intent.putExtra("rem_min", setremindermin);
                        intent.putExtra("alarmstart_eventid", myeventid);
                        context.startService(intent);

create service name AlaramService

public class AlaramService extends Service{
   
   
    private static final String tag = AlaramService.class.getSimpleName();
    String taskdate,tasktime,user_id,startdatetime,sdate,edate,upeventid,myhr,mymin,eventidfromactive;
    Calendar calCurrent = Calendar.getInstance();
    UpcomingEventParser upcomingeventparser;
    UpcomingEventSetget upcomingeventsetget;
    List<UpcomingEventSetget> upcomingsetgetlist;
     public static AlarmManager mAlarmManager;
     public static PendingIntent pendingintentbeforemin;
    long hrs,min;
   
    @Override
    public void onStart(Intent intent, int startId) {
        // TODO Auto-generated method stub
        super.onStart(intent, startId);
      
        try{
          
        if(null != intent.getExtras()){
            if(intent.getExtras().containsKey("startdate")){
                startdatetime = intent.getExtras().getString("startdate");      
            }if(intent.getExtras().containsKey("alarmstart_eventid")){
                upeventid = intent.getExtras().getString("alarmstart_eventid");      
            }if(intent.getExtras().containsKey("rem_hr")){
                myhr = intent.getExtras().getString("rem_hr");      
            }if(intent.getExtras().containsKey("rem_min")){
                mymin = intent.getExtras().getString("rem_min");      
            }
          
            Utility.setSharedKey("startdate", startdatetime, AlaramService.this);
            Utility.setSharedKey("alarmstart_eventid", upeventid, AlaramService.this);
            Utility.setSharedKey("rem_hr", myhr, AlaramService.this);
            Utility.setSharedKey("rem_min", mymin, AlaramService.this);
        }else{
            startdatetime = Utility.getSharedKey("startdate", AlaramService.this);
            upeventid = Utility.getSharedKey("alarmstart_eventid", AlaramService.this);
            myhr = Utility.getSharedKey("rem_hr", AlaramService.this);
            mymin = Utility.getSharedKey("rem_min", AlaramService.this);
          
            if(upeventid == null){
                upeventid = AddEvent.myeventid;
            }if(startdatetime == null){
                startdatetime = AddEvent.strmysdate;
            }if(myhr == null){
                myhr = AddEvent.setreminderhrs;
            }if(mymin == null){
                mymin = AddEvent.setremindermin;
            }
        }
      
        Log.i(tag, "Get Event id.."+upeventid);
        Log.i(tag, "Get Start date.."+startdatetime);
        Log.i(tag, "myhr.."+myhr);
        Log.i(tag, "mymin.."+mymin);
        }catch(Exception e){
            e.printStackTrace();
        }
        new AsyncTask<Void, Void, Void> (){
            @Override
            protected Void doInBackground(Void... params) {
                updateNotofications();  
                return null;
            }
         }.execute();
    }

    private void updateNotofications() {
      
        try{
        String[] minis = null;
        String[] hris = null;
        Log.d(tag, "updateNotofications for start time");
        SimpleDateFormat mDateFormat = new  SimpleDateFormat("MM-dd-yyyy HH:mm");
        if(myhr != null){
            hris = myhr.split(" ");  
            if(hris != null){
                hrs = Integer.parseInt(hris[0].toString()) * 60 * 60 * 1000;  
            }
        }if(mymin != null){
            minis = mymin.split(" ");
            if(minis != null){
                min = Integer.parseInt(minis[0].toString()) * 60 * 1000;  
            }
        }
      
        //long min = 2 * 60 * 1000;
        long oneDay = 24 * 60 * 60 * 60 * 1000;
      
            Calendar calDb = Calendar.getInstance();
            calDb.setTime(mDateFormat.parse(startdatetime));
            long diff = calDb.getTimeInMillis() - calCurrent.getTimeInMillis();
      
            if(diff < oneDay && diff >= 0) {
              
                Intent mIntent = new Intent(this, NotificationService1.class);
                mIntent.putExtra("event_id", upeventid);
                mIntent.putExtra("reminder_min",minis[0].toString());
                mIntent.putExtra("reminder_hr",hris[0].toString());
                mIntent.putExtra("event_from", "start");

                 mAlarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
              
              
                long diffr  = calCurrent.getTimeInMillis() + diff-(hrs+min);
                System.out.println("d is...."+diffr);
          
                long cur = calCurrent.getTimeInMillis();
                System.out.println("calcurrent is..."+cur);
              
                if(cur < diffr)
                {
                    pendingintentbeforemin = PendingIntent.getService(getApplicationContext(), Integer.parseInt(upeventid), mIntent, PendingIntent.FLAG_ONE_SHOT);
                    mAlarmManager.set(AlarmManager.RTC_WAKEUP, calCurrent.getTimeInMillis() + diff-(hrs+min),  pendingintentbeforemin);
                    System.out.println("Alarm set for start " + startdatetime);
                }
            }
          
        }catch(Exception e){
            e.printStackTrace();
        }

        stopSelf();
    }

    @Override
    public IBinder onBind(Intent arg0) {
        // TODO Auto-generated method stub
        return null;
    }

   
}
 

create service name NotificationService1

public class NotificationService1 extends Service{

    //private int upeventid;
    String eventfrom,eventhr,eventmin,activeeventid,upeventid;
    CharSequence contentText,contentTitle;
   
    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        System.out.println("NotificationService1 is started");

    }
   
    @Override
    public void onStart(Intent intent, int startId) {
        // TODO Auto-generated method stub
        super.onStart(intent, startId);
      
        try{
        upeventid = intent.getExtras().getString("event_id");
        eventhr = intent.getExtras().getString("reminder_hr");
        eventmin = intent.getExtras().getString("reminder_min");
        eventfrom = intent.getStringExtra("event_from");
        activeeventid = Utility.getSharedKey("curentevntis", NotificationService1.this);
      
        Log.i("Notification Srevice", "activeeventid.."+activeeventid);
        Log.i("Notification Srevice", "Get hr is.."+eventhr);
        Log.i("Notification Srevice", "Get min is.."+eventmin);
        Log.i("Notification Srevice", "Get upeventid is.."+upeventid);
        Log.i("Notification Srevice", "Get eventfrom is.."+eventfrom);
      
      
        if (upeventid.equalsIgnoreCase("-1")) {
            stopSelf();
            return;
        } else {
          
            if(!TextUtils.isEmpty(eventfrom)){
                if(eventfrom.equalsIgnoreCase("start")){
                    if(!TextUtils.isEmpty(eventhr)){
                        if(!TextUtils.isEmpty(eventmin)){
                            createNotification();      
                        }
                    }  
                }else{
                    if(upeventid.equalsIgnoreCase(activeeventid)){
                        createNotification();  
                    }
                }
            }
            stopSelf();
        }
      
        }catch(Exception e){
            e.printStackTrace();
        }
    }
   
    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return null;
    }
   
    private void createNotification(){
        System.out.println("createNotification");
      
        NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        int icon = R.drawable.tixeappicon;
        CharSequence tickerText = getString(R.string.app_name);
      
        Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
        vibrator.vibrate(new long[] { 0, 1000, 200, 1000 }, -1);
      
        Notification notification = new Notification(icon, tickerText,
                System.currentTimeMillis());
        notification.flags |= Notification.FLAG_AUTO_CANCEL;

        Intent notificationIntent = new Intent(NotificationService1.this,UpcomingEvent.class);
        Intent notificationIntentactive = new Intent(NotificationService1.this,ActiveEvents.class);
      
         contentTitle = "Title";
        if(!TextUtils.isEmpty(eventfrom)){
            if(eventfrom.equalsIgnoreCase("start")){
                Log.i("Notification Service", "Event from Start event service");
                if(eventhr.equalsIgnoreCase("0")){
                    contentText = "Your event Starts with in next "+eventmin+" minutes";
                }else{
                    contentText = "Your event Starts with in next "+eventhr+":"+eventmin+" minutes";
                }
            }else{
            Log.i("Notification Service", "Event from End event service");
                 contentText = "Your event ends with in next 10 minutes";
        }
        }
      
        if(eventfrom.equalsIgnoreCase("start")){
            PendingIntent contentIntent = PendingIntent.getActivity(this, Integer.parseInt(upeventid),notificationIntent, 0);
            notification.setLatestEventInfo(this, contentTitle, contentText,contentIntent);
            mNotificationManager.notify(Integer.parseInt(upeventid), notification);
        }else{
            PendingIntent contentIntent = PendingIntent.getActivity(this, Integer.parseInt(upeventid),notificationIntentactive, 0);
            notification.setLatestEventInfo(this, contentTitle, contentText,contentIntent);
            mNotificationManager.notify(Integer.parseInt(upeventid), notification);
        }
      
    }

}
 

Crop Image

Intent for getting image from captured image

 Intent intent      = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    mImageCaptureUri = Uri.fromFile(new File(Environment.getExternalStorageDirectory(),
                                       "MyImage_" + String.valueOf(System.currentTimeMillis()) + ".jpg"));
                    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, mImageCaptureUri);
                    try {
                        intent.putExtra("return-data", true);
                        startActivityForResult(intent, CAMERA_RESULT);
                    } catch (ActivityNotFoundException e) {
                        e.printStackTrace();
                    }

Intent for getting image from sd card image

try {
                    Intent intent = new Intent();
                    intent.setType("image/*");
                    intent.setAction(Intent.ACTION_GET_CONTENT);
                    startActivityForResult(Intent.createChooser(intent, "Complete action using"), RESULT_LOAD_IMAGE);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }


then onActivityResult code

private static final int RESULT_LOAD_IMAGE = 101;
    private static final int CAMERA_RESULT = 102;
    private static final int CROP_FROM_CAMERA = 103;

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // TODO Auto-generated method stub
        super.onActivityResult(requestCode, resultCode, data);

        switch (requestCode) {
        case CAMERA_RESULT:
            try{
                doCrop();
            }catch(Exception e){
                e.printStackTrace();
            }
            break;

        case RESULT_LOAD_IMAGE:
            try{
                mImageCaptureUri = data.getData();
                doCrop();
            }catch(Exception e){
                e.printStackTrace();
            }
            break;          

        case CROP_FROM_CAMERA:    
          
            try{
                Bundle extras = data.getExtras();

                if (extras != null) {              
                     photo = extras.getParcelable("data");

                  
                    imguser.setImageBitmap(photo);
                    imguser.setBackgroundColor(getResources().getColor(R.color.transparent));
                }

                File f = new File(mImageCaptureUri.getPath());  
                Log.i(tag, "Get Image uri file........"+f);
                selectedImagePath = f.getAbsolutePath();
                Log.i(tag, "Get Absolute image path........"+selectedImagePath);
                if (f.exists()) f.delete();
              
                boolean success = false;
                if(photo != null){
                    Log.i(tag, "Bitmap.........."+photo);
                    try {
                        byte[] bitmapdata;
                        ByteArrayOutputStream stream = new ByteArrayOutputStream();
                        photo.compress(Bitmap.CompressFormat.JPEG, 90, stream);
                        bitmapdata = stream.toByteArray();

                        if (bitmapdata != null) {
                            MyWrite(bitmapdata);
                            success = true;
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                        success = false;
                    }
                }
                if (success) {
                     Log.i(tag, "Image Saved Successfully");
                    } else {
                        Log.i(tag, "Error during image saving");
                    }  
            }catch(Exception e){
                e.printStackTrace();
            }
            break;
        }
    }  

Crop function

private Uri mImageCaptureUri;
Bitmap photo;
ImageView imguser;
String selectedImagePath
 

     private void doCrop() {
            final ArrayList<CropOption> cropOptions = new ArrayList<CropOption>();
          
            Intent intent = new Intent("com.android.camera.action.CROP");
            intent.setType("image/*");
          
            List<ResolveInfo> list = getPackageManager().queryIntentActivities( intent, 0 );
          
            int size = list.size();
          
            if (size == 0) {          
                //Toast.makeText(this, "Can not find image crop app", Toast.LENGTH_SHORT).show();
              
                return;
            } else {
                intent.setData(mImageCaptureUri);
              
                intent.putExtra("outputX", 200);
                intent.putExtra("outputY", 200);
                intent.putExtra("aspectX", 1);
                intent.putExtra("aspectY", 1);
                intent.putExtra("scale", true);
                intent.putExtra("return-data", true);
              
                if (size == 1) {
                    Intent i         = new Intent(intent);
                    ResolveInfo res    = list.get(0);

                    i.setComponent( new ComponentName(res.activityInfo.packageName, res.activityInfo.name));

                    startActivityForResult(i, CROP_FROM_CAMERA);
                } else {
                    for (ResolveInfo res : list) {
                        final CropOption co = new CropOption();

                        co.title     = getPackageManager().getApplicationLabel(res.activityInfo.applicationInfo);
                        co.icon        = getPackageManager().getApplicationIcon(res.activityInfo.applicationInfo);
                        co.appIntent= new Intent(intent);

                        co.appIntent.setComponent( new ComponentName(res.activityInfo.packageName, res.activityInfo.name));

                        cropOptions.add(co);
                    }

                    CropOptionAdapter adapter = new CropOptionAdapter(getApplicationContext(), cropOptions);

                    AlertDialog.Builder builder = new AlertDialog.Builder(this);
                    builder.setTitle("Choose Crop App");
                    builder.setAdapter( adapter, new DialogInterface.OnClickListener() {
                        public void onClick( DialogInterface dialog, int item ) {
                            startActivityForResult( cropOptions.get(item).appIntent, CROP_FROM_CAMERA);
                        }
                    });

                    builder.setOnCancelListener( new DialogInterface.OnCancelListener() {
                        @Override
                        public void onCancel( DialogInterface dialog ) {

                            if (mImageCaptureUri != null ) {
                                getContentResolver().delete(mImageCaptureUri, null, null );
                                mImageCaptureUri = null;
                            }
                        }
                    } );

                    AlertDialog alert = builder.create();

                    alert.show();
                }
            }
        }

    public void MyWrite(byte[] buffer) {
        System.gc();
        File sdCard = Environment.getExternalStorageDirectory();
        File directory = new File(sdCard.getAbsolutePath() + "/MyImage");
        directory.mkdirs();
        // Now create the file in the above directory and write the contents
        // into it
        System.out.println("Image path=" + selectedImagePath);
        File file;
        file = new File(directory, currentDateandTime + ".jpg");

        // File file = new File(directory, "sample.jpg");
        selectedImagePath = file.getAbsolutePath();
        System.out.println("Path=" + selectedImagePath);

        try {
            if (!file.exists())
                file.createNewFile();
        } catch (IOException e2) {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }

        FileOutputStream fOut = null;
        try {
            fOut = new FileOutputStream(file);
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        BufferedOutputStream osw = new BufferedOutputStream(fOut);
        try {
            // osw.write(path);
            osw.write(buffer);
            // osw.write(buffer, offset, length);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            osw.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            osw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Saving Image path URL into SD Card

When you get image path from web url and want to store it on sd card then

Bitmap bitmap;

when you get image path do this code
(get bitmap from image path)

bitmap = DownloadImage(streventphoto); 

private Bitmap DownloadImage(String URL)
    {      
        Bitmap bitmap = null;
        InputStream in = null;      
        try {
            if(!TextUtils.isEmpty(URL)){
                in = OpenHttpConnection(URL);
                bitmap = BitmapFactory.decodeStream(in);
                in.close();   
            }
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        //http://demo.me/demo/upload/bevent/768/20130422133939.jpg
        return bitmap;              
    }

private InputStream OpenHttpConnection(String urlString)
        throws IOException
        {
            InputStream in = null;
            int response = -1;
                   
            URL url = new URL(urlString);
            URLConnection conn = url.openConnection();
                     
            if (!(conn instanceof HttpURLConnection))                   
                throw new IOException("Not an HTTP connection");
            
            try{
                HttpURLConnection httpConn = (HttpURLConnection) conn;
                httpConn.setAllowUserInteraction(false);
                httpConn.setInstanceFollowRedirects(true);
                httpConn.setRequestMethod("GET");
                httpConn.connect();
   
                response = httpConn.getResponseCode();               
                if (response == HttpURLConnection.HTTP_OK) {
                    in = httpConn.getInputStream();                               
                }                   
            }
            catch (Exception ex)
            {
                throw new IOException("Error connecting");          
            }
            return in;   
        }



 now saving image


if(streventphoto.contains("mnt")){
                        // your image path is from sd card
                    }else{
                        boolean success = false;
                        if(bitmap != null){
                            Log.i(tag, "Bitmap.........."+bitmap);
                            try {
                                byte[] bitmapdata;
                                ByteArrayOutputStream stream = new ByteArrayOutputStream();
                                bitmap.compress(Bitmap.CompressFormat.JPEG, 90, stream);
                                bitmapdata = stream.toByteArray();

                                if (bitmapdata != null) {
                                    MyWrite(bitmapdata);
                                    success = true;
                                }

                            } catch (Exception e) {
                                e.printStackTrace();
                                success = false;
                            }
                        }
                        if (success) {
                             Log.i(tag, "Image Saved Successfully");
                            } else {
                                Log.i(tag, "Error during image saving");
                            }  
                    }


this is the function  MyWrite

String currentDateandTime;

    public void MyWrite(byte[] buffer) {
       
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
        currentDateandTime = sdf.format(new Date());
        System.gc();
        File sdCard = Environment.getExternalStorageDirectory();
        File directory = new File(sdCard.getAbsolutePath() + "/MyImage");
        directory.mkdirs();
        // Now create the file in the above directory and write the contents
        // into it
        System.out.println("Image path=" + streventphoto);
        File file;
        file = new File(directory, currentDateandTime + ".jpg");

        // File file = new File(directory, "sample.jpg");
        streventphoto = file.getAbsolutePath();
        System.out.println("Path=" + streventphoto);

        try {
            if (!file.exists())
                file.createNewFile();
        } catch (IOException e2) {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }

        FileOutputStream fOut = null;
        try {
            fOut = new FileOutputStream(file);
        } catch (FileNotFoundException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        BufferedOutputStream osw = new BufferedOutputStream(fOut);
        try {
            // osw.write(path);
            osw.write(buffer);
            // osw.write(buffer, offset, length);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            osw.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            osw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

Working with SQLite Database

Create class name TaskDatabaseHelper for creating database and table

import org.groundme.general.General;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

public class TaskDatabaseHelper extends SQLiteOpenHelper {

    public static final String TAG = "TaskDatabaseHelper";
    public static final String DATABASE_NAME = "MyTask.db";
    public static final int DATABASE_VERSION = 9;

    public static final String TABLE_NAME = "tasklist";
    public static String ID="id";
    public static final String TASK_TITLE = "task_title";
    public static final String TASK_DESC = "task_desc";
    public static final String TASK_DATE = "task_date";
    public static final String TASK_TIME = "task_time";
    public static final String TASK_LOCATION = "task_location";
    public static final String TASK_LAT = "task_lat";
    public static final String TASK_LNG = "task_lng";
    public static final String TASK_STATUS = "status";
    public static final String TASK_TLBASE = "timeloc_base";
    public static final String TASK_DURATION = "task_duration";
   
    private static final String DATABASE_CREATE = "create table " + TABLE_NAME + "(" +
            ID + " integer primary key autoincrement ," +
            TASK_TITLE + " text," +
            TASK_DESC + " text," +
            TASK_DATE + " text," +
            TASK_TIME + " text," +
            TASK_LOCATION + " text ," +
            TASK_LAT + " text ," +
            TASK_LNG + " text ," +
            TASK_STATUS + " text ," +
            TASK_TLBASE + " INTEGER default 0," +
            TASK_DURATION + " text)";

    public TaskDatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        // TODO Auto-generated constructor stub
        Log.i(General.TAG, TAG + "constructer");
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        // TODO Auto-generated method stub
        Log.i(General.TAG, TAG + "oncreate");
        db.execSQL(DATABASE_CREATE);
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // TODO Auto-generated method stub
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
        onCreate(db);
    }
}
 

create class name TaskData for other operations

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.groundme.data.Task;
import org.groundme.general.General;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

public class TaskData {

    public static final String TAG = "TaskData";
    private TaskDatabaseHelper taskdbhelper;
    private SQLiteDatabase sqlitedb;
//    Integer id;

    private String[] taskcol = {TaskDatabaseHelper.ID,TaskDatabaseHelper.TASK_TITLE,
            TaskDatabaseHelper.TASK_DESC, TaskDatabaseHelper.TASK_DATE,
            TaskDatabaseHelper.TASK_TIME, TaskDatabaseHelper.TASK_LOCATION, TaskDatabaseHelper.TASK_LAT,
            TaskDatabaseHelper.TASK_LNG,TaskDatabaseHelper.TASK_STATUS,TaskDatabaseHelper.TASK_TLBASE};

   
    String[] MyCol = { TaskDatabaseHelper.TASK_TIME };

    public TaskData(Context ctx) {
        Log.i(General.TAG, TAG + "TaskData");
        taskdbhelper = new TaskDatabaseHelper(ctx);
    }

    public void open() throws SQLException {

        Log.i(General.TAG, TAG + "open");
        if (sqlitedb == null) {          
            sqlitedb = taskdbhelper.getWritableDatabase();
        }
    }

    public void createTask(String title, String description, String date,
            String time, String location,String lat,String lng,String datetimeloc) {

        Log.i(General.TAG, TAG + "create task for insert ");
        ContentValues contentvalue = new ContentValues();

        contentvalue.put(TaskDatabaseHelper.TASK_TITLE, title);
        contentvalue.put(TaskDatabaseHelper.TASK_DESC, description);
        contentvalue.put(TaskDatabaseHelper.TASK_DATE, date);
        contentvalue.put(TaskDatabaseHelper.TASK_TIME, time);
        contentvalue.put(TaskDatabaseHelper.TASK_LOCATION, location);
        contentvalue.put(TaskDatabaseHelper.TASK_LAT, lat);
        contentvalue.put(TaskDatabaseHelper.TASK_LNG, lng);
        contentvalue.put(TaskDatabaseHelper.TASK_STATUS, "true");
        contentvalue.put(TaskDatabaseHelper.TASK_TLBASE, datetimeloc);
    //    contentvalue.put(TaskDatabaseHelper.TASK_DURATION, duration);
      
   
      
        sqlitedb.insert(TaskDatabaseHelper.TABLE_NAME, null, contentvalue);
        Log.i(General.TAG, TAG + "insert complete");

    }

    public void updateStatus(String id, String status) {
        ContentValues contentvalue = new ContentValues();
        contentvalue.put(TaskDatabaseHelper.TASK_STATUS, status);
      
        sqlitedb.update(TaskDatabaseHelper.TABLE_NAME, contentvalue, TaskDatabaseHelper.ID + "=?", new String[]{id});
        Log.i(General.TAG, TAG + "updateStatus for id="+ id + " status set to " + status);

    }


    public void update(Integer id,String utitle,String udesc,String udate,String utime,String uloc,String ulat,String ulng,String ustatus,String udatetimeloc)
    {
        Log.i(General.TAG, TAG + "update start...");

        ContentValues cv = new ContentValues();
        cv.put(TaskDatabaseHelper.TASK_TITLE, utitle);
        cv.put(TaskDatabaseHelper.TASK_DESC, udesc);
        cv.put(TaskDatabaseHelper.TASK_DATE, udate);
        cv.put(TaskDatabaseHelper.TASK_TIME, utime);
        cv.put(TaskDatabaseHelper.TASK_LOCATION, uloc);
        cv.put(TaskDatabaseHelper.TASK_LAT, ulat);
        cv.put(TaskDatabaseHelper.TASK_LNG, ulng);
        cv.put(TaskDatabaseHelper.TASK_STATUS, ustatus);
        cv.put(TaskDatabaseHelper.TASK_TLBASE, udatetimeloc);
        //cv.put(TaskDatabaseHelper.TASK_DURATION, dur);
      
        String whered= "id" + "=" + id;
        sqlitedb.update(TaskDatabaseHelper.TABLE_NAME, cv, whered , null);

        Log.i(General.TAG, TAG + "update end...");
    }


    public void deleteTask(String id)
    {
        Log.i("delete task", "Delete Task");
        long idis = Long.parseLong(id);      
        System.out.println("Sqlite database id is............."+idis);
        sqlitedb.delete(TaskDatabaseHelper.TABLE_NAME, TaskDatabaseHelper.ID + " = " + idis, null);
              
    }
   
    private Task cursorTotask(Cursor cursor) {

        Log.i(General.TAG, TAG + "cursortotask");

        Task task = new Task();
        task.setId(cursor.getInt(cursor.getColumnIndex("id")));
        //task.setId(cursor.getInt(0));
        task.setTtile(cursor.getString(1));
        task.setDescription(cursor.getString(2));
        task.setDate(cursor.getString(3));
        task.setTime(cursor.getString(4));
        task.setLocation(cursor.getString(5));
        task.setLang(cursor.getString(7));
        task.setLat(cursor.getString(6));
        task.setStatus(cursor.getString(8));
        task.setBase(cursor.getString(9));
    //    task.setDuration(cursor.getString(10));
      
      
        //        task.setLat(cursor.getString(cursor.getColumnIndex("lat")));
        return task;

    }
   
    public List<Task> getListofDate(String curdate)
    {  
        Log.i(General.TAG, TAG + "Start to Get List Of Date");
        List<Task> taskdatelist = new ArrayList<Task>();
   
    //Cursor c = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol, TaskDatabaseHelper.TASK_DATE + " =? ",new String[]{curdate}, null, null, TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");
    Cursor c = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol,TaskDatabaseHelper.TASK_TLBASE + " =?" + " AND " + TaskDatabaseHelper.TASK_DATE + "=?",new String[]{"10",curdate}, null, null, TaskDatabaseHelper.TASK_TLBASE + " ASC, " + TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");
   
        c.moveToFirst();
        while(!c.isAfterLast())
        {
            Task taskdate=cursorTotask(c);
            taskdatelist.add(taskdate);
            c.moveToNext();
        }
        c.close();
        Log.i(General.TAG, TAG + "Get List of Date End");
        return taskdatelist;
      
    }
   
   
   
    public List<Task> gettomorrowListofDate(String tomorrowdate)
    {
        Log.i(General.TAG, TAG+ "start tomorrow date list");
        List<Task> tasktomorrowdatelist = new ArrayList<Task>();
        Cursor c = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol,TaskDatabaseHelper.TASK_TLBASE + " =?" + " AND " + TaskDatabaseHelper.TASK_DATE + " =? ",new String[]{"10",tomorrowdate},null, null, TaskDatabaseHelper.TASK_TLBASE + " ASC, " + TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");
        c.moveToFirst();
        while(!c.isAfterLast())
        {
            Task taskdate=cursorTotask(c);
            tasktomorrowdatelist.add(taskdate);
            c.moveToNext();
        }
        c.close();
        Log.i(General.TAG, TAG + "Get List of Date End");
        return tasktomorrowdatelist;
    }
   
   
    public List<Task> getListofOtherDate(String otherdate)
    {  
        Log.i(General.TAG, TAG + "Start to Get List Of Date");
        List<Task> taskdatelist = new ArrayList<Task>();
   
        //Cursor c = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol, TaskDatabaseHelper.TASK_DATE + " >? ",new String[]{otherdate}, null, null, TaskDatabaseHelper.TASK_DATE + ", " + TaskDatabaseHelper.TASK_TIME + " ASC");
        Cursor c = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol,TaskDatabaseHelper.TASK_TLBASE + " =?" + " AND " + TaskDatabaseHelper.TASK_DATE + " >? ",new String[]{"10",otherdate}, null , null,TaskDatabaseHelper.TASK_TLBASE + " ASC, " + TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");
        c.moveToFirst();
        while(!c.isAfterLast())
        {
            Task taskdate=cursorTotask(c);
            taskdatelist.add(taskdate);
            c.moveToNext();
        }
        c.close();
        Log.i(General.TAG, TAG + "Get List of Date End");
        return taskdatelist;
    }
   
    public List<Task> getAllTask() {

        Log.i(General.TAG, TAG + "getalltasklist..");
        List<Task> tasklist = new ArrayList<Task>();

        SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy");
        Cursor cursor = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME,taskcol,TaskDatabaseHelper.TASK_DATE + " >= ?",new String[]{sdf.format(new Date())},null,null, TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");

        cursor.moveToFirst();

        while (!cursor.isAfterLast()) {
            Task task = cursorTotask(cursor);
            tasklist.add(task);

            cursor.moveToNext();
        }
        cursor.close();
        Log.i(General.TAG, TAG + "Get List Of Task...");

        return tasklist;

    }
   
   
    public List<Task> getAllTaskForLocationBased() {

        Log.i(General.TAG, TAG + "getalltasklist..");
        List<Task> tasklist = new ArrayList<Task>();
   
        //Cursor cursor = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME,taskcol,TaskDatabaseHelper.TASK_TLBASE + " =? ",new String[]{one},null,null, TaskDatabaseHelper.TASK_DATE + " ASC, " + TaskDatabaseHelper.TASK_TIME + " ASC");
        Cursor cursor = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME,taskcol,TaskDatabaseHelper.TASK_TLBASE + " = " + "11",null,null,null, TaskDatabaseHelper.ID + " DESC");
        cursor.moveToFirst();

        while (!cursor.isAfterLast()) {
            Task task = cursorTotask(cursor);
            tasklist.add(task);

            cursor.moveToNext();
        }
        cursor.close();
        Log.i(General.TAG, TAG + "Get List Of Task for the Location Based Data..."+tasklist);

        return tasklist;

    }

   

   
    public Task GetRecord(int id)
    {
        Task gettask = new Task();

        Cursor cursor = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol, TaskDatabaseHelper.ID + "="+ id, null, null, null,null);

        if(cursor.moveToFirst()) {
            gettask = cursorTotask(cursor);
            cursor.moveToNext();
        }

        cursor.close();
        Log.i(General.TAG, TAG + "Get Single data");
        return gettask;
    }


    public List<Task> GetRecord(Integer id)
    {
        List<Task> gettask = new ArrayList<Task>();


        Cursor cursor = sqlitedb.query(TaskDatabaseHelper.TABLE_NAME, taskcol, TaskDatabaseHelper.ID + "="+ id.toString(), null, null, null,null);

        cursor.moveToFirst();
        while(!cursor.isAfterLast())
        {
            Task taskobj = cursorTotask(cursor);
            gettask.add(taskobj);
            cursor.moveToNext();

        }
        cursor.close();
        Log.i(General.TAG, TAG + "Get Single data");
        return gettask;
    }



    public void close() {

        Log.i(General.TAG, TAG + "close");
        sqlitedb.close();
    }

}

now using this operations in our main activity

Get Record from database using id

List<Task> lsttask;
Task taskgetset;(This is your getter setter class)
 
TaskData taskdataobj = new TaskData(AddTask.this);
            taskdataobj.open();
            Log.i(General.TAG, TAG + "get Single id");

            lsttask = taskdataobj.GetRecord(singleid);

taskgetset = lsttask.get(0);  

String name = taskgetset.getTitle();
            String desc = taskgetset.getDescrption();
            String date = taskgetset.getDate();
            String time = taskgetset.getTime();


for insert record

taskdataobj = new TaskData(AddTask.this);
                    taskdataobj.open();

                    taskdataobj.createTask(title, desc, date, time, loc, lat,
                            lang, datetimeloc);

                    Log.d(TAG, "Date :" + date + " Time: " + time + " Lat="

                    + lat + " Lon=" + lang);
                    taskdataobj.close();