munday / sliding-menu Goto Github PK

public class DrugListActivity extends SlidingMenuActivity implements
    OnLongClickListener, OnDateSetListener,
    OnSharedPreferenceChangeListener, ViewFactory, OnClickListener {
private static final String TAG = DrugListActivity.class.getSimpleName();
private static final boolean LOGV = false;

private static final boolean DEBUG_DATE_MISMATCH = true;

private static final int CMENU_TOGGLE_INTAKE = 0;
private static final int CMENU_EDIT_DRUG = 2;
private static final int CMENU_IGNORE_DOSE = 4;

private static final int DIALOG_INFO = 0;

public static final String EXTRA_DATE = "date";
public static final String EXTRA_STARTED_FROM_NOTIFICATION = "started_from_notification";

public static final int TAG_DRUG_ID = R.id.tag_drug_id;

private ViewPager mPager;
private TextView mTextDate;
private Fragment mContent;

private Date mOriginalDate;
private Date mCurrentDate;

private ImageButton mBtnNext;
private ImageButton mBtnPrev;
private ImageButton mBtnAdd;
private ImageButton mBtnJumpDate;
private ImageButton mBtnShowAll;

private boolean mShowingAll = false;
private int mCurrentPatientId = Patient.DEFAULT_PATIENT_ID;

private int mSwipeDirection = 0;
private int mLastPage = -1;

private boolean mIsShowing = false;

@Override
public void onCreate(Bundle savedInstanceState) {
    Components.onCreateActivity(this, 0);
    setLayoutIds(R.layout.drug_list, R.layout.main);
    super.onCreate(savedInstanceState);

    mPager = (ViewPager) findViewById(R.id.drug_list_pager);
    mTextDate = (TextView) findViewById(R.id.text_date);
    mBtnPrev = (ImageButton) findViewById(R.id.btnPrevPage);
    mBtnNext = (ImageButton) findViewById(R.id.btnNextPage);
    mBtnAdd = (ImageButton) findViewById(R.id.btnAdd);
    mBtnJumpDate = (ImageButton) findViewById(R.id.btnJumpDate);
    mBtnShowAll = (ImageButton) findViewById(R.id.btnShowAll);

    mTextDate.setOnLongClickListener(mDateClickListener);
    mTextDate.setOnClickListener(mDateClickListener);
    mBtnPrev.setOnClickListener(this);
    mBtnNext.setOnClickListener(this);

    mBtnAdd.setOnClickListener(this);
    mBtnJumpDate.setOnClickListener(this);
    mBtnShowAll.setOnClickListener(this);

    //mPager.setOnPageChangeListener(mPageListener);
    mPager.setOffscreenPageLimit(1);

    // startNotificationService();
    NotificationReceiver.rescheduleAlarmsAndUpdateNotification(true);

    Database.registerEventListener(mDatabaseListener);
    Settings.registerOnChangeListener(this);

}

@Override
public void onClick(View v) {
    switch (v.getId()) {
    case R.id.btnPrevPage: {
        mPager.setCurrentItem(mPager.getCurrentItem() - 1);
        break;
    }case R.id.btnNextPage: {
        mPager.setCurrentItem(mPager.getCurrentItem() + 1);
        break;
    }case R.id.btnAdd: {
        Intent intent = new Intent(Intent.ACTION_INSERT);
        intent.setClass(this, DrugEditActivity.class);
        startActivity(intent);
        break;
    }case R.id.btnJumpDate: {
        if (isCurrentDateActive())
            mDateClickListener.onLongClick(null);
        else
            mDateClickListener.onClick(null);
        break;
    }case R.id.btnShowAll: {
        mShowingAll = !mShowingAll;
        invalidateViewPager();
        if(mShowingAll){
            mBtnShowAll.setImageResource(R.drawable.ic_side_show_all);
        }else{
            mBtnShowAll.setImageResource(R.drawable.ic_side_show_less);
        }
        break;
    }
    default:
        break;
    }
}

@Override
protected void onResume() {
    super.onResume();

    Components.onResumeActivity(this, 0);
    mIsShowing = true;

    final Intent intent = getIntent();
    Date date = null;

    if (intent != null)
        date = (Date) intent.getSerializableExtra(EXTRA_DATE);

    if (date == null)
        date = Settings.getActiveDate();

    setDate(date, PAGER_INIT);
    NotificationReceiver
            .registerOnDoseTimeChangeListener(mDoseTimeListener);

    if (false) {
        final String isoLang = Locale.getDefault().getLanguage();
        if (!CollectionUtils.contains(Version.LANGUAGES, isoLang)) {
            final String language = Locale.getDefault().getDisplayLanguage(
                    Locale.US);
            showInfoDialog("missing_translation_" + isoLang,
                    R.string._msg_no_translation, language);
        }
    }
}

@Override
protected void onPause() {
    super.onPause();
    mIsShowing = false;
    Components.onPauseActivity(this, 0);
    NotificationReceiver
            .unregisterOnDoseTimeChangeListener(mDoseTimeListener);
}

@Override
protected void onStop() {
    super.onStop();
    mPager.removeAllViews();
    Database.unregisterEventListener(mDatabaseListener);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    final int menuResId;

    if (Settings.getBoolean(Keys.COMPACT_ACTION_BAR,
            Defaults.COMPACT_ACTION_BAR))
        menuResId = R.menu.activity_drug_list_compact;
    else
        menuResId = R.id.menu_default_drug_list_activity;

    new MenuInflater(this).inflate(menuResId, menu);

    return true;
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
    case R.id.menuitem_preferences: {
        Intent intent = new Intent();
        intent.setClass(this, PreferencesActivity.class);
        startActivity(intent);
        return true;
    }

    }
    return super.onOptionsItemSelected(item);
}

