Android Camera2 API от чайника

  • Tutorial


Не так давно я возился со своей роботележкой, пытаясь водрузить на нее ANDROID смартфон. Моей, то есть его задачей, было сделать тележку эволюционно продвинутой. Чтобы она, так сказать, чувствовала мир его сенсорами, смотрела его глазом (камерой), слышала микрофоном и ругалась по громкой связи. Ресурсов AVR, понятное дело, на это уже не хватало и поэтому бывший на телеге микроконтроллер переехал на уровень ниже, куда-то в район спинного мозга управлять моторчиками и разными безусловными рефлексами.

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

camera = Camera.open();

Особенно, как вы видите, в тех частях, где я пытался работать с камерой. Это было очень обидно, потому что я прочитал в интернете и усвоил множество уроков работы с андроидом и камерой здесь, здесь, здесь и даже здесь. Там ничего не зачеркивалось. И называлось заурядно Camera API. Все там было просто и логично. Но Google упрямо толкал меня к какому-то Сamera2 API.

Я туда посмотрел и просто опупел от количества разных коллбэков, билдеров, хэндлеров и луперов на каждую строчку демонстрационного кода. Было совершенно непонятно с какой стороны к этому подступиться, если ты обычный любитель, а не android developer. Причем в сети даже на сегодня статей на тему Сamera2 API чуть, хотя вышло это обновление вроде как, аж четыре года назад. Но всё что я нашел, это статью в Хакере в 2016, пост в трех частях от украинских братьев того же года, двойной пост на Хабре в 2017 и статью Understanding Camera2 от японского мегагика Томоаки Имаи. И это я ещё имею в виду какую-то структурированную и оформленную информацию, а не раскиданные в интернете обрывки кода типа, «смотрите, как я могу» и простыни в стиле, «посмотрите код плиз, у меня ничего не работает».

А теперь, если вам всё ещё интересно зачем мне потребовалось пилить свой пост на эту тему
уже в 2019, то добро пожаловать под кат.

Собственно статья из Хакера мне понравилась тем, что дала хотя бы обзорное понимание того, на кой черт внедрили новую парадигму работы с камерой. Также стало понятно для чего нужны некоторые новые методы, которых не было в предыдущем API. Но написать работающую программу по этой статье было совершенно невозможно, поскольку авторы, видимо, как настоящие хакеры, приводили только лишь заглавия методов, ну может быть, ещё там пару строчек дополнительного кода. Но этого мне категорически не хватало.

Пост на Хабре был хорош, не спорю и я даже понял несколько первых абзацев, но на этом дело и встало, поскольку автор поста побеждал камеру при помощи RxJava2, что автоматически исключало меня из числа дальнейших читателей. Мне бы с ООП нормально разобраться, а тут какое-то реактивное программирование.

Статья японца была ещё лучше, пусть он и писал не на своем родном языке. Но Kotlin я тоже не знаю, хотя я, конечно, порадовался за отечественных разработчиков и оценил краткость его синтаксиса, в отличии от той JAVA-вермишели, которая была на странице разработчиков Google (кстати, с этой страницей, тоже было ясно, что мне там ясно мало чего).

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



Дескать, это от того, что версия Lollipop 5.0, а там баг. Надо вот обновить до Lollipop 5.1 и тогда всё будет хорошо. Но как-то пока не до этого. А ещё вредные хохлы пристегнули к статье JAVA SCRIPT, и при копировании кода мне в текст программы насыпалось дикое количество мусора. Ребята, ну нельзя же так… Пришлось специальный плагин в Firefox инсталлировать.

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

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

А потому, что сейчас производители смартфонов разрабатывают совершенно новые подходы к камеростроению.
С месяц назад в сеть просочился слух о смартфонах Nokia с пятью основными камерами. Как к этому относиться? Интересный и многообещающий слух или очередная странная штука? Каким бы уникальным ни выглядел такой дизайн, Nokia уж точно не сможет стать пионером в области внедрения непривычного количества объективов и сенсоров в компактные устройства. Фотоаппарат Light L16 уже в 2015 году оснастили 16-ю объективами, и у компании, очевидно, имеется в работе новый прототип. Выше можно увидеть, как это потенциально может выглядеть.

После того, как в Huawei P20 Pro появилась тройная камера, переход к смартфону с пятью камерами уже не звучит так комично, как это могло бы быть еще пару лет назад. Впрочем, остается главный вопрос – а какой в этом смысл?
Что делать с таким количеством объективов?

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

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

Huawei P20 Pro уже предлагает свою версию того, как несколько модулей камеры могут работать вместе, чтоб давать интересный результат. Речь о таких технологиях от Huawei, как Monochrome и Hybrid Zoom. Первая улучшает динамический диапазон стандартных кадров, объединяя данные обычного RGB и светочувствительного черно-белого сенсора. А Hybrid Zoom обещает и того больше: он объединяет данные с нескольких камер, чтобы повысить разрешение снимка для более качественного зума. В результате, в P20 Pro 8 MП сенсор телефото-объектива дает возможность снимать в разрешении 10 MП на 3x и 5x зуме.
Выше разрешение — больше гибкости

Первая камера Light L16 работала сходным образом, используя перископические зеркала, чтобы уместить модули камеры в компактный корпус. Камера брала данные с нескольких модулей на 28, 70 и 150 мм, в зависимости от уровня зума. В конечном итоге получался большой снимок на 52 МП, сделанный с 10 немного отличающихся ракурсов, доступных на уровне увеличения до 5x. Концепция новой модели, разработанной для смартфонов, работает с 5-9 объективами. Такой модуль камеры способен делать большие 64-мегапиксельные снимки.

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

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

