Лайв вью: Для чего нужен режим Live View

Live View, настройки автофокуса объектива или как быстро фокусироваться?

Настройки автофокуса или как быстро фокусироваться?
 

Статья о режимах автофокуса. Как быстро настроить автофокус объектива. Что такое режим Live View? Типы видоискателей и многое другое про автофокус фотоаппарата

Автофокус есть в каждом фотоаппарате, начиная от мыльницы и заканчивая профессиональными камерами.

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

 

С профессиональной камерой придется немного повозиться. Глубина резкости на этой камере меньше и резкими становятся лишь те объекты, попавшие в фокус.

Во многом все зависит также и от самих настройках камеры и объектива.


 

Обычный видоискатель или Live View

 

Также существуют камеры с оптическим видоискателем и дисплей-видоискатель.

 

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

 

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

 

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

 

 

Недостатки Live View и способы его применения:

 

1. Во время съемки через дисплей скорость работы автофокуса значительно падает по сравнению с обычным видоискателем. Встраивая функцию живого просмотра, производитель не учел что, практически все объективы не приспособлены для работы с таким видоискателем. Автофокусировка производится медленно и становится не оптимальным выбором, особенно для репортажной съемки.

 

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

 

3.Рабочий дисплей работает благодаря аккумулятору в камере, поэтому энергия тратится в 2 раза быстрее. 

 

 

Но так как функция существует, то ее можно использовать, особенно зная, что в каких ситуациях она будет полезной.  

 

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

 

• Функция LiveView оснащена очень полезной настройкой, такой как ручная фокусировка. Она позволяет приблизить картинку и сфокусироваться именно на том объекте, который нужен. Особенно полезна подобная настройка будет тем, кто имеет оптику без автофокусировки. 

 

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

 

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

 

 

Как использовать зеркальный видоискатель

 

Для работы с автофокусировкой у зеркальной камеры следует знать принципы его работы. Заглянув в видоискатель на экране можно увидеть маленькие точки или квадратики. Они называются датчиками фокусировки. Благодаря им камера может сама произвести автофокусировку. Существует 3 схемы автофокусировки по датчикам. 

 

1.Линейный фазовый датчик. С его помощью фокус будет наводиться только по этой линии. Если камера расположена вертикально, то фокусировка будет производиться только по вертикали и наоборот, если повернуть камеру на горизонтально, то и в фокусе будут предметы по этой линии.

 

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

 

3.Двойной крестообразный датчик. Подобный датчик установлен только на профессиональной технике. На данный момент это самый быстрый способ автофокусировки, которая осуществляется по трем линиям: вертикаль, горизонталь и диагональ.

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

Телефоны: 

+375 29 700-34-69
+375 29 122-92-40
 
E-mail: [email protected]
 
Skype: sigma-by

Напишите в чате на сайте, мы готовы вам помочь! 

 


← Сумка или рюкзак для фотоаппарата. Что лучше купить?  |  Видео тест Canon 80D + Sigma 17-50mm F2.8 EX DC OS HSM →

Как реализовать Live Preview в проекте на UIKit — SwiftBook на vc.ru

Всем привет! Вы на канале школы мобильной разработки SwiftBook. Здесь мы рассказываем и показываем всё, что знаем о языке Swift и Kotlin: увлечённо, понятно и без воды.

101 просмотров

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

Ссылка на видео здесь.

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

Для этого я создам проект с интерфейсом Storyboard и перейду в файл ViewController.

Здесь мы импортируем фреймворк SwiftUI и объявим структуру ViewControllerPreview, подписанную под протокол UIViewControllerRepresentable

Эта структура при обращении к ней будет принимать замыкание с типом вью контроллера.

Для этого внутри мы создадим свойство с типом такого замыкающего выражения и к нему инициализатор, в котором мы укажем это замыкание как убегающее.

Помимо этого мы реализуем два метода, которые требует протокол

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

