Руководство по android api

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

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

Это может звучать сложно, но с большим количеством сайтов, которые раскрывают свои ресурсы через REST API, на самом деле это довольно просто. (Смотрите руководство для начинающих по HTTP и REST для примера.)

В этом уроке я расскажу вам, как использовать классы и методы, доступные в Android SDK, для подключения к удаленным веб-серверам и взаимодействия с ними с использованием их REST API.

1. Включение доступа к Интернету

Использование REST API, очевидно, связано с использованием Интернета. Тем не менее, приложения Android могут получить доступ к Интернету только в том случае, если у них есть разрешение android.permission.INTERNET. Поэтому перед началом написания любого сетевого кода вы должны убедиться, что в файле манифеста вашего проекта присутствуют следующие uses-permission теги:

1

<uses-permission android:name="android.permission.INTERNET" />

Поскольку android.permission.INTERNET не считается опасным разрешением, вам не нужно запрашивать его во время выполнения на устройствах с уровнем API 23 или выше.

2. Создание фоновых потоков

Платформа Android не позволяет выполнять сетевые операции в основном потоке приложения. Поэтому весь ваш сетевой код должен принадлежать фоновому потоку. Самый простой способ создать такой поток — использовать метод execute() класса AsyncTask. В качестве единственного аргумента execute() ожидает объект Runnable.

1

AsyncTask.execute(new Runnable() {

2

    @Override

3

    public void run() {

4

        // All your networking logic

5

        // should be here

6

    }

7

});

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

3. Создание HTTP-соединения

Используя метод openConnection() класса URL, вы можете быстро настроить соединение с любой конечной точкой REST. Возвращаемое значение openConnection() должно быть передано в экземпляр HttpURLConnection или HttpsURLConnection, в зависимости от доступа к конечной точке через HTTP или HTTPS. Оба HttpURLConnection и HttpsURLConnection позволяют выполнять такие операции, как добавление заголовков запросов и чтение ответов.

В следующем фрагменте кода показано, как настроить соединение с корневой конечной точкой API GitHub:

1

// Create URL

2

URL githubEndpoint = new URL("https://api.github.com/");

3

4

// Create connection

5

HttpsURLConnection myConnection =

6

        (HttpsURLConnection) githubEndpoint.openConnection();

Обратите внимание, что HttpsURLConnection является подклассом класса HttpURLConnection.

4. Добавление заголовков запросов

Большинство веб-сайтов, предлагающих REST API, хотят иметь возможность однозначно идентифицировать ваше приложение. Самый простой способ помочь им сделать это — включить уникальный заголовок User-Agent во все ваши запросы.

Чтобы добавить заголовок User-Agent в ваш запрос, вы должны использовать метод setRequestProperty() объекта HttpURLConnection. Например, вот как вы устанавливаете заголовок User-Agent в my-rest-app-v0.1:

1

myConnection.setRequestProperty("User-Agent", "my-rest-app-v0.1");

Вы можете добавить несколько заголовков к своему запросу, вызвав несколько раз метод setRequestProperty(). Например, следующий фрагмент кода добавляет заголовок Accept и кастомный заголовок Contact-Me:

1

myConnection.setRequestProperty("Accept", 

2

        "application/vnd.github.v3+json");

3

myConnection.setRequestProperty("Contact-Me", 

4

        "hathibelagal@example.com");

5. Чтение ответов

После того как вы передали все заголовки запросов, вы можете проверить, есть ли у вас валидный ответ, используя метод getResponseCode() объекта HttpURLConnection.

1

if (myConnection.getResponseCode() == 200) {

2

    // Success

3

    // Further processing here

4

} else {

5

    // Error handling code goes here

6

}

Если класс HttpURLConnection получает код ответа на перенаправление, например 301, он автоматически обрабатывает его и следует за перенаправлением. Поэтому, как правило, вам не нужно будет писать дополнительный код для проверки перенаправления.

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

1

InputStream responseBody = myConnection.getInputStream();

Большинство REST API в наши дни возвращают данные, отформатированные как документы JSON. Поэтому, вместо прямого чтения из объекта InputStream, я предлагаю вам создать для него InputStreamReader.

1

InputStreamReader responseBodyReader = 

2

        new InputStreamReader(responseBody, "UTF-8");

6. Разбор JSON ответов

