diff --git a/translate/final/app/build.gradle b/translate/final/app/build.gradle
new file mode 100644
index 0000000..8135786
--- /dev/null
+++ b/translate/final/app/build.gradle
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+apply plugin: 'com.android.application'
+
+apply plugin: 'kotlin-android'
+
+apply plugin: 'kotlin-android-extensions'
+
+android {
+ compileSdkVersion 29
+ buildToolsVersion "29.0.2"
+ defaultConfig {
+ applicationId "com.google.mlkit.codelab.translate"
+ minSdkVersion 21
+ targetSdkVersion 29
+ versionCode 1
+ versionName "1.0"
+ testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+ }
+ buildTypes {
+ release {
+ minifyEnabled false
+ proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+ }
+ }
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_8
+ targetCompatibility JavaVersion.VERSION_1_8
+ }
+ kotlinOptions {
+ jvmTarget = "1.8"
+ }
+}
+
+dependencies {
+ implementation fileTree(dir: 'libs', include: ['*.jar'])
+ implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
+ implementation 'androidx.appcompat:appcompat:1.1.0'
+ implementation 'androidx.core:core-ktx:1.3.0'
+ implementation 'androidx.fragment:fragment-ktx:1.2.4'
+ implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+ implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
+ implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0'
+ testImplementation 'junit:junit:4.12'
+ androidTestImplementation 'androidx.test:runner:1.2.0'
+ androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+
+ // Add CameraX dependencies
+ def camerax_version = "1.0.0-beta10"
+ implementation "androidx.camera:camera-core:${camerax_version}"
+ implementation "androidx.camera:camera-camera2:${camerax_version}"
+ implementation "androidx.camera:camera-lifecycle:${camerax_version}"
+ implementation "androidx.camera:camera-view:1.0.0-alpha17"
+
+ // Add ML Kit dependencies
+ implementation 'com.google.android.gms:play-services-mlkit-text-recognition:16.1.1'
+ implementation 'com.google.mlkit:language-id:16.1.1'
+ implementation 'com.google.mlkit:translate:16.1.1'
+}
diff --git a/translate/final/app/proguard-rules.pro b/translate/final/app/proguard-rules.pro
new file mode 100644
index 0000000..f1b4245
--- /dev/null
+++ b/translate/final/app/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/translate/final/app/src/main/AndroidManifest.xml b/translate/final/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..8ed4db2
--- /dev/null
+++ b/translate/final/app/src/main/AndroidManifest.xml
@@ -0,0 +1,45 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/MainActivity.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/MainActivity.kt
new file mode 100644
index 0000000..006e0cb
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/MainActivity.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate
+
+import androidx.appcompat.app.AppCompatActivity
+import android.os.Bundle
+import com.google.mlkit.codelab.translate.main.MainFragment
+
+class MainActivity : AppCompatActivity() {
+
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ setContentView(R.layout.main_activity)
+ if (savedInstanceState == null) {
+ supportFragmentManager.beginTransaction()
+ .replace(R.id.container, MainFragment.newInstance())
+ .commitNow()
+ }
+ }
+
+}
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/analyzer/TextAnalyzer.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/analyzer/TextAnalyzer.kt
new file mode 100644
index 0000000..07a875b
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/analyzer/TextAnalyzer.kt
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.analyzer
+
+import android.content.Context
+import android.graphics.Rect
+import android.util.Log
+import android.widget.Toast
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.MutableLiveData
+import com.google.android.gms.tasks.Task
+import com.google.mlkit.common.MlKitException
+import com.google.mlkit.codelab.translate.util.ImageUtils
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.text.Text
+import com.google.mlkit.vision.text.TextRecognition
+import java.lang.Exception
+
+/**
+ * Analyzes the frames passed in from the camera and returns any detected text within the requested
+ * crop region.
+ */
+class TextAnalyzer(
+ private val context: Context,
+ private val lifecycle: Lifecycle,
+ private val result: MutableLiveData,
+ private val imageCropPercentages: MutableLiveData>
+) : ImageAnalysis.Analyzer {
+
+ // TODO: Instantiate TextRecognition detector
+
+ // TODO: Add lifecycle observer to properly close ML Kit detectors
+
+ @androidx.camera.core.ExperimentalGetImage
+ override fun analyze(imageProxy: ImageProxy) {
+ val mediaImage = imageProxy.image ?: return
+
+ val rotationDegrees = imageProxy.imageInfo.rotationDegrees
+
+ // We requested a setTargetAspectRatio, but it's not guaranteed that's what the camera
+ // stack is able to support, so we calculate the actual ratio from the first frame to
+ // know how to appropriately crop the image we want to analyze.
+ val imageHeight = mediaImage.height
+ val imageWidth = mediaImage.width
+
+ val actualAspectRatio = imageWidth / imageHeight
+
+ val convertImageToBitmap = ImageUtils.convertYuv420888ImageToBitmap(mediaImage)
+ val cropRect = Rect(0, 0, imageWidth, imageHeight)
+
+ // If the image has a way wider aspect ratio than expected, crop less of the height so we
+ // don't end up cropping too much of the image. If the image has a way taller aspect ratio
+ // than expected, we don't have to make any changes to our cropping so we don't handle it
+ // here.
+ val currentCropPercentages = imageCropPercentages.value ?: return
+ if (actualAspectRatio > 3) {
+ val originalHeightCropPercentage = currentCropPercentages.first
+ val originalWidthCropPercentage = currentCropPercentages.second
+ imageCropPercentages.value =
+ Pair(originalHeightCropPercentage / 2, originalWidthCropPercentage)
+ }
+
+ // If the image is rotated by 90 (or 270) degrees, swap height and width when calculating
+ // the crop.
+ val cropPercentages = imageCropPercentages.value ?: return
+ val heightCropPercent = cropPercentages.first
+ val widthCropPercent = cropPercentages.second
+ val (widthCrop, heightCrop) = when (rotationDegrees) {
+ 90, 270 -> Pair(heightCropPercent / 100f, widthCropPercent / 100f)
+ else -> Pair(widthCropPercent / 100f, heightCropPercent / 100f)
+ }
+
+ cropRect.inset(
+ (imageWidth * widthCrop / 2).toInt(),
+ (imageHeight * heightCrop / 2).toInt()
+ )
+ val croppedBitmap =
+ ImageUtils.rotateAndCrop(convertImageToBitmap, rotationDegrees, cropRect)
+
+ // TODO call recognizeText() once implemented
+ }
+
+ fun recognizeText() {
+ // TODO Use ML Kit's TextRecognition to analyze frames from the camera live feed.
+ }
+
+ private fun getErrorMessage(exception: Exception): String? {
+ val mlKitException = exception as? MlKitException ?: return exception.message
+ return if (mlKitException.errorCode == MlKitException.UNAVAILABLE) {
+ "Waiting for text recognition model to be downloaded"
+ } else exception.message
+ }
+
+ companion object {
+ private const val TAG = "TextAnalyzer"
+ }
+}
\ No newline at end of file
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainFragment.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainFragment.kt
new file mode 100644
index 0000000..c7390ee
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainFragment.kt
@@ -0,0 +1,366 @@
+/*
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.main
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.graphics.*
+import android.os.Bundle
+import android.util.DisplayMetrics
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.SurfaceHolder
+import android.view.View
+import android.view.ViewGroup
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Toast
+import androidx.camera.core.*
+import androidx.camera.core.Camera
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.constraintlayout.widget.ConstraintLayout
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.viewModels
+import androidx.lifecycle.Observer
+import com.google.mlkit.codelab.translate.R
+import com.google.mlkit.codelab.translate.analyzer.TextAnalyzer
+import com.google.mlkit.codelab.translate.util.Language
+import com.google.mlkit.codelab.translate.util.ScopedExecutor
+import kotlinx.android.synthetic.main.main_fragment.*
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import kotlin.math.abs
+import kotlin.math.ln
+import kotlin.math.max
+import kotlin.math.min
+
+class MainFragment : Fragment() {
+
+ companion object {
+ fun newInstance() = MainFragment()
+
+ // We only need to analyze the part of the image that has text, so we set crop percentages
+ // to avoid analyze the entire image from the live camera feed.
+ const val DESIRED_WIDTH_CROP_PERCENT = 8
+ const val DESIRED_HEIGHT_CROP_PERCENT = 74
+
+ // This is an arbitrary number we are using to keep tab of the permission
+ // request. Where an app has multiple context for requesting permission,
+ // this can help differentiate the different contexts
+ private const val REQUEST_CODE_PERMISSIONS = 10
+
+ // This is an array of all the permission specified in the manifest
+ private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
+ private const val RATIO_4_3_VALUE = 4.0 / 3.0
+ private const val RATIO_16_9_VALUE = 16.0 / 9.0
+ private const val TAG = "MainFragment"
+ }
+
+ private var displayId: Int = -1
+ private val viewModel: MainViewModel by viewModels()
+ private var cameraProvider: ProcessCameraProvider? = null
+ private var camera: Camera? = null
+ private var imageAnalyzer: ImageAnalysis? = null
+ private lateinit var container: ConstraintLayout
+ private lateinit var viewFinder: PreviewView
+
+ /** Blocking camera operations are performed using this executor */
+ private lateinit var cameraExecutor: ExecutorService
+
+ private lateinit var scopedExecutor: ScopedExecutor
+
+ override fun onCreateView(
+ inflater: LayoutInflater, container: ViewGroup?,
+ savedInstanceState: Bundle?
+ ): View {
+ return inflater.inflate(R.layout.main_fragment, container, false)
+ }
+
+ override fun onDestroyView() {
+ super.onDestroyView()
+
+ // Shut down our background executor
+ cameraExecutor.shutdown()
+ scopedExecutor.shutdown()
+ }
+
+ override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+ super.onViewCreated(view, savedInstanceState)
+
+ container = view as ConstraintLayout
+ viewFinder = container.findViewById(R.id.viewfinder)
+
+ // Initialize our background executor
+ cameraExecutor = Executors.newSingleThreadExecutor()
+ scopedExecutor = ScopedExecutor(cameraExecutor)
+
+ // Request camera permissions
+ if (allPermissionsGranted()) {
+ // Wait for the views to be properly laid out
+ viewFinder.post {
+ // Keep track of the display in which this view is attached
+ displayId = viewFinder.display.displayId
+
+ // Set up the camera and its use cases
+ setUpCamera()
+ }
+ } else {
+ requestPermissions(REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
+ }
+
+ // Get available language list and set up the target language spinner
+ // with default selections.
+ val adapter = ArrayAdapter(
+ requireContext(),
+ android.R.layout.simple_spinner_dropdown_item, viewModel.availableLanguages
+ )
+
+ targetLangSelector.adapter = adapter
+ targetLangSelector.setSelection(adapter.getPosition(Language("en")))
+ targetLangSelector.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+ override fun onItemSelected(
+ parent: AdapterView<*>,
+ view: View?,
+ position: Int,
+ id: Long
+ ) {
+ viewModel.targetLang.value = adapter.getItem(position)
+ }
+
+ override fun onNothingSelected(parent: AdapterView<*>) {}
+ }
+
+ viewModel.sourceLang.observe(viewLifecycleOwner, Observer { srcLang.text = it.displayName })
+ viewModel.translatedText.observe(viewLifecycleOwner, Observer { resultOrError ->
+ resultOrError?.let {
+ if (it.error != null) {
+ translatedText.error = resultOrError.error?.localizedMessage
+ } else {
+ translatedText.text = resultOrError.result
+ }
+ }
+ })
+ viewModel.modelDownloading.observe(viewLifecycleOwner, Observer { isDownloading ->
+ progressBar.visibility = if (isDownloading) {
+ View.VISIBLE
+ } else {
+ View.INVISIBLE
+ }
+ progressText.visibility = progressBar.visibility
+ })
+
+ overlay.apply {
+ setZOrderOnTop(true)
+ holder.setFormat(PixelFormat.TRANSPARENT)
+ holder.addCallback(object : SurfaceHolder.Callback {
+ override fun surfaceChanged(
+ holder: SurfaceHolder?,
+ format: Int,
+ width: Int,
+ height: Int
+ ) {
+ }
+
+ override fun surfaceDestroyed(holder: SurfaceHolder?) {
+ }
+
+ override fun surfaceCreated(holder: SurfaceHolder?) {
+ holder?.let { drawOverlay(it, DESIRED_HEIGHT_CROP_PERCENT, DESIRED_WIDTH_CROP_PERCENT) }
+ }
+
+ })
+ }
+ }
+
+
+ /** Initialize CameraX, and prepare to bind the camera use cases */
+ private fun setUpCamera() {
+ val cameraProviderFuture = ProcessCameraProvider.getInstance(requireContext())
+ cameraProviderFuture.addListener(Runnable {
+
+ // CameraProvider
+ cameraProvider = cameraProviderFuture.get()
+
+ // Build and bind the camera use cases
+ bindCameraUseCases()
+ }, ContextCompat.getMainExecutor(requireContext()))
+ }
+
+ private fun bindCameraUseCases() {
+ val cameraProvider = cameraProvider
+ ?: throw IllegalStateException("Camera initialization failed.")
+
+ // Get screen metrics used to setup camera for full screen resolution
+ val metrics = DisplayMetrics().also { viewFinder.display.getRealMetrics(it) }
+ Log.d(TAG, "Screen metrics: ${metrics.widthPixels} x ${metrics.heightPixels}")
+
+ val screenAspectRatio = aspectRatio(metrics.widthPixels, metrics.heightPixels)
+ Log.d(TAG, "Preview aspect ratio: $screenAspectRatio")
+
+ val rotation = viewFinder.display.rotation
+
+ val preview = Preview.Builder()
+ .setTargetAspectRatio(screenAspectRatio)
+ .setTargetRotation(rotation)
+ .build()
+
+ // Build the image analysis use case and instantiate our analyzer
+ imageAnalyzer = ImageAnalysis.Builder()
+ // We request aspect ratio but no resolution
+ .setTargetAspectRatio(screenAspectRatio)
+ .setTargetRotation(rotation)
+ .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+ .build()
+ .also {
+ it.setAnalyzer(
+ cameraExecutor
+ , TextAnalyzer(
+ requireContext(),
+ lifecycle,
+ viewModel.sourceText,
+ viewModel.imageCropPercentages
+ )
+ )
+ }
+ viewModel.sourceText.observe(viewLifecycleOwner, Observer { srcText.text = it })
+ viewModel.imageCropPercentages.observe(viewLifecycleOwner,
+ Observer { drawOverlay(overlay.holder, it.first, it.second) })
+
+ // Select back camera since text detection does not work with front camera
+ val cameraSelector =
+ CameraSelector.Builder().requireLensFacing(CameraSelector.LENS_FACING_BACK).build()
+
+ try {
+ // Unbind use cases before rebinding
+ cameraProvider.unbindAll()
+
+ // Bind use cases to camera
+ camera = cameraProvider.bindToLifecycle(
+ this, cameraSelector, preview, imageAnalyzer
+ )
+ preview.setSurfaceProvider(viewFinder.surfaceProvider)
+ } catch (exc: IllegalStateException) {
+ Log.e(TAG, "Use case binding failed. This must be running on main thread.", exc)
+ }
+ }
+
+ private fun drawOverlay(
+ holder: SurfaceHolder,
+ heightCropPercent: Int,
+ widthCropPercent: Int
+ ) {
+ val canvas = holder.lockCanvas()
+ val bgPaint = Paint().apply {
+ alpha = 140
+ }
+ canvas.drawPaint(bgPaint)
+ val rectPaint = Paint()
+ rectPaint.xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
+ rectPaint.style = Paint.Style.FILL
+ rectPaint.color = Color.WHITE
+ val outlinePaint = Paint()
+ outlinePaint.style = Paint.Style.STROKE
+ outlinePaint.color = Color.WHITE
+ outlinePaint.strokeWidth = 4f
+ val surfaceWidth = holder.surfaceFrame.width()
+ val surfaceHeight = holder.surfaceFrame.height()
+
+ val cornerRadius = 25f
+ // Set rect centered in frame
+ val rectTop = surfaceHeight * heightCropPercent / 2 / 100f
+ val rectLeft = surfaceWidth * widthCropPercent / 2 / 100f
+ val rectRight = surfaceWidth * (1 - widthCropPercent / 2 / 100f)
+ val rectBottom = surfaceHeight * (1 - heightCropPercent / 2 / 100f)
+ val rect = RectF(rectLeft, rectTop, rectRight, rectBottom)
+ canvas.drawRoundRect(
+ rect, cornerRadius, cornerRadius, rectPaint
+ )
+ canvas.drawRoundRect(
+ rect, cornerRadius, cornerRadius, outlinePaint
+ )
+ val textPaint = Paint()
+ textPaint.color = Color.WHITE
+ textPaint.textSize = 50F
+
+ val overlayText = getString(R.string.overlay_help)
+ val textBounds = Rect()
+ textPaint.getTextBounds(overlayText, 0, overlayText.length, textBounds)
+ val textX = (surfaceWidth - textBounds.width()) / 2f
+ val textY = rectBottom + textBounds.height() + 15f // put text below rect and 15f padding
+ canvas.drawText(getString(R.string.overlay_help), textX, textY, textPaint)
+ holder.unlockCanvasAndPost(canvas)
+ }
+
+ /**
+ * [androidx.camera.core.ImageAnalysisConfig] requires enum value of
+ * [androidx.camera.core.AspectRatio]. Currently it has values of 4:3 & 16:9.
+ *
+ * Detecting the most suitable ratio for dimensions provided in @params by comparing absolute
+ * of preview ratio to one of the provided values.
+ *
+ * @param width - preview width
+ * @param height - preview height
+ * @return suitable aspect ratio
+ */
+ private fun aspectRatio(width: Int, height: Int): Int {
+ val previewRatio = ln(max(width, height).toDouble() / min(width, height))
+ if (abs(previewRatio - ln(RATIO_4_3_VALUE))
+ <= abs(previewRatio - ln(RATIO_16_9_VALUE))
+ ) {
+ return AspectRatio.RATIO_4_3
+ }
+ return AspectRatio.RATIO_16_9
+ }
+
+ /**
+ * Process result from permission request dialog box, has the request
+ * been granted? If yes, start Camera. Otherwise display a toast
+ */
+ override fun onRequestPermissionsResult(
+ requestCode: Int, permissions: Array, grantResults: IntArray
+ ) {
+ if (requestCode == REQUEST_CODE_PERMISSIONS) {
+ if (allPermissionsGranted()) {
+ viewFinder.post {
+ // Keep track of the display in which this view is attached
+ displayId = viewFinder.display.displayId
+
+ // Set up the camera and its use cases
+ setUpCamera()
+ }
+ } else {
+ Toast.makeText(
+ context,
+ "Permissions not granted by the user.",
+ Toast.LENGTH_SHORT
+ ).show()
+ }
+ }
+ }
+
+ /**
+ * Check if all permission specified in the manifest have been granted
+ */
+ private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
+ ContextCompat.checkSelfPermission(
+ requireContext(), it
+ ) == PackageManager.PERMISSION_GRANTED
+ }
+}
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainViewModel.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainViewModel.kt
new file mode 100644
index 0000000..bf047c4
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/main/MainViewModel.kt
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.main
+
+import android.app.Application
+import android.os.Handler
+import android.util.LruCache
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.MediatorLiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.Transformations
+import com.google.android.gms.tasks.OnCompleteListener
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.tasks.Tasks
+import com.google.mlkit.codelab.translate.util.Language
+import com.google.mlkit.codelab.translate.util.ResultOrError
+import com.google.mlkit.codelab.translate.util.SmoothedMutableLiveData
+import com.google.mlkit.nl.languageid.LanguageIdentification
+import com.google.mlkit.nl.translate.TranslateLanguage
+import com.google.mlkit.nl.translate.Translation
+import com.google.mlkit.nl.translate.Translator
+import com.google.mlkit.nl.translate.TranslatorOptions
+import com.google.mlkit.codelab.translate.main.MainFragment.Companion.DESIRED_HEIGHT_CROP_PERCENT
+import com.google.mlkit.codelab.translate.main.MainFragment.Companion.DESIRED_WIDTH_CROP_PERCENT
+
+class MainViewModel(application: Application) : AndroidViewModel(application) {
+
+ // TODO Instantiate LanguageIdentification
+ val targetLang = MutableLiveData()
+ val sourceText = SmoothedMutableLiveData(SMOOTHING_DURATION)
+
+ // We set desired crop percentages to avoid having to analyze the whole image from the live
+ // camera feed. However, we are not guaranteed what aspect ratio we will get from the camera, so
+ // we use the first frame we get back from the camera to update these crop percentages based on
+ // the actual aspect ratio of images.
+ val imageCropPercentages = MutableLiveData>()
+ .apply { value = Pair(DESIRED_HEIGHT_CROP_PERCENT, DESIRED_WIDTH_CROP_PERCENT) }
+ val translatedText = MediatorLiveData()
+ private val translating = MutableLiveData()
+ val modelDownloading = SmoothedMutableLiveData(SMOOTHING_DURATION)
+
+ private var modelDownloadTask: Task = Tasks.forCanceled()
+
+ private val translators =
+ object : LruCache(NUM_TRANSLATORS) {
+ override fun create(options: TranslatorOptions): Translator {
+ return Translation.getClient(options)
+ }
+
+ override fun entryRemoved(
+ evicted: Boolean,
+ key: TranslatorOptions,
+ oldValue: Translator,
+ newValue: Translator?
+ ) {
+ oldValue.close()
+ }
+ }
+
+ val sourceLang = Transformations.switchMap(sourceText) { text ->
+ val result = MutableLiveData()
+ // TODO Call the language identification method and assigns the result if it is not
+ // undefined (“und”)
+ result
+ }
+
+ override fun onCleared() {
+ // TODO Shut down ML Kit clients.
+ }
+
+ private fun translate(): Task {
+ // TODO Take the source language value, target language value, and the source text and
+ // perform the translation.
+ // If the chosen target language model has not been downloaded to the device yet,
+ // call downloadModelIfNeeded() and then proceed with the translation.
+ return Tasks.forResult("") // replace this with your code
+ }
+
+ // Gets a list of all available translation languages.
+ val availableLanguages: List = TranslateLanguage.getAllLanguages()
+ .map { Language(it) }
+
+ init {
+ modelDownloading.setValue(false)
+ translating.value = false
+ // Create a translation result or error object.
+ val processTranslation =
+ OnCompleteListener { task ->
+ if (task.isSuccessful) {
+ translatedText.value = ResultOrError(task.result, null)
+ } else {
+ if (task.isCanceled) {
+ // Tasks are cancelled for reasons such as gating; ignore.
+ return@OnCompleteListener
+ }
+ translatedText.value = ResultOrError(null, task.exception)
+ }
+ }
+ // Start translation if any of the following change: detected text, source lang, target lang.
+ translatedText.addSource(sourceText) { translate().addOnCompleteListener(processTranslation) }
+ translatedText.addSource(sourceLang) { translate().addOnCompleteListener(processTranslation) }
+ translatedText.addSource(targetLang) { translate().addOnCompleteListener(processTranslation) }
+ }
+
+ companion object {
+ // Amount of time (in milliseconds) to wait for detected text to settle
+ private const val SMOOTHING_DURATION = 50L
+
+ private const val NUM_TRANSLATORS = 1
+ }
+}
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ImageUtils.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ImageUtils.kt
new file mode 100644
index 0000000..1c28187
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ImageUtils.kt
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2020 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.util
+
+import android.graphics.Bitmap
+import android.graphics.ImageFormat
+import android.graphics.Matrix
+import android.graphics.Rect
+import android.media.Image
+import androidx.annotation.ColorInt
+
+/**
+ * Utility class for manipulating images.
+ */
+object ImageUtils {
+ private val CHANNEL_RANGE = 0 until (1 shl 18)
+
+ fun convertYuv420888ImageToBitmap(image: Image): Bitmap {
+ require(image.format == ImageFormat.YUV_420_888) {
+ "Unsupported image format $(image.format)"
+ }
+
+ val planes = image.planes
+
+ // Because of the variable row stride it's not possible to know in
+ // advance the actual necessary dimensions of the yuv planes.
+ val yuvBytes = planes.map { plane ->
+ val buffer = plane.buffer
+ val yuvBytes = ByteArray(buffer.capacity())
+ buffer[yuvBytes]
+ buffer.rewind() // Be kind…
+ yuvBytes
+ }
+
+ val yRowStride = planes[0].rowStride
+ val uvRowStride = planes[1].rowStride
+ val uvPixelStride = planes[1].pixelStride
+ val width = image.width
+ val height = image.height
+ @ColorInt val argb8888 = IntArray(width * height)
+ var i = 0
+ for (y in 0 until height) {
+ val pY = yRowStride * y
+ val uvRowStart = uvRowStride * (y shr 1)
+ for (x in 0 until width) {
+ val uvOffset = (x shr 1) * uvPixelStride
+ argb8888[i++] =
+ yuvToRgb(
+ yuvBytes[0][pY + x].toIntUnsigned(),
+ yuvBytes[1][uvRowStart + uvOffset].toIntUnsigned(),
+ yuvBytes[2][uvRowStart + uvOffset].toIntUnsigned()
+ )
+ }
+ }
+ val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+ bitmap.setPixels(argb8888, 0, width, 0, 0, width, height)
+ return bitmap
+ }
+
+ fun rotateAndCrop(
+ bitmap: Bitmap,
+ imageRotationDegrees: Int,
+ cropRect: Rect
+ ): Bitmap {
+ val matrix = Matrix()
+ matrix.preRotate(imageRotationDegrees.toFloat())
+ return Bitmap.createBitmap(
+ bitmap,
+ cropRect.left,
+ cropRect.top,
+ cropRect.width(),
+ cropRect.height(),
+ matrix,
+ true
+ )
+ }
+
+ @ColorInt
+ private fun yuvToRgb(nY: Int, nU: Int, nV: Int): Int {
+ var nY = nY
+ var nU = nU
+ var nV = nV
+ nY -= 16
+ nU -= 128
+ nV -= 128
+ nY = nY.coerceAtLeast(0)
+
+ // This is the floating point equivalent. We do the conversion in integer
+ // because some Android devices do not have floating point in hardware.
+ // nR = (int)(1.164 * nY + 2.018 * nU);
+ // nG = (int)(1.164 * nY - 0.813 * nV - 0.391 * nU);
+ // nB = (int)(1.164 * nY + 1.596 * nV);
+ var nR = 1192 * nY + 1634 * nV
+ var nG = 1192 * nY - 833 * nV - 400 * nU
+ var nB = 1192 * nY + 2066 * nU
+
+ // Clamp the values before normalizing them to 8 bits.
+ nR = nR.coerceIn(CHANNEL_RANGE) shr 10 and 0xff
+ nG = nG.coerceIn(CHANNEL_RANGE) shr 10 and 0xff
+ nB = nB.coerceIn(CHANNEL_RANGE) shr 10 and 0xff
+ return -0x1000000 or (nR shl 16) or (nG shl 8) or nB
+ }
+}
+
+private fun Byte.toIntUnsigned(): Int {
+ return toInt() and 0xFF
+}
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/Language.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/Language.kt
new file mode 100644
index 0000000..628c573
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/Language.kt
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.util
+
+import java.util.*
+
+/**
+ * Holds the language code (i.e. "en") and the corresponding localized full language name
+ * (i.e. "English")
+ */
+class Language(val code: String) : Comparable {
+
+ val displayName: String
+ get() = Locale(code).displayName
+
+ override fun equals(other: Any?): Boolean {
+ if (other === this) {
+ return true
+ }
+
+ if (other !is Language) {
+ return false
+ }
+
+ val otherLang = other as Language?
+ return otherLang!!.code == code
+ }
+
+ override fun toString(): String {
+ return displayName
+ }
+
+ override fun compareTo(other: Language): Int {
+ return this.displayName.compareTo(other.displayName)
+ }
+
+ override fun hashCode(): Int {
+ return code.hashCode()
+ }
+}
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ResultOrError.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ResultOrError.kt
new file mode 100644
index 0000000..553acc1
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ResultOrError.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.util
+
+/**
+ * Holds a result or some operation or the exception.
+ */
+class ResultOrError(var result: String?, var error: Exception?)
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ScopedExecutor.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ScopedExecutor.kt
new file mode 100644
index 0000000..f514858
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/ScopedExecutor.kt
@@ -0,0 +1,19 @@
+package com.google.mlkit.codelab.translate.util
+
+import java.util.concurrent.Executor
+import java.util.concurrent.atomic.AtomicBoolean
+
+class ScopedExecutor(private val executor: Executor) : Executor {
+
+ private val isShutdown = AtomicBoolean()
+
+ fun shutdown() {
+ isShutdown.set(true)
+ }
+
+ override fun execute(command: Runnable) {
+ executor.execute {
+ if (!isShutdown.get()) command.run()
+ }
+ }
+}
\ No newline at end of file
diff --git a/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/SmoothedMutableLiveData.kt b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/SmoothedMutableLiveData.kt
new file mode 100644
index 0000000..f7179bf
--- /dev/null
+++ b/translate/final/app/src/main/java/com/google/mlkit/codelab/translate/util/SmoothedMutableLiveData.kt
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package com.google.mlkit.codelab.translate.util
+
+import android.os.Handler
+import androidx.lifecycle.MutableLiveData
+
+/**
+ * A {@link MutableLiveData} that only emits change events when the underlying data has been stable
+ * for the configured amount of time.
+ *
+ * @param duration time delay to wait in milliseconds
+ */
+class SmoothedMutableLiveData(private val duration: Long) : MutableLiveData() {
+ private var pendingValue: T? = null
+ private val runnable = Runnable {
+ super.setValue(pendingValue)
+ }
+
+ override fun setValue(value: T) {
+ if (value != pendingValue) {
+ pendingValue = value
+ Handler().removeCallbacks(runnable)
+ Handler().postDelayed(runnable, duration)
+ }
+ }
+}
diff --git a/translate/final/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/translate/final/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
new file mode 100644
index 0000000..93b7d80
--- /dev/null
+++ b/translate/final/app/src/main/res/drawable-v24/ic_launcher_foreground.xml
@@ -0,0 +1,51 @@
+
+
+
+
+
+
+