Хранение настроек android studio

В этом уроке мы научимся выполнять сохранение данных нашего приложения для того, чтобы при следующих его запусках воссоздать сохраненное, а не вводить заново. Самый, наверное, распространенный и полезный способ от такого сохранения — это сохранение логина и пароля к чему либо: аккаунту, архиву и многое другое. Хотя на паролях все возможности далеко не исчерпываются, но мы рассмотрим пример использования стандартного интерфейса Shared Preferences на примере сохранения текстовых данных. Мы сделаем Android приложение, в котором будет два поля для ввода логина и пароля (любых двух слов) и две кнопки, сохранить и загрузить. Если заполнить поля ввода, но не нажать кнопку сохранить — введенные данные будут теряться, если же перед выходом пользователь нажмет на кнопку «Сохранить» то при следующем запуске он нажмет кнопку «Загрузить» и поля автоматически заполнятся введенными и сохраненными ранее символами.

Сохранение данных с помощью Shared Preferences происходит благодаря тому, что при сохранении данных таким образом, приложение создает специальный xml файл, где будет храниться нужная информация, и при нужде получить сохраненные данные, программа будет обращаться к этому xml файлу. Файл храниться в системе устройства по адресу /data/data/НАЗВАНИЕ_ПРОЕКТА/shared_prefs.

Интерфейс для сохранения настроек Shared Preferences довольно прост в использовании. Для этого вызывается специальный метод под названием getPreferences(). По отношению к введенным данным можно выбрать 3 уровня доступности:

— MODE_PRIVATE — только это приложение может читать настройки с xml файла;

— MODE_WORLD_READABLE — все приложения могут читать с xml файла;

— MODE_WORLD_WRITEABLE — все приложения могут выполнять запись в xml файл.

После объявления метода работы с Shared Preferences нужно создать объект Editor, который нужен для создания пар имя-значение, которые будут записаны в xml файл для сохранения с помощью метода put() . Для успешного внесения данных в файл сохранения в конце нужно выполнить команду commit.

Для того, чтобы извлечь сохраненные данные, нужно обратиться к ним с помощью команды get (), ссылаясь на необходимые пары-значения.

Итак, начнем делать наше приложение, описанное вначале. Создаем новый проект, выбираем Blank Activity. Интерфейс программы будет иметь два поля для ввода текста и две кнопки. Открываем файл activity_main.xml и добавляем в него следующее:

Теперь открываем MainActivity.java и добавляем этот код (объяснения там же):

Как видите, при сохранении и загрузке сохраненных данных будет высвечиваться Toast сообщение с информацией о выполненной операции.

Теперь осталось только протестировать наше приложение:

Похоже на чудо, но оно работает!

Таким образом, в этом уроке мы научились как в Android программировании выполнять сохранение данных приложения с помощью стандартного интерфейса под названием Shared Preferences. Надеюсь у вас все получилось, удачи в начинаниях.

Также можете переходить к изучению SQLite Database.

Источник

Сохраняем настройки

Введение

Очень часто требуется сохранить какие-то настройки. Простой пример — девочка с удовольствим пользовалась нашей программой Счётчик ворон и вертела головой в поисках очередной птицы. Но вот незадача — когда девочка вечером закрывала своё приложение, то на следующий день счётчик обнулялся. А так хотелось узнать, сколько ворон можно насчитать за месяц. Но однажды в дождливый осенний день она встретила рыжее чудо. Впрочем, это уже совсем другая история.

Самый простой способ, который приходит в голову — сбросить данные в файл, а при запуске приложения считывать необходимые данные из файла. Второй вариант — работать с базой данных и хранить настройки там.

Рассмотрим сначала второй вариант. Хранить данные в базе данных не всегда оправдано, если данных не слишком много, они простые и нам не нужно анализировать данные на предмет, сколько мышек поймал котик в прошлом году и сколько часов он спал в январе и феврале.