@Override
public void onCreateContextMenu(ContextMenu menu, final View v,
        ContextMenuInfo menuInfo) {
    final DoseView doseView = (DoseView) v;

    if (toastIfPastMaxHistoryAge(doseView.getDate()))
        return;

    final Drug drug = doseView.getDrug();
    final int doseTime = doseView.getDoseTime();

    // menu.setHeaderIcon(android.R.drawable.ic_menu_agenda);
    menu.setHeaderTitle(drug.getName());

    // ////////////////////////////////////////////////

    final Intent editIntent = new Intent(this, DrugEditActivity.class);
    editIntent.setAction(Intent.ACTION_EDIT);
    editIntent.putExtra(DrugEditActivity.EXTRA_DRUG_ID, drug.getId());
    menu.add(0, CMENU_EDIT_DRUG, 0, R.string._title_edit_drug).setIntent(
            editIntent);

    // ////////////////////////////////////////////////

    final boolean wasDoseTaken = doseView.wasDoseTaken();
    final int toggleIntakeMessageId;

    if (wasDoseTaken)
        toggleIntakeMessageId = R.string._title_mark_not_taken;
    else
        toggleIntakeMessageId = R.string._title_mark_taken;

    menu.add(0, CMENU_TOGGLE_INTAKE, 0, toggleIntakeMessageId)
            .setOnMenuItemClickListener(new OnMenuItemClickListener() {
                @Override
                public boolean onMenuItemClick(android.view.MenuItem item) {
                    if (!wasDoseTaken)
                        doseView.performClick();
                    else {
                        MutableFraction dose = new MutableFraction();
                        for (Intake intake : Entries.findIntakes(drug,
                                mCurrentDate, doseTime)) {
                            dose.add(intake.getDose());
                            Database.delete(intake);
                        }

                        drug.setCurrentSupply(drug.getCurrentSupply().plus(
                                dose));
                        Database.update(drug);
                    }

                    return true;
                }
            });

    if (!wasDoseTaken) {
        menu.add(0, CMENU_IGNORE_DOSE, 0, R.string._title_ignore_dose)
                .setOnMenuItemClickListener(new OnMenuItemClickListener() {

                    @Override
                    public boolean onMenuItemClick(
                            android.view.MenuItem item) {
                        Database.create(new Intake(drug,
                                doseView.getDate(), doseTime));
                        return true;
                    }
                });
    }
}

public void onDrugNameClick(View view) {
    Intent intent = new Intent(Intent.ACTION_EDIT);
    intent.setClass(this, DrugEditActivity.class);

    Drug drug = Drug.get((Integer) view.getTag(TAG_DRUG_ID));
    intent.putExtra(DrugEditActivity.EXTRA_DRUG_ID, drug.getId());
    intent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

    // startActivityForResult(intent, 0);
    startActivity(intent);
}