Такую же идею можно проследить, обратившись к опыту Nokia в области внедрения нескольких камер, учитывая старую историю с инвестициями в Pelican Imaging в 2013 году. В отличие от Light, сенсор тут гораздо меньше. И даже при этом технология обещает очень похожие преимущества, в том числе программную смену фокуса, замера глубины и повышения размера итогового изображения. К сожалению, Tessera выкупила компанию в 2016, но сама идея могла и не покинуть умы инженеров Nokia.

Zeiss, нынешний партнер Nokia по фоточасти, имеет патент на переключаемый зум, но мы не слышали от них больше ничего о дизайне с несколькими объективами. Возможно, более многообещающим выглядит другой партнер Nokia, FIH Mobile. Эта компания принадлежит Foxconn, выпускает телефоны Nokia и также инвестировала в Light в 2015, дав ей лицензию на использование технологии.

И если вы думаете, что у утечки от Nokia и прототипа от Light есть нечто общее, это не совпадение. Связывает эти две компании Foxconn. Так будет ли смартфон от Nokia первым, где используется технология от Light?
Так это и есть будущее?

Сверхбольшое разрешение — не новая концепция.В 2014 году в Oppo Find 7 использовался сходный принцип, а Hybrid Zoom от Huawei позволил технологии работать с несколькими камерами. Исторически главной проблемой технологии были высокие требования производительности, качество алгоритма и энергопотребление. Но на стороне современных смартфонов более мощные процессоры обработки сигнала, энергоэффективные DSP чипы и даже улучшенные способности нейронных сетей, что постепенно снижает значимость проблемы.

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

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




Непросто будет настроить такой агрегат из камер ручками в программе. Быть может, круг замкнётся и для того чтобы сделать снимок, нам снова придется писать явный intent, с содержанием, типа, “камера, сделай пожалуйста снимок сама как умеешь, но красиво, и верни мне его в моё activity”.

Но пока времени, хоть и немного нам ещё осталось. Поэтому приступим немедля.

Зачем всё это было нужно Гуглу

Вроде, как всё дело в безопасной и правильной многопоточности (а ещё стало можно делать напрямую всякие эффекты и фильтры ). Вот если в ванильной JAVA вам в случае необходимости надо везде грамотно распихивать мьютексы, синхронайзы и семафоры, то здесь Гугль берет почти всё на себя. Вам надо только прописать в тексте программы коллбэки, которые будут вызываться в случае необходимости. То есть, например, вы подаете запрос на включение камеры:

mCameraManager.openCamera()

Но это не команда, это просьба. Сразу приступить к работе с камерой вы не можете. Во-первых ей надо время на включение, во-вторых у андроида и так полно важных дел, и ваше пожелание ставится в немаленькую очередь. Но зато нам не надо ждать открытия камеры в цикле в главном потоке, вешая всё приложение (все же помнят, что можно делать в UI-потоке, а что нет). Поэтому, мы отправляем свое пожелание и пока занимаемся своими делами, открываем вьюшки, пишем «hello world», настраиваем обработчики кнопок и тому подобное.

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

 private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {

            @Override
            public void onOpened(CameraDevice camera) {
               
    mCameraDevice = camera;
          
                createCameraPreviewSession();
…..
            }

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

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

Но и этого мало. Полная схема работы камеры имеет вот такой устрашающий вид



Но к счастью, для начала её можно свести к намного более привлекательной картинке



Хоть там всё и по английски, но как говорится, понятно без слов. Для начала нам хватит такой конструкции. Откроем камеру, выведем изображение на экран смартфона, сделаем снимок и как только он будет готов (снова коллбэки), сработает слушатель этого события и запишет картинку в файл.

Приступаем к творению кода

Создадим новый проект в IDE Android Studio, выберем минимальную версию SDK 22, чтобы избежать зеленых картинок и заказываем empty Activity (а еще лучше взять 23 версию, а то с permissions траблы могут возникнуть). Для начала хватит. Даже разрешений в манифесте пока делать не нужно.

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

А характеристики мы посмотрим следующие:

идентификатор камеры ( 0, 1, 2 ….)
направление куда камера направлена (вперед, назад)
разрешение камеры в пихелях

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

package com.example.camera;
import android.content.Context;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;

import android.graphics.ImageFormat;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.util.Size;

public class MainActivity extends AppCompatActivity {

    public static final String LOG_TAG = "myLogs";
    String[] myCameras = null;
    private CameraManager mCameraManager    = null;


    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try{
            // Получение списка камер с устройства

            myCameras = new String[mCameraManager.getCameraIdList().length];

            // выводим информацию по камере
            for (String cameraID : mCameraManager.getCameraIdList()) {
                Log.i(LOG_TAG, "cameraID: "+cameraID);
                int id = Integer.parseInt(cameraID);

           // Получениe характеристик камеры
                CameraCharacteristics cc = mCameraManager.getCameraCharacteristics(cameraID);
           // Получения списка выходного формата, который поддерживает камера
                StreamConfigurationMap configurationMap =
                        cc.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);

          //  Определение какая камера куда смотрит
                int Faceing = cc.get(CameraCharacteristics.LENS_FACING);

                if (Faceing ==  CameraCharacteristics.LENS_FACING_FRONT)
                {
                    Log.i(LOG_TAG,"Camera with ID: "+cameraID +  "  is FRONT CAMERA  ");
                }

                if (Faceing ==  CameraCharacteristics.LENS_FACING_BACK)
                {
                    Log.i(LOG_TAG,"Camera with: ID "+cameraID +  " is BACK CAMERA  ");
                }


         // Получения списка разрешений которые поддерживаются для формата jpeg
                Size[] sizesJPEG = configurationMap.getOutputSizes(ImageFormat.JPEG);

                if (sizesJPEG != null) {
                    for (Size item:sizesJPEG) {
                        Log.i(LOG_TAG, "w:"+item.getWidth()+" h:"+item.getHeight());
                    }
                }  else {
                    Log.i(LOG_TAG, "camera don`t support JPEG");
                }
            }
        }
        catch(CameraAccessException e){
            Log.e(LOG_TAG, e.getMessage());
            e.printStackTrace();
        }
    }
}