Первый вариант с файлами хорош, например, для сохранения больших текстовых заметок. Естественно, и для простых данных мы тоже можем использовать файлы. Записали что-то в файл, а потом открыли его и считали данные.

На самом деле нет необходимости изобретать свой велосипед и придумывать свою структуру для хранения данных. В Android существует класс SharedPreferences (Общие настройки), разработанный специально для этих целей. Приложение автоматически создаёт файл в своей папке и хранит простые данные в виде «ключ — значение». Весь процесс создания, открытия, чтения файла оптимизирован и избавляет вас от головной боли.

Общие настройки поддерживают базовые типы boolean, String, float, long и int, что делает их идеальным средством для быстрого сохранения значений по умолчанию, переменных экземпляра класса, текущего состояния UI и пользовательских настроек. Они чаще всего используются для обеспечения постоянства данных между пользовательскими сессиями и доступа к ним компонентов приложения.

Сохранение значений параметров

Если у вас сохранился старый проект по подсчёту ворон, то можете снова его открыть и добавить новый код. Либо заново создайте проект по памяти, заодно проверите, как усвоили урок и сможете ли вы самостоятельно создать проект с нуля, не заглядывая на сайт за подсказкой.

Создаём переменную, представляющую экземпляр класса SharedPreferences, который отвечает за работу с настройками:

Вы передаёте в указанный метод getSharedPreferences() имя вашего файла (файл будет создан автоматически) и стандартное разрешение по умолчанию MODE_PRIVATE — только приложение имеет доступ к настройкам. Если вам необходимо, вы можете создать несколько подобных файлов настроек.

Немного опередим события и представим, что приложение запущено, и мы считаем ворон весь день. Когда мы закрываем приложение, то нам необходимо сохранить информацию в «Общих настройках». Обычно для этих целей используют методы onPause() или onStop().

Чтобы внести изменения в настройки, нужно использовать класс SharedPreferences.Editor. Получить объект Editor можно через вызов метода edit() объекта SharedPreferences. После того, как вы внесли все необходимые изменения, вызовите метод apply(), чтобы изменения вступили в силу.

Теперь при закрытии программы значение счётчика автоматически запишется в файл. При повторном запуске приложения нам уже не нужно инициализировать счётчик со значением 0. Мы можем прочитать сохранённое значение и использовать его для счётчика, чтобы продолжить подсчёт. Сделаем это в методе onResume().

Мы проверяем сначала наличие ключа APP_PREFERENCES_COUNTER, а затем извлекаем из ключа его значение.

Вот и всё. Небольшие изменения в коде сделали программу продвинутой. Теперь вы можете спокойно закрывать и открывать программу, ваши данные не будут потеряны. При желании вы можете добавить кнопку для сброса счётчика. Это вам в качестве домашнего задания.

В теории показаны дополнительные примеры и даны подробные сведения об использовании «Общих настроек». Вам следует хорошенько разобраться в этом механизме, так как он часто используется на практике. Более того, некоторые программисты предпочитают использовать «Общие настройки» вместо базы данных, если это позволяет логика программы, так как это работает быстрее и потребляет меньше ресурсов. Выбор за вами.

Вместо послесловия

Не волнуйтесь, с котёнком всё в порядке. Девочка подобрала его и принесла домой. И добрая девочка по-прежнему пользуется нашей программой «Счётчик ворон». Наверное, биологом станет или ветеринаром.

При написании статьи использовались иллюстрации Рины З..

Источник

Полный список

— используем Preferences для работы с настройками приложения

Мы уже проходили Preferences, использовали их для хранения своих данных, знаем механизм. Теперь посмотрим, как они используются для хранения настроек приложения. Android предоставляет специальное Activity для работы с настройками – PreferenceActivity. Оно умеет читать определенные xml-файлы и создавать из них экран с настройками.

Создадим простое приложение. На первом экране будем читать и отображать настройки приложения, а на втором будем их задавать с помощью PreferenceActivity.