@Override
public boolean onLongClick(View view) {
    if (view.getId() == R.id.text_date) {

    }
    return false;
}

@Override
public void onDateSet(DatePicker view, int year, int month, int day) {
    setDate(DateTime.date(year, month, day), PAGER_INIT);
}

@Override
public void onSharedPreferenceChanged(SharedPreferences preferences,
        String key) {
    if (Settings.Keys.THEME_IS_DARK.equals(key))
        finish(); // TODO fix this naughty hack
    else if (mIsShowing)
        invalidateViewPager();
}

@Override
public View makeView(int offset) {
    if (offset <= -(InfiniteViewPagerAdapter.MAX / 2)) {
        if (LOGV)
            Log.d(TAG, "makeView: returning stub for offset=" + offset);
        return new ViewStub(this);
    }

    final View v = getLayoutInflater().inflate(R.layout.drug_list_fragment,
            null);
    final AutoDragSortListView listView = (AutoDragSortListView) v
            .findViewById(android.R.id.list);
    final TextView emptyView = (TextView) v
            .findViewById(android.R.id.empty);

    final Date date = DateTime.add(mOriginalDate, Calendar.DAY_OF_MONTH,
            offset);

    if (LOGV)
        Log.d(TAG, "makeView: date=" + DateTime.toDateString(date));

    final List<Drug> drugs = Entries.getAllDrugs(mCurrentPatientId);
    Collections.sort(drugs, new DrugComparator());

    updateListAdapter(listView, date, drugs);

    final int emptyResId;

    if (drugs.isEmpty()) {
            if (Settings.getBoolean(Keys.COMPACT_ACTION_BAR,
                    Defaults.COMPACT_ACTION_BAR)) {
                Log.d(TAG, "COMPACT_ACTION_BAR");
                emptyResId = R.string._msg_no_drugs_compact_ab;
            } else {
                Log.d(TAG, "EXTENDED_ACTION_BAR");
                emptyResId = R.string._msg_no_drugs_extended_ab;
            }
    } else
        emptyResId = R.string._msg_no_doses_on_this_day;

    emptyView
            .setText(getString(emptyResId, getString(R.string._title_add)));

    listView.setEmptyView(emptyView);
    listView.setDragHandleId(R.id.drug_icon);

    return v;
}

public void onDoseViewClick(View view) {
    final DoseView doseView = (DoseView) view;
    Date date = doseView.getDate();

    if (toastIfPastMaxHistoryAge(date))
        return;
    else if (!date.equals(mCurrentDate)) {
        Log.i(TAG,
                "DoseView date " + DateTime.toDateString(date)
                        + " differs from Activity date "
                        + DateTime.toDateString(mCurrentDate) + " ");

        invalidateViewPager();
        date = mCurrentDate;

        if (BuildConfig.DEBUG)
            Toast.makeText(this, "Invoked workaround!", Toast.LENGTH_SHORT)
                    .show();

        // throw new IllegalStateException("Activity date " + mCurrentDate +
        // " differs from DoseView date " + date);
    }

    final Bundle args = new Bundle();
    args.putInt(IntakeDialog.ARG_DRUG_ID, doseView.getDrug().getId());
    args.putInt(IntakeDialog.ARG_DOSE_TIME, doseView.getDoseTime());
    args.putSerializable(IntakeDialog.ARG_DATE, date);

    showDialog(R.id.dose_dialog, args);
}

public void onMissedIndicatorClicked(View view) {
    final Drug drug = (Drug) view.getTag();
    final Calendar cal = DateTime.calendarFromDate(mCurrentDate);

    do {
        cal.add(Calendar.DAY_OF_MONTH, -1);
    } while (!drug.hasDoseOnDate(cal.getTime()));

    Toast.makeText(getApplicationContext(),
            R.string._toast_drug_notification_icon, Toast.LENGTH_SHORT)
            .show();

    setDate(cal.getTime(), PAGER_INIT | PAGER_SCROLL);
}

public void onLowSupplyIndicatorClicked(View view) {
    final Drug drug = ((DrugSupplyMonitor) view).getDrug();
    if (drug == null)
        return;

    final Date today = DateTime.today();

    final int daysLeft = Entries.getSupplyDaysLeftForDrug(drug, today);
    final String dateString = DateTime.toNativeDate(DateTime.add(today,
            Calendar.DAY_OF_MONTH, daysLeft));

    Toast.makeText(this,
            getString(R.string._toast_low_supplies, dateString),
            Toast.LENGTH_LONG).show();
}