Android SDK имеет класс JsonReader, который позволяет легко разбирать документы JSON. Вы можете создать новый экземпляр класса JsonReader, передав объект InputStreamReader его конструктору.

1

JsonReader jsonReader = new JsonReader(responseBodyReader);

То как вы извлекаете определенную часть информации из документа JSON, зависит от его структуры. Например, документ JSON, возвращаемый корневой конечной точкой REST API GitHub, выглядит следующим образом:

1

{

2

  "current_user_url": "https://api.github.com/user",

3

  "current_user_authorizations_html_url": "https://github.com/settings/connections/applications{/client_id}",

4

  "authorizations_url": "https://api.github.com/authorizations",

5

  "code_search_url": "https://api.github.com/search/code?q=1{&page,per_page,sort,order}",

6

  "emails_url": "https://api.github.com/user/emails",

7

  "emojis_url": "https://api.github.com/emojis",

8

  "events_url": "https://api.github.com/events",

9

  "feeds_url": "https://api.github.com/feeds",

10

  "followers_url": "https://api.github.com/user/followers",

11

  "following_url": "https://api.github.com/user/following{/target}",

12

  "gists_url": "https://api.github.com/gists{/gist_id}",

13

  "hub_url": "https://api.github.com/hub",

14

  "issue_search_url": "https://api.github.com/search/issues?q=1{&page,per_page,sort,order}",

15

  "issues_url": "https://api.github.com/issues",

16

  "keys_url": "https://api.github.com/user/keys",

17

  "notifications_url": "https://api.github.com/notifications",

18

  "organization_repositories_url": "https://api.github.com/orgs/{org}/repos{?type,page,per_page,sort}",

19

  "organization_url": "https://api.github.com/orgs/{org}",

20

  "public_gists_url": "https://api.github.com/gists/public",

21

  "rate_limit_url": "https://api.github.com/rate_limit",

22

  "repository_url": "https://api.github.com/repos/{owner}/{repo}",

23

  "repository_search_url": "https://api.github.com/search/repositories?q=1{&page,per_page,sort,order}",

24

  "current_user_repositories_url": "https://api.github.com/user/repos{?type,page,per_page,sort}",

25

  "starred_url": "https://api.github.com/user/starred{/owner}{/repo}",

26

  "starred_gists_url": "https://api.github.com/gists/starred",

27

  "team_url": "https://api.github.com/teams",

28

  "user_url": "https://api.github.com/users/{user}",

29

  "user_organizations_url": "https://api.github.com/user/orgs",

30

  "user_repositories_url": "https://api.github.com/users/{user}/repos{?type,page,per_page,sort}",

31

  "user_search_url": "https://api.github.com/search/users?q=1{&page,per_page,sort,order}"

32

}

Как вы можете видеть, ответ — это только один большой объект JSON, содержащий несколько ключей. Чтобы извлечь из него значение с именем organization_url, вам нужно будет написать следующий код:

1

jsonReader.beginObject(); // Start processing the JSON object

2

while (jsonReader.hasNext()) { // Loop through all keys

3

    String key = jsonReader.nextName(); // Fetch the next key

4

    if (key.equals("organization_url")) { // Check if desired key

5

        // Fetch the value as a String

6

        String value = jsonReader.nextString();

7

8

        // Do something with the value

9

        // ...

10

11

        break; // Break out of the loop

12

    } else {

13

        jsonReader.skipValue(); // Skip values of other keys

14

    }

15

}

Вышеупомянутый код обрабатывает ответ JSON как поток токенов. Поэтому он потребляет очень мало памяти. Однако, поскольку он должен обрабатывать каждый отдельный токен один за другим, он может оказаться медленным при обработке больших ответов.

После того как вы извлечете всю необходимую информацию, вы всегда должны вызвать метод close() для объекта JsonReader, чтобы он освобождал все сохраненные ресурсы.

Вы также должны закрыть соединение, вызвав метод disconnect() объекта HttpURLConnection.

1

myConnection.disconnect();

7. Использование разных HTTP методов

HTTP-интерфейсы REST используют методы HTTP для определения типа операции, которая должна выполняться над ресурсом. На предыдущих шагах мы использовали метод HTTP GET для выполнения операции чтения. Поскольку класс HttpURLConnection использует по умолчанию метод GET, нам не нужно было его явно указывать.

