java/com/android/dialer/app/calllog/CallLogFragment.java - platform/packages/apps/Dialer - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dialer.app.calllog;

 import static android.Manifest.permission.READ_CALL_LOG;

 import android.app.Activity;
 import android.app.Fragment;
 import android.app.KeyguardManager;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.provider.CallLog;
 import android.provider.CallLog.Calls;
 import android.provider.ContactsContract;
 import android.support.annotation.CallSuper;
 import android.support.annotation.Nullable;
 import android.support.v13.app.FragmentCompat;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import com.android.dialer.app.Bindings;
 import com.android.dialer.app.R;
 import com.android.dialer.app.calllog.calllogcache.CallLogCache;
 import com.android.dialer.app.contactinfo.ContactInfoCache;
 import com.android.dialer.app.contactinfo.ContactInfoCache.OnContactInfoChangedListener;
 import com.android.dialer.app.contactinfo.ExpirableCacheHeadlessFragment;
 import com.android.dialer.app.list.ListsFragment;
 import com.android.dialer.app.voicemail.VoicemailPlaybackPresenter;
 import com.android.dialer.app.widget.EmptyContentView;
 import com.android.dialer.app.widget.EmptyContentView.OnEmptyViewActionButtonClickedListener;
 import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
 import com.android.dialer.common.Assert;
 import com.android.dialer.common.LogUtil;
 import com.android.dialer.database.CallLogQueryHandler;
 import com.android.dialer.location.GeoUtil;
 import com.android.dialer.phonenumbercache.ContactInfoHelper;
 import com.android.dialer.util.PermissionsUtil;

 /**
  * Displays a list of call log entries. To filter for a particular kind of call (all, missed or
  * voicemails), specify it in the constructor.
  */
 public class CallLogFragment extends Fragment
     implements CallLogQueryHandler.Listener,
         CallLogAdapter.CallFetcher,
         OnEmptyViewActionButtonClickedListener,
         FragmentCompat.OnRequestPermissionsResultCallback,
         CallLogModalAlertManager.Listener {
   private static final String KEY_FILTER_TYPE = "filter_type";
   private static final String KEY_LOG_LIMIT = "log_limit";
   private static final String KEY_DATE_LIMIT = "date_limit";
   private static final String KEY_IS_CALL_LOG_ACTIVITY = "is_call_log_activity";
   private static final String KEY_HAS_READ_CALL_LOG_PERMISSION = "has_read_call_log_permission";
   private static final String KEY_REFRESH_DATA_REQUIRED = "refresh_data_required";

   // No limit specified for the number of logs to show; use the CallLogQueryHandler's default.
   private static final int NO_LOG_LIMIT = -1;
   // No date-based filtering.
   private static final int NO_DATE_LIMIT = 0;

   private static final int READ_CALL_LOG_PERMISSION_REQUEST_CODE = 1;

   private static final int EVENT_UPDATE_DISPLAY = 1;

   private static final long MILLIS_IN_MINUTE = 60 * 1000;
   private final Handler mHandler = new Handler();
   // See issue 6363009
   private final ContentObserver mCallLogObserver = new CustomContentObserver();
   private final ContentObserver mContactsObserver = new CustomContentObserver();
   private RecyclerView mRecyclerView;
   private LinearLayoutManager mLayoutManager;
   private CallLogAdapter mAdapter;
   private CallLogQueryHandler mCallLogQueryHandler;
   private boolean mScrollToTop;
   private EmptyContentView mEmptyListView;
   private KeyguardManager mKeyguardManager;
   private ContactInfoCache mContactInfoCache;
   private final OnContactInfoChangedListener mOnContactInfoChangedListener =
       new OnContactInfoChangedListener() {
         @Override
         public void onContactInfoChanged() {
           if (mAdapter != null) {
             mAdapter.notifyDataSetChanged();
           }
         }
       };
   private boolean mRefreshDataRequired;
   private boolean mHasReadCallLogPermission;
   // Exactly same variable is in Fragment as a package private.
   private boolean mMenuVisible = true;
   // Default to all calls.
   private int mCallTypeFilter = CallLogQueryHandler.CALL_TYPE_ALL;
   // Log limit - if no limit is specified, then the default in {@link CallLogQueryHandler}
   // will be used.
   private int mLogLimit = NO_LOG_LIMIT;
   // Date limit (in millis since epoch) - when non-zero, only calls which occurred on or after
   // the date filter are included.  If zero, no date-based filtering occurs.
   private long mDateLimit = NO_DATE_LIMIT;
   /*
    * True if this instance of the CallLogFragment shown in the CallLogActivity.
    */
   private boolean mIsCallLogActivity = false;
   private final Handler mDisplayUpdateHandler =
       new Handler() {
         @Override
         public void handleMessage(Message msg) {
           switch (msg.what) {
             case EVENT_UPDATE_DISPLAY:
               refreshData();
               rescheduleDisplayUpdate();
               break;
             default:
               throw Assert.createAssertionFailException("Invalid message: " + msg);
           }
         }
       };
   protected CallLogModalAlertManager mModalAlertManager;
   private ViewGroup mModalAlertView;

   public CallLogFragment() {
     this(CallLogQueryHandler.CALL_TYPE_ALL, NO_LOG_LIMIT);
   }

   public CallLogFragment(int filterType) {
     this(filterType, NO_LOG_LIMIT);
   }

   public CallLogFragment(int filterType, boolean isCallLogActivity) {
     this(filterType, NO_LOG_LIMIT);
     mIsCallLogActivity = isCallLogActivity;
   }

   public CallLogFragment(int filterType, int logLimit) {
     this(filterType, logLimit, NO_DATE_LIMIT);
   }

   /**
    * Creates a call log fragment, filtering to include only calls of the desired type, occurring
    * after the specified date.
    *
    * @param filterType type of calls to include.
    * @param dateLimit limits results to calls occurring on or after the specified date.
    */
   public CallLogFragment(int filterType, long dateLimit) {
     this(filterType, NO_LOG_LIMIT, dateLimit);
   }

   /**
    * Creates a call log fragment, filtering to include only calls of the desired type, occurring
    * after the specified date. Also provides a means to limit the number of results returned.
    *
    * @param filterType type of calls to include.
    * @param logLimit limits the number of results to return.
    * @param dateLimit limits results to calls occurring on or after the specified date.
    */
   public CallLogFragment(int filterType, int logLimit, long dateLimit) {
     mCallTypeFilter = filterType;
     mLogLimit = logLimit;
     mDateLimit = dateLimit;
   }

   @Override
   public void onCreate(Bundle state) {
     LogUtil.d("CallLogFragment.onCreate", toString());
     super.onCreate(state);
     mRefreshDataRequired = true;
     if (state != null) {
       mCallTypeFilter = state.getInt(KEY_FILTER_TYPE, mCallTypeFilter);
       mLogLimit = state.getInt(KEY_LOG_LIMIT, mLogLimit);
       mDateLimit = state.getLong(KEY_DATE_LIMIT, mDateLimit);
       mIsCallLogActivity = state.getBoolean(KEY_IS_CALL_LOG_ACTIVITY, mIsCallLogActivity);
       mHasReadCallLogPermission = state.getBoolean(KEY_HAS_READ_CALL_LOG_PERMISSION, false);
       mRefreshDataRequired = state.getBoolean(KEY_REFRESH_DATA_REQUIRED, mRefreshDataRequired);
     }

     final Activity activity = getActivity();
     final ContentResolver resolver = activity.getContentResolver();
     mCallLogQueryHandler = new CallLogQueryHandler(activity, resolver, this, mLogLimit);
     mKeyguardManager = (KeyguardManager) activity.getSystemService(Context.KEYGUARD_SERVICE);

     if (PermissionsUtil.hasCallLogReadPermissions(getContext())) {
       resolver.registerContentObserver(CallLog.CONTENT_URI, true, mCallLogObserver);
     } else {
       LogUtil.w("CallLogFragment.onCreate", "call log permission not available");
     }
     if (PermissionsUtil.hasContactsReadPermissions(getContext())) {
       resolver.registerContentObserver(
           ContactsContract.Contacts.CONTENT_URI, true, mContactsObserver);
     } else {
       LogUtil.w("CallLogFragment.onCreate", "contacts permission not available.");
     }
     setHasOptionsMenu(true);
   }

   /** Called by the CallLogQueryHandler when the list of calls has been fetched or updated. */
   @Override
   public boolean onCallsFetched(Cursor cursor) {
     if (getActivity() == null || getActivity().isFinishing()) {
       // Return false; we did not take ownership of the cursor
       return false;
     }
     mAdapter.invalidatePositions();
     mAdapter.setLoading(false);
     mAdapter.changeCursor(cursor);
     // This will update the state of the "Clear call log" menu item.
     getActivity().invalidateOptionsMenu();

     if (cursor != null && cursor.getCount() > 0) {
       mRecyclerView.setPaddingRelative(
           mRecyclerView.getPaddingStart(),
           0,
           mRecyclerView.getPaddingEnd(),
           getResources().getDimensionPixelSize(R.dimen.floating_action_button_list_bottom_padding));
       mEmptyListView.setVisibility(View.GONE);
     } else {
       mRecyclerView.setPaddingRelative(
           mRecyclerView.getPaddingStart(), 0, mRecyclerView.getPaddingEnd(), 0);
       mEmptyListView.setVisibility(View.VISIBLE);
     }
     if (mScrollToTop) {
       // The smooth-scroll animation happens over a fixed time period.
       // As a result, if it scrolls through a large portion of the list,
       // each frame will jump so far from the previous one that the user
       // will not experience the illusion of downward motion.  Instead,
       // if we're not already near the top of the list, we instantly jump
       // near the top, and animate from there.
       if (mLayoutManager.findFirstVisibleItemPosition() > 5) {
         // TODO: Jump to near the top, then begin smooth scroll.
         mRecyclerView.smoothScrollToPosition(0);
       }
       // Workaround for framework issue: the smooth-scroll doesn't
       // occur if setSelection() is called immediately before.
       mHandler.post(
           new Runnable() {
             @Override
             public void run() {
               if (getActivity() == null || getActivity().isFinishing()) {
                 return;
               }
               mRecyclerView.smoothScrollToPosition(0);
             }
           });

       mScrollToTop = false;
     }
     return true;
   }

   @Override
   public void onVoicemailStatusFetched(Cursor statusCursor) {}

   @Override
   public void onVoicemailUnreadCountFetched(Cursor cursor) {}

   @Override
   public void onMissedCallsUnreadCountFetched(Cursor cursor) {}

   @Override
   public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
     View view = inflater.inflate(R.layout.call_log_fragment, container, false);
     setupView(view);
     return view;
   }

   protected void setupView(View view) {
     mRecyclerView = (RecyclerView) view.findViewById(R.id.recycler_view);
     mRecyclerView.setHasFixedSize(true);
     mLayoutManager = new LinearLayoutManager(getActivity());
     mRecyclerView.setLayoutManager(mLayoutManager);
     mEmptyListView = (EmptyContentView) view.findViewById(R.id.empty_list_view);
     mEmptyListView.setImage(R.drawable.empty_call_log);
     mEmptyListView.setActionClickedListener(this);
     mModalAlertView = (ViewGroup) view.findViewById(R.id.modal_message_container);
     mModalAlertManager =
         new CallLogModalAlertManager(LayoutInflater.from(getContext()), mModalAlertView, this);
   }

   protected void setupData() {
     int activityType =
         mIsCallLogActivity
             ? CallLogAdapter.ACTIVITY_TYPE_CALL_LOG
             : CallLogAdapter.ACTIVITY_TYPE_DIALTACTS;
     String currentCountryIso = GeoUtil.getCurrentCountryIso(getActivity());

     mContactInfoCache =
         new ContactInfoCache(
             ExpirableCacheHeadlessFragment.attach((AppCompatActivity) getActivity())
                 .getRetainedCache(),
             new ContactInfoHelper(getActivity(), currentCountryIso),
             mOnContactInfoChangedListener);
     mAdapter =
         Bindings.getLegacy(getActivity())
             .newCallLogAdapter(
                 getActivity(),
                 mRecyclerView,
                 this,
                 CallLogCache.getCallLogCache(getActivity()),
                 mContactInfoCache,
                 getVoicemailPlaybackPresenter(),
                 new FilteredNumberAsyncQueryHandler(getActivity()),
                 activityType);
     mRecyclerView.setAdapter(mAdapter);
     fetchCalls();
   }

   @Nullable
   protected VoicemailPlaybackPresenter getVoicemailPlaybackPresenter() {
     return null;
   }

   @Override
   public void onActivityCreated(Bundle savedInstanceState) {
     super.onActivityCreated(savedInstanceState);
     setupData();
     mAdapter.onRestoreInstanceState(savedInstanceState);
   }

   @Override
   public void onViewCreated(View view, Bundle savedInstanceState) {
     super.onViewCreated(view, savedInstanceState);
     updateEmptyMessage(mCallTypeFilter);
   }

   @Override
   public void onResume() {
     LogUtil.d("CallLogFragment.onResume", toString());
     super.onResume();
     final boolean hasReadCallLogPermission =
         PermissionsUtil.hasPermission(getActivity(), READ_CALL_LOG);
     if (!mHasReadCallLogPermission && hasReadCallLogPermission) {
       // We didn't have the permission before, and now we do. Force a refresh of the call log.
       // Note that this code path always happens on a fresh start, but mRefreshDataRequired
       // is already true in that case anyway.
       mRefreshDataRequired = true;
       updateEmptyMessage(mCallTypeFilter);
     }

     mHasReadCallLogPermission = hasReadCallLogPermission;

     /*
      * Always clear the filtered numbers cache since users could have blocked/unblocked numbers
      * from the settings page
      */
     mAdapter.clearFilteredNumbersCache();
     refreshData();
     mAdapter.onResume();

     rescheduleDisplayUpdate();
   }

   @Override
   public void onPause() {
     LogUtil.d("CallLogFragment.onPause", toString());
     cancelDisplayUpdate();
     mAdapter.onPause();
     super.onPause();
   }

   @Override
   public void onStop() {
     updateOnTransition();

     super.onStop();
     mAdapter.onStop();
     mContactInfoCache.stop();
   }

   @Override
   public void onDestroy() {
     LogUtil.d("CallLogFragment.onDestroy", toString());
     mAdapter.changeCursor(null);

     getActivity().getContentResolver().unregisterContentObserver(mCallLogObserver);
     getActivity().getContentResolver().unregisterContentObserver(mContactsObserver);
     super.onDestroy();
   }

   @Override
   public void onSaveInstanceState(Bundle outState) {
     super.onSaveInstanceState(outState);
     outState.putInt(KEY_FILTER_TYPE, mCallTypeFilter);
     outState.putInt(KEY_LOG_LIMIT, mLogLimit);
     outState.putLong(KEY_DATE_LIMIT, mDateLimit);
     outState.putBoolean(KEY_IS_CALL_LOG_ACTIVITY, mIsCallLogActivity);
     outState.putBoolean(KEY_HAS_READ_CALL_LOG_PERMISSION, mHasReadCallLogPermission);
     outState.putBoolean(KEY_REFRESH_DATA_REQUIRED, mRefreshDataRequired);

     mAdapter.onSaveInstanceState(outState);
   }

   @Override
   public void fetchCalls() {
     mCallLogQueryHandler.fetchCalls(mCallTypeFilter, mDateLimit);
     if (!mIsCallLogActivity) {
       ((ListsFragment) getParentFragment()).updateTabUnreadCounts();
     }
   }

   private void updateEmptyMessage(int filterType) {
     final Context context = getActivity();
     if (context == null) {
       return;
     }

     if (!PermissionsUtil.hasPermission(context, READ_CALL_LOG)) {
       mEmptyListView.setDescription(R.string.permission_no_calllog);
       mEmptyListView.setActionLabel(R.string.permission_single_turn_on);
       return;
     }

     final int messageId;
     switch (filterType) {
       case Calls.MISSED_TYPE:
         messageId = R.string.call_log_missed_empty;
         break;
       case Calls.VOICEMAIL_TYPE:
         messageId = R.string.call_log_voicemail_empty;
         break;
       case CallLogQueryHandler.CALL_TYPE_ALL:
         messageId = R.string.call_log_all_empty;
         break;
       default:
         throw new IllegalArgumentException(
             "Unexpected filter type in CallLogFragment: " + filterType);
     }
     mEmptyListView.setDescription(messageId);
     if (mIsCallLogActivity) {
       mEmptyListView.setActionLabel(EmptyContentView.NO_LABEL);
     } else if (filterType == CallLogQueryHandler.CALL_TYPE_ALL) {
       mEmptyListView.setActionLabel(R.string.call_log_all_empty_action);
     }
   }

   public CallLogAdapter getAdapter() {
     return mAdapter;
   }

   @Override
   public void setMenuVisibility(boolean menuVisible) {
     super.setMenuVisibility(menuVisible);
     if (mMenuVisible != menuVisible) {
       mMenuVisible = menuVisible;
       if (!menuVisible) {
         updateOnTransition();
       } else if (isResumed()) {
         refreshData();
       }
     }
   }

   /** Requests updates to the data to be shown. */
   private void refreshData() {
     // Prevent unnecessary refresh.
     if (mRefreshDataRequired) {
       // Mark all entries in the contact info cache as out of date, so they will be looked up
       // again once being shown.
       mContactInfoCache.invalidate();
       mAdapter.setLoading(true);

       fetchCalls();
       mCallLogQueryHandler.fetchVoicemailStatus();
       mCallLogQueryHandler.fetchMissedCallsUnreadCount();
       updateOnTransition();
       mRefreshDataRequired = false;
     } else {
       // Refresh the display of the existing data to update the timestamp text descriptions.
       mAdapter.notifyDataSetChanged();
     }
   }

   /**
    * Updates the voicemail notification state.
    *
    * <p>TODO: Move to CallLogActivity
    */
   private void updateOnTransition() {
     // We don't want to update any call data when keyguard is on because the user has likely not
     // seen the new calls yet.
     // This might be called before onCreate() and thus we need to check null explicitly.
     if (mKeyguardManager != null
         && !mKeyguardManager.inKeyguardRestrictedInputMode()
         && mCallTypeFilter == Calls.VOICEMAIL_TYPE) {
       CallLogNotificationsService.markNewVoicemailsAsOld(getActivity(), null);
     }
   }

   @Override
   public void onEmptyViewActionButtonClicked() {
     final Activity activity = getActivity();
     if (activity == null) {
       return;
     }

     if (!PermissionsUtil.hasPermission(activity, READ_CALL_LOG)) {
       FragmentCompat.requestPermissions(
           this, new String[] {READ_CALL_LOG}, READ_CALL_LOG_PERMISSION_REQUEST_CODE);
     } else if (!mIsCallLogActivity) {
       // Show dialpad if we are not in the call log activity.
       ((HostInterface) activity).showDialpad();
     }
   }

   @Override
   public void onRequestPermissionsResult(
       int requestCode, String[] permissions, int[] grantResults) {
     if (requestCode == READ_CALL_LOG_PERMISSION_REQUEST_CODE) {
       if (grantResults.length >= 1 && PackageManager.PERMISSION_GRANTED == grantResults[0]) {
         // Force a refresh of the data since we were missing the permission before this.
         mRefreshDataRequired = true;
       }
     }
   }

   /** Schedules an update to the relative call times (X mins ago). */
   private void rescheduleDisplayUpdate() {
     if (!mDisplayUpdateHandler.hasMessages(EVENT_UPDATE_DISPLAY)) {
       long time = System.currentTimeMillis();
       // This value allows us to change the display relatively close to when the time changes
       // from one minute to the next.
       long millisUtilNextMinute = MILLIS_IN_MINUTE - (time % MILLIS_IN_MINUTE);
       mDisplayUpdateHandler.sendEmptyMessageDelayed(EVENT_UPDATE_DISPLAY, millisUtilNextMinute);
     }
   }

   /** Cancels any pending update requests to update the relative call times (X mins ago). */
   private void cancelDisplayUpdate() {
     mDisplayUpdateHandler.removeMessages(EVENT_UPDATE_DISPLAY);
   }

   @CallSuper
   public void onVisible() {
     LogUtil.enterBlock("CallLogFragment.onPageSelected");
     if (getActivity() != null) {
       ((HostInterface) getActivity())
           .enableFloatingButton(mModalAlertManager == null || mModalAlertManager.isEmpty());
     }
   }

   @CallSuper
   public void onNotVisible() {
     LogUtil.enterBlock("CallLogFragment.onPageUnselected");
   }

   @Override
   public void onShowModalAlert(boolean show) {
     LogUtil.d(
         "CallLogFragment.onShowModalAlert",
         "show: %b, fragment: %s, isVisible: %b",
         show,
         this,
         getUserVisibleHint());
     getAdapter().notifyDataSetChanged();
     HostInterface hostInterface = (HostInterface) getActivity();
     if (show) {
       mRecyclerView.setVisibility(View.GONE);
       mModalAlertView.setVisibility(View.VISIBLE);
       if (hostInterface != null && getUserVisibleHint()) {
         hostInterface.enableFloatingButton(false);
       }
     } else {
       mRecyclerView.setVisibility(View.VISIBLE);
       mModalAlertView.setVisibility(View.GONE);
       if (hostInterface != null && getUserVisibleHint()) {
         hostInterface.enableFloatingButton(true);
       }
     }
   }

   public interface HostInterface {

     void showDialpad();

     void enableFloatingButton(boolean enabled);
   }

   protected class CustomContentObserver extends ContentObserver {

     public CustomContentObserver() {
       super(mHandler);
     }

     @Override
     public void onChange(boolean selfChange) {
       mRefreshDataRequired = true;
     }
   }
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dialer.app.calllog;

	import static android.Manifest.permission.READ_CALL_LOG;

	import android.app.Activity;
	import android.app.Fragment;
	import android.app.KeyguardManager;
	import android.content.ContentResolver;
	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.database.ContentObserver;
	import android.database.Cursor;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.Message;
	import android.provider.CallLog;
	import android.provider.CallLog.Calls;
	import android.provider.ContactsContract;
	import android.support.annotation.CallSuper;
	import android.support.annotation.Nullable;
	import android.support.v13.app.FragmentCompat;
	import android.support.v7.app.AppCompatActivity;
	import android.support.v7.widget.LinearLayoutManager;
	import android.support.v7.widget.RecyclerView;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import com.android.dialer.app.Bindings;
	import com.android.dialer.app.R;
	import com.android.dialer.app.calllog.calllogcache.CallLogCache;
	import com.android.dialer.app.contactinfo.ContactInfoCache;
	import com.android.dialer.app.contactinfo.ContactInfoCache.OnContactInfoChangedListener;
	import com.android.dialer.app.contactinfo.ExpirableCacheHeadlessFragment;
	import com.android.dialer.app.list.ListsFragment;
	import com.android.dialer.app.voicemail.VoicemailPlaybackPresenter;
	import com.android.dialer.app.widget.EmptyContentView;
	import com.android.dialer.app.widget.EmptyContentView.OnEmptyViewActionButtonClickedListener;
	import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler;
	import com.android.dialer.common.Assert;
	import com.android.dialer.common.LogUtil;
	import com.android.dialer.database.CallLogQueryHandler;
	import com.android.dialer.location.GeoUtil;
	import com.android.dialer.phonenumbercache.ContactInfoHelper;
	import com.android.dialer.util.PermissionsUtil;

	/**
	* Displays a list of call log entries. To filter for a particular kind of call (all, missed or
	* voicemails), specify it in the constructor.
	*/
	public class CallLogFragment extends Fragment
	implements CallLogQueryHandler.Listener,
	CallLogAdapter.CallFetcher,
	OnEmptyViewActionButtonClickedListener,
	FragmentCompat.OnRequestPermissionsResultCallback,
	CallLogModalAlertManager.Listener {
	private static final String KEY_FILTER_TYPE = "filter_type";
	private static final String KEY_LOG_LIMIT = "log_limit";
	private static final String KEY_DATE_LIMIT = "date_limit";
	private static final String KEY_IS_CALL_LOG_ACTIVITY = "is_call_log_activity";
	private static final String KEY_HAS_READ_CALL_LOG_PERMISSION = "has_read_call_log_permission";
	private static final String KEY_REFRESH_DATA_REQUIRED = "refresh_data_required";

	// No limit specified for the number of logs to show; use the CallLogQueryHandler's default.
	private static final int NO_LOG_LIMIT = -1;
	// No date-based filtering.
	private static final int NO_DATE_LIMIT = 0;

	private static final int READ_CALL_LOG_PERMISSION_REQUEST_CODE = 1;

	private static final int EVENT_UPDATE_DISPLAY = 1;

	private static final long MILLIS_IN_MINUTE = 60 * 1000;
	private final Handler mHandler = new Handler();
	// See issue 6363009
	private final ContentObserver mCallLogObserver = new CustomContentObserver();
	private final ContentObserver mContactsObserver = new CustomContentObserver();
	private RecyclerView mRecyclerView;
	private LinearLayoutManager mLayoutManager;
	private CallLogAdapter mAdapter;
	private CallLogQueryHandler mCallLogQueryHandler;
	private boolean mScrollToTop;
	private EmptyContentView mEmptyListView;
	private KeyguardManager mKeyguardManager;
	private ContactInfoCache mContactInfoCache;
	private final OnContactInfoChangedListener mOnContactInfoChangedListener =
	new OnContactInfoChangedListener() {
	@Override
	public void onContactInfoChanged() {
	if (mAdapter != null) {
	mAdapter.notifyDataSetChanged();
	}
	}
	};
	private boolean mRefreshDataRequired;
	private boolean mHasReadCallLogPermission;
	// Exactly same variable is in Fragment as a package private.
	private boolean mMenuVisible = true;
	// Default to all calls.
	private int mCallTypeFilter = CallLogQueryHandler.CALL_TYPE_ALL;
	// Log limit - if no limit is specified, then the default in {@link CallLogQueryHandler}
	// will be used.
	private int mLogLimit = NO_LOG_LIMIT;
	// Date limit (in millis since epoch) - when non-zero, only calls which occurred on or after
	// the date filter are included. If zero, no date-based filtering occurs.
	private long mDateLimit = NO_DATE_LIMIT;
	/*
	* True if this instance of the CallLogFragment shown in the CallLogActivity.
	*/
	private boolean mIsCallLogActivity = false;
	private final Handler mDisplayUpdateHandler =
	new Handler() {
	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case EVENT_UPDATE_DISPLAY:
	refreshData();
	rescheduleDisplayUpdate();
	break;
	default:
	throw Assert.createAssertionFailException("Invalid message: " + msg);
	}
	}
	};
	protected CallLogModalAlertManager mModalAlertManager;
	private ViewGroup mModalAlertView;

	public CallLogFragment() {
	this(CallLogQueryHandler.CALL_TYPE_ALL, NO_LOG_LIMIT);
	}

	public CallLogFragment(int filterType) {
	this(filterType, NO_LOG_LIMIT);
	}

	public CallLogFragment(int filterType, boolean isCallLogActivity) {
	this(filterType, NO_LOG_LIMIT);
	mIsCallLogActivity = isCallLogActivity;
	}

	public CallLogFragment(int filterType, int logLimit) {
	this(filterType, logLimit, NO_DATE_LIMIT);
	}

	/**
	* Creates a call log fragment, filtering to include only calls of the desired type, occurring
	* after the specified date.
	*
	* @param filterType type of calls to include.
	* @param dateLimit limits results to calls occurring on or after the specified date.
	*/
	public CallLogFragment(int filterType, long dateLimit) {
	this(filterType, NO_LOG_LIMIT, dateLimit);
	}

	/**
	* Creates a call log fragment, filtering to include only calls of the desired type, occurring
	* after the specified date. Also provides a means to limit the number of results returned.
	*
	* @param filterType type of calls to include.
	* @param logLimit limits the number of results to return.
	* @param dateLimit limits results to calls occurring on or after the specified date.
	*/
	public CallLogFragment(int filterType, int logLimit, long dateLimit) {
	mCallTypeFilter = filterType;
	mLogLimit = logLimit;
	mDateLimit = dateLimit;
	}

	@Override
	public void onCreate(Bundle state) {
	LogUtil.d("CallLogFragment.onCreate", toString());
	super.onCreate(state);
	mRefreshDataRequired = true;
	if (state != null) {
	mCallTypeFilter = state.getInt(KEY_FILTER_TYPE, mCallTypeFilter);
	mLogLimit = state.getInt(KEY_LOG_LIMIT, mLogLimit);
	mDateLimit = state.getLong(KEY_DATE_LIMIT, mDateLimit);
	mIsCallLogActivity = state.getBoolean(KEY_IS_CALL_LOG_ACTIVITY, mIsCallLogActivity);
	mHasReadCallLogPermission = state.getBoolean(KEY_HAS_READ_CALL_LOG_PERMISSION, false);
	mRefreshDataRequired = state.getBoolean(KEY_REFRESH_DATA_REQUIRED, mRefreshDataRequired);
	}

	final Activity activity = getActivity();
	final ContentResolver resolver = activity.getContentResolver();
	mCallLogQueryHandler = new CallLogQueryHandler(activity, resolver, this, mLogLimit);
	mKeyguardManager = (KeyguardManager) activity.getSystemService(Context.KEYGUARD_SERVICE);

	if (PermissionsUtil.hasCallLogReadPermissions(getContext())) {
	resolver.registerContentObserver(CallLog.CONTENT_URI, true, mCallLogObserver);
	} else {
	LogUtil.w("CallLogFragment.onCreate", "call log permission not available");
	}
	if (PermissionsUtil.hasContactsReadPermissions(getContext())) {
	resolver.registerContentObserver(
	ContactsContract.Contacts.CONTENT_URI, true, mContactsObserver);
	} else {
	LogUtil.w("CallLogFragment.onCreate", "contacts permission not available.");
	}
	setHasOptionsMenu(true);
	}

	/** Called by the CallLogQueryHandler when the list of calls has been fetched or updated. */
	@Override
	public boolean onCallsFetched(Cursor cursor) {
	if (getActivity() == null \|\| getActivity().isFinishing()) {
	// Return false; we did not take ownership of the cursor
	return false;
	}
	mAdapter.invalidatePositions();
	mAdapter.setLoading(false);
	mAdapter.changeCursor(cursor);
	// This will update the state of the "Clear call log" menu item.
	getActivity().invalidateOptionsMenu();

	if (cursor != null && cursor.getCount() > 0) {
	mRecyclerView.setPaddingRelative(
	mRecyclerView.getPaddingStart(),
	0,
	mRecyclerView.getPaddingEnd(),
	getResources().getDimensionPixelSize(R.dimen.floating_action_button_list_bottom_padding));
	mEmptyListView.setVisibility(View.GONE);
	} else {
	mRecyclerView.setPaddingRelative(
	mRecyclerView.getPaddingStart(), 0, mRecyclerView.getPaddingEnd(), 0);
	mEmptyListView.setVisibility(View.VISIBLE);
	}
	if (mScrollToTop) {
	// The smooth-scroll animation happens over a fixed time period.
	// As a result, if it scrolls through a large portion of the list,
	// each frame will jump so far from the previous one that the user
	// will not experience the illusion of downward motion. Instead,
	// if we're not already near the top of the list, we instantly jump
	// near the top, and animate from there.
	if (mLayoutManager.findFirstVisibleItemPosition() > 5) {
	// TODO: Jump to near the top, then begin smooth scroll.
	mRecyclerView.smoothScrollToPosition(0);
	}
	// Workaround for framework issue: the smooth-scroll doesn't
	// occur if setSelection() is called immediately before.
	mHandler.post(
	new Runnable() {
	@Override
	public void run() {
	if (getActivity() == null \|\| getActivity().isFinishing()) {
	return;
	}
	mRecyclerView.smoothScrollToPosition(0);
	}
	});

	mScrollToTop = false;
	}
	return true;
	}

	@Override
	public void onVoicemailStatusFetched(Cursor statusCursor) {}

	@Override
	public void onVoicemailUnreadCountFetched(Cursor cursor) {}

	@Override
	public void onMissedCallsUnreadCountFetched(Cursor cursor) {}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
	View view = inflater.inflate(R.layout.call_log_fragment, container, false);
	setupView(view);
	return view;
	}

	protected void setupView(View view) {
	mRecyclerView = (RecyclerView) view.findViewById(R.id.recycler_view);
	mRecyclerView.setHasFixedSize(true);
	mLayoutManager = new LinearLayoutManager(getActivity());
	mRecyclerView.setLayoutManager(mLayoutManager);
	mEmptyListView = (EmptyContentView) view.findViewById(R.id.empty_list_view);
	mEmptyListView.setImage(R.drawable.empty_call_log);
	mEmptyListView.setActionClickedListener(this);
	mModalAlertView = (ViewGroup) view.findViewById(R.id.modal_message_container);
	mModalAlertManager =
	new CallLogModalAlertManager(LayoutInflater.from(getContext()), mModalAlertView, this);
	}

	protected void setupData() {
	int activityType =
	mIsCallLogActivity
	? CallLogAdapter.ACTIVITY_TYPE_CALL_LOG
	: CallLogAdapter.ACTIVITY_TYPE_DIALTACTS;
	String currentCountryIso = GeoUtil.getCurrentCountryIso(getActivity());

	mContactInfoCache =
	new ContactInfoCache(
	ExpirableCacheHeadlessFragment.attach((AppCompatActivity) getActivity())
	.getRetainedCache(),
	new ContactInfoHelper(getActivity(), currentCountryIso),
	mOnContactInfoChangedListener);
	mAdapter =
	Bindings.getLegacy(getActivity())
	.newCallLogAdapter(
	getActivity(),
	mRecyclerView,
	this,
	CallLogCache.getCallLogCache(getActivity()),
	mContactInfoCache,
	getVoicemailPlaybackPresenter(),
	new FilteredNumberAsyncQueryHandler(getActivity()),
	activityType);
	mRecyclerView.setAdapter(mAdapter);
	fetchCalls();
	}

	@Nullable
	protected VoicemailPlaybackPresenter getVoicemailPlaybackPresenter() {
	return null;
	}

	@Override
	public void onActivityCreated(Bundle savedInstanceState) {
	super.onActivityCreated(savedInstanceState);
	setupData();
	mAdapter.onRestoreInstanceState(savedInstanceState);
	}

	@Override
	public void onViewCreated(View view, Bundle savedInstanceState) {
	super.onViewCreated(view, savedInstanceState);
	updateEmptyMessage(mCallTypeFilter);
	}

	@Override
	public void onResume() {
	LogUtil.d("CallLogFragment.onResume", toString());
	super.onResume();
	final boolean hasReadCallLogPermission =
	PermissionsUtil.hasPermission(getActivity(), READ_CALL_LOG);
	if (!mHasReadCallLogPermission && hasReadCallLogPermission) {
	// We didn't have the permission before, and now we do. Force a refresh of the call log.
	// Note that this code path always happens on a fresh start, but mRefreshDataRequired
	// is already true in that case anyway.
	mRefreshDataRequired = true;
	updateEmptyMessage(mCallTypeFilter);
	}

	mHasReadCallLogPermission = hasReadCallLogPermission;

	/*
	* Always clear the filtered numbers cache since users could have blocked/unblocked numbers
	* from the settings page
	*/
	mAdapter.clearFilteredNumbersCache();
	refreshData();
	mAdapter.onResume();

	rescheduleDisplayUpdate();
	}

	@Override
	public void onPause() {
	LogUtil.d("CallLogFragment.onPause", toString());
	cancelDisplayUpdate();
	mAdapter.onPause();
	super.onPause();
	}

	@Override
	public void onStop() {
	updateOnTransition();

	super.onStop();
	mAdapter.onStop();
	mContactInfoCache.stop();
	}

	@Override
	public void onDestroy() {
	LogUtil.d("CallLogFragment.onDestroy", toString());
	mAdapter.changeCursor(null);

	getActivity().getContentResolver().unregisterContentObserver(mCallLogObserver);
	getActivity().getContentResolver().unregisterContentObserver(mContactsObserver);
	super.onDestroy();
	}

	@Override
	public void onSaveInstanceState(Bundle outState) {
	super.onSaveInstanceState(outState);
	outState.putInt(KEY_FILTER_TYPE, mCallTypeFilter);
	outState.putInt(KEY_LOG_LIMIT, mLogLimit);
	outState.putLong(KEY_DATE_LIMIT, mDateLimit);
	outState.putBoolean(KEY_IS_CALL_LOG_ACTIVITY, mIsCallLogActivity);
	outState.putBoolean(KEY_HAS_READ_CALL_LOG_PERMISSION, mHasReadCallLogPermission);
	outState.putBoolean(KEY_REFRESH_DATA_REQUIRED, mRefreshDataRequired);

	mAdapter.onSaveInstanceState(outState);
	}

	@Override
	public void fetchCalls() {
	mCallLogQueryHandler.fetchCalls(mCallTypeFilter, mDateLimit);
	if (!mIsCallLogActivity) {
	((ListsFragment) getParentFragment()).updateTabUnreadCounts();
	}
	}

	private void updateEmptyMessage(int filterType) {
	final Context context = getActivity();
	if (context == null) {
	return;
	}

	if (!PermissionsUtil.hasPermission(context, READ_CALL_LOG)) {
	mEmptyListView.setDescription(R.string.permission_no_calllog);
	mEmptyListView.setActionLabel(R.string.permission_single_turn_on);
	return;
	}

	final int messageId;
	switch (filterType) {
	case Calls.MISSED_TYPE:
	messageId = R.string.call_log_missed_empty;
	break;
	case Calls.VOICEMAIL_TYPE:
	messageId = R.string.call_log_voicemail_empty;
	break;
	case CallLogQueryHandler.CALL_TYPE_ALL:
	messageId = R.string.call_log_all_empty;
	break;
	default:
	throw new IllegalArgumentException(
	"Unexpected filter type in CallLogFragment: " + filterType);
	}
	mEmptyListView.setDescription(messageId);
	if (mIsCallLogActivity) {
	mEmptyListView.setActionLabel(EmptyContentView.NO_LABEL);
	} else if (filterType == CallLogQueryHandler.CALL_TYPE_ALL) {
	mEmptyListView.setActionLabel(R.string.call_log_all_empty_action);
	}
	}

	public CallLogAdapter getAdapter() {
	return mAdapter;
	}

	@Override
	public void setMenuVisibility(boolean menuVisible) {
	super.setMenuVisibility(menuVisible);
	if (mMenuVisible != menuVisible) {
	mMenuVisible = menuVisible;
	if (!menuVisible) {
	updateOnTransition();
	} else if (isResumed()) {
	refreshData();
	}
	}
	}

	/** Requests updates to the data to be shown. */
	private void refreshData() {
	// Prevent unnecessary refresh.
	if (mRefreshDataRequired) {
	// Mark all entries in the contact info cache as out of date, so they will be looked up
	// again once being shown.
	mContactInfoCache.invalidate();
	mAdapter.setLoading(true);

	fetchCalls();
	mCallLogQueryHandler.fetchVoicemailStatus();
	mCallLogQueryHandler.fetchMissedCallsUnreadCount();
	updateOnTransition();
	mRefreshDataRequired = false;
	} else {
	// Refresh the display of the existing data to update the timestamp text descriptions.
	mAdapter.notifyDataSetChanged();
	}
	}

	/**
	* Updates the voicemail notification state.
	*
	* <p>TODO: Move to CallLogActivity
	*/
	private void updateOnTransition() {
	// We don't want to update any call data when keyguard is on because the user has likely not
	// seen the new calls yet.
	// This might be called before onCreate() and thus we need to check null explicitly.
	if (mKeyguardManager != null
	&& !mKeyguardManager.inKeyguardRestrictedInputMode()
	&& mCallTypeFilter == Calls.VOICEMAIL_TYPE) {
	CallLogNotificationsService.markNewVoicemailsAsOld(getActivity(), null);
	}
	}

	@Override
	public void onEmptyViewActionButtonClicked() {
	final Activity activity = getActivity();
	if (activity == null) {
	return;
	}

	if (!PermissionsUtil.hasPermission(activity, READ_CALL_LOG)) {
	FragmentCompat.requestPermissions(
	this, new String[] {READ_CALL_LOG}, READ_CALL_LOG_PERMISSION_REQUEST_CODE);
	} else if (!mIsCallLogActivity) {
	// Show dialpad if we are not in the call log activity.
	((HostInterface) activity).showDialpad();
	}
	}

	@Override
	public void onRequestPermissionsResult(
	int requestCode, String[] permissions, int[] grantResults) {
	if (requestCode == READ_CALL_LOG_PERMISSION_REQUEST_CODE) {
	if (grantResults.length >= 1 && PackageManager.PERMISSION_GRANTED == grantResults[0]) {
	// Force a refresh of the data since we were missing the permission before this.
	mRefreshDataRequired = true;
	}
	}
	}

	/** Schedules an update to the relative call times (X mins ago). */
	private void rescheduleDisplayUpdate() {
	if (!mDisplayUpdateHandler.hasMessages(EVENT_UPDATE_DISPLAY)) {
	long time = System.currentTimeMillis();
	// This value allows us to change the display relatively close to when the time changes
	// from one minute to the next.
	long millisUtilNextMinute = MILLIS_IN_MINUTE - (time % MILLIS_IN_MINUTE);
	mDisplayUpdateHandler.sendEmptyMessageDelayed(EVENT_UPDATE_DISPLAY, millisUtilNextMinute);
	}
	}

	/** Cancels any pending update requests to update the relative call times (X mins ago). */
	private void cancelDisplayUpdate() {
	mDisplayUpdateHandler.removeMessages(EVENT_UPDATE_DISPLAY);
	}

	@CallSuper
	public void onVisible() {
	LogUtil.enterBlock("CallLogFragment.onPageSelected");
	if (getActivity() != null) {
	((HostInterface) getActivity())
	.enableFloatingButton(mModalAlertManager == null \|\| mModalAlertManager.isEmpty());
	}
	}

	@CallSuper
	public void onNotVisible() {
	LogUtil.enterBlock("CallLogFragment.onPageUnselected");
	}

	@Override
	public void onShowModalAlert(boolean show) {
	LogUtil.d(
	"CallLogFragment.onShowModalAlert",
	"show: %b, fragment: %s, isVisible: %b",
	show,
	this,
	getUserVisibleHint());
	getAdapter().notifyDataSetChanged();
	HostInterface hostInterface = (HostInterface) getActivity();
	if (show) {
	mRecyclerView.setVisibility(View.GONE);
	mModalAlertView.setVisibility(View.VISIBLE);
	if (hostInterface != null && getUserVisibleHint()) {
	hostInterface.enableFloatingButton(false);
	}
	} else {
	mRecyclerView.setVisibility(View.VISIBLE);
	mModalAlertView.setVisibility(View.GONE);
	if (hostInterface != null && getUserVisibleHint()) {
	hostInterface.enableFloatingButton(true);
	}
	}
	}

	public interface HostInterface {

	void showDialpad();

	void enableFloatingButton(boolean enabled);
	}

	protected class CustomContentObserver extends ContentObserver {

	public CustomContentObserver() {
	super(mHandler);
	}

	@Override
	public void onChange(boolean selfChange) {
	mRefreshDataRequired = true;
	}
	}
	}