text: /*
   * Copyright (C) 2015 The CyanogenMod 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.settings.notification;
  
  import android.content.Context;
  import android.os.Bundle;
  import android.preference.PreferenceCategory;
  import android.provider.SearchIndexableResource;
  import android.provider.Settings;
  import android.util.Log;
  import com.android.internal.widget.LockPatternUtils;
  import com.android.settings.R;
  import com.android.settings.SettingsPreferenceFragment;
  import com.android.settings.search.BaseSearchIndexProvider;
  import com.android.settings.search.Indexable;
  
  import java.util.ArrayList;
  import java.util.List;
  
  public class NotificationManagerSettings extends SettingsPreferenceFragment
          implements Indexable {
  
      private static final String TAG = NotificationManagerSettings.class.getSimpleName();
  
      private static final String KEY_LOCK_SCREEN_NOTIFICATIONS = "lock_screen_notifications";
  
      private boolean mSecure;
      private int mLockscreenSelectedValue;
      private DropDownPreference mLockscreen;
  
      @Override
      public void onCreate(Bundle icicle) {
          super.onCreate(icicle);
          addPreferencesFromResource(R.xml.notification_manager_settings);
          mSecure = new LockPatternUtils(getActivity()).isSecure();
          initLockscreenNotifications();
      }
  
      // === Lockscreen (public / private) notifications ===
  
      private void initLockscreenNotifications() {
          mLockscreen = (DropDownPreference) findPreference(KEY_LOCK_SCREEN_NOTIFICATIONS);
          if (mLockscreen == null) {
              Log.i(TAG, "Preference not found: " + KEY_LOCK_SCREEN_NOTIFICATIONS);
              return;
          }
  
          mLockscreen.addItem(R.string.lock_screen_notifications_summary_show,
                  R.string.lock_screen_notifications_summary_show);
          if (mSecure) {
              mLockscreen.addItem(R.string.lock_screen_notifications_summary_hide,
                      R.string.lock_screen_notifications_summary_hide);
          }
          mLockscreen.addItem(R.string.lock_screen_notifications_summary_disable,
                  R.string.lock_screen_notifications_summary_disable);
          updateLockscreenNotifications();
          mLockscreen.setCallback(new DropDownPreference.Callback() {
              @Override
              public boolean onItemSelected(int pos, Object value) {
                  final int val = (Integer) value;
                  if (val == mLockscreenSelectedValue) {
                      return true;
                  }
                  final boolean enabled = val != R.string.lock_screen_notifications_summary_disable;
                  final boolean show = val == R.string.lock_screen_notifications_summary_show;
                  Settings.Secure.putInt(getContentResolver(),
                          Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, show ? 1 : 0);
                  Settings.Secure.putInt(getContentResolver(),
                          Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, enabled ? 1 : 0);
                  mLockscreenSelectedValue = val;
                  return true;
              }
          });
      }
  
      private void updateLockscreenNotifications() {
          if (mLockscreen == null) {
              return;
          }
          final boolean enabled = getLockscreenNotificationsEnabled();
          final boolean allowPrivate = !mSecure || getLockscreenAllowPrivateNotifications();
          mLockscreenSelectedValue = !enabled ? R.string.lock_screen_notifications_summary_disable :
                  allowPrivate ? R.string.lock_screen_notifications_summary_show :
                          R.string.lock_screen_notifications_summary_hide;
          mLockscreen.setSelectedValue(mLockscreenSelectedValue);
      }
  
  
      private boolean getLockscreenNotificationsEnabled() {
          return Settings.Secure.getInt(getContentResolver(),
                  Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS, 0) != 0;
      }
  
      private boolean getLockscreenAllowPrivateNotifications() {
          return Settings.Secure.getInt(getContentResolver(),
                  Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS, 0) != 0;
      }
  
      public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
              new BaseSearchIndexProvider() {
                  @Override
                  public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
                                                                              boolean enabled) {
                      ArrayList<SearchIndexableResource> result =
                              new ArrayList<SearchIndexableResource>();
  
                      SearchIndexableResource sir = new SearchIndexableResource(context);
                      sir.xmlResId = R.xml.notification_manager_settings;
                      result.add(sir);
  
                      return result;
                  }
              };
  }
  