Чтобы изменить метод HTTP вашего объекта HttpURLConnection, вы должны использовать его метод setRequestMethod(). Например, следующий фрагмент кода открывает соединение с конечной точкой, принадлежащей httpbin.org, и устанавливает свой HTTP-метод в POST:

1

URL httpbinEndpoint = new URL("https://httpbin.org/post");

2

HttpsURLConnection myConnection

3

        = (HttpsURLConnection) httpbinEndpoint.openConnection();

4

5

myConnection.setRequestMethod("POST");

Как вы уже знаете, POST-запросы используются для отправки данных на сервер. При записи в выходной поток соединения вы можете легко добавить любые данные в тело запроса POST. Однако, прежде чем вы это сделаете, вы должны убедиться, что вы вызываете метод setDoOutput() объекта HttpURLConnection и передаете ему значение true.

В следующем фрагменте кода показано, как отправить на сервер простую пару «ключ-значение»:

1

// Create the data

2

String myData = "message=Hello";

3

4

// Enable writing

5

myConnection.setDoOutput(true);

6

7

// Write the data

8

myConnection.getOutputStream().write(myData.getBytes());

8. Кэширование ответов

Всегда рекомендуется кэшировать ответы HTTP. Таким образом, вы можете не только сократить потребление пропускной способности вашего приложения, но и сделать его более отзывчивым. Начиная с уровня API 13, Android SDK предлагает класс HttpResponseCache, который позволяет легко реализовать кэширование без каких-либо изменений в вашей сетевой логике.

Чтобы установить кэш для вашего приложения, вы должны вызвать метод install() класса HttpResponseCache. Метод ожидает абсолютный путь, указывающий, где должен быть установлен кеш, и число, определяющее размер кеша. Вы можете использовать метод getCacheDir(), если вы не хотите указывать абсолютный путь вручную.

В следующем фрагменте кода устанавливается кеш размером 100 000 байт:

1

HttpResponseCache myCache = HttpResponseCache.install(

2

                                getCacheDir(), 100000L);

Как только кеш установлен, класс HttpURLConnection начинает использовать его автоматически. Чтобы проверить, работает ли ваш кеш, вы можете использовать его метод getHitCount(), который возвращает количество HTTP-ответов, которые были отправлены из кеша.

1

if (myCache.getHitCount() > 0) {

2

    // The cache is working

3

}

Заключение

Существуют тысячи REST API-интерфейсов, которые вы можете свободно использовать в своих приложениях для Android. Используя их, вы можете сделать ваше приложение более информативным, интересным и многофункциональным. В этом уроке вы узнали, как использовать класс HttpURLConnection для использования таких REST API. Вы также узнали, как создать кеш ответов HTTP, который снижает использование потребление сетевого трафика вашим приложением.

Если вы считаете, что использование HttpURLConnection слишком сложное, вам следует обратить внимание на сторонние библиотеки, такие как например, Volley. Библиотеки, подобные этой, используют класс HttpURLConnection внутри, но предоставляют множество удобных методов, которые позволяют сделать ваш код более кратким и читаемым.

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

Сегодня редко можно встретить приложение для Android, которое никогда не подключается к Интернету.

Независимо от того, выполняет ли ваше приложение резервное копирование данных в облако, аутентифицирует пользователей с помощью функции «Войти в Google», загружает изображения или размещает контент на сайтах социальных сетей, многие приложения должны поддерживать регулярную связь с удаленными серверами.

Сеть стала таким основным продуктом мобильных приложений, что существует широкий спектр библиотек, специально разработанных, чтобы помочь вам извлекать данные с удаленных серверов и обмениваться данными с более широким Интернетом.

В этой статье я покажу вам, как добавить сетевые возможности в ваше приложение Android с помощью Retrofit. Мы рассмотрим, что такое Retrofit и как вы можете использовать его для подключения к любой службе API на основе HTTP, получения данных из этого API, а затем использования этих данных в своем приложении.

К концу этой статьи вы создадите приложение для Android, которое отправляет HTTP-запрос к бесплатному JSONPlaceholder API, обрабатывает ответ и затем отображает эту информацию пользователю в виде прокручиваемого RecyclerView.

Retrofit – это типобезопасный HTTP-клиент для Android, который позволяет подключаться к интерфейсу программирования веб-приложений (API). Вы можете использовать Retrofit для подключения к Twitter API, чтобы вы могли отображать последние твиты в своем приложении, получать информацию о последних блокбастерах с помощью API базы данных фильмов (TMDb) или проверять прогноз через Weather API.

