1 В избранное 0 Ответвления 0

OSCHINA-MIRROR/HarmonyOS-tpc-ReactiveNetwork

Присоединиться к Gitlife
Откройте для себя и примите участие в публичных проектах с открытым исходным кодом с участием более 10 миллионов разработчиков. Приватные репозитории также полностью бесплатны :)
Присоединиться бесплатно
Клонировать/Скачать
README.md 16 КБ
Копировать Редактировать Web IDE Исходные данные Просмотреть построчно История
Отправлено 20.04.2025 03:34 bb5e252

Реактивная Сеть

ReactiveNetwork: ReactiveNetwork — это библиотека OHOS, которая слушает состояние подключения сети и соединение с интернетом с помощью RxJava Observables. Она написана с использованием подхода реактивного программирования.

ReactiveNetwork включает:

  • Наблюдение за подключением сети.
  • Проверку соединения с интернетом непрерывно и/или один раз.
  • Поддержку пользовательского хоста с использованием собственной стратегии InternetObservingStrategy.
  • Поддержку цепочки подключения к сети и соединения с интернетом.

Инструкции по использованию

Пример приложения требует следующих разрешений:

ohos.permission.INTERNET
ohos.permission.GET_NETWORK_INFO

Поддержка cleartextTraffic по умолчанию отключена для HTTP. Однако, HTTPS поддерживается по умолчанию. Чтобы поддержать HTTP, необходимо добавить "network" в файл config.json и установить атрибут "cleartextTraffic" в true.

{
  "deviceConfig": {
    "default": {
      "network": {
        "cleartextTraffic": true
      }
    }
  }
}

Наблюдение за подключением сети

Мы можем наблюдать Connectivity с помощью метода observeNetworkConnectivity(context) следующим образом:

ReactiveNetwork
  .observeNetworkConnectivity(context)
  .subscribeOn(Schedulers.io())
  ... // что-либо ещё, что вы можете сделать с RxJava
  .observeOn(HarmonySchedulers.mainThread())
  .subscribe(connectivity -> {
      // делайте что-либо с connectivity
      // вы можете вызвать connectivity.getNetworkState();
      // или connectivity.getNetworkCapabilities();
  },
  throwable -> { /* обрабатывайте ошибку здесь */} );
```Когда `Connectivity` изменяется, подписчик будет уведомлен. `Connectivity` может изменять своё состояние или тип.

**Ошибки** могут быть обработаны таким же образом, как и в любом другом RxJava observable. Например:

ReactiveNetwork .observeNetworkConnectivity(context) .subscribeOn(Schedulers.io()) .observeOn(HarmonySchedulers.mainThread()) .subscribe( connectivity -> /* обрабатывайте connectivity здесь /, throwable -> / обрабатывайте ошибку здесь */ );


### Наблюдение за соединением с интернетом

#### Наблюдение за непрерывным соединением с интернетом

Мы можем наблюдать соединение с интернетом непрерывно следующим образом:

ReactiveNetwork .observeInternetConnectivity() .subscribeOn(Schedulers.io()) .observeOn(HarmonySchedulers.mainThread()) .subscribe(isConnectedToInternet -> { // делайте что-либо с значением isConnectedToInternet }, throwable -> { /* обрабатывайте ошибку здесь */} );


`Observable` вернёт `true` подписке (disposing) если устройство подключено к Интернету и `false` если нет.

Проверка подключения к Интернету будет выполнена _по возможности как можно скорее_.**Обратите внимание**: Этот метод менее эффективен, чем метод `observeNetworkConnectivity(context)`, так как по умолчанию стратегия наблюдения открывает соединение с удалённым хостом каждые две секунды с таймаутом в две секунды и потребляет трафик. Используйте этот метод, если это действительно необходимо. В качестве альтернативы вы можете уничтожить подписку (disposing) сразу после получения уведомления о доступности Интернета и выполнить необходимую работу, чтобы уменьшить количество запросов к сети.Методы в этом разделе следует использовать, если они действительно необходимы из-за специфических сценариев использования.

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

```java
InternetObservingSettings settings = InternetObservingSettings.builder()
  .initialInterval(initialInterval)
  .interval(interval)
  .host(host)
  .port(port)
  .timeout(timeout)
  .httpResponse(httpResponse)
  .errorHandler(testErrorHandler)
  .strategy(strategy)
  .build();

