Superuser/src/com/koushikdutta/superuser/SettingsFragmentInternal.java

   1 /*
   2  * Copyright (C) 2013 Koushik Dutta (@koush)
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.koushikdutta.superuser;
  18
  19 import android.annotation.SuppressLint;
  20 import android.app.AlertDialog;
  21 import android.app.Dialog;
  22 import android.content.Context;
  23 import android.content.DialogInterface;
  24 import android.content.DialogInterface.OnClickListener;
  25 import android.content.Intent;
  26 import android.os.Bundle;
  27 import android.view.LayoutInflater;
  28 import android.view.View;
  29 import android.view.ViewGroup;
  30 import android.view.ViewGroup.LayoutParams;
  31 import android.widget.Toast;
  32
  33 import com.koushikdutta.superuser.util.Settings;
  34 import com.koushikdutta.widgets.BetterListFragmentInternal;
  35 import com.koushikdutta.widgets.FragmentInterfaceWrapper;
  36 import com.koushikdutta.widgets.ListItem;
  37
  38 @SuppressLint("ValidFragment")
  39 public class SettingsFragmentInternal extends BetterListFragmentInternal {
  40     public SettingsFragmentInternal(FragmentInterfaceWrapper fragment) {
  41         super(fragment);
  42     }
  43
  44     @Override
  45     protected int getListFragmentResource() {
  46         return R.layout.settings;
  47     }
  48
  49     ListItem pinItem;
  50     void confirmPin(final String pin) {
  51         final Dialog d = new Dialog(getContext());
  52         d.setTitle(R.string.confirm_pin);
  53         d.setContentView(new PinViewHelper((LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE), null, null) {
  54             public void onEnter(String password) {
  55                 super.onEnter(password);
  56                 if (pin.equals(password)) {
  57                     Settings.setPin(getActivity(), password);
  58                     pinItem.setSummary(Settings.isPinProtected(getActivity()) ? R.string.pin_set : R.string.pin_protection_summary);
  59                     if (password != null && password.length() > 0)
  60                         Toast.makeText(getActivity(), getString(R.string.pin_set), Toast.LENGTH_SHORT).show();
  61                     d.dismiss();
  62                     return;
  63                 }
  64                 Toast.makeText(getActivity(), getString(R.string.pin_mismatch), Toast.LENGTH_SHORT).show();
  65             };
  66
  67             public void onCancel() {
  68                 super.onCancel();
  69                 d.dismiss();
  70             };
  71         }.getView(), new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
  72         d.show();
  73     }
  74
  75     void setPin() {
  76         final Dialog d = new Dialog(getContext());
  77         d.setTitle(R.string.enter_new_pin);
  78         d.setContentView(new PinViewHelper((LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE), null, null) {
  79             public void onEnter(String password) {
  80                 super.onEnter(password);
  81                 confirmPin(password);
  82                 d.dismiss();
  83             };
  84
  85             public void onCancel() {
  86                 super.onCancel();
  87                 d.dismiss();
  88             };
  89         }.getView());
  90         d.show();
  91     }
  92
  93     void checkPin() {
  94         if (Settings.isPinProtected(getActivity())) {
  95             final Dialog d = new Dialog(getContext());
  96             d.setTitle(R.string.enter_pin);
  97             d.setContentView(new PinViewHelper((LayoutInflater)getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE), null, null) {
  98                 public void onEnter(String password) {
  99                     super.onEnter(password);
 100                     if (Settings.checkPin(getActivity(), password)) {
 101                         super.onEnter(password);
 102                         Settings.setPin(getActivity(), null);
 103                         pinItem.setSummary(R.string.pin_protection_summary);
 104                         Toast.makeText(getActivity(), getString(R.string.pin_disabled), Toast.LENGTH_SHORT).show();
 105                         d.dismiss();
 106                         return;
 107                     }
 108                     Toast.makeText(getActivity(), getString(R.string.incorrect_pin), Toast.LENGTH_SHORT).show();
 109                 };
 110
 111                 public void onCancel() {
 112                     super.onCancel();
 113                     d.dismiss();
 114                 };
 115             }.getView(), new ViewGroup.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
 116             d.show();
 117         }
 118         else {
 119             setPin();
 120         }
 121     }
 122
 123     @Override
 124     protected void onCreate(Bundle savedInstanceState, View view) {
 125         super.onCreate(savedInstanceState, view);
 126
 127         // NOTE to future koush
 128         // dark icons use the color #f3f3f3
 129
 130         addItem(R.string.security, new ListItem(this, R.string.superuser_access, 0, 0) {
 131             void update() {
 132                 switch (Settings.getSuperuserAccess()) {
 133                 case Settings.SUPERUSER_ACCESS_ADB_ONLY:
 134                     setSummary(R.string.adb_only);
 135                     break;
 136                 case Settings.SUPERUSER_ACCESS_APPS_ONLY:
 137                     setSummary(R.string.apps_only);
 138                     break;
 139                 case Settings.SUPERUSER_ACCESS_APPS_AND_ADB:
 140                     setSummary(R.string.apps_and_adb);
 141                     break;
 142                 case Settings.SUPERUSER_ACCESS_DISABLED:
 143                     setSummary(R.string.access_disabled);
 144                     break;
 145                 default:
 146                     setSummary(R.string.apps_and_adb);
 147                     break;
 148                 }
 149             }
 150             {
 151                 update();
 152             }
 153
 154             @Override
 155             public void onClick(View view) {
 156                 super.onClick(view);
 157
 158                 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 159                 builder.setTitle(R.string.superuser_access);
 160                 String[] items = new String[] { getString(R.string.access_disabled), getString(R.string.apps_only), getString(R.string.adb_only), getString(R.string.apps_and_adb) };
 161                 builder.setItems(items, new OnClickListener() {
 162                     @Override
 163                     public void onClick(DialogInterface dialog, int which) {
 164                         switch (which) {
 165                         case 0:
 166                             Settings.setSuperuserAccess(Settings.SUPERUSER_ACCESS_DISABLED);
 167                             break;
 168                         case 1:
 169                             Settings.setSuperuserAccess(Settings.SUPERUSER_ACCESS_APPS_ONLY);
 170                             break;
 171                         case 2:
 172                             Settings.setSuperuserAccess(Settings.SUPERUSER_ACCESS_ADB_ONLY);
 173                             break;
 174                         case 3:
 175                             Settings.setSuperuserAccess(Settings.SUPERUSER_ACCESS_APPS_AND_ADB);
 176                             break;
 177                         }
 178                         update();
 179                     }
 180                 });
 181                 builder.create().show();
 182             }
 183         }).setAttrDrawable(R.attr.toggleIcon);
 184
 185         if (Settings.getMultiuserMode(getActivity()) != Settings.MULTIUSER_MODE_NONE) {
 186             addItem(R.string.security, new ListItem(this, R.string.multiuser_policy, 0) {
 187                 void update() {
 188                     int res = -1;
 189                     switch (Settings.getMultiuserMode(getActivity())) {
 190                     case Settings.MULTIUSER_MODE_OWNER_MANAGED:
 191                         res = R.string.multiuser_owner_managed_summary;
 192                         break;
 193                     case Settings.MULTIUSER_MODE_OWNER_ONLY:
 194                         res = R.string.multiuser_owner_only_summary;
 195                         break;
 196                     case Settings.MULTIUSER_MODE_USER:
 197                         res = R.string.multiuser_user_summary;
 198                         break;
 199                     }
 200
 201                     if (!Helper.isAdminUser(getActivity())) {
 202                         setEnabled(false);
 203                         String s = "";
 204                         if (res != -1)
 205                             s = getString(res) + "\n";
 206                         setSummary(s + getString(R.string.multiuser_require_owner));
 207                     }
 208                     else {
 209                         if (res != -1)
 210                             setSummary(res);
 211                     }
 212                 }
 213
 214                 {
 215                     update();
 216                 }
 217
 218                 @Override
 219                 public void onClick(View view) {
 220                     super.onClick(view);
 221
 222                     AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 223                     builder.setTitle(R.string.multiuser_policy);
 224                     String[] items = new String[] { getString(R.string.multiuser_owner_only), getString(R.string.multiuser_owner_managed), getString(R.string.multiuser_user) };
 225                     builder.setItems(items, new OnClickListener() {
 226                         @Override
 227                         public void onClick(DialogInterface dialog, int which) {
 228                             switch (which) {
 229                             case 0:
 230                                 Settings.setMultiuserMode(getActivity(), Settings.MULTIUSER_MODE_OWNER_ONLY);
 231                                 break;
 232                             case 1:
 233                                 Settings.setMultiuserMode(getActivity(), Settings.MULTIUSER_MODE_OWNER_MANAGED);
 234                                 break;
 235                             case 2:
 236                                 Settings.setMultiuserMode(getActivity(), Settings.MULTIUSER_MODE_USER);
 237                                 break;
 238                             }
 239                             update();
 240                         }
 241                     });
 242                     builder.create().show();
 243                 }
 244             }).setAttrDrawable(R.attr.multiuserIcon);
 245         }
 246
 247         addItem(R.string.security, new ListItem(this, R.string.declared_permission, R.string.declared_permission_summary) {
 248             @Override
 249             public void onClick(View view) {
 250                 super.onClick(view);
 251                 Settings.setRequirePermission(getActivity(), getChecked());
 252             }
 253         })
 254         .setAttrDrawable(R.attr.declaredPermissionsIcon)
 255         .setCheckboxVisible(true)
 256         .setChecked(Settings.getRequirePermission(getActivity()));
 257
 258         addItem(R.string.security, new ListItem(this, R.string.automatic_response, 0) {
 259             void update() {
 260                 switch (Settings.getAutomaticResponse(getActivity())) {
 261                 case Settings.AUTOMATIC_RESPONSE_ALLOW:
 262                     setSummary(R.string.automatic_response_allow_summary);
 263                     break;
 264                 case Settings.AUTOMATIC_RESPONSE_DENY:
 265                     setSummary(R.string.automatic_response_deny_summary);
 266                     break;
 267                 case Settings.AUTOMATIC_RESPONSE_PROMPT:
 268                     setSummary(R.string.automatic_response_prompt_summary);
 269                     break;
 270                 }
 271             }
 272
 273             {
 274                 update();
 275             }
 276             @Override
 277             public void onClick(View view) {
 278                 super.onClick(view);
 279
 280                 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 281                 builder.setTitle(R.string.automatic_response);
 282                 String[] items = new String[] { getString(R.string.prompt), getString(R.string.su_deny), getString(R.string.su_allow) };
 283                 builder.setItems(items, new OnClickListener() {
 284                     @Override
 285                     public void onClick(DialogInterface dialog, int which) {
 286                         switch (which) {
 287                         case 0:
 288                             Settings.setAutomaticResponse(getActivity(), Settings.AUTOMATIC_RESPONSE_PROMPT);
 289                             break;
 290                         case 1:
 291                             Settings.setAutomaticResponse(getActivity(), Settings.AUTOMATIC_RESPONSE_DENY);
 292                             break;
 293                         case 2:
 294                             Settings.setAutomaticResponse(getActivity(), Settings.AUTOMATIC_RESPONSE_ALLOW);
 295                             break;
 296                         }
 297                         update();
 298                     }
 299                 });
 300                 builder.create().show();
 301             }
 302         })
 303         .setAttrDrawable(R.attr.automaticResponseIcon);
 304
 305         pinItem = addItem(R.string.security, new ListItem(this, R.string.pin_protection, Settings.isPinProtected(getActivity()) ? R.string.pin_set : R.string.pin_protection_summary) {
 306             @Override
 307             public void onClick(View view) {
 308                 super.onClick(view);
 309                 checkPin();
 310             }
 311         })
 312         .setAttrDrawable(R.attr.pinProtectionIcon);
 313
 314         addItem(R.string.security, new ListItem(this, getString(R.string.request_timeout), getString(R.string.request_timeout_summary, Settings.getRequestTimeout(getActivity()))) {
 315             @Override
 316             public void onClick(View view) {
 317                 super.onClick(view);
 318                 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 319                 builder.setTitle(R.string.request_timeout);
 320                 String[] seconds = new String[3];
 321                 for (int i = 0; i < seconds.length; i++) {
 322                     seconds[i] = getString(R.string.number_seconds, (i + 1) * 10);
 323                 }
 324                 builder.setItems(seconds, new OnClickListener() {
 325                     @Override
 326                     public void onClick(DialogInterface dialog, int which) {
 327                         Settings.setTimeout(getActivity(), (which + 1) * 10);
 328                         setSummary(getString(R.string.request_timeout_summary, Settings.getRequestTimeout(getActivity())));
 329                     }
 330                 });
 331                 builder.create().show();
 332             }
 333         })
 334         .setAttrDrawable(R.attr.requestTimeoutIcon);
 335
 336         addItem(R.string.settings, new ListItem(this, R.string.logging, R.string.logging_summary) {
 337             @Override
 338             public void onClick(View view) {
 339                 super.onClick(view);
 340                 Settings.setLogging(getActivity(), getChecked());
 341             }
 342         })
 343         .setAttrDrawable(R.attr.loggingIcon)
 344         .setCheckboxVisible(true)
 345         .setChecked(Settings.getLogging(getActivity()));
 346
 347         addItem(R.string.settings, new ListItem(this, R.string.notifications, 0) {
 348             void update() {
 349                 switch (Settings.getNotificationType(getActivity())) {
 350                 case Settings.NOTIFICATION_TYPE_NONE:
 351                     setSummary(getString(R.string.no_notification));
 352                     break;
 353                 case Settings.NOTIFICATION_TYPE_NOTIFICATION:
 354                     setSummary(getString(R.string.notifications_summary, getString(R.string.notification)));
 355                     break;
 356                 case Settings.NOTIFICATION_TYPE_TOAST:
 357                     setSummary(getString(R.string.notifications_summary, getString(R.string.toast)));
 358                     break;
 359                 }
 360             }
 361
 362             {
 363                 update();
 364             }
 365             @Override
 366             public void onClick(View view) {
 367                 super.onClick(view);
 368
 369                 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 370                 builder.setTitle(R.string.notifications);
 371                 String[] items = new String[] { getString(R.string.none), getString(R.string.toast), getString(R.string.notification) };
 372                 builder.setItems(items, new OnClickListener() {
 373                     @Override
 374                     public void onClick(DialogInterface dialog, int which) {
 375                         switch (which) {
 376                         case 0:
 377                             Settings.setNotificationType(getActivity(), Settings.NOTIFICATION_TYPE_NONE);
 378                             break;
 379                         case 2:
 380                             Settings.setNotificationType(getActivity(), Settings.NOTIFICATION_TYPE_NOTIFICATION);
 381                             break;
 382                         case 1:
 383                             Settings.setNotificationType(getActivity(), Settings.NOTIFICATION_TYPE_TOAST);
 384                             break;
 385                         }
 386                         update();
 387                     }
 388                 });
 389                 builder.create().show();
 390             }
 391         })
 392         .setAttrDrawable(R.attr.notificationsIcon);
 393
 394         if ("com.koushikdutta.superuser".equals(getActivity().getPackageName())) {
 395             addItem(R.string.settings, new ListItem(this, R.string.theme, 0) {
 396                 void update() {
 397                     switch (Settings.getTheme(getActivity())) {
 398                     case Settings.THEME_DARK:
 399                         setSummary(R.string.dark);
 400                         break;
 401                     default:
 402                         setSummary(R.string.light);
 403                         break;
 404                     }
 405                 }
 406                 {
 407                     update();
 408                 }
 409
 410                 @Override
 411                 public void onClick(View view) {
 412                     super.onClick(view);
 413
 414                     AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
 415                     builder.setTitle(R.string.theme);
 416                     String[] items = new String[] { getString(R.string.light), getString(R.string.dark) };
 417                     builder.setItems(items, new OnClickListener() {
 418                         @Override
 419                         public void onClick(DialogInterface dialog, int which) {
 420                             switch (which) {
 421                             case Settings.THEME_DARK:
 422                                 Settings.setTheme(getContext(), Settings.THEME_DARK);
 423                                 break;
 424                             default:
 425                                 Settings.setTheme(getContext(), Settings.THEME_LIGHT);
 426                                 break;
 427                             }
 428                             update();
 429                             getActivity().startActivity(new Intent(getActivity(), MainActivity.class));
 430                             getActivity().finish();
 431                         }
 432                     });
 433                     builder.create().show();
 434                 }
 435             })
 436             .setAttrDrawable(R.attr.themeIcon);
 437         }
 438     }
 439 }