Как сделать запрос на модернизацию?

Чтобы сделать запрос на модернизацию, вам понадобится следующее:

• Класс Retrofit: здесь вы создадите экземпляр Retrofit и определите базовый URL-адрес, который ваше приложение будет использовать для всех своих HTTP-запросов. В нашем приложении базовый URL-адрес будет https://jsonplaceholder.typicode.com/.
• Интерфейс, определяющий операции HTTP: здесь вы будете описывать каждый запрос на модернизацию, который вы хотите сделать, используя специальные аннотации модернизации, которые содержат подробные сведения о параметрах и методе запроса.
• POJO: это класс модели данных, который обеспечивает автоматическое отображение ответа сервера, поэтому вам не нужно выполнять какой-либо анализ вручную.
• Синхронный или асинхронный сетевой запрос: после того, как вы создали свой сетевой запрос, вам необходимо выполнить его и указать, как ваше приложение должно обрабатывать ответ – будь то успех или неудача.

После создания этих компонентов структура вашего проекта должна выглядеть примерно так:

Существует множество API, но мы будем использовать JSONPlaceholder, поддельный REST API, разработанный для людей, которым нужен легкий доступ к поддельным данным, например тех, кто тестирует новую библиотеку или приложение, или кто-то, кто следит за онлайн-руководством! В частности, мы будем использовать ресурс API «/ users», который предоставляет список имен.

Начало работы: сериализация и десериализация с Gson

Для начала создайте новый проект Android с настройками по вашему выбору, а затем добавьте зависимости, которые мы будем использовать в этом проекте.

Для отправки HTTP-запросов нам понадобится последняя версия Retrofit, но нам также понадобится специальный конвертер.

В большинстве случаев запросы и ответы сервера отображаются в нейтральном для языка формате, таком как JSON, а не предоставляются как объекты Java. Когда вы используете Retrofit, вам обычно приходится иметь дело с сериализацией и десериализацией данных JSON:

• Сериализация: это процесс преобразования структур данных или состояния объекта в формат, который можно сохранить.
• Десериализация: это процесс, при котором структура данных извлекается из серии байтов.

По умолчанию Retrofit может десериализовать HTTP-тела только в тип ResponseBody OkHttp, но вы можете поддерживать другие типы, используя другие конвертеры.

Существуют различные конвертеры, доступные для разных форматов, но мы будем использовать Gson, библиотеку Java, которая может преобразовывать объекты Java в их представление JSON. Он также может преобразовывать строки JSON в их эквивалентные объекты Java. Одним из основных преимуществ использования Gson является то, что вам не придется выполнять дополнительную настройку в ваших классах Java, поскольку ответ будет отображаться автоматически.

После того, как мы успешно получили данные с сервера, мы отобразим их в виде списка. Я также добавляю RecyclerView и CardView в качестве зависимостей проекта.

После добавления этих зависимостей ваш файл build.gradle на уровне проекта должен выглядеть примерно так:

dependencies {
   implementation fileTree(dir: 

Поскольку мы будем связываться с удаленным сервером, вам также необходимо открыть манифест проекта и добавить разрешение в Интернете:

<?xml version="1.0" encoding="utf-8"?>

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

Определение конечных точек с помощью HTTP-аннотаций

Затем давайте создадим интерфейс, содержащий информацию о конечных точках API, с которыми мы хотим взаимодействовать. Конечная точка – это просто URL-адрес, с которого мы хотим получить некоторую информацию, в данном случае это https://jsonplaceholder.typicode.com/users. Мы укажем базовый URL (https://jsonplaceholder.typicode.com) в другом месте нашего проекта, поэтому сейчас нам просто нужно определить относительный URL-адрес конечной точки, то есть «/ users».

Каждая конечная точка представлена ​​как метод, который должен включать по крайней мере одну аннотацию HTTP, указывающую, как следует обрабатывать этот запрос.

Retrofit поддерживает следующие встроенные аннотации для каждого из стандартных типов запросов:

• GET: метод, помеченный @GET, отвечает за обработку HTTP-запроса GET, где данные извлекаются с сервера. Это аннотация, которую мы будем использовать для получения списка имен.
• POST: метод, помеченный @POST, отвечает за обработку HTTP-запроса POST, по которому вы отправляете данные на сервер.
• PUT: этот метод будет обрабатывать HTTP-запрос PUT, где мы предоставляем некоторые данные и просим сервер сохранить их под определенным URL-адресом.
• DELETE: этот метод будет обрабатывать HTTP-запрос DELETE, в котором указывается ресурс, который следует удалить.
• HEAD: этот метод обрабатывает HTTP-запрос HEAD. HEAD похож на GET, за исключением того, что метод @HEAD извлекает информацию без соответствующего тела ответа. Используя аннотации @HEAD, вы можете получить данные, записанные в заголовке ответа, без необходимости извлекать остальную часть этого содержимого.

В нашем приложении мы будем использовать аннотацию @GET, чтобы сделать простой HTTP-запрос GET на относительный URL-адрес, который дает нам следующее:

@GET

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

Чтобы создать этот интерфейс:

• Выберите «Файл»> «Создать»> «Класс Java» на панели инструментов Android Studio.
• В следующем меню откройте раскрывающийся список «Тип» и выберите «Интерфейс».
• Дайте этому интерфейсу имя «GetData» и нажмите «ОК».
• Откройте новый интерфейс «GetData» и добавьте следующее:

package

Чтобы упростить задачу, этот интерфейс содержит одну конечную точку, но вы можете включить несколько конечных точек в один интерфейс.

Создание модели данных

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

Мы также собираемся использовать аннотацию @SerializedName, которая указывает, что поле должно быть сериализовано с предоставленным именем, а не стандартным именем поля API.

Чтобы создать эту модель:

• Выберите «Файл»> «Создать»> «Класс Java» на панели инструментов Android Studio.
• Назовите этот класс «RetroUsers» и нажмите «ОК».
• Откройте новый класс «RetroUsers» и добавьте следующее:

package

Создание экземпляра Retrofit

Следующим шагом будет использование класса Retrofit.Builder для создания экземпляра Retrofit, где мы вызовем нашу конечную точку и получим список имен.

После создания нашего объекта Retrofit нам нужно указать:

• Фабрика преобразователей по умолчанию, которой в данном случае является Gson. Вы применяете преобразователь с помощью метода addConverterFactory().
• Базовый URL. Требования к проекту меняются нередко, поэтому в какой-то момент вам может потребоваться переключить свой проект на другой URL-адрес. Если ваш базовый URL-адрес определен в одном месте, вы можете изменить его, не затрагивая все конечные точки приложения. Обычно вы определяете свой базовый URL при создании экземпляра Retrofit, что мы и делаем здесь.

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

Мы собираемся реализовать эту функцию в повторно используемом классе, поскольку это позволяет нам создать объект Retrofit один раз, а затем повторно использовать его во всем нашем приложении.

Создайте новый класс Java («Файл> Новый> Класс Java») с именем «RetrofitClient», а затем добавьте следующее:

package

Хотя мы используем только один преобразователь в нашем проекте, вы можете использовать несколько преобразователей в одном экземпляре Retrofit, например:

Если вы применяете несколько конвертеров, ваше приложение всегда будет использовать первый совместимый конвертер, переданный в Retrofit, которым в приведенном выше примере является Gson. Предполагая, что приведенный выше код извлекает данные, которые могут обрабатываться Gson или Moshi, он всегда будет использовать конвертер Gson.

Выполнение сетевого запроса

Теперь все на месте, мы готовы выполнить наш сетевой вызов.

Вы можете выполнять запросы на модернизацию синхронно с помощью call.execute () или асинхронно с помощью call.enqueue. Синхронные запросы выполняются в основном потоке и рискуют заблокировать основной поток пользовательского интерфейса во всех версиях Android. Кроме того, если вы попытаетесь выполнить запрос на модернизацию синхронно на Android 4.0 или выше, ваше приложение выйдет из строя с ошибкой NetworkOnMainThreadException. Итак, мы будем использовать метод enqueue () для асинхронной отправки нашего запроса.

Retrofit загрузит и проанализирует данные API в фоновом потоке, а затем вернет ответ в потоке пользовательского интерфейса. Мы обработаем этот ответ с помощью методов обратного вызова onResponse () и onFailure (), где мы определим, как наше приложение должно реагировать после завершения запроса.

Откройте класс MainActivity и добавьте следующее:

package

Отображение данных API

После получения данных нам нужно отобразить их в прокручиваемом списке.

Откройте файл activity_main.xml своего проекта и добавьте виджет RecylcerView.

<?xml version="1.0" encoding="utf-8"?>

Нам также необходимо определить макет каждой строки в нашем RecyclerView:

• Удерживая нажатой клавишу Control, щелкните папку «res / layout» вашего проекта.
• Выберите «Создать> Файл ресурсов макета».
• Дайте этому файлу имя «row_layout» и нажмите «ОК».
• Откройте этот файл и добавьте следующее:

<?xml version="1.0" encoding="utf-8"?>

Связывание данных с помощью адаптеров Android

RecyclerView состоит из нескольких компонентов:

• Виджет RecyclerView, который мы уже добавили в наш макет.
• Диспетчер компоновки, например LinearLayoutManager или GridLayoutManager.
• Объекты-держатели представления, которые являются экземплярами класса, расширяющего RecyclerView.ViewHolder. Каждый держатель представления отображает один элемент.
• Адаптер, который создает объекты-держатели представлений по мере необходимости и привязывает держателей представлений к их данным, вызывая метод onBindViewHolder ().

Чтобы связать наши данные, создайте новый класс Java с именем «MyAdapter», а затем добавьте следующее:

import

Выполнение сетевого вызова: тестирование нашего приложения Retrofit

Настало время протестировать наше приложение! Убедитесь, что у вас есть активное подключение к Интернету, а затем установите приложение на физический смартфон или планшет Android или виртуальное устройство Android (AVD).

Как только вы запустите приложение, Retrofit загрузит и проанализирует данные API, а затем отобразит их в RecylcerView.

Вы можете скачать этот завершенный проект с GitHub.

Использование дооснащения с RxJava 2

Также возможно использовать Retrofit в сочетании с другими библиотеками, включая RxJava.

Чтобы создать методы интерфейса API, которые возвращают типы RxJava, вам необходимо добавить адаптер RxJava в качестве зависимости проекта:

dependencies {
...
...
...
  implementation 

Затем вам нужно будет добавить RxJava2CallAdapterFactory в качестве адаптера вызова при создании экземпляра Retrofit:

После применения этого адаптера вы можете возвращать типы RxJava, такие как Observables и Flowables. Например:

@GET

Если вы хотите узнать больше о RxJava, ознакомьтесь с нашей статьей «Начало разработки приложений для Android с помощью RxJava 2.0».

Подведение итогов

В этом руководстве мы рассмотрели, как вы можете запрашивать информацию с удаленного сервера, обрабатывать ответ и отображать эту информацию в своем приложении с помощью популярного HTTP-клиента Retrofit. Мы также коснулись того, как использовать Retrofit в сочетании с другими библиотеками, включая RxJava, с помощью адаптеров.

Планируете ли вы использовать Retrofit в своих будущих проектах? Или у вас есть рекомендации по API, которые вы регулярно используете в своих проектах Android?

Связанный

• Лучшие инструменты разработчика Android
• Изучите приемы веб-разработки за 44 часа
• Очень простой обзор разработки приложений под Android для начинающих
• Лучшие бесплатные и платные курсы по разработке приложений для Android
• Я хочу разрабатывать приложения для Android. Какие языки мне следует изучать?
• Лучшие советы по облегчению изучения разработки под Android

Источник записи: https://www.androidauthority.com

Работа с API различных порталов — одна из самых распространенных задач, возникающих при разработке под Android. Казалось бы, ничего сложного — асинхронно посылать HTTP-запросы и отображать ответы, но дьявол, как всегда, кроется в деталях.

Основные антипаттерны:

• Отправка запроса прямо из кода Activity в основном треде — тут без комментариев, т.к. это приводит к заморозке UI, вследствие чего система может предложить убить приложением;
• Отправка запроса из кода Activity при помощи AsyncTask — плохо, т.к. если пользователь, к примеру, повернет экран, Activity пересоздастся и запрос придется выполнять заново, что приводит увеличению времени ожидания и количества потребляемого трафика;
• Отсутствие кэширования — после каждого действия пользователя ему придется ждать полной загрузки данных.

Решение проблем

Эти проблемы далеко не новы, и в 2010 году на коференции Google I/O Virgil Dobjanschi представил три патерна для REST клиентов (слайды с презентации). Их объединяют следующие черты:

• Все данные кэшируются в базу данных SQLite, работа с ней ведется при помощи ContentProvider-а, что обеспечивает отделение данных от представление и удобство работы с ними;
• Сетевые вопросы выполняются через специально созданный сервис (каждый запрос в отдельном потоке), это необходимо для того, чтобы даже если пользователь выйдет из приложения, данные все равно докачались и сохранились.

Сами паттерны:
    A. Activity → Service → ContentProvider, Activity взаимодействует с сервисом для выполнения сетевых запросов, сервис сохраняет полученные из сети данные в ContentProvider, откуда потом Activity их получает;
    B. Activity → ContentProvider → Service, Activity взаимодействует только с ContentProvider, ContentProvider выполняет сетевые запросы через сервис;
    C. Activity → ContentProvider → SyncAdapter, аналогично предыдущему, но предназначено для специфической ситуации, в которой локальные данные полностью синхронизируются с данными в облаке. В качестве примера можно
указать на контакты в аккаунте Google.

Наше приложение

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

ContentProvider

В первую очередь, нам необходимо создать модель данных для нашего приложения. Данные будем хранить в виде таблицы tweets, в которой два поля кроме _id: user_name и body — имя пользователя и текст твита, соответственно.
Опишем контакт нашего провайдера:

public final class Contract {
	public static final String AUTHORITY = "com.example.rest_a";
	
	public static final Uri AUTHORITY_URI = Uri.parse("content://" + AUTHORITY);
	
	public interface TweetsCoulmns {
		public static final String USER_NAME = "user_name";
		public static final String BODY = "body";
	}
	
	public static final class Tweets implements BaseColumns, TweetsCoulmns {
		public static final String CONTENT_PATH = "tweets";
		public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, CONTENT_PATH);
		public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd." + AUTHORITY + "." + CONTENT_PATH;
	}
}

Исходный код самого класса провайдера можно опустить, в нем создается база данных SQLite при помощи DatabaseHelper-а с названными полями и обеспечивается прямая работа с ней, в точности как в примере из документации. Стоит отметить только необходимость оповещать об изменениях данных подключенных наблюдателей, для чего в методе insert() имеется строка

getContext().getContentResolver().notifyChange(Contract.Tweets.CONTENT_URI, null);

а в методе query(), соответственно,

cursor.setNotificationUri(getContext().getContentResolver(), Contract.Tweets.CONTENT_URI);

Service

Теперь пришло время создать сервис, который бы выполнял запросы к серверу. Мы не будем изобретать велосипед и воспользуемся библитекой DataDroid для этого.

Для начала создадим напишем код, который получает данные из твиттера из объекта и вставляет их в базу данных. В DataDroid его нужно писать в классе, реализующем интерфейс Operation:

public final class TweetsOperation implements Operation {
	@Override
	public Bundle execute(Context context, Request request)
			throws ConnectionException, DataException, CustomRequestException {
		NetworkConnection connection = new NetworkConnection(context, "https://api.twitter.com/1/statuses/user_timeline.json");
		HashMap<String, String> params = new HashMap<String, String>();
		params.put("screen_name", request.getString("screen_name"));
		connection.setParameters(params);
		ConnectionResult result = connection.execute();
		ContentValues[] tweetsValues;
		try {
			JSONArray tweetsJson = new JSONArray(result.body);
			tweetsValues = new ContentValues[tweetsJson.length()];
			
			for (int i = 0; i < tweetsJson.length(); ++i) {
				ContentValues tweet = new ContentValues();
				tweet.put("user_name", tweetsJson.getJSONObject(i).getJSONObject("user").getString("name"));
				tweet.put("body", tweetsJson.getJSONObject(i).getString("text"));
				tweetsValues[i] = tweet;
			}
		} catch (JSONException e) {
			throw new DataException(e.getMessage());
		}
		
		context.getContentResolver().delete(Contract.Tweets.CONTENT_URI, null, null);
		context.getContentResolver().bulkInsert(Contract.Tweets.CONTENT_URI, tweetsValues);
		return null;
	}

Как видно из исходника, параметр screen_name передается через объект Request из DataDroid, который реализует интерфейс Parcelable и может быть передан через Intent. Напишем вспомогательный класс, который создавал бы Request-ы:

public final class RequestFactory {
	public static final int REQUEST_TWEETS = 1;
	
	public static Request getTweetsRequest(String screenName) {
		Request request = new Request(REQUEST_TWEETS);
		request.put("screen_name", screenName);
		return request;
	}
	
	private RequestFactory() {
	}
}

и класс сервиса, родителем которого является RequestService из DataDroid, так что нам достаточно определить соответствие типов запросов и объектов Operation:

public class RestService extends RequestService {

	@Override
	public Operation getOperationForType(int requestType) {
		switch (requestType) {
		case RequestFactory.REQUEST_TWEETS:
			return new TweetsOperation();
		default:
			return null;
		}
	}

Осталось определить синглотон типа RequestManager из DataDroid, в конструктор которому передать наш сервис, и модель готова.

Activity

Реализуем Activity. Для начала создадим layout со списком, правда, вместо ListView будем использовать PullToRefreshListView для обновления ленты скроллингом вниз.
Создаем SimpleCursorAdapter и подключаем к нему CursorLoader, который будет загружать данных из нашего ContentProvider-а:

	private static final int LOADER_ID = 1;
	private static final String[] PROJECTION = { 
		Tweets._ID,
		Tweets.USER_NAME,
		Tweets.BODY
	};
	private LoaderCallbacks<Cursor> loaderCallbacks = new LoaderCallbacks<Cursor>() {

		@Override
		public Loader<Cursor> onCreateLoader(int loaderId, Bundle arg1) {
			return new CursorLoader(
				MainActivity.this,
				Tweets.CONTENT_URI,
				PROJECTION,
				null,
				null,
				null
			);
		}

		@Override
		public void onLoadFinished(Loader<Cursor> arg0, Cursor cursor) {
			adapter.swapCursor(cursor);
		}

		@Override
		public void onLoaderReset(Loader<Cursor> arg0) {
			adapter.swapCursor(null);
		}
	};
	protected void onCreate(Bundle savedInstanceState) {
		// ...
		adapter = new SimpleCursorAdapter(this,
			R.layout.tweet_view, 
			null, 
			new String[]{ Tweets.USER_NAME, Tweets.BODY },
			new int[]{ R.id.user_name_text_view, R.id.body_text_view }, 
			0);
		listView.setAdapter(adapter);
		getSupportLoaderManager().initLoader(LOADER_ID, null, loaderCallbacks);
		// ...
	}

Теперь осталось добавить загрузку твитов. Для этого нужно при помощи RequestFactory создать объект запроса для загрузки твитов и запустить этот запрос при помощи RequestManager-а. Все это повесим на событие pull-down нашего списка. Вот код:

	private RestRequestManager requestManager;
	// ...
	protected void onCreate(Bundle savedInstanceState) {
		// ...
		listView.setOnRefreshListener(new OnRefreshListener<ListView>() {

			@Override
			public void onRefresh(PullToRefreshBase<ListView> refreshView) {
				update();
			}
		});
		requestManager = RestRequestManager.from(this);
	}
	// ...
	void update() {
		listView.setRefreshing();
		Request updateRequest = new Request(RequestFactory.REQUEST_TWEETS);
		updateRequest.put("screen_name", "habrahabr");
		requestManager.execute(updateRequest, requestListener);
	}
	RequestListener requestListener = new RequestListener() {
		
		@Override
		public void onRequestFinished(Request request, Bundle resultData) {
			listView.onRefreshComplete();
		}
		
		void showError() {
			listView.onRefreshComplete();
			AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
			builder.
				setTitle(android.R.string.dialog_alert_title).
				setMessage(getString(R.string.faled_to_load_data)).
				create().
				show();
		}
		
		@Override
		public void onRequestDataError(Request request) {
			showError();
		}
		
		@Override
		public void onRequestCustomError(Request request, Bundle resultData) {
			showError();
		}
		
		@Override
		public void onRequestConnectionError(Request request, int statusCode) {
			showError();
		}
	};

Все, прописываем Service и ContentProvider в манифест и запускаем приложение:

Ссылки

• Исходники на github: github.com/therussianphysicist/rest_a
• Исходники из книги O’Reilly «Programming Android», реализующие паттерн B: github.com/bmeike/ProgrammingAndroidExamples (проекты FinchFramework и FinchVideo)

Автор: therussianphysicist

Источник