ReactiveNetwork
  .observeInternetConnectivity(settings)
  .subscribeOn(Schedulers.io())
  .observeOn(HarmonySchedulers.mainThread())
  .subscribe(isConnectedToInternet -> {
      // выполните что-то с isConnectedToInternet
  },
  throwable    -> { /* обработайте ошибку здесь */} );

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

Обратите внимание, что не все параметры релевантны для всех стратегий.

Проверка подключения к Интернету один раз

Если мы не хотим наблюдать за подключением к Интернету в интервале с помощью метода Observable<Boolean> observeInternetConnectivity(...), мы можем использовать Single<Boolean> checkInternetConnectivity(), который делает то же самое, но только один раз. Это может быть полезно в специфических сценариях использования.``` Single single = ReactiveNetwork.checkInternetConnectivity();

single .subscribeOn(Schedulers.io()) .observeOn(HarmonySchedulers.mainThread()) .subscribe(isConnectedToInternet -> { // выполните что-то с isConnectedToInternet }, throwable -> { /* обработайте ошибку здесь */} );


Также, как и в предыдущем случае, вы можете настроить эту функцию с помощью класса `InternetObservingSettings` и его билдера.

```java
InternetObservingSettings settings = InternetObservingSettings.builder()
  .initialInterval(initialInterval)
  .interval(interval)
  .host(host)
  .port(port)
  .timeout(timeout)
  .httpResponse(httpResponse)
  .errorHandler(testErrorHandler)
  .strategy(strategy)
  .build();

Single<Boolean> single = ReactiveNetwork.checkInternetConnectivity(settings);

single
  .subscribeOn(Schedulers.io())
  .observeOn(HarmonySchedulers.mainThread())
  .subscribe(isConnectedToInternet -> {
      // делайте что-то с isConnectedToInternet
  },
  throwable    -> { /* обрабатывайте ошибку здесь */} );

Основная идея та же. Единственное отличие в том, что у нас есть тип возвращаемого значения Single<Boolean> вместо Observable<Boolean>, и мы не имеем параметров int initialIntervalInMs и int intervalInMs.

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

Стратегии наблюдения за подключением к Интернету

В настоящее время у нас есть следующие стратегии для наблюдения за подключением к Интернету:

  • SocketInternetObservingStrategy - отслеживает подключение к Интернету путем открытия сокетного соединения с удаленным хостом
  • WalledGardenInternetObservingStrategy - устанавливает соединение с удаленным хостом и уважает страны в "стене сада" (например, Китай) ```Все эти стратегии реализуют интерфейс NetworkObservingStrategy. По умолчанию используется стратегия `WalledGardenInternetObservingStrategy`, но с помощью методов `checkInternetConnectivity(strategy)` и `observeInternetConnectivity(strategy)` можно явно использовать одну из этих стратегий.

Пользовательский хост

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

InternetObservingSettings settings = InternetObservingSettings.builder()
  .host("www.yourhost.com")
  .port(port)
  .strategy(new SocketInternetObservingStrategy())
  .build();

ReactiveNetwork
  .observeInternetConnectivity(settings)
  .subscribeOn(Schedulers.io())
  .observeOn(HarmonySchedulers.mainThread())
  .subscribe(isConnectedToHost -> {
      // делайте что-то с isConnectedToHost
  },
  throwable -> { /* обрабатывайте ошибку здесь */} );

Если вы хотите использовать WalledGardenInternetObservingStrategy, пожалуйста, обновите код HTTP-ответа через InternetObservingSettings. Например, установите его значение на 200, так как по умолчанию используется 204.

То же самое действие можно выполнить с помощью метода checkInternetConnectivity(strategy, host), который возвращает Single вместо Observable.

Цепочка сетевых и интернет-соединений потоков

Допустим, мы хотим реагировать на каждое изменение сетевого соединения и если мы подключаемся к сети, то проверить, подключена ли эта сеть к интернету. Мы можем это сделать следующим образом:``` ReactiveNetwork .observeNetworkConnectivity(getApplicationContext()) .flatMapSingle(connectivity -> ReactiveNetwork.checkInternetConnectivity()) .subscribeOn(Schedulers.io()) .observeOn(HarmonySchedulers.mainThread()) .subscribe(isConnected -> { // isConnected может быть true или false }, throwable -> { /* обработайте ошибку здесь */} );


В случае, если мы получаем слишком много событий, связанных с изменениями сети, или хотим игнорировать предыдущие observable (в данном фрагменте кода только один), после их подписки, мы можем использовать оператор `switchMapSingle` вместо `flatMapSingle`, чтобы получать обновления только из последнего observable. В этом случае, это будет observable, созданное методом `checkInternetConnectivity`.

# Инструкции по установке

Библиотека зависит от rxohos.har, rxjava3 и gson.

1. Для использования модуля ReactiveNetwork в вашем образце приложения, добавьте следующую библиотечную зависимость для генерации hap/library.har.

	Измените entry build.gradle следующим образом:
	```
	dependencies {
	    implementation 'io.openharmony.tpc.thirdlib:Rxohos:1.0.0'
        implementation 'io.reactivex.rxjava3:rxjava:3.0.4'
        implementation 'com.google.code.gson:gson:2.8.6'
        implementation project(path: ':library')
	}
	```

2. Для использования ReactiveNetwork в отдельном приложении, добавьте следующие зависимости и "library.har" в папку libs модуля "entry".
	Измените entry build.gradle следующим образом:
	```
	dependencies {
		implementation fileTree(dir: 'libs', include: ['*.har'])
		implementation 'io.openharmony.tpc.thirdlib:Rxohos:1.0.0'
		implementation 'io.reactivex.rxjava3:rxjava:3.0.4'
		implementation 'com.google.code.gson:gson:2.8.6'
	}
	```
	3. Для использования ReactiveNetwork из удаленного репозитория в отдельном приложении, добавьте следующие зависимости в "entry" build.gradle.	Измените entry build.gradle следующим образом:
	```
	dependencies {
		implementation 'io.openharmony.tpc.thirdlib:Rxohos:1.0.0'
		implementation 'io.openharmony.tpc.thirdlib:ReactiveNetwork:1.0.2'
		implementation 'io.reactivex.rxjava3:rxjava:3.0.4'
		implementation 'com.google.code.gson:gson:2.8.6'
	}

Лицензия

Copyright 2016 Piotr Wittchen

Разрешено к использованию под лицензией Apache License, Version 2.0 («Лицензия»);
вы не можете использовать этот файл, если не будете соблюдать условия Лицензии.
Вы можете получить копию Лицензии по адресу

   http://www.apache.org/licenses/LICENSE-2.0

Если не требуется законом или не согласовано письменно, программное обеспечение,
распространяемое под Лицензией, распространяется на условиях «КАК ЕСТЬ»,
БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ ИЛИ УСЛОВИЙ, ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ.
См. Лицензию для определения языка, регулирующего права и условия использования,
установленные Лицензией.

Опубликовать ( 0 )

Вы можете оставить комментарий после Вход в систему

1
https://api.gitlife.ru/oschina-mirror/HarmonyOS-tpc-ReactiveNetwork.git
git@api.gitlife.ru:oschina-mirror/HarmonyOS-tpc-ReactiveNetwork.git
oschina-mirror
HarmonyOS-tpc-ReactiveNetwork
HarmonyOS-tpc-ReactiveNetwork
RxJava1.x