Надо придумать какие-нибудь настройки. Пусть это будут настройки неких уведомлений, а именно возможность включить/выключить уведомления (чекбокс) и возможность прописать адрес получателя (поле для ввода текста).

Project name: P0711_PreferencesSimple
Build Target: Android 2.3.3
Application name: PreferencesSimple
Package name: ru.startandroid.develop.p0711preferencessimple
Create Activity: MainActivity

Сначала создадим xml-файл с описанием настроек. В папке res создаем папку xml, а в ней создаем файл pref.xml:

Здесь мы указали, что наш экран настроек (PreferenceScreen) будет содержать чекбокс (CheckBoxPreference) и поле (EditTextPreference) для ввода значения. Параметры: key – ключ для сохранения/чтения, summary – текст-пояснение, title – заголовок. Далее увидим, что и где используется.

Создаем Activity для настроек. PrefActivity.java:

Вместо setContentView используется метод addPreferencesFromResource, который берет файл pref.xml и по нему создает экран настроек.

Не забудьте добавить это Activity в манифест. Тут никаких особенностей, все как обычно.

Рисуем экран main.xml:

Одно TextView, которое будет читать и отображать настройки приложения.

В onCreate мы находим TextView и получаем объект для работы с настройками — SharedPreferences. Он нам знаком, мы с ним работали ранее в уроке про Preferences. Далее идет закоментированный код полной очистки настроек приложения. Мы его не используем, я на всякий случай указал, может кому понадобится.

В onResume мы читаем из SharedPreferences настройки и выводим их в TextView. При чтении используем те самые ключи, которые прописывали в xml-файле в атрибутах key.

В onCreateOptionsMenu просто настраиваем меню для вызова окна настроек. Мы создаем пункт меню и вешаем на него Intent — в итоге при нажатии вызовется Activity.

На всякий случай уточню, почему для вывода инфы на экран здесь использую onResume, а не onCreate. Потому что, когда мы будем возвращаться с экрана настроек в главное окно, то onCreate главного окна не сработает (т.к. окно уже создано и висит в памяти) и изменения мы не увидим. А onResume точно сработает.

Все сохраняем и запускаем приложение. Видим такой экран:

По умолчанию, если настройки еще не заданы, мы получаем false и пустую строку, как и указывали в методах getBoolean и getString в onResume.

Жмем menu и переходим к настройкам.

То, что мы указывали в pref.xml система прочитала и сама создала экран настроек. Теперь мы можем здесь указывать нужные нам значения и они сразу же будут сохраняться без всяких кнопок Save. Впрочем, это стандартное поведение Android-настроек. Думаю, каждый из вас когда-нить копался в настройках и знает это.

Давайте включим наши уведомления

и пропишем адрес

Жмем кнопку назад, попадаем на главный экран

который в onResume прочел свежие настройки и отобразил их.

На следующем уроке:

— используем в настройках список
— группируем настройки по экранам и категориям

Присоединяйтесь к нам в Telegram:

— в канале StartAndroid публикуются ссылки на новые статьи с сайта startandroid.ru и интересные материалы с хабра, medium.com и т.п.

— в чатах решаем возникающие вопросы и проблемы по различным темам: Android, Kotlin, RxJava, Dagger, Тестирование

— ну и если просто хочется поговорить с коллегами по разработке, то есть чат Флудильня

— новый чат Performance для обсуждения проблем производительности и для ваших пожеланий по содержанию курса по этой теме

Источник

Android с нуля: как хранить данные приложения локально

Russian (Pусский) translation by Ellen Nelson (you can also view the original English article)

Когда доходит до сохранения данных приложений локально, разработчики Android определённо избалованы выбором. Помимо прямого доступа к внутренним и внешним областям хранения Android-устройства, платформа Android предлагает базы данных SQLite для хранения реляционных данных и специальные файлы для хранения пар ключ-значение. Более того, приложения для Android также могут использовать сторонние базы данных, которые предлагают поддержку NoSQL.