struct ViewControllerPreview: UIViewControllerRepresentable {

let viewControllerGenerator: () -> UIViewController

init(viewControllerGenerator: @escaping () -> UIViewController) {

self.viewControllerGenerator = viewControllerGenerator

}

func makeUIViewController(context: Context) -> some UIViewController {

viewControllerGenerator()

}

func updateUIViewController(_ uiViewController: UIViewControllerType, context: Context) {

}

}

Теперь во viewDidLoad мы поменяем цвет фона на, например, оранжевый.

Внизу под классом объявим ещё одну структуру ViewControllerProvider, подписанную под PreviewProvider для отображения превью.

Внутри мы создадим статичное вычисляемое свойство previews с типом соответствующим протоколу View, и здесь будем вызывать структуру по генерации превью и передавать в её замыкание наш вью контроллер

Также через точку вызовем здесь метод для того, чтобы не отображать safe area:

struct ViewControllerProvider: PreviewProvider {

static var previews: some View {

ViewControllerPreview {

ViewController()

}.edgesIgnoringSafeArea(.all)

}

}

Включим режим canvas и увидим превью нашего вью контроллера.

Добавим в него лэйбл.

let helloLabel: UILabel = {

let label = UILabel()

label.text = «Hello World»

label.textColor = .white

label.font = .systemFont(ofSize: 30, weight: .semibold)

return label

}()

И метод по настройке констрейнтов:

private func setupConstraints() {

view.addSubview(helloLabel)

helloLabel.translatesAutoresizingMaskIntoConstraints = false

NSLayoutConstraint. activate([

helloLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),

helloLabel.centerYAnchor.constraint(equalTo: view.centerYAnchor)

])

}

Вызовем метод во viewDidLoad и увидим все изменения в превью.

Можем поменять цвет фона и также увидеть изменения.

Теперь предлагаю вынести структуру для генерации превью в расширение.

Добавляем файл UiViewController + Extension

Импортируем здесь SwiftUI.

Делаем расширение к вью контроллера и копируем сюда структуру из файла вью контроллер, сделаем теперь её приватной и поменяем название на просто Preview.

Внутри мы объявим свойство с типом вьюконтроллера, инициализатор убегающего замыкания нам больше не нужен, в методе вернём вью контроллер.

И также в расширении добавим метод по отображению превью.

Внутри будем инициализировать структуру вью контроллером и вызывать также функцию для игнорирования safe area extension UIViewController {

private struct Preview: UIViewControllerRepresentable {

let viewController: UIViewController

func makeUIViewController(context: Context) -> some UIViewController {

viewController

}

func updateUIViewController(_ uiViewController: UIViewControllerType, context: Context) {

}

}

func showPreview() -> some View {

Preview(viewController: self). edgesIgnoringSafeArea(.all)

}

}

Теперь вернёмся в файл с вью контроллером, удалим отсюда структуру, а в структуре провайдере внутри вычисляемого свойства обратимся к самому вью контролеру и вызовем у него метод shoPreview

И всё будет работать также.

Но при такой организации кода нам теперь будет доступно вызывать этот метод для всех UIViewController в нашем приложении.

На этом у меня всё, надеюсь, это видео было для вас полезным, спасибо за внимание!

Подписывайся на наши соцсети: Telegram / VKontakte
Вступай в открытый чат для iOS-разработчиков: t.me/swiftbook_chat

Новое чувство направления с Live View

01 октября 2020 г.

min read

Mirko Ranieri

Менеджер по продукту, Google Maps

Live View в Картах Google помогает вам ориентироваться, чтобы вы могли ориентироваться. С новыми способами использования Live View мы делаем еще проще ориентироваться в мире, когда вы гуляете, покидаете остановку общественного транспорта или встречаетесь с друзьями.

Мы запустили Live View в прошлом году, и с тех пор он помогает людям эффективно передвигаться, особенно во время пандемии, когда важнее всего добраться с места на место как можно быстрее. Благодаря дополненной реальности (AR) вы можете видеть стрелки, направления и маркеры расстояния, расположенные прямо над вашим миром, поэтому вы тратите меньше времени на выяснение того, в каком направлении вам следует двигаться.