В логе получится что-то вроде этого:

2019-09-13 10:56:31.489 11130-11130/? I/myLogs: cameraID: 0
2019-09-13 10:56:31.504 11130-11130/? I/myLogs: Camera with: ID 0 is BACK CAMERA  
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:4000 h:3000
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:4000 h:2250
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:3840 h:2160
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:2592 h:1944
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:2592 h:1940
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:2048 h:1536
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1920 h:1080
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1600 h:1200
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1440 h:1080
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1440 h:720
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1280 h:960
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1280 h:768
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1280 h:720
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1280 h:480
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:1280 h:400
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:800 h:480
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:720 h:480
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:640 h:480
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:480 h:640
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:480 h:360
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:480 h:320
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:352 h:288
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:320 h:240
2019-09-13 10:56:31.506 11130-11130/? I/myLogs: w:240 h:320
2019-09-13 10:56:31.507 11130-11130/? I/myLogs: w:176 h:144
2019-09-13 10:56:31.507 11130-11130/? I/myLogs: w:144 h:176
2019-09-13 10:56:31.507 11130-11130/? I/myLogs: cameraID: 1
2019-09-13 10:56:31.514 11130-11130/? I/myLogs: Camera with ID: 1  is FRONT CAMERA  
2019-09-13 10:56:31.515 11130-11130/? I/myLogs: w:4224 h:3136
2019-09-13 10:56:31.515 11130-11130/? I/myLogs: w:4224 h:2376
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:4160 h:3120
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:4160 h:2340
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:4000 h:3000
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:4000 h:2250
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:3840 h:2160
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:2592 h:1944
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:2592 h:1940
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:2048 h:1536
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1920 h:1080
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1600 h:1200
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1440 h:1080
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1440 h:720
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1280 h:960
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1280 h:768
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1280 h:720
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1280 h:480
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:1280 h:400
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:800 h:480
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:720 h:480
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:640 h:480
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:480 h:640
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:480 h:360
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:480 h:320
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:352 h:288
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:320 h:240
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:240 h:320
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:176 h:144
2019-09-13 10:56:31.516 11130-11130/? I/myLogs: w:144 h:176


Нам эта информация, в принципе, особо и не нужна, любой чайник ещё по предыдущему API и так знает, что камеры имеют идентификаторы от нуля и далее, что разрешением 1920 на 1080 никого не удивишь, а форматом JPEG тем более. По сути, эти данные нужны уже «взрослому» приложению готовому для продакшена и которое на их основе сделает менюшки выбора для пользователя и так далее. В нашем же простейшем случае, в общем, и так все понятно. Но раз все статьи начинают с этого, то и мы начнём.

Убедившись, что фронтальная камера имеет идентификатор номер «1», а задняя «0» (они почему-то заданы в формате String), а также, что разрешение 1920 х 1080 и сохранение файла JPG нам доступны, продолжим наступление.

Получаем нужные permissions

Первоначально нам надо озаботится рядом разрешений. Для этого в манифесте придется прописать следующее:

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


Первое понятно для камеры, второе для записи картинки в файл (и это не внешняя карта памяти, как могло бы показаться из значения слова EXTERNAL, а вполне себе родная память смартфона)

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

Для этого, в самом простом случае, требуется добавить вот это:


 protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
……...

        if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
                ||
                (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        )
        {
            requestPermissions(new String[]{Manifest.permission.CAMERA,Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
        }
…..


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


 @Override

    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {

        if (requestCode == MY_REQUEST_CODE_FOR_CAMERA) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {

             startCameraActivity(); // запускаем активность с камерой (ну или фрагмент)
        }
      }
    }

Хотя я вот раньше не зная всего этого, запускал нужную Activity через AsyncTask, а ещё раньше просто лепил новый Thread как в Java.

Готовим камеру

Для удобства вынесем всё что связано с камерами в отдельный класс по совету умных людей и создадим класс CameraService. Там мы разместим инициализацию камер и затем пропишем все коллбэки, которые потребуются.

…..

  CameraService[] myCameras = null;

    private CameraManager mCameraManager    = null;
    private final int CAMERA1   = 0;
    private final int CAMERA2   = 1;

  protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

…..

}

   public class CameraService {
        private String mCameraID;
        private CameraDevice mCameraDevice = null;
        private CameraCaptureSession mCaptureSession;

        public CameraService(CameraManager cameraManager, String cameraID) {

            mCameraManager = cameraManager;
            mCameraID = cameraID;
        }

   public boolean isOpen() {

            if (mCameraDevice == null) {
                return false;
            } else {
                return true;
            }
        }


   public void openCamera() {
            try {
                if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {

                mCameraManager.openCamera(mCameraID,mCameraCallback,null);
                }
            }
           catch (CameraAccessException e) {
                Log.i(LOG_TAG,e.getMessage());
            }
        }


 public void closeCamera() {

            if (mCameraDevice != null) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
        }
}


В главном потоке создаем экземпляр mCameraManager и с его помощью заполним массив объектов myCameras. В данном случае их всего два — фронтальная и селфи камеры.

     mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try{

            // Получение списка камер с устройства

            myCameras = new CameraService[mCameraManager.getCameraIdList().length];

            for (String cameraID : mCameraManager.getCameraIdList()) {
                Log.i(LOG_TAG, "cameraID: "+cameraID);
                int id = Integer.parseInt(cameraID);

                // создаем обработчик для камеры
                myCameras[id] = new CameraService(mCameraManager,cameraID);
            }
        }
        catch(CameraAccessException e){
            Log.e(LOG_TAG, e.getMessage());
            e.printStackTrace();
        }

В методе public void openCamera() можно видеть строчку:

 mCameraManager.openCamera(mCameraID,mCameraCallback,null);

именно отсюда ведет дорожка к первому коллбэку состояния камеры CameraDevice. StateCallback. Он сообщит нам открыта ли камера, закрыта или может быть вообще ничего там нет и выдаст ошибку. Пропишем его в методах класса CameraService.

   private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {

            @Override
            public void onOpened(CameraDevice camera) {
                mCameraDevice = camera;
                Log.i(LOG_TAG, "Open camera  with id:"+mCameraDevice.getId());

                createCameraPreviewSession();
            }

            @Override
            public void onDisconnected(CameraDevice camera) {
                mCameraDevice.close();

                Log.i(LOG_TAG, "disconnect camera  with id:"+mCameraDevice.getId());
                mCameraDevice = null;
            }

            @Override
            public void onError(CameraDevice camera, int error) {
                Log.i(LOG_TAG, "error! camera id:"+camera.getId()+" error:"+error);
            }
        };

Соответственно, если камера доступна для работы (сработал метод public void onOpened(CameraDevice camera) {}), то мы именно там пишем дальнейшие наши действия, например, вызов метода createCameraPreviewSession(). Он поможет вывести нам на вьюшку изображение с камеры и работать с ним далее.

CreateCameraPreviewSession

Здесь мы пытаемся вывести изображение (поток данных) на текстуру mImageView, которая уже определена в макете. Можно даже определить с каким именно разрешением в пихелях.

       private void createCameraPreviewSession() {

            SurfaceTexture texture = mImageView.getSurfaceTexture();
   // texture.setDefaultBufferSize(1920,1080);
            Surface surface = new Surface(texture);

            try {
                final CaptureRequest.Builder builder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                builder.addTarget(surface);
                mCameraDevice.createCaptureSession(Arrays.asList(surface),
                        new CameraCaptureSession.StateCallback() {

                            @Override
                            public void onConfigured(CameraCaptureSession session) {
                                mCaptureSession = session;
                                try {
                                    mCaptureSession.setRepeatingRequest(builder.build(),null,null);
                                } catch (CameraAccessException e) {
                                    e.printStackTrace();
                                }
                            }

                            @Override
                            public void onConfigureFailed(CameraCaptureSession session) { }}, null );
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

И вот когда эта самая сессия готова, вызывается вышеупомянутый коллбэк и мы начинаем по выражению гуглоделов: «displaying the camera preview». Здесь же желающие могут настроить параметры автофокуса и вспышки, но мы пока обойдемся параметрами по умолчанию.

Творим макет

Теперь нам надо, так сказать, набросать красок на холст и создать гениальную картину в стиле
«три экранные кнопки и одна вьюшка».
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextureView
        android:id="@+id/textureView"
        android:layout_width="356dp"
        android:layout_height="410dp"
        android:layout_marginTop="32dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.49"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <LinearLayout
        android:layout_width="292dp"
        android:layout_height="145dp"
        android:layout_marginStart="16dp"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textureView"
        app:layout_constraintVertical_bias="0.537">

        <Button
            android:id="@+id/button4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="КАМЕРА ПЕРЕДНЯЯ" />

        <Button
            android:id="@+id/button5"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="КАМЕРА ЗАДНЯЯ" />

        <Button
            android:id="@+id/button6"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="СДЕЛАТЬ СНИМОК" />
    </LinearLayout>

</androidx.constr



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

Соответственно в самой Activity мы создаем listeners, то есть слушателей для кнопок и вьюшки.

    private Button mButtonOpenCamera1 = null;
    private Button mButtonOpenCamera2 = null;
    private Button mButtonToMakeShot = null;
    private TextureView mImageView = null;

    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

……...

        mButtonOpenCamera1 =  findViewById(R.id.button1);
        mButtonOpenCamera2 =  findViewById(R.id.button2);
        mButtonToMakeShot =findViewById(R.id.button3);
        mImageView = findViewById(R.id.textureView);

        mButtonOpenCamera1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].closeCamera();
                if (myCameras[CAMERA1] != null) {
                    if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
                }
            }
        });

        mButtonOpenCamera2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].closeCamera();
                if (myCameras[CAMERA2] != null) {
                    if (!myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].openCamera();
                }
            }
        });


        mButtonToMakeShot.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v)
            {

             // тут пока пусто

            }
        });


……..

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

И если теперь свести все кусочки кода вместе то

получится следующее:
package com.example.camera;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;

import java.util.Arrays;

public class MainActivity extends AppCompatActivity {


    public static final String LOG_TAG = "myLogs";


    CameraService[] myCameras = null;

    private CameraManager mCameraManager    = null;
    private final int CAMERA1   = 0;
    private final int CAMERA2   = 1;
    private Button mButtonOpenCamera1 = null;
    private Button mButtonOpenCamera2 = null;
    private Button mButtonToMakeShot = null;
    private TextureView mImageView = null;


    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        Log.d(LOG_TAG, "Запрашиваем разрешение");
        if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
                ||
                (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        )
        {
            requestPermissions(new String[]{Manifest.permission.CAMERA,Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }


        mButtonOpenCamera1 =  findViewById(R.id.button1);
        mButtonOpenCamera2 =  findViewById(R.id.button2);
        mButtonToMakeShot =findViewById(R.id.button3);
        mImageView = findViewById(R.id.textureView);

        mButtonOpenCamera1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA2].isOpen()) {myCameras[CAMERA2].closeCamera();}
                if (myCameras[CAMERA1] != null) {
                    if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
                }
            }
        });

        mButtonOpenCamera2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA1].isOpen()) {myCameras[CAMERA1].closeCamera();}
                if (myCameras[CAMERA2] != null) {
                    if (!myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].openCamera();
                }
            }
        });


        mButtonToMakeShot.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v)
            {


            //    if (myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].makePhoto();
           //     if (myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].makePhoto();

            }
        });


        mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try{
            // Получение списка камер с устройства


            myCameras = new CameraService[mCameraManager.getCameraIdList().length];



            for (String cameraID : mCameraManager.getCameraIdList()) {
                Log.i(LOG_TAG, "cameraID: "+cameraID);
                int id = Integer.parseInt(cameraID);


                // создаем обработчик для камеры
                myCameras[id] = new CameraService(mCameraManager,cameraID);




            }
        }
        catch(CameraAccessException e){
            Log.e(LOG_TAG, e.getMessage());
            e.printStackTrace();
        }

    }


    public class CameraService {


        private String mCameraID;
        private CameraDevice mCameraDevice = null;
        private CameraCaptureSession mCaptureSession;

        public CameraService(CameraManager cameraManager, String cameraID) {

            mCameraManager = cameraManager;
            mCameraID = cameraID;

        }

        private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {

            @Override
            public void onOpened(CameraDevice camera) {
                mCameraDevice = camera;
                Log.i(LOG_TAG, "Open camera  with id:"+mCameraDevice.getId());

                createCameraPreviewSession();
            }

            @Override
            public void onDisconnected(CameraDevice camera) {
                mCameraDevice.close();

                Log.i(LOG_TAG, "disconnect camera  with id:"+mCameraDevice.getId());
                mCameraDevice = null;
            }

            @Override
            public void onError(CameraDevice camera, int error) {
                Log.i(LOG_TAG, "error! camera id:"+camera.getId()+" error:"+error);
            }
        };


        private void createCameraPreviewSession() {



            SurfaceTexture texture = mImageView.getSurfaceTexture();

           texture.setDefaultBufferSize(1920,1080);
            Surface surface = new Surface(texture);

            try {
                final CaptureRequest.Builder builder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                builder.addTarget(surface);




                mCameraDevice.createCaptureSession(Arrays.asList(surface),
                        new CameraCaptureSession.StateCallback() {

                            @Override
                            public void onConfigured(CameraCaptureSession session) {
                                mCaptureSession = session;
                                try {
                                    mCaptureSession.setRepeatingRequest(builder.build(),null,null);
                                } catch (CameraAccessException e) {
                                    e.printStackTrace();
                                }
                            }

                            @Override
                            public void onConfigureFailed(CameraCaptureSession session) { }}, null );
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }

        }




        public boolean isOpen() {
            if (mCameraDevice == null) {
                return false;
            } else {
                return true;
            }
        }

        public void openCamera() {
            try {

                if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {


                    mCameraManager.openCamera(mCameraID,mCameraCallback,null);

                }



            } catch (CameraAccessException e) {
                Log.i(LOG_TAG,e.getMessage());

            }
        }

        public void closeCamera() {

            if (mCameraDevice != null) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
        }



    }


    @Override
    public void onPause() {
        if(myCameras[CAMERA1].isOpen()){myCameras[CAMERA1].closeCamera();}
        if(myCameras[CAMERA2].isOpen()){myCameras[CAMERA2].closeCamera();}
        super.onPause();
    }


}


Грузим, запускаем, работает!

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



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

CameraCaptureSession.StateCallback().

Затем камера переходит в режим предварительной съемки PRECAPTURE. На этой стадии камера вычисляет экспозицию, баланс белого и светосилу (когда-то в детстве я знал что это, но теперь эти знания утрачены). Иногда коллбэк может вернуть требование CONTROL_AE_STATE_FLASH_REQUIRED, что означает «хорошо бы включить вспышку». Её можно кстати включить автоматически — setAutoFlash(mPreviewRequestBuilder).

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

На странице гуглоидов, всё это есть уже в примерах, и если у вас хватит терпения пробиться через эти минные поля и проволочные заграждения, то честь тогда вам и хвала.

Делаем снимок и сохраняем картинку в файл

Вот как раз с этого места у меня начались проблемы. Нет, судя по блок-схеме приведенной выше (не японской, а предыдущей) всё как бы не очень сложно. Дожидаемся, когда камера захватит изображение. После обработки классом CamerCaptureSession оно будет доступно в виде объекта Surface, который в свою очередь можно обработать с помощью класса ImageReader.

Правда на то, чтобы создать объект ImageReader опять же надо время. Дожидаемся этого времени мы в очередном слушателе под названием OnImageAvailableListener. И наконец, с помощью инстанса последнего класса ImageSaver сохраняем изображение в файл и естественно делаем это тоже асинхронно, потому как ImageSaver он у нас Runnable.

Проблема была в том, что я никуда не мог пристроить этот ImageReader, поскольку коллбэк CameraCaptureSession.StateCallback() уже был занят под трансляцию видео на вьюшку смартфона. А если я делал новую сессию то Android предсказуемо ругался и крашил приложение. В итоге (не спрашивайте меня как) я сумел скрестить коня и трепетную лань в одном методе createCameraPreviewSession(), который раньше выводил изображение с камеры только на вьюшку.

Вот этот кусок кода до:


private void createCameraPreviewSession() {

            SurfaceTexture texture = mImageView.getSurfaceTexture();
            Surface surface = new Surface(texture);

            try {
                final CaptureRequest.Builder builder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                builder.addTarget(surface);

                mCameraDevice.createCaptureSession(Arrays.asList(surface),
                        new CameraCaptureSession.StateCallback() …….

А вот он после:

 private ImageReader mImageReader;

 private void createCameraPreviewSession() {

            mImageReader = ImageReader.newInstance(1920,1080,ImageFormat.JPEG,1);
            mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, null);

            SurfaceTexture texture = mImageView.getSurfaceTexture();
            Surface surface = new Surface(texture);

            try {
                final CaptureRequest.Builder builder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                builder.addTarget(surface);

                mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                        new CameraCaptureSession.StateCallback() ……

Разница, если не считать определения инстанса ImageReader вверху, почти неуловима. Всего-то добавили к surface, через запятую mImageReader.getSurface() и всё. Но пока до этого дойдешь…

С этого момента дела пошли веселее и можно было задействовать третью экранную кнопку «Сделать Снимок». При ее нажатии вызывается метод makePhoto() (ну кто бы мог подумать):

 mButtonToMakeShot.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v)
            {
                if (myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].makePhoto();
                if (myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].makePhoto();
            }
        });

……

     public class CameraService {
     public void makePhoto (){
            try {

                // This is the CaptureRequest.Builder that we use to take a picture.
                final CaptureRequest.Builder captureBuilder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
                captureBuilder.addTarget(mImageReader.getSurface());
                CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {

                    @Override
                    public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                                   @NonNull CaptureRequest request,
                                                   @NonNull TotalCaptureResult result) {
                      }
                };

                   mCaptureSession.stopRepeating();
                   mCaptureSession.abortCaptures();
                   mCaptureSession.capture(captureBuilder.build(), CaptureCallback, null);
            }
            catch (CameraAccessException e) {
                e.printStackTrace();
            }
      }


А сразу за ним прописываем слушатель OnImageAvailableListener:

   private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
                = new ImageReader.OnImageAvailableListener() {

            @Override
            public void onImageAvailable(ImageReader reader) {

                { Toast.makeText(MainActivity.this,"фотка доступна для сохранения", Toast.LENGTH_SHORT).show();}
           }
        };

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

А для этого нам потребуется сам файл:

public class CameraService {

private File mFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test1.jpg");;

А также специальный объект класса ImageSaver, который быстренько перекачает данные с картинки в байтовый буфер, а оттуда уже в бинарный файл.

Этот класс статический да ещё и Runnable. Поэтому мы его размещаем в самой MainActivity:

 private static class ImageSaver implements Runnable {

        private final File mFile;

        ImageSaver(Image image, File file) {
            mImage = image;
            mFile = file;
        }

        @Override
        public void run() {
            ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
            byte[] bytes = new byte[buffer.remaining()];
            buffer.get(bytes);
            FileOutputStream output = null;
            try {
                output = new FileOutputStream(mFile);
                output.write(bytes);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                mImage.close();
                if (null != output) {
                    try {
                        output.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }


А чтобы он сработал, пропишем в слушателе OnImageAvailableListener дополнительно:

mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));

WAIT! OH, SHIT!!

Что ещё за mBackgroundHandler??? Всё же прекрасно работало и без него.

Но на самом деле правильный вопрос — а как оно вообще работало без него? Потому что, как прописано в примерах Гугля BackgroundHandler обеспечивает работу BackgroundThread, который в свою очередь является потоком работающим в фоновом режиме и собственно отвечающим за деятельность камеры. И на самом деле мы должны еще в самом начале нашей Activity прописать:

   private HandlerThread mBackgroundThread;
   private Handler mBackgroundHandler = null;

    private void startBackgroundThread() {
        mBackgroundThread = new HandlerThread("CameraBackground");
        mBackgroundThread.start();
        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        mBackgroundThread.quitSafely();
        try {
            mBackgroundThread.join();
            mBackgroundThread = null;
            mBackgroundHandler = null;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Мало этого, еще надо добавить запуск и остановку BackgroundThread еще и сюда:

  public void onPause() {
    super.onPause();
        stopBackgroundThread();
   }

    @Override
    public void onResume() {
        super.onResume();
        startBackgroundThread();
    }

Что же касается mBackgroundHandler, то его надо добавить во все наши коллбэки, которые требуют handler и куда мы, не парясь, писали вместо этого null.

Самое интригующее, что этот фоновый поток мы сами НЕ запускаем при открытии приложения, как легко видеть из текста программы. То есть он запускается неявно и без нашей помощи. Зато мы должны его сами останавливать и запускать в режимах onPause() и onResume(). Какое-то здесь противоречие получается.

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



Правда картинка почему-то лежит на боку, но решить эту проблему задача уже будущих поколений.

Полный листинг программы
package com.example.camera;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.ImageFormat;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.Arrays;

public class MainActivity extends AppCompatActivity {


    public static final String LOG_TAG = "myLogs";


    CameraService[] myCameras = null;

    private CameraManager mCameraManager    = null;
    private final int CAMERA1   = 0;
    private final int CAMERA2   = 1;

    private Button mButtonOpenCamera1 = null;
    private Button mButtonOpenCamera2 = null;
    private Button mButtonToMakeShot = null;
    private TextureView mImageView = null;
    private HandlerThread mBackgroundThread;
    private Handler mBackgroundHandler = null;



    private void startBackgroundThread() {
        mBackgroundThread = new HandlerThread("CameraBackground");
        mBackgroundThread.start();
        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        mBackgroundThread.quitSafely();
        try {
            mBackgroundThread.join();
            mBackgroundThread = null;
            mBackgroundHandler = null;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }




    @RequiresApi(api = Build.VERSION_CODES.M)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        Log.d(LOG_TAG, "Запрашиваем разрешение");
        if (checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
                ||
                (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)
        )
        {
            requestPermissions(new String[]{Manifest.permission.CAMERA,Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }


        mButtonOpenCamera1 =  findViewById(R.id.button1);
        mButtonOpenCamera2 =  findViewById(R.id.button2);
        mButtonToMakeShot =findViewById(R.id.button3);
        mImageView = findViewById(R.id.textureView);

        mButtonOpenCamera1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA2].isOpen()) {myCameras[CAMERA2].closeCamera();}
                if (myCameras[CAMERA1] != null) {
                    if (!myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].openCamera();
                }
            }
        });

        mButtonOpenCamera2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (myCameras[CAMERA1].isOpen()) {myCameras[CAMERA1].closeCamera();}
                if (myCameras[CAMERA2] != null) {
                    if (!myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].openCamera();
                }
            }
        });


        mButtonToMakeShot.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v)
            {




                if (myCameras[CAMERA1].isOpen()) myCameras[CAMERA1].makePhoto();
                if (myCameras[CAMERA2].isOpen()) myCameras[CAMERA2].makePhoto();

            }
        });


        mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
        try{
            // Получение списка камер с устройства


            myCameras = new CameraService[mCameraManager.getCameraIdList().length];



            for (String cameraID : mCameraManager.getCameraIdList()) {
                Log.i(LOG_TAG, "cameraID: "+cameraID);
                int id = Integer.parseInt(cameraID);


                // создаем обработчик для камеры
                myCameras[id] = new CameraService(mCameraManager,cameraID);




            }
        }
        catch(CameraAccessException e){
            Log.e(LOG_TAG, e.getMessage());
            e.printStackTrace();
        }


    }


    public class CameraService {

        private File mFile = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM), "test1.jpg");;
        private String mCameraID;
        private CameraDevice mCameraDevice = null;
        private CameraCaptureSession mCaptureSession;
        private ImageReader mImageReader;




        public CameraService(CameraManager cameraManager, String cameraID) {

            mCameraManager = cameraManager;
            mCameraID = cameraID;

        }

        public void makePhoto (){





            try {
                // This is the CaptureRequest.Builder that we use to take a picture.
                final CaptureRequest.Builder captureBuilder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
                captureBuilder.addTarget(mImageReader.getSurface());
                CameraCaptureSession.CaptureCallback CaptureCallback = new CameraCaptureSession.CaptureCallback() {

                    @Override
                    public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                                   @NonNull CaptureRequest request,
                                                   @NonNull TotalCaptureResult result) {


                    }
                };

                mCaptureSession.stopRepeating();
                mCaptureSession.abortCaptures();
                mCaptureSession.capture(captureBuilder.build(), CaptureCallback, mBackgroundHandler);
            }
            catch (CameraAccessException e) {
                e.printStackTrace();


            }




        }


        private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
                = new ImageReader.OnImageAvailableListener() {

            @Override
            public void onImageAvailable(ImageReader reader) {

                mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));


            }

        };


        private CameraDevice.StateCallback mCameraCallback = new CameraDevice.StateCallback() {

            @Override
            public void onOpened(CameraDevice camera) {
                mCameraDevice = camera;
                Log.i(LOG_TAG, "Open camera  with id:"+mCameraDevice.getId());

                createCameraPreviewSession();
            }

            @Override
            public void onDisconnected(CameraDevice camera) {
                mCameraDevice.close();

                Log.i(LOG_TAG, "disconnect camera  with id:"+mCameraDevice.getId());
                mCameraDevice = null;
            }

            @Override
            public void onError(CameraDevice camera, int error) {
                Log.i(LOG_TAG, "error! camera id:"+camera.getId()+" error:"+error);
            }
        };


        private void createCameraPreviewSession() {

            mImageReader = ImageReader.newInstance(1920,1080, ImageFormat.JPEG,1);
            mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, null);

            SurfaceTexture texture = mImageView.getSurfaceTexture();

           texture.setDefaultBufferSize(1920,1080);
            Surface surface = new Surface(texture);

            try {
                final CaptureRequest.Builder builder =
                        mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

                builder.addTarget(surface);




                mCameraDevice.createCaptureSession(Arrays.asList(surface,mImageReader.getSurface()),
                        new CameraCaptureSession.StateCallback() {

                            @Override
                            public void onConfigured(CameraCaptureSession session) {
                                mCaptureSession = session;
                                try {
                                    mCaptureSession.setRepeatingRequest(builder.build(),null,mBackgroundHandler);
                                } catch (CameraAccessException e) {
                                    e.printStackTrace();
                                }
                            }

                            @Override
                            public void onConfigureFailed(CameraCaptureSession session) { }}, mBackgroundHandler);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }

        }




        public boolean isOpen() {
            if (mCameraDevice == null) {
                return false;
            } else {
                return true;
            }
        }

        public void openCamera() {
            try {

                if (checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {


                    mCameraManager.openCamera(mCameraID,mCameraCallback,mBackgroundHandler);

                }



            } catch (CameraAccessException e) {
                Log.i(LOG_TAG,e.getMessage());

            }
        }

        public void closeCamera() {

            if (mCameraDevice != null) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
        }



    }


    @Override
    public void onPause() {
        if(myCameras[CAMERA1].isOpen()){myCameras[CAMERA1].closeCamera();}
        if(myCameras[CAMERA2].isOpen()){myCameras[CAMERA2].closeCamera();}
        stopBackgroundThread();
        super.onPause();
    }

    @Override
    public void onResume() {
        super.onResume();
        startBackgroundThread();


    }


    private static class ImageSaver implements Runnable {

        /**
         * The JPEG image
         */
        private final Image mImage;
        /**
         * The file we save the image into.
         */
        private final File mFile;

        ImageSaver(Image image, File file) {
            mImage = image;
            mFile = file;
        }

        @Override
        public void run() {
            ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
            byte[] bytes = new byte[buffer.remaining()];
            buffer.get(bytes);
            FileOutputStream output = null;
            try {
                output = new FileOutputStream(mFile);
                output.write(bytes);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                mImage.close();
                if (null != output) {
                    try {
                        output.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

Поделиться публикацией
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама

Комментарии 21

    0
    В сторону CameraX не смотрели? Хоть и в бете, но для задачи просто фоточки сойдёт уже.
      0
      Да оно все похоже ныне в ту сторону и идет.
      0

      В камере 1 есть метод onFrame, можно каждый кадр из камеры анализировать.
      В camera2 такого решения не нашел, как можно обрабатывать кадры, кто знает?

        0
        CaptureRequest.Builder может принимать разные таргеты(surface'ы). Одна surface обычная(SurfaceView/TextureView) для отображения превью, другая для анализа(эту surface можно сделать из ImageReader например.
          0

          Этот вариант не подходит, потому что:


          1. Он вызывает зависание preview
          2. Fps никак не 30 кадров в секунду. Очень медленно они приходят
          3. Кадр который приходит расходится с тем, что на preview.
            0
            ImageReader действильно тормозит и подходит больше для снятие фоток, а не видео-стрима.
            Есть небольшой хак чтоб брать текстуру из самой превьюшки. Главное, после получения текстуры, обрабатывать её в другом потоке.

            Вырезка из рабочего кода для видео-потока + превью:

            все как обычно по статье создаём TextureView и надо добавить callback
            mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);

            дальше в самом callback
            @Override
                    public void onSurfaceTextureUpdated(SurfaceTexture texture) {
                        long time = System.currentTimeMillis();
                        Bitmap b = Bitmap.createBitmap(1920,1080,Bitmap.Config.ARGB_8888)
                        b = mTextureView.getBitmap(b);
                        int[] pixels = new int[b.getByteCount()];
                        b.getPixels(pixels,0,1920,0,0,1920,1080);
                        imageProcessStream.pushImage(pixels,time/1000L);
                    }
              0
              А почемуГугловцы тогда пишут
              You normally cannot access the raw video data when using a Surface, but you can use the ImageReader class to access unsecured decoded (raw) video frames
              Мне то как раз видео надо
                0
                этот пример как раз-таки и вызовет подвисание preview.
                  0
                  Дык, не совсем корректный способ вроде.
                  Как раз вот mTextureView.getBitmap(b) на разных девайсах занимает от 20 до 100мс.
                  А onSurfaceTextureUpdated срабатываем вообще на main потоке.
                  Если и getBitmap() выносить на другой поток — то тут я не уверен насчёт thread safe такого действия…
                  0
                  Просто для интереса, зачем вам каждый кадр анализировать? Мое мнение, что для такого больше подойдет не API камеры, а ARCore. Получаете фрейм + информацию об окружающем пространстве (сцене), запихиваете в очередь и асинхронно обрабатываете.
                    0

                    Как написали ниже, для считывания bar/qr кодов в реальном времени.
                    Но и не только их.

                    0
                    Опишите что нужно вам именно, я так делаю для считывания bar/qr кодов, превью не тормозит если сам анализ после imagereader уносить на другой поток. Опять же, посмотрите исходники CameraX, там тот же imagereader, ну и может, что то для своего кейса найдёте…
                      0

                      Именно это и нужно. Использую для распознавания bar/qr кодов и OCR.
                      Почему-то не удалось нормально подрубить Camera2, чтобы получать фреймы.

                        0
                        А какой размер surface устанавливаете для анализа? На поток отдельный выносите?
                          0
                          размер как раз full hd, попробовал ваш способ. Но есть проблемы с подвисанием превью. если уменьшить размер, то, возможно подвисание будет меньше. Но для моих целей full hd желательно использовать.

                          также, на сколько я понял, значение iso из каждого фрейма получить не получится.
                            0
                            Слежу за этой вашей веткой, т.к. уперся в теже проблемы с подвисанием.
                            Старое API позволяет искать qr-коды на моем железе 4 раза в секунду, а с Camera2 только получение каждого preview FullHD кадра занимает у меня ~0.45 секунды, без учета дальнейшего распознавания еще :(
                            Не говоря о том, что подвисает интерфейс, т.е. вообще неюзабельно.
                            Как же с Camera2 распознавать qr-коды «почти realtime», но и имея возможность крутить настройки камеры?
                              0
                              Есть предположение, что процессинг нужно выносить на отдельный тред, в Camera2 API и в самом ImageReader есть всё для этого(передача handler). При этом в примере для CameraX походу так и делают…
                  0

                  Странно, когда я делал свой 3D сканер https://habr.com/ru/post/412479/
                  то работа с камерой не показалась слишком сложной. Все логично и дает почти полный доступ. Да и примеров и документации просто масса.


                  Наверное, не хватает простой "кнопки счастье" "записать видео" в API. Но для этого проще поискать обертку вокруг фактически низкоуровневого (скорее средне..) управления камерой от Android.


                  Хотя, если честно, не понял зачем 2019 году очередная статья "как я разбирался с Camera2 API".


                  А теперь, если вам всё ещё интересно зачем мне потребовалось пилить свой пост на эту тему уже в 2019, то добро пожаловать под кат.

                  Аплодирую! Эта фраза заставила меня заглянуть внутрь.

                    0
                    Я согласен с автором, апи Гугл сделал, но для простых случаев использования слишком много гемора, хорошо хоть CameraX в процессе
                    0
                    А никто не сталкивался с тем, что на некоторых телефонах превью отображается с инвертированными цветами(как негатив)?

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

                    Самое читаемое