В этом уроке я покажу вам, как использовать все эти параметры хранения в приложениях для Android. Я также помогу вам понять, как выбрать наиболее подходящий вариант хранения данных.

Вам проще учиться по видео? Почему бы не посмотреть наш курс:

1. Хранение пар ключ-значение

Если вы ищете быстрый способ хранения нескольких строк или номеров, вам следует рассмотреть возможность использования файла настроек (preferences). Активити и службы Android могут использовать метод getDefaultSharedPreferences() класса PreferenceManager , чтобы ссылаться на объект SharedPreferences , который может быть использован и для чтения, и для записи в файл настроек по умолчанию.

Чтобы начать запись в файл настроек, вы должны вызвать метод edit() объекта SharedPreferences , который возвращает объект SharedPreferences.Editor .

Объект SharedPreferences.Editor имеет несколько интуитивных методов, которые можно использовать для хранения новых пар ключ-значение в файле настроек. Например, вы можете использовать метод putString() , чтобы поместить пару ключ-значение со значением типа String . Аналогично, вы можете использовать метод putFloat() , чтобы поместить пару ключ-значение, чьё значение типа float . Следующий пример кода создаёт три пары ключ-значение:

После того, как вы добавили все пары, вы должны вызвать метод commit() объекта SharedPreferences.Editor , чтобы сохранить их.

Чтение из объекта SharedPreferences гораздо проще. Всё, что вам нужно сделать, так это вызвать соответствующий метод get*() . Например, чтобы получить пару ключ-значение, чьё значение является String , вы должны вызывать метод getString() . Вот фрагмент кода, который извлекает все значения, которые мы добавили ранее:

Как вы видите из кода выше, второй параметр всех методов get*() ожидает значение по-умолчанию, которое является значением, которое должно быть возвращено, если ключ не существует и файле настроек.

Обратите внимание, что файлы настроек ограничены только строками и примитивными типами данных. Если вы хотите сохранить более сложные типы данных или двоичные данные, вы должны выбрать другой вариант хранения.

2. Использование базы данных SQLite

Каждое приложение для Android может создавать и использовать базы данных SQLite для хранения больших объемов структурированных данных. Как вы уже знаете, SQLite не только лёгкая, но и очень быстрая. Если у вас есть опыт работы с системами управления реляционными базами данных и вы знакомы как с SQL, что является сокращением для Structured Query Language, и JDBC, что является сокращением для Java Database Connectivity, это может быть предпочтительным вариантом хранения.

Чтобы создать новую базу данных SQLite или открыть уже существующую, вы можете использовать метод openOrCreateDatabase() внутри своей активити или службы. В качестве аргументов вы должны передать имя своей базы данных и режим, в котором вы хотите её открыть. Наиболее часто используемый режим MODE_PRIVATE , который гарантирует, что база данных доступна только для вашего приложения. Например, вот как вы можете открыть или создать базу данных с именем my.db:

После создания базы данных вы можете использовать метод execSQL() для запуска SQL-инструкций. В следующем коде показано, как использовать оператор SQL CREATE TABLE для создания таблицы названной user, которая имеет три столбца:

Хотя можно вставить новые строки в таблицу с помощью метода execSQL() , лучше использовать метод insert() . Метод insert() ожидает объект ContentValues , содержащий значения для каждого столбца таблицы. Объект ContentValues очень похож на объект Map и содержит пары ключ-значение.

Вот два объекта ContentValues , которые вы можете использовать с таблицей user :

Как вы могли догадаться, ключи, которые вы передаете методу put() , должны соответствовать именам столбцов в таблице.

Когда объекты ContentValues готовы, вы можете передать их методу insert() вместе с именем таблицы.

Чтобы отправить запрос в базу данных, вы можете использовать метод rawQuery() , который возвращает объект Cursor , содержащий результаты запроса.

Объект Cursor может содержать ноль или несколько строк. Самый простой способ перебрать все его строки, так это вызвать метод moveToNext() внутри цикла while .