Используйте ориентиры, чтобы ориентироваться в режиме Live View

Когда вы выбираете или ищете место на Картах Google, вы уже можете нажать кнопку Live View, чтобы визуализировать пункт назначения в реальном мире. Вскоре вы также сможете видеть близлежащие ориентиры, чтобы быстро и легко ориентироваться и понимать, что вас окружает. Live View покажет вам, как далеко от вас находятся определенные ориентиры и в каком направлении вам нужно идти, чтобы добраться до них. Эти достопримечательности могут включать в себя знаковые места, такие как Эмпайр Стейт Билдинг в Нью-Йорке и Пантеон в Риме, а также легко узнаваемые места, такие как местные парки и туристические достопримечательности.

Наблюдение за достопримечательностями в режиме Live View поможет вам лучше понять, что вас окружает.


Получите доступ к Live View в других местах 

Теперь вы можете получить доступ к Live View прямо с вкладки общественного транспорта в Картах Google. Еще в 2018 году мы запустили мультимодальную навигацию — способ проложить маршрут для поездки, который включает в себя сочетание типов транспорта, включая ходьбу, вождение, езду на велосипеде и общественный транспорт. Теперь, если вы пользуетесь маршрутами общественного транспорта и вам предстоит пешая часть пути, вы можете использовать Live View, чтобы найти дорогу. Это особенно полезно, когда вы выходите из транзитной станции и не знаете, куда идти.

Используйте Live View прямо из транзитной навигации.

Просмотр в режиме реального времени в разделе «Обмен местоположением» —

скоро будет доступно на Android и iOS

Если вы встречаетесь с друзьями на социально удаленной встрече, может быть трудно точно определить, где они находятся. В прошлом месяце мы запустили функцию Live View в функции «Передача геоданных» для пользователей Pixel, и вскоре мы расширим ее для всех пользователей Android и iOS по всему миру. Когда друг решил поделиться с вами своим местоположением, вы можете легко нажать на его значок, а затем на просмотр в реальном времени, чтобы увидеть, где и как далеко он находится, с помощью наложенных стрелок и направлений, которые помогут вам понять, куда идти.

Просмотр в режиме реального времени при передаче местоположения скоро станет доступным для всех пользователей Android и iOS по всему миру на телефонах с поддержкой ARCore и ARKit.

Более точный PIN-код

Чтобы воплотить все эти функции в жизнь, мы улучшили глобальную локализацию, базовую технологию, которая обеспечивает работу всех функций Live View на Картах Google. С помощью машинного обучения и нашего понимания топографии мира мы можем учитывать высоту места, чтобы мы могли более точно отображать местоположение метки назначения в режиме Live View. Ниже вы можете увидеть, как Ломбард-стрит — крутая извилистая улица в Сан-Франциско — раньше казалась далеко-далеко. Теперь вы можете быстро увидеть, что Ломбард-стрит намного ближе, а булавка совмещена с тем местом, где улица начинается у подножия холма.

 Улучшения в глобальной локализации теперь показывают более точное размещение контактов.

Независимо от того, куда вы идете, Live View поможет вам добраться туда максимально эффективно. В ближайшие недели вы начнете видеть Live View на вкладке «Транспорт» и «Обмен местоположением» на Android и iOS вместе с более точным пин-кодом. Ориентиры скоро начнут развертываться на Android и iOS почти в 25 городах* по всему миру, и их число будет увеличиваться.

*Амстердам, Бангкок, Барселона, Берлин, Будапешт, Дубай, Флоренция, Стамбул, Куала-Лумпур, Киото, Лондон, Лос-Анджелес, Мадрид, Милан, Мюнхен, Нью-Йорк, Осака, Париж, Прага, Рим, Сан-Франциско, Сидней , Токио, Вена

