no entiendo porque los telefonos de samsung, con respecto a las camaras, las fotos sales…
- User
no entiendo porque los telefonos de samsung, con respecto a las camaras, las fotos sales muy suavizadas...le he desactivado el modo "Scene optimizer" pero la comparo con otra aplicacion que tengo que es snap camera HDR..que es fabulosa...y podes sacarle todo el denoiser ..etc. hay algina manera de que me allides a crear un codigo para poder modificar en la camara app del samdung Note 20 ultra?
- Assistant
Entiendo tu frustración con las fotos algo suavizadas de los móviles Samsung, es un tema común debido al procesamiento de imagen que aplican para hacer las fotos más "atractivas", pero que puede perder detalles finos.
Por qué las fotos salen suavizadas en Samsung
Samsung aplica un postprocesado agresivo, incluyendo reducción de ruido, nitidez inteligente y mejoras automáticas que en conjunto suavizan las imágenes para obtener colores vibrantes y pieles más "agradables" visualmente. El modo "Scene optimizer" hace parte de eso, pero aunque lo desactives, la cámara sigue aplicando cierto procesamiento.
¿Se puede modificar la app oficial del Note 20 Ultra para cambiar el procesamiento de imagen de la cámara?
- No es sencillo ni directamente posible modificar la app original de cámara de Samsung (que viene integrada en el sistema) para cambiar estos parámetros internos.
- Esa app está firmada por Samsung y está muy ligada al hardware y al software propietario del teléfono.
- Cambiar el comportamiento interno requeriría modificar archivos de sistema o usar un software de cámara diferente.
Alternativas/recomendaciones:
-
Usar otras apps de cámara que permiten mayor control como Snap Camera HDR, Open Camera o Camera FV-5, que te permiten controlar reducción de ruido, balance de blancos, ISO, etc.
-
Usar la API de cámara de Android para crear una app personalizada, pero para acceder a controles muy específicos del hardware Samsung a nivel RAW o procesamiento avanzado puede que no sea posible, o requiere conocimiento avanzado y acceso root o al menos a la API Camera2 con modo RAW.
-
Rootear el teléfono e instalar un firmware modificado o una app modificada: Esto es bastante avanzado, con riesgos de seguridad y estabilidad.
Sobre crear un código para modificar la app de cámara Samsung
No es posible modificar directamente la app, pero puedo ayudarte con un ejemplo básico de código Android usando Camera2 API para capturar imágenes con controles manuales. Luego podrías procesarlas con menos suavizado o aplicar tú mismo el filtro que desees.
// Este es un ejemplo básico para abrir la cámara y capturar una imagen usando Camera2 API en Android. // Para un proyecto real debes manejar permisos, cámara lifecycle y más. CameraManager manager = (CameraManager) getSystemService(Context.CAMERA_SERVICE); String cameraId = manager.getCameraIdList()[0]; // elegir cámara trasera generalmente CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId); StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP); Size[] jpegSizes = null; if (map != null) { jpegSizes = map.getOutputSizes(ImageFormat.JPEG); } int width = 640; int height = 480; if (jpegSizes != null && jpegSizes.length > 0) { width = jpegSizes[0].getWidth(); height = jpegSizes[0].getHeight(); } ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG,1); Surface surface = reader.getSurface(); manager.openCamera(cameraId, new CameraDevice.StateCallback() { @Override public void onOpened(CameraDevice camera) { try { CaptureRequest.Builder captureBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE); captureBuilder.addTarget(surface); // Ejemplo para modificar sensibilidad y evitar procesamiento agresivo captureBuilder.set(CaptureRequest.NOISE_REDUCTION_MODE, CaptureRequest.NOISE_REDUCTION_MODE_OFF); captureBuilder.set(CaptureRequest.SHARPNESS, 0); camera.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() { @Override public void onConfigured(CameraCaptureSession session) { try { session.capture(captureBuilder.build(), new CameraCaptureSession.CaptureCallback() { @Override public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, TotalCaptureResult result) { super.onCaptureCompleted(session, request, result); // Imagen capturada, manejar resultado } }, null); } catch (CameraAccessException e) { e.printStackTrace(); } } @Override public void onConfigureFailed(CameraCaptureSession session) {} }, null); } catch (CameraAccessException e) { e.printStackTrace(); } } @Override public void onDisconnected(CameraDevice camera) { camera.close(); } @Override public void onError(CameraDevice camera, int error) { camera.close(); } }, null);
En resumen
- No es posible modificar la app oficial sin un nivel avanzado de cambios en firmware o root.
- Lo más práctico es usar apps de terceros que den más control o crear una app propia que use la Camera2 API para controlar el procesamiento.
- Puedes controlar parámetros como reducción de ruido, nitidez, ISO manualmente para evitar el suavizado excesivo.
Si quieres, puedo ayudarte a crear una app sencilla para hacer esto. ¿Te interesa?
- User
....me lo podrias explicar? mi samsung esta en idioma ingles porque me gusta asi. perome lo explicas en espanol con los nombres en ingles.....el codigo que me as dado como lo ejecuto?
- Assistant
Claro, te lo explico paso a paso y en español, usando los términos en inglés (como están en el código y en Android Studio), para que puedas entender bien.
1. ¿Qué es ese código?
El código que te di es un ejemplo básico para usar la Camera2 API de Android, que es la API oficial para controlar cámaras en Android con más precisión que la cámara tradicional.
Este ejemplo abre la cámara, configura algunos parámetros importantes para evitar que la cámara aplique reducción agresiva de ruido, y toma una foto.
2. ¿Cómo usar ese código? ¿Dónde y cómo lo ejecuto?
Paso 1: Instalar Android Studio
- Debes descargar e instalar Android Studio, que es el entorno oficial de desarrollo para crear apps Android.
- Aquí el link (desde PC o Mac): https://developer.android.com/studio
Paso 2: Crear un proyecto nuevo básico
- Abre Android Studio.
- Haz click en "Create New Project".
- Elige "Empty Activity" y clic en Next.
- Ponle un nombre al proyecto, por ejemplo:
CameraApp. - Elige que el lenguaje sea Java o Kotlin (el código que te envié lo puedes traducir a Kotlin si quieres, pero Java es más común en ejemplos).
- Luego clic en Finish y el proyecto se creará.
Paso 3: Añadir permisos en el archivo
AndroidManifest.xmlPara usar la cámara necesitas permisos.
Abre el archivo
AndroidManifest.xmly agrega dentro de la etiqueta<manifest>pero fuera de<application>este permiso:<uses-permission android:name="android.permission.CAMERA" />Y dentro de la etiqueta
<application>, si quieres grabar o guardar fotos, agrega otros permisos según necesites (como almacenamiento).
Paso 4: Pedir permisos en tiempo de ejecución
A partir de Android 6.0 (Marshmallow), además de declararlos en AndroidManifest, tienes que pedirlos en tiempo de ejecución. Esto quiere decir que tu app debe solicitar permiso para usar cámara.
Aquí un ejemplo rápido (desde tu actividad principal
MainActivity.java):private static final int REQUEST_CAMERA_PERMISSION = 200; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, REQUEST_CAMERA_PERMISSION); } else { // Aquí puedes iniciar la cámara } } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode == REQUEST_CAMERA_PERMISSION) { if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { // Permiso concedido, puedes iniciar la cámara } else { // Permiso denegado, muestra un mensaje Toast.makeText(this, "Camera permission required", Toast.LENGTH_SHORT).show(); } } }
Paso 5: Poner el código para abrir la cámara y sacar una foto
El código que te pasé tienes que ponerlo dentro de la actividad donde manejarás la cámara.
Para un ejemplo sencillo tienes que:
- Abrir la cámara (
CameraManager.openCamera()) - Preparar las vistas para mostrar la preview si quieres
- Capturar la imagen
- Guardar el resultado
Esto es más complejo y necesita bastante código adicional.
¿Qué recomendaciones te doy?
-
Aprende los conceptos básicos de Android y Camera2 API con tutoriales.
-
Mira esta página oficial para Camera2 API que tiene ejemplos animados y explicaciones: https://developer.android.com/reference/android/hardware/camera2/package-summary
-
Busca tutoriales en Youtube o blogs que enseñen paso a paso "Camera2 API Android example" para entender mejor cómo montar todo.
Resumen simple para que entiendas los pasos (en español con términos en inglés):
Acción Términos en inglés Qué hacer / Por qué Crear proyecto Android Android Studio, New Project Necesitas un entorno para hacer apps Pedir permiso para cámara Permission CAMERA El sistema Android te exige permiso Abrir cámara CameraManager.openCamera() Usar la cámara para sacar fotos Configurar captura CaptureRequest.Builder Ajustar parámetros como NOISE_REDUCTION_MODE_OFF para menos suavizado Tomar la foto CameraCaptureSession.capture() Enviar la orden para sacar la foto Guardar imagen ImageReader, almacenar JPEG Guardar la foto en almacenamiento
Para avanzar
Si quieres, puedo ayudarte a crear un proyecto paso a paso para que funcione en tu Samsung Note 20 Ultra. No es un código corto, porque la cámara es hardware complejo, pero te puedo guiar.
¿Quieres que prepare ese proyecto básico para ti y te explique paso a paso?
- User
en la parte de new project hay una ventana que dice Minimun SDK ..que opsion elijo..."API 24 Nougat, Android 7" hay otras mas...
- Assistant
¡Perfecto! Sobre la ventana de Minimum SDK en Android Studio, te explico qué es y cuál elegir para tu proyecto:
¿Qué es Minimum SDK?
- El Minimum SDK (nivel mínimo de API) define la versión mínima de Android que tu aplicación podrá usar.
- Esto quiere decir que tu app solo podrá instalarse y funcionar en dispositivos con esa versión o superior.
- Cada versión de Android tiene un número de API (por ejemplo, Android 7.0 Nougat es API 24).
¿Cuál elegir para tu Samsung Note 20 Ultra?
Tu Samsung Note 20 Ultra probablemente tiene Android 10 o superior (Android 10 es API 29, Android 11 es 30, etc).
Por lo tanto, si quieres que tu app funcione en tu teléfono sin problemas:
- Puedes elegir un Minimum SDK mínimo que esté por debajo o igual a la versión que tiene tu teléfono.
- La elección de API 24 (Nougat) es bastante buena porque:
- Es un equilibrio: no es tan bajo que tengas que programar para versiones antiguas (que ya casi nadie usa),
- Pero tampoco es alto que excluya demasiados dispositivos.
¿Recomendación?
- Elige API 24: Android 7.0 (Nougat) para un buen balance.
- Esto también es suficiente para usar la mayoría de las características modernas de
Camera2 API. - Si quieres, puedes elegir algo más alto como API 26 o API 28 si solo quieres enfocarte en dispositivos recientes, pero no es necesario.
En resumen:
- En la ventana de "Minimum SDK" selecciona:
API 24: Android 7.0 (Nougat) - Luego sigue configurando tu proyecto.
Si tienes dudas o quieres avanzar con tu proyecto, me dices y te puedo ayudar a seguir paso a paso.
- User
mi version de Android es 13, voy a eleguir API 33 Tiramisu, Android 13...
- Assistant
Perfecto, elegir API 33 (Android 13 - Tiramisu) como Minimum SDK tiene sentido si solo quieres que tu app se pueda instalar en dispositivos con Android 13 o superior.
Ventajas de elegir API 33 como mínimo:
- Puedes usar las últimas funcionalidades y APIs sin preocuparte por compatibilidad hacia atrás.
- El código puede ser más simple ya que no necesitas manejar tantas versiones antiguas.
- Es ideal si tu uso es personal o para un grupo reducido que tenga dispositivos modernos.
Consideraciones:
- Tu app no funcionará en teléfonos con Android 12 o inferior.
- Si solo vas a usarla en tu Note 20 Ultra (con Android 13) no hay problema.
Entonces, con esa decisión:
- Sigue adelante seleccionando API 33 como mínimo.
- Android Studio configurará automáticamente las dependencias y SDK correspondientes.
- Podrás usar todas las funciones modernas, incluida Camera2 API para Android 13.
Si quieres, te puedo ayudar a crear la estructura básica de la app para tu cámara con esta configuración y que puedas probar en tu Note 20 Ultra. ¿Quieres que sigamos?
- User
ok...estoy en el .....Paso 3: Añadir permisos en el archivo AndroidManifest.xml Para usar la cámara necesitas permisos.
Abre el archivo AndroidManifest.xml y agrega dentro de la etiqueta pero fuera de este permiso:
<application android:allowBackup="true" android:dataExtractionRules="@xml/data_extraction_rules" android:fullBackupContent="@xml/backup_rules" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/Theme.DitoCamara" tools:targetApi="31"> <activity android:name=".MainActivity" android:exported="true" android:label="@string/app_name" android:theme="@style/Theme.DitoCamara"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> - Assistant
Claro, te preparé el archivo AndroidManifest.xml con el permiso para la cámara insertado justo donde debe ir.
Así debe quedar tu archivo, agregué el permiso
android.permission.CAMERAdentro de<manifest>pero fuera de<application>, y además añadí los permisos para guardar fotos en almacenamiento (acceso a archivos), necesarios si quieres guardar imágenes en la memoria del dispositivo:<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"> <!-- Permiso para usar cámara --> <uses-permission android:name="android.permission.CAMERA" /> <!-- Permisos para leer/escribir almacenamiento externo (guardar fotos) --> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <application android:allowBackup="true" android:dataExtractionRules="@xml/data_extraction_rules" android:fullBackupContent="@xml/backup_rules" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" android:supportsRtl="true" android:theme="@style/Theme.DitoCamara" tools:targetApi="31"> <activity android:name=".MainActivity" android:exported="true" android:label="@string/app_name" android:theme="@style/Theme.DitoCamara"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>
Nota importante (sobre permisos de almacenamiento a partir de Android 10/11/13)
- En Android 11 (API 30) y superiores el manejo de permisos para almacenamiento cambió por políticas de seguridad (Scoped Storage).
- En muchos casos no necesitarás WRITE_EXTERNAL_STORAGE si guardas archivos dentro de las carpetas oficiales de tu app o usas MediaStore con la API moderna.
- Para simple prototipo o pruebas, los permisos que puse te ayudarán a evitar problemas.
Cuando tengas esto listo, el siguiente paso es pedir explícitamente los permisos en tiempo de ejecución (porque “declarar” el permiso en el Manifest no es suficiente en Android 6 y superiores).
Si quieres, te ayudo después con ese paso para que tu app te pregunte por esos permisos cuando la ejecutas. ¿Quieres?
- User
ya pegue el codigo....cual es el siguiente paso? tengo que guardar , que debo hacer
- Assistant
Perfecto, ya que pegaste y guardaste el archivo
AndroidManifest.xmlcon los permisos, el siguiente paso es:
Paso 4: Solicitar permisos en tiempo de ejecución
¿Por qué?
Desde Android 6 (API 23) en adelante, declarar los permisos en el manifest NO es suficiente. Tu aplicación tiene que pedir permiso al usuario mientras se está usando la app (en tiempo de ejecución), especialmente para permisos "sensibles" como la cámara y almacenamiento.
¿Cómo hacerlo?
Vamos a modificar tu actividad principal (
MainActivity.javaoMainActivity.kt) para que:- Cuando la app inicie, revise si tiene permiso para usar cámara (y almacenamiento si quieres),
- Si no tiene el permiso, le pida al usuario que lo acepte,
- Solo si el permiso está aceptado, iniciar el uso de la cámara.
Código básico para pedir permisos en Java (MainActivity.java)
import android.Manifest; import android.content.pm.PackageManager; import android.os.Bundle; import android.widget.Toast; import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat; public class MainActivity extends AppCompatActivity { private static final int REQUEST_CAMERA_PERMISSION = 200; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { // Pedir permisos ActivityCompat.requestPermissions(this, new String[]{ Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE}, REQUEST_CAMERA_PERMISSION); } else { // Ya tiene permisos: inicializar cámara o continuar startCamera(); // tu método para iniciar cámara o lógica } } // Aquí se recibe la respuesta del usuario sobre permisos @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { if (requestCode == REQUEST_CAMERA_PERMISSION) { if (grantResults.length > 0) { boolean cameraAccepted = grantResults[0] == PackageManager.PERMISSION_GRANTED; boolean storageAccepted = grantResults.length > 1 && grantResults[1] == PackageManager.PERMISSION_GRANTED; if (cameraAccepted && storageAccepted) { Toast.makeText(this, "Permisos concedidos", Toast.LENGTH_SHORT).show(); startCamera(); // iniciar cámara } else { Toast.makeText(this, "Permisos denegados, la app no funcionará correctamente", Toast.LENGTH_LONG).show(); // Aquí puedes cerrar la app o limitar funcionalidad } } } else { super.onRequestPermissionsResult(requestCode, permissions, grantResults); } } // Aquí pones el código que abriría la cámara (en los pasos siguientes) private void startCamera() { // Por ahora solo un Toast para comprobar permisos Toast.makeText(this, "Aquí iniciaremos la cámara", Toast.LENGTH_SHORT).show(); } }
Qué hacer ahora:
- Copia este código en tu archivo
MainActivity.java, o agrégalo respetando lo que ya tienes. - Guarda los cambios.
- Ejecuta la app en tu teléfono (conecta el Note 20 Ultra con USB depuración activada y selecciona en Android Studio Run → tu dispositivo).
- Cuando arranque la app, te debería preguntar por los permisos de cámara y almacenamiento.
- Concede los permisos para poder continuar.
Si quieres, te ayudo a avanzar con el paso que abre efectivamente la cámara y captura la foto después de esto.
¿Quieres que sigamos con el código para usar la cámara después de que ya tengas los permisos?
- Assistant
Parece que no enviaste ninguna pregunta nueva.
¿Quieres que te ayude a continuar con el siguiente paso para abrir la cámara y capturar imágenes en tu app?
O si tienes alguna duda sobre los pasos anteriores o necesitas aclaraciones, dime por favor.
¡Estoy aquí para ayudarte! - User
lo siento.....tengo dos ventanas ...MainActivity.kt y AndroidManifest.xml.....no veo MainActivity.java
- Assistant
No te preocupes, eso es completamente normal.
Por qué no ves
MainActivity.javapero síMainActivity.kt- Tu proyecto está configurado para usar Kotlin (extensión
.kt) en lugar de Java. - Kotlin es el lenguaje oficial recomendado por Google para Android, y funciona perfectamente para todo lo que necesitas.
Lo que debes hacer:
En vez de poner el código en un archivo
.java, lo debes poner (o adaptar) en el archivoMainActivity.kt.
Aquí tienes el mismo código de permisos pero en Kotlin para que lo copies en tu
MainActivity.kt:import android.Manifest import android.content.pm.PackageManager import android.os.Bundle import android.widget.Toast import androidx.appcompat.app.AppCompatActivity import androidx.core.app.ActivityCompat import androidx.core.content.ContextCompat class MainActivity : AppCompatActivity() { private val REQUEST_CAMERA_PERMISSION = 200 override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { // Pedir permisos ActivityCompat.requestPermissions( this, arrayOf(Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE), REQUEST_CAMERA_PERMISSION ) } else { // Ya tiene permisos: inicializar cámara o continuar startCamera() // tu método para iniciar cámara o lógica } } override fun onRequestPermissionsResult( requestCode: Int, permissions: Array<String>, grantResults: IntArray ) { super.onRequestPermissionsResult(requestCode, permissions, grantResults) if (requestCode == REQUEST_CAMERA_PERMISSION) { if (grantResults.isNotEmpty()) { val cameraAccepted = grantResults[0] == PackageManager.PERMISSION_GRANTED val storageAccepted = grantResults.size > 1 && grantResults[1] == PackageManager.PERMISSION_GRANTED if (cameraAccepted && storageAccepted) { Toast.makeText(this, "Permisos concedidos", Toast.LENGTH_SHORT).show() startCamera() // iniciar cámara } else { Toast.makeText(this, "Permisos denegados, la app no funcionará correctamente", Toast.LENGTH_LONG).show() } } } } private fun startCamera() { // Aquí pondremos el código para iniciar la cámara (más adelante) Toast.makeText(this, "Aquí iniciaremos la cámara", Toast.LENGTH_SHORT).show() } }
¿Qué hacer ahora?
- Abre tu archivo
MainActivity.kt. - Sustituye o añade el código anterior (si tienes código dentro, solo añade la parte para permisos).
- Guarda.
- Ejecuta la app en tu teléfono.
Cuando tengas eso funcionando (que la app te pida permisos y te confirme cuando estén concedidos) dime y te ayudo a avanzar con el siguiente paso para abrir la cámara, configurar y tomar la foto controlando el suavizado.
¿Quieres que sigamos?
- Tu proyecto está configurado para usar Kotlin (extensión
- User
package com.example.dito_camara
import android.os.Bundle import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.padding import androidx.compose.material3.Scaffold import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.ui.Modifier import androidx.compose.ui.tooling.preview.Preview import com.example.dito_camara.ui.theme.DitoCamaraTheme
class MainActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) enableEdgeToEdge() setContent { DitoCamaraTheme { Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding -> Greeting( name = "Android", modifier = Modifier.padding(innerPadding) ) } } } } }
@Composable fun Greeting(name: String, modifier: Modifier = Modifier) { Text( text = "Hello $name!", modifier = modifier ) }
@Preview(showBackground = true) @Composable fun GreetingPreview() { DitoCamaraTheme { Greeting("Android") } }
- Assistant
Gracias por compartir tu código. Veo que estás usando Jetpack Compose para la interfaz, y tu
MainActivityextiende deComponentActivityy utiliza la funciónsetContentpara mostrar la UI en Compose.
Cómo integrar la solicitud de permisos (cámara y almacenamiento) en tu proyecto con Compose
Dado que usas Compose y una actividad que extiende
ComponentActivity, el código para pedir permisos en tiempo de ejecución cambia un poco para adaptarse a esta arquitectura.
Paso 1: Añadir las dependencias para manejar permisos en Compose (opcional pero recomendado)
Google provee accesos convenientes para permisos en Compose, pero vamos a hacer la solución sin librerías externas para que sea más sencillo.
Paso 2: Solicitar permisos en
onCreatecomo en el ejemplo anterior, pero usandoContextCompatyActivityCompatigual que antes.Te muestro cómo modificar tu clase
MainActivitypara pedir permisos estándar:package com.example.dito_camara import android.Manifest import android.content.pm.PackageManager import android.os.Bundle import android.widget.Toast import androidx.activity.ComponentActivity import androidx.activity.compose.setContent import androidx.activity.result.contract.ActivityResultContracts import androidx.core.content.ContextCompat import com.example.dito_camara.ui.theme.DitoCamaraTheme class MainActivity : ComponentActivity() { private val requestPermissionLauncher = registerForActivityResult( ActivityResultContracts.RequestMultiplePermissions() ) { permissions -> val granted = permissions[Manifest.permission.CAMERA] == true && permissions[Manifest.permission.WRITE_EXTERNAL_STORAGE] == true if (granted) { Toast.makeText(this, "Permisos concedidos", Toast.LENGTH_SHORT).show() startCamera() } else { Toast.makeText(this, "Permisos denegados, la app no funcionará correctamente", Toast.LENGTH_LONG).show() } } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Pedimos permisos si no están concedidos if (!hasCameraPermission() || !hasStoragePermission()) { requestPermissionLauncher.launch( arrayOf( Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE ) ) } else { startCamera() } setContent { DitoCamaraTheme { // Tu UI Compose } } } private fun hasCameraPermission() = ContextCompat.checkSelfPermission( this, Manifest.permission.CAMERA ) == PackageManager.PERMISSION_GRANTED private fun hasStoragePermission() = ContextCompat.checkSelfPermission( this, Manifest.permission.WRITE_EXTERNAL_STORAGE ) == PackageManager.PERMISSION_GRANTED private fun startCamera() { // Aquí pondremos el código para iniciar la cámara (en los próximos pasos) Toast.makeText(this, "Aquí iniciaremos la cámara", Toast.LENGTH_SHORT).show() } }
Explicación rápida de este código:
- Usamos
registerForActivityResultpara pedir múltiples permisos y recibir la respuesta sin tener que sobreescribironRequestPermissionsResult. - Preguntamos si ya tenemos permisos; si no, los pedimos.
- Si el usuario los acepta, podemos ejecutar
startCamera()donde pondremos la lógica para la cámara. - La UI Compose queda lista para que la desarrolles y la muestres dentro del bloque
setContent { ... }.
Próximo paso
- Ejecuta esta versión, deberías ver que al iniciar la app te pide los permisos.
- Confirma que aparecen los diálogos y acepta para que puedas continuar.
- Luego, te ayudo a integrar el código para abrir la cámara y capturar la foto controlando el procesamiento (sin suavizado excesivo).
Si quieres, también puedo ayudarte a poner un texto en Compose para indicar el estado (por ejemplo “Permisos concedidos” o “Permisos denegados”).
¿Quieres que avanzamos con eso o prefieres que primero confirmes que los permisos ya corren bien?
- Usamos
- User
ok, ya lo pegue y lo remplace.....cual es el ciguiente paso
- Assistant
¡Perfecto! Ahora que tu app pide y gestiona correctamente los permisos, el siguiente paso es abrir la cámara con Camera2 API para poder tomar fotos con control manual sobre el procesamiento, por ejemplo, desactivando la reducción de ruido para evitar el suavizado excesivo que mencionabas.
Paso 5: Abrir la cámara y capturar una imagen con Camera2 API
Este paso es algo más complejo, porque la API es un poco extensa, pero te guiaré con un ejemplo básico adaptado para Android y Compose.
Consideraciones para el ejemplo:
- Crearás una clase que gestione la cámara.
- Mostrarás la cámara en pantalla con un
PreviewViewo con Surface. - Capturarás una foto y la guardarás (o procesarás).
1. Agrega la dependencia necesaria para PreviewView
En tu archivo
build.gradle (app), añade esta dependencia si no la tienes ya, para usarPreviewView(vista que muestra la imagen en la pantalla y es fácil de manejar):dependencies { // ... implementation "androidx.camera:camera-camera2:1.2.3" implementation "androidx.camera:camera-lifecycle:1.2.3" implementation "androidx.camera:camera-view:1.2.3" implementation "androidx.camera:camera-extensions:1.2.3" }Luego sincroniza el proyecto para que tome estas librerías.
2. Crea una vista para mostrar el
PreviewView(fuera de Compose)Para simplificar y porque CameraX (que usa Camera2 bajo el capó) es más amigable, puedes usar CameraX con previews y captura sencilla. Esto evita manejar directamente Camera2 API, que es más compleja.
Si quieres usar CameraX dentro de Compose, puedes usar AndroidView para incluir vistas tradicionales.
3. Ejemplo básico para integrar PreviewView en Compose y tomar foto sin suavizado agresivo
Este es un ejemplo simplificado, enfocado en que puedas controlar la reducción de ruido (usando Camera2 API con CameraX):
// Imports que necesitas import android.Manifest import android.content.Context import android.util.Log import android.widget.Toast import androidx.camera.core.CameraSelector import androidx.camera.core.ImageCapture import androidx.camera.core.ImageCaptureException import androidx.camera.core.Preview import androidx.camera.lifecycle.ProcessCameraProvider import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.material3.Button import androidx.compose.material3.Text import androidx.compose.runtime.* import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.viewinterop.AndroidView import androidx.core.content.ContextCompat import androidx.lifecycle.LifecycleOwner import androidx.camera.view.PreviewView import androidx.camera.core.CaptureRequest @Composable fun CameraScreen() { val context = LocalContext.current val lifecycleOwner = context as LifecycleOwner var imageCapture: ImageCapture? by remember { mutableStateOf(null) } var cameraProvider by remember { mutableStateOf<ProcessCameraProvider?>(null) } var previewView = remember { PreviewView(context) } LaunchedEffect(Unit) { val cameraProviderFuture = ProcessCameraProvider.getInstance(context) cameraProviderFuture.addListener({ cameraProvider = cameraProviderFuture.get() val preview = Preview.Builder() // Desactiva reducción de ruido agresiva (si se puede) .setCaptureRequestOption(CaptureRequest.NOISE_REDUCTION_MODE, CaptureRequest.NOISE_REDUCTION_MODE_OFF) .build() .also { it.setSurfaceProvider(previewView.surfaceProvider) } imageCapture = ImageCapture.Builder().build() try { cameraProvider?.unbindAll() cameraProvider?.bindToLifecycle( lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, preview, imageCapture ) } catch (exc: Exception) { Toast.makeText(context, "Error iniciando cámara: ${exc.message}", Toast.LENGTH_LONG).show() Log.e("CameraScreen", "Use case binding failed", exc) } }, ContextCompat.getMainExecutor(context)) } Box(modifier = Modifier.fillMaxSize()) { AndroidView(factory = { previewView }, modifier = Modifier.matchParentSize()) Button(onClick = { val file = createFile(context) // función para crear archivo donde guardar val outputOptions = ImageCapture.OutputFileOptions.Builder(file).build() imageCapture?.takePicture( outputOptions, ContextCompat.getMainExecutor(context), object : ImageCapture.OnImageSavedCallback { override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) { Toast.makeText(context, "Imagen guardada en: ${file.absolutePath}", Toast.LENGTH_SHORT).show() } override fun onError(exception: ImageCaptureException) { Toast.makeText(context, "Error al guardar imagen: ${exception.message}", Toast.LENGTH_LONG).show() } } ) }, modifier = Modifier.align(Alignment.BottomCenter)) { Text(text = "Tomar Foto") } } } // Función para crear archivo de foto, ejemplo básico dentro de app private files fun createFile(context: Context): java.io.File { val dir = context.filesDir return java.io.File(dir, "photo_${System.currentTimeMillis()}.jpg") }
Qué hace este código:
- Crea una pantalla con la vista previa de la cámara usando
PreviewView. - Usa CameraX para iniciar la cámara trasera y mostrar preview.
- Tiene un botón para capturar y guardar fotos en archivo privado.
- Desactiva la reducción de ruido agresiva usando la configuración
NOISE_REDUCTION_MODE_OFFen el builder del preview.
¿Qué hacer ahora?
- Añade las dependencias de CameraX en tu
build.gradle. - Crea el composable
CameraScreen()y llama a este composable dentro de tu métodosetContentenMainActivity(remplaza el placeholder de UI que tengas). - Ejecuta la app y verás la cámara con el botón para tomar foto.
- Las imágenes se guardarán dentro de la carpeta privada de tu app (sin acceso externo para simplificar).
Si quieres, te ayudo a hacer estos pasos uno por uno o aclararte cualquier punto.
Resumen rápido
Paso Qué hacer Instalar dependencias Añadir CameraX en build.gradle Mostrar preview Usar PreviewView dentro de composable AndroidView Iniciar Cámara Usar ProcessCameraProvider y bindToLifecycle Configurar reducción ruido CaptureRequest.NOISE_REDUCTION_MODE_OFFCapturar foto Usar ImageCapture.takePicture()
¿Quieres que te guíe con los archivos y configuración de
build.gradlepara activar esto primero? - User
un segundo....me dicen en el Paso 5: Abrir la cámara y capturar una imagen con Camera2 API no entieno, tengo que copiar el archivo que cree al telefono? tengo que sacar una foto con el telefono?...
- Assistant
¡Claro! Te explico paso a paso para que quede clarísimo qué pasa en el Paso 5 y qué debes hacer:
¿Qué significa "Abrir la cámara y capturar una imagen con Camera2 API"?
- No es que tengas que copiar un archivo extra al teléfono.
- Significa que tienes que programar tu aplicación para que desde dentro de la app, al ejecutarla en tu teléfono, abra la cámara del dispositivo y tome una foto cuando tú pulses un botón.
¿Cómo funciona el proceso práctico?
-
Escribes código en Android Studio (la aplicación que estás desarrollando) para que:
- al abrir la app, active la cámara del teléfono,
- muestre lo que ve la cámara en la pantalla (preview),
- y que puedas tomar una foto con un botón.
-
Ejecutas el proyecto Android desde Android Studio:
- Conectas tu Samsung Note 20 Ultra al PC con el modo de depuración USB activado,
- Le das a "Run" (Ejecutar) en Android Studio,
- La app se instalará en el teléfono y se ejecutará.
-
Interactúas en tu teléfono con la app:
- Verás la cámara funcionando dentro de la app,
- Pulsas el botón para tomar la foto,
- La app guarda la foto (en almacenamiento interno o externo, según programes).
¿Para qué es este paso?
El objetivo de este paso es que tu app reemplace la app de cámara tradicional, pero con más control sobre los parámetros internos.
Así puedes:- Evitar que la cámara suavice la foto demasiado,
- Controlar reducción de ruido, ISO, etc.
En resumen:
- No tienes que copiar un archivo al teléfono para "hacer la foto".
- En cambio, tienes que escribir el código para que tu app use la cámara y tome fotos.
- Luego ejecutar esa app en tu teléfono, donde tú tomas fotos desde la app.
¿Qué necesitas para seguir?
- El ejemplo que te envié usa CameraX (una librería oficial para simplificar el uso de cámara en Android).
- Debes agregar esas dependencias en tu proyecto para usarla.
- Implementar el código para mostrar la cámara y tomar fotos.
- Ejecutar la app en tu teléfono.
Si quieres, te puedo ayudar con los pasos para:
- Añadir las dependencias en
build.gradle, - Poner el código para mostrar la cámara,
- Configurar un botón para tomar fotos,
- Probar la app en tu teléfono.
¿Quieres que prepare y te guíe con esto paso a paso?
- User
tengo una opcion que dice "running devices" tu duces "Run" es lo mismo?
- Assistant
Sí, exactamente.
En Android Studio, cuando quieres ejecutar o probar tu aplicación, debes hacer clic en el botón que suele llamarse "Run" (ícono de un triángulo verde ▶️).
-
Al hacer clic en Run, Android Studio te muestra una ventana llamada "Running Devices" o algo similar, donde aparecen los dispositivos conectados disponibles para instalar y ejecutar la app.
-
Ahí eliges tu Samsung Note 20 Ultra (que debe estar conectado por USB y con la opción de Depuración USB activada en las opciones de desarrollador).
-
Luego Android Studio compila la app, la instala en ese dispositivo y la ejecuta automáticamente.
Pasos concretos:
- Conecta tu teléfono al PC con el cable USB.
- Asegúrate de que Depuración USB esté activada en el teléfono (opciones de desarrollador).
- En Android Studio, haz clic en el botón Run (triángulo verde ▶️, usualmente arriba de todo).
- Cuando aparezca la ventana Running Devices, selecciona tu teléfono.
- Presiona OK o Run para desplegar la app.
- La app se abrirá en tu teléfono y podrás empezar a usarla.
Si no ves tu dispositivo en la lista:
- Verifica que el cable esté bien conectado.
- Comprueba que el teléfono está en modo depuración USB.
- Si es la primera vez que conectas el dispositivo, puede pedirte que aceptes la clave de seguridad (autorizar la PC).
¿Quieres que te ayude a verificar o configurar alguna de estas cosas antes de ejecutar la app?
-