public void onSupplyMonitorLongClick(View view) {
    final Drug drug = ((DrugSupplyMonitor) view).getDrug();
    if (drug == null)
        return;

    final DrugSupplyEditFragment dialog = DrugSupplyEditFragment
            .newInstance(drug);
    dialog.show(getSupportFragmentManager(), "supply_edit_dialog");
}

@SuppressWarnings("deprecation")
@Override
protected Dialog onCreateDialog(int id, Bundle args) {
    if (id == R.id.dose_dialog)
        return new IntakeDialog(this);
    else if (id == DIALOG_INFO) {
        final String msg = args.getString("msg");
        final String onceId = args.getString("once_id");

        final AlertDialog.Builder ab = new AlertDialog.Builder(this);
        ab.setIcon(android.R.drawable.ic_dialog_info);
        ab.setTitle(R.string._title_info);
        ab.setMessage(msg);
        ab.setCancelable(false);
        ab.setPositiveButton(android.R.string.ok,
                new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        Settings.setDisplayedOnce(onceId);
                    }
                });

        return ab.create();
    }

    return super.onCreateDialog(id, args);
}

@SuppressWarnings("deprecation")
@Override
protected void onPrepareDialog(int id, Dialog dialog, Bundle args) {
    if (id == R.id.dose_dialog) {
        if (!Database.exists(Drug.class,
                args.getInt(IntakeDialog.ARG_DRUG_ID, -1))) {
            // If the drug currently associated with the dialog is deleted,
            // setArgs() throws when attempting to restore from the
            // non-existent
            // drug id.
            return;
        }

        ((IntakeDialog) dialog).setArgs(args);
    } else
        super.onPrepareDialog(id, dialog, args);
}

@Override
protected void onNewIntent(Intent intent) {
    setIntent(intent);
}

private static final int PAGER_SCROLL = 1;
private static final int PAGER_INIT = 1 << 1;

private void invalidateViewPager() {
    setDate(mCurrentDate, PAGER_INIT);
}

private void setDate(Date date, int flags) {
    if (DEBUG_DATE_MISMATCH)
        Log.d(TAG, "setDate(" + date + ", " + flags + ")");

    if (!mIsShowing) {
        if (LOGV)
            Log.v(TAG, "setDate: activity is not showing; ignoring");
        return;
    }

    if (toastIfPastMaxHistoryAge(date))
        return;

    mCurrentDate = date;
    getIntent().putExtra(EXTRA_DATE, date);

    if ((flags & PAGER_INIT) != 0) {
        mOriginalDate = date;
        mSwipeDirection = 0;

        mPager.setOnPageChangeListener(null);
        mPager.removeAllViews();

        final int drugCount = Database.countAll(Drug.class);
        if (drugCount != 0) {
            final boolean smoothScroll = (flags & PAGER_SCROLL) != 0;

            mPager.setAdapter(new InfiniteViewPagerAdapter(this));
            mPager.setCurrentItem(InfiniteViewPagerAdapter.CENTER,
                    smoothScroll);

            mLastPage = InfiniteViewPagerAdapter.CENTER;

            if (drugCount >= 2)
                showInfoDialog(Settings.OnceIds.DRAG_DROP_SORTING,
                        R.string._msg_drag_drop_sorting);
        } else {
            mPager.setAdapter(new PagerAdapter() {

                @Override
                public boolean isViewFromObject(View v, Object o) {
                    return v == (View) o;
                }

                @Override
                public int getCount() {
                    // TODO Auto-generated method stub
                    return 1;
                }

                @Override
                public Object instantiateItem(ViewGroup container,
                        int position) {
                    final View v = makeView(0);
                    Util.detachFromParent(v);
                    container.addView(v);
                    return v;
                }

                @Override
                public void destroyItem(ViewGroup container, int position,
                        Object item) {
                    container.removeView((View) item);
                }
            });

            mPager.setCurrentItem(0);
            mLastPage = 0;
        }

        mPager.setOnPageChangeListener(mPageListener);
    }

    updateDateString();
}

private boolean isCurrentDateActive() {
    return DateTime.isToday(mCurrentDate);
}

private void updateListAdapter(DragSortListView listView, Date date,
        List<Drug> drugs) {
    if (listView == null) {
        Log.w(TAG, "updateListAdapter: listView==null");
        return;
    }

    if (drugs == null) {
        drugs = Database.getAll(Drug.class);
        Collections.sort(drugs);
    }

    final DrugOverviewAdapter adapter = new DrugOverviewAdapter(this,
            drugs, date);
    adapter.setFilter(mShowingAll ? null : new DrugFilter(date));

    listView.setAdapter(adapter);
}

//
// private void startNotificationService()
// {
// NotificationReceiver.rescheduleAlarmsAndUpdateNotification(false);
// Database.registerEventListener(mDatabaseWatcher);
// }

@TargetApi(11)
private void updateDateString() {
    if (mCurrentDate == null)
        return;

    final SpannableString dateString = new SpannableString(DateFormat
            .getDateFormat(this).format(mCurrentDate.getTime()));

    if (isCurrentDateActive())
        Util.applyStyle(dateString, new UnderlineSpan());

    mTextDate.setText(dateString);
}

private boolean toastIfPastMaxHistoryAge(Date date) {
    if (Settings.isPastMaxHistoryAge(DateTime.today(), date)) {
        Toast.makeText(this, R.string._toast_past_max_history_age,
                Toast.LENGTH_LONG).show();
        // mPager.setCurrentItem(mLastPage);
        // setDate(mDate, PAGER_INIT | PAGER_SCROLL);
        return true;
    }

    return false;
}

@SuppressWarnings("deprecation")
private void showInfoDialog(String onceId, int msgResId, Object... args) {
    if (Settings.wasDisplayedOnce(onceId))
        return;

    Bundle bundle = new Bundle();
    bundle.putString("once_id", onceId);
    bundle.putString("msg", getString(msgResId, args));

    showDialog(DIALOG_INFO, bundle);
}

static class DrugFilter implements CollectionUtils.Filter<Drug> {
    final boolean mShowSupplyMonitors = Settings.getBoolean(
            Settings.Keys.SHOW_SUPPLY_MONITORS, false);

    private Date mFilterDate;

    public DrugFilter(Date date) {
        mFilterDate = date;
    }

    @Override
    public boolean matches(Drug drug) {
        if (mFilterDate == null)
            return true;

        if (drug.isAutoAddIntakesEnabled()) {
            if (Entries.hasLowSupplies(drug))
                return true;

            return mShowSupplyMonitors;
        }

        if (!drug.isActive())
            return false;

        if (Entries.countIntakes(drug, mFilterDate, null) != 0)
            return true;

        if (Entries.hasLowSupplies(drug))
            return true;

        if (DateTime.isToday(mFilterDate)
                && Entries.hasMissingIntakesBeforeDate(drug, mFilterDate))
            return true;

        if (!drug.hasDoseOnDate(mFilterDate))
            return false;

        return true;
    }
}

interface OnClickAndLongClickListener extends OnClickListener,
        OnLongClickListener {
};

private final OnClickAndLongClickListener mDateClickListener = new OnClickAndLongClickListener() {

    @Override
    public boolean onLongClick(View v) {
        /*
         * Calendar cal = DateTime.calendarFromDate(mDate);
         * 
         * final int year = cal.get(Calendar.YEAR); final int month =
         * cal.get(Calendar.MONTH); final int day =
         * cal.get(Calendar.DAY_OF_MONTH);
         * 
         * DatePickerDialog dialog = new
         * DatePickerDialog(DrugListActivity.this, DrugListActivity.this,
         * year, month, day); dialog.setCancelable(true); dialog.show();
         * return true;
         */

        DatePickerFragment datePicker = DatePickerFragment.newInstance(
                mCurrentDate, DrugListActivity.this);
        datePicker.show(getSupportFragmentManager(), "datePicker");
        return true;
    }

    @Override
    public void onClick(View v) {
        final Date activeDate = Settings.getActiveDate();
        setDate(activeDate, PAGER_INIT | PAGER_SCROLL);
    }
};

private final OnPageChangeListener mPageListener = new OnPageChangeListener() {

    int mPage = InfiniteViewPagerAdapter.CENTER;

    @Override
    public void onPageSelected(int page) {
        if (DEBUG_DATE_MISMATCH)
            Log.d(TAG, "onPageSelected(" + page + ")");

        mPage = page;

        // final int swipeDirection;

        if (mLastPage == -1) {
            mLastPage = InfiniteViewPagerAdapter.CENTER;
            mSwipeDirection = 0;
        } else
            mSwipeDirection = mPage - mLastPage;

        if (mSwipeDirection != 0) {
            final Date date = DateTime.add(mCurrentDate,
                    Calendar.DAY_OF_MONTH, mSwipeDirection);
            setDate(date, 0);
            // if(LOGV) Log.d(TAG, "onPageSelected: swipe " +
            // (mSwipeDirection < 0 ? "right" : "left"));
        }
        // else if(LOGV) Log.d(TAG, "onPageSelected: no swipe");

        mLastPage = page;
    }

    @Override
    public void onPageScrolled(int arg0, float arg1, int arg2) {
    }

    @Override
    public void onPageScrollStateChanged(int state) {
        // if(LOGV)
        // {
        // final String[] states = { "IDLE", "DRAGGING", "SETTLING" };
        // Log.v(TAG, "onPageScrollStateChanged: page=" + mPage);
        // Log.v(TAG, "  state=" + states[state]);
        // }
        //
        // if(state == ViewPager.SCROLL_STATE_IDLE)
        // {
        // mSwipeDirection = mLastPage != -1 ? mPage - mLastPage : 0;
        //
        // if(LOGV) Log.v(TAG, "onPageScrollStateChanged: mPage=" + mPage +
        // ", mLastPage=" + mLastPage + ", mSwipeDirection=" +
        // mSwipeDirection);
        //
        // if(mSwipeDirection != 0)
        // {
        // //final int shiftBy = mSwipeDirection < 0 ? -1 : 1;
        // //setDate(DateTime.add(mDate, Calendar.DAY_OF_MONTH, shiftBy),
        // 0);
        // }
        //
        // //mLastPage = mPage;
        // }
    }
};

private final Database.OnChangeListener mDatabaseListener = new Database.EmptyOnChangeListener() {

    @SuppressWarnings("deprecation")
    @Override
    public void onEntryDeleted(Entry entry, int flags) {
        try {
            DrugListActivity.this.removeDialog(R.id.dose_dialog);
        } catch (Exception e) {

        }

        if (entry instanceof Drug)
            invalidateViewPager();
    }

    @Override
    public void onEntryCreated(Entry entry, int flags) {
        if (entry instanceof Drug)
            invalidateViewPager();
    }
};

private final OnDoseTimeChangeListener mDoseTimeListener = new OnDoseTimeChangeListener() {

    @Override
    public void onDoseTimeBegin(Date date, int doseTime) {
        if (!date.equals(mCurrentDate))
            setDate(date, PAGER_INIT);
    }

    public void onDoseTimeEnd(Date date, int doseTime) {
        invalidateViewPager();
    }
};

static class DrugComparator implements Comparator<Drug> {
    private int mDoseTime;
    private Date mDate;
    private boolean mSmartSortEnabled;

    DrugComparator() {
        final DoseTimeInfo dtInfo = Settings.getDoseTimeInfo();
        mDoseTime = dtInfo.activeDoseTime();

        if (mDoseTime != Schedule.TIME_INVALID)
            mDate = dtInfo.activeDate();
        else {
            mDoseTime = dtInfo.nextDoseTime();
            mDate = dtInfo.nextDoseTimeDate();
        }

        mSmartSortEnabled = Settings.getBoolean(Keys.USE_SMART_SORT, false);
    }

    @Override
    public int compare(Drug lhs, Drug rhs) {
        if (mSmartSortEnabled) {
            boolean lActive = lhs.isActive();
            boolean rActive = rhs.isActive();

            if (lActive != rActive)
                return lActive ? -1 : 1;

            boolean lHasDose = lhs.hasDoseOnDate(mDate);
            boolean rHasDose = rhs.hasDoseOnDate(mDate);

            if (lHasDose != rHasDose)
                return lHasDose ? -1 : 1;

            lHasDose = !lhs.getDose(mDoseTime, mDate).isZero();
            rHasDose = !rhs.getDose(mDoseTime, mDate).isZero();

            if (lHasDose != rHasDose)
                return lHasDose ? -1 : 1;
        }

        return lhs.compareTo(rhs);
    }
}
}

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

////empty for now

</LinearLayout>