ОПУБЛИКОВАНО В:

Блог · Школа Эликсира

Узнайте, как использовать Phoenix LiveView для функций реального времени без сложных фреймворков JS.

Это здесь! Phoenix LiveView использует отображаемый на сервере HTML и собственный инструментарий Phoenix WebSocket, поэтому вы можете создавать причудливые функции в реальном времени без всего этого сложного JavaScript. Если вам до смерти надоело писать на JS (у меня был плохой день с Redux, не спрашивайте), то эта библиотека для вас!

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

Что такое Live View?

Крис МакКорд сказал это лучше всего в своем объявлении еще в декабре:

Phoenix LiveView — это замечательная новая библиотека, которая позволяет пользователям в режиме реального времени работать с HTML, визуализируемым на сервере. Приложения на основе LiveView сохраняют состояние на сервере с двунаправленной связью через WebSockets, предлагая значительно упрощенную модель программирования по сравнению с альтернативами JavaScript.

Убей свой JavaScript

Если вы пробирались через чрезмерно сложный SPA, который редуксирует все вещи (например), вы почувствовали затраты на обслуживание и итерацию, которые часто сопровождают весь этот причудливый JavaScript.

Phoenix LiveView идеально подходит для тех 90% случаев, когда вам нужны обновления в реальном времени, но на самом деле вам не нужен разрушительный шар многих современных JS-фреймворков.

Давайте запустим и запустим LiveView для поддержки функции, которая выдает оперативные обновления, когда наш сервер запускает пошаговый процесс создания репозитория GitHub.

Вот функции, которые мы создаем:


Начало работы

Следующие шаги подробно описаны в файле Readme для Phoenix LiveView.

  • Установите зависимость в файле mix.exs :
 деф депс делать
  [
    {:phoenix_live_view, "~> 0. 2.0"}
  ]
конец 
  • Обновите конфигурацию конечной точки вашего приложения, указав соль подписи для подключения к просмотру в реальном времени:
  • .
 # Настраивает конечную точку
конфигурация: my_app, MyApp.Endpoint,
  ...
  прямая трансляция: [
    signing_salt: "ВАШ_СЕКРЕТ"
  ] 

Примечание. Вы можете создать секрет, запустив mix phx.gen.secret 9.0084 из командной строки.

  • Обновите конфигурацию, чтобы включить запись шаблонов LiveView с расширением .leex .
 конфигурация: феникс,
  template_engines: [leex: Phoenix.LiveView.Engine] 
  • Добавьте флэш-плагин просмотра в реальном времени в конвейер браузера после :fetch_flash
  • .
 конвейер: браузер сделать
  ...
  плагин: fetch_flash
  подключаем Phoenix.LiveView.Flash
конец 
  • Импортируйте следующее в свой lib/app_web.ex файл:
 вид по умолчанию
  цитата делать
    . ..
    импортировать Phoenix.LiveView, только: [live_render: 2, live_render: 3]
  конец
конец
Def Router делать
  цитата делать
    ...
    импортировать Phoenix.LiveView.Router
  конец
конец 
  • Предоставьте сокет для LiveView для использования в вашем модуле конечной точки:
defmodule MyAppWeb.Endpoint сделать
  использовать Phoenix.Endpoint
  сокет "/live", Phoenix.LiveView.Socket
  # ...
конец 
  • Добавьте LiveView к своим зависимостям NPM:
 # активы/package.json
{
  "зависимости": {
    ...
    "phoenix_live_view": "файл:../deps/phoenix_live_view"
  }
} 

После этого шага вам нужно будет запустить npm install .

  • Используйте библиотеку JavaScript LiveView для подключения к сокету LiveView в app.js
 импортировать LiveSocket из "phoenix_live_view"