Чтобы получить значение отдельного столбца, вы должны использовать такие методы, как getString() и getInt() , которые ожидают индекс столбца. Например, вот как вы получите все значения, вставленные в таблице user :

После того, как вы получите все результаты вашего запроса, убедитесь, что вы вызвали метод close() для объекта Cursor , чтобы освободить все ресурсы, которые он хранит.

Аналогичным образом, когда вы закончили все операции с базой данных, не забудьте вызвать метод close() для объекта SQLiteDatabase .

3. Использование внутреннего хранилища

Каждое приложение Android имеет свой собственный внутренний каталог хранения, взаимодействующий с ним, в котором приложение может хранить текстовые и двоичные файлы. Файлы внутри этого каталога недоступны для пользователя или других приложений, установленных на устройстве пользователя. Они также автоматически удаляются, когда пользователь удаляет приложение.

Прежде чем вы сможете использовать внутренний каталог хранилища, вы должны определить его местоположение. Для этого вы можете вызвать метод getFilesDir() , который доступен как для активити, так и для служб.

Чтобы получить ссылку на файл внутри каталога, вы можете передать имя файла вместе с указанным вами расположением. Например, вот как вы получите ссылку на файл alice.csv:

С этого момента вы можете использовать свои знания о классах и методах I/O (ввода/вывода) Java для чтения или записи в файл. В следующем фрагменте кода показано, как использовать объект FileOutputStream и метод write() для записи в файл:

4 . Использование внешнего хранилища

Поскольку внутреннее хранилище устройств Android обычно фиксировано и часто довольно ограничено, некоторые устройства Android поддерживают внешние носители данных, такие как съемные микро SD-карты. Я рекомендую использовать этот вариант хранения для больших файлов, таких как фотографии и видео.

В отличие от внутреннего хранилища, внешнее хранилище может не всегда быть доступно. Поэтому, перед его использованием, вы должны всегда проверять, смонтировано ли оно. Для этого используйте метод getExternalStorageState() класса Environment .

Как только вы убедитесь, что внешнее хранилище доступно, вы можете получить путь к файлу внешнего хранилища для своего приложения, вызвав метод getExternalFilesDir() и передав null в качестве аргумента. Затем вы можете использовать путь для ссылки на файлы внутри каталога. Например, вот как вы можете ссылаться на файл с именем bob.jpg в каталоге внешнего хранилища приложения:

Попросив пользователя предоставить вам разрешение WRITE_EXTERNAL_STORAGE , вы можете получить доступ для чтения/записи ко всей файловой системе во внешнем хранилище. Затем вы можете использовать известные общедоступные каталоги для хранения ваших фотографий, фильмов и других мультимедийных файлов. Класс Environment предлагает метод getExternalStoragePublicDirectory() для определения путей этих общих каталогов.

Например, передав этому методу значение Environment.DIRECTORY_PICTURES , вы можете определить путь к общедоступному каталогу, в котором вы можете хранить фотографии. Аналогично, если вы передадите этому методу значение Environment.DIRECTORY_MOVIES , вы получите путь к общедоступному каталогу, в котором могут быть сохранены фильмы.

Вот как вы можете ссылаться на файл bob.jpg в каталоге общих изображений:

Когда у вас есть объект File , вы можете снова использовать классы FileInputStream и FileOutputStream для чтения или записи на него.

Заключение

Теперь вы знаете, как максимально использовать возможности локального хранилища, предоставляемые Android SDK. Независимо от выбранного вами варианта хранения операции чтения/записи могут потребовать много времени, если задействованы большие объемы данных. Поэтому, чтобы убедиться, что основной поток пользовательского интерфейса всегда остается отзывчивым, вы должны рассмотреть возможность запуска операций в другом потоке.

Чтобы узнать больше о сохранении данных приложения локально, обратитесь к официальному руководству API хранения данных.

Источник