пусть liveSocket = новый LiveSocket("/live")
liveSocket.connect() 
  • Ваши живые просмотры должны быть сохранены в каталог lib/my_app_web/live/. Для поддержки перезагрузки страницы в реальном времени добавьте следующий шаблон в файл config/dev.exs :
  • .
 конфигурация: демо, MyApp.Endpoint,
  live_reload: [
    узоры: [
      ...,
      ~r{lib/my_app_web/live/.*(ex)$}
    ]
  ] 

Теперь мы готовы построить и визуализировать живое представление!

Рендеринг просмотра в реальном времени с контроллера

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

 дефмодуль MyApp.PageController сделать
  использовать MyApp, :контроллер
  псевдоним Phoenix.LiveView
  индекс защиты (соед., _) сделать
    LiveView.Controller.live_render(подключение, MyAppWeb.GithubDeployView, сеанс: %{})
  конец
конец 

Мы вызываем функцию live_render/3 , которая принимает аргумент conn , вид в реальном времени, который мы хотим визуализировать, и любую информацию о сеансе, которую мы хотим отправить в вид в реальном времени.

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

Определение просмотра в реальном времени

Наше первое живое представление будет жить в my_app_web/live/github_deploy_view.ex . Это представление отвечает за обработку взаимодействия, при котором пользователь «развертывает» некоторый контент в GitHub. Этот процесс включает в себя создание организации GitHub, создание репозитория и отправку некоторого содержимого в этот репозиторий. В этом примере мы не будем заботиться о деталях реализации этого процесса.

Наш просмотр в реальном времени будет использовать Phoenix.LiveView и должен реализовать две функции: render/1 и mount/2 .

 дефмодуль MyAppWeb.GithubDeployView сделать
  используйте Phoenix.LiveView
  def render(назначает) делать
    ~Л"""
    <дел>
      <дел>
        <%= @deploy_step %>
      
""" конец def mount(_session, socket) делать {:ok, assign(socket, deploy_step: "Готово!")} конец конец

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

Как это работает

Процесс подключения live view выглядит примерно так:

Когда наше приложение получает HTTP-запрос для индексного маршрута, оно отвечает рендерингом статического HTML, определенного в функции render/1 нашего живого представления. Он сделает это, сначала вызвав функцию mount/2 нашего представления, и только затем отобразив HTML, заполненный любыми значениями по умолчанию mount/2 , назначенными сокету.

Визуализированный HTML-код будет включать информацию о подписанном сеансе. Сеанс подписывается с использованием соли подписи, которую мы предоставили нашей конфигурации просмотра в реальном времени в config.exs . Этот подписанный сеанс будет отправлен обратно на сервер, когда клиент откроет соединение сокета для просмотра в реальном времени. Если вы проверите страницу, отображающую ваш просмотр в реальном времени в браузере, вы увидите этот подписанный сеанс:

 
GithubDeployView" data-phx-session="SFMyNTY.g3QAAAACZAAEZGF0YW0AAACQZzNRQUFBQUVaQUFDYVdS"> ...

Как только этот статический HTML-код будет отрендерен, клиент отправит запрос на подключение к живому сокету благодаря этому фрагменту кода:

 импортировать LiveSocket из "phoenix_live_view"
пусть liveSocket = новый LiveSocket("/live")
liveSocket.connect() 

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

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

Рендеринг Live Updates

LiveView прослушивает обновления нашего сокета и повторно отображает только те части страницы, которые нуждаются в обновлении . Присмотревшись к нашей функции render/1 , мы увидим, что она отображает значения ключей, назначенных нашему сокету.

Там, где mount/2 присвоены значения :deploy_step , наша функция render/1 отображает их следующим образом:

 def render(assigns) do
  ~Л"""
  <дел>
    <дел>
      <%= @deploy_step %>
    
""" конец

Примечание. Символ ~L представляет Live EEx. Это встроенный шаблон LiveView. В отличие от шаблонов .eex , шаблоны LEEx способны отслеживать и отображать только необходимые изменения. Таким образом, если значение @deploy_step изменится, наш шаблон повторно отобразит только эту часть страницы.

Давайте дадим нашему пользователю возможность запустить процесс «развертывания на GitHub» и увидеть обновление страницы по мере выполнения каждого шага развертывания.

LiveView поддерживает привязки элементов DOM, чтобы дать нам возможность реагировать на события на стороне клиента. Мы создадим кнопку «развернуть на GitHub» и будем прослушивать нажатие этой кнопки с помощью привязки события phx-click.

 def render(назначает) сделать
  ~Л"""
  <дел>
    <дел>
      <дел>
        
      
Статус: <%= @deploy_step %>
""" конец

Привязка phx-click отправит событие click на сервер для обработки GithubDeployView . События обрабатываются в наших представлениях в режиме реального времени с помощью функции handle_event/3 . Эта функция примет в качестве аргумента имя события, значение и сокет.

Существует несколько способов заполнить аргумент value , но мы не будем использовать эту точку данных в этом примере.

Давайте создадим нашу функцию handle_event/3 для события "github_deploy" :

 def handle_event("github_deploy", _value, socket) do
  # выполнить процесс развертывания
  {:noreply, assign(socket, deploy_step: "Начало развертывания. ..")}
конец 

Наша функция отвечает за две вещи. Во-первых, он запустит процесс развертывания (скоро). Затем он обновит значение :deploy_step ключ в нашем сокете. Это заставит наш шаблон повторно отображать часть страницы с <%= @deploy_step %> , поэтому пользователь увидит Статус: Готово! изменить на Статус: Начало развертывания... .

Затем нам нужно, чтобы процесс «развертывание на GitHub» мог обновлять сокет :deploy_step на каждом шагу. У нас будет функция handle_event/3 нашего представления, которая отправляет сообщение самой себе, чтобы активировать каждый последующий шаг в процессе.

 def handle_event («github_deploy», _value, socket) делать
  :ok = MyApp.start_deploy()
  отправить (я (), :create_org)
  {:noreply, assign(socket, deploy_step: "Начало развертывания...")}
конец
def handle_info(:create_org, сокет) сделать
  {:ok, org} = MyApp.create_org()
  отправить (я (), {: create_repo, org})
  {:noreply, assign(socket, deploy_step: "Создание организации GitHub. ..")}
конец
def handle_info({:create_repo, org}, socket) сделать
  {:хорошо, репо} = MyApp.create_repo(org)
  отправить (я (), {: push_contents, репо})
  {:noreply, assign(socket, deploy_step: "Создание репозитория GitHub...")}
конец
def handle_info({:push_contents, repo}, socket) сделать
  :ok = MyApp.push_contents(репозиторий)
  отправить (я (), : сделано)
  {:noreply, assign(socket, deploy_step: "Отправка в репозиторий...")}
конец
def handle_info(:готово, сокет) сделать
  {:noreply, assign(socket, deploy_step: "Готово!")}
конец 

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

Наша функция handle_event/3 запускает процесс развертывания, отправляя сообщение :create_org самому представлению. Наше представление реагирует на это сообщение, вызывая код, выполняющий этот шаг, и обновляя сокет. Это приведет к повторному рендерингу нашего шаблона, поэтому пользователь увидит Статус: Начало развертывания... изменить на Статус: Создание организации GitHub... . Таким образом, представление реализует каждый шаг процесса развертывания GitHub, обновляя сокет и каждый раз вызывая повторную визуализацию шаблона.

Теперь, когда у нас работают оперативные обновления, давайте реорганизуем HTML-код из нашей функции render/1 в отдельный файл шаблона.

Рендеринг файла шаблона

Мы определим наш шаблон в lib/my_app_web/templates/page/github_deploy.html.leex 9.0084 :

 <дел>
  <класс деления>
    
    <дел>
      Статус: <%= @deploy_step %>
    

Затем у нас будет функция render/1 нашего живого просмотра, просто скажите нашему PageView отобразить этот шаблон:

 defmodule MyApp.

alexxlab

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *