Introducción a ContextMenu.Android

ContextMenu.Android es una biblioteca de código abierto desarrollada por Yalantis para crear menús contextuales con animaciones fluidas en aplicaciones Android. Ofrece opciones personalizables para mejorar la experiencia de usuario con iconos, estilos de texto y configuraciones de animación.

Características principales

Guía de inicio rápido

Configuración del entorno

Primero, añade el repositorio de JitPack en el archivo build.gradle de tu proyecto:

allprojects {
    repositories {
        maven { url 'https://jitpack.io' }
    }
}

Luego, agrega la dependencia:

dependencies {
    implementation 'com.github.Yalantis:Context-Menu.Android:1.1.4'
}

Ejemplo básico de uso

Crea una lista de objetos de menú y configura los parámetros:

// Crear objetos de menú
private fun buildMenuItems() = mutableListOf<menuobject>().apply {
    val exitItem = MenuObject().apply { setResourceValue(R.drawable.ic_exit) }
    val sendMessageItem = MenuObject("Enviar mensaje").apply { setResourceValue(R.drawable.ic_send) }
    val favoriteItem = MenuObject("Favorito").apply {
        setBitmapValue(BitmapFactory.decodeResource(resources, R.drawable.ic_star))
    }
    add(exitItem)
    add(sendMessageItem)
    add(favoriteItem)
}

// Inicializar el fragmento de menú
private fun configureMenuFragment() {
    val menuConfig = MenuParams(
        actionBarSize = resources.getDimension(R.dimen.toolbar_height).toInt(),
        menuObjects = buildMenuItems(),
        isClosableOutside = false
    )
    contextMenuFragment = ContextMenuDialogFragment.newInstance(menuConfig)
}</menuobject>

Personalización avanzada

1. Configuración de iconos

ContextMenu.Android admite varios métodos para establecer iconos:

// Método 1: Usar Drawable
menuItem.drawable = tuDrawable

// Método 2: Usar ID de recurso
menuItem.setResourceValue(R.drawable.tu_icono)

// Método 3: Usar Bitmap
menuItem.setBitmapValue(tuBitmap)

// Método 4: Usar valor de color
menuItem.setColorValue(Color.BLUE)

2. Estilos de texto

Define estilos personalizados en XML:

<style name="MenuTextCustom" parent="TextView.DefaultStyle">
    <item name="android:textStyle">italic</item>
    <item name="android:textColor">#FF5722</item>
    <item name="android:textSize">16sp</item>
</style>

Aplica el estilo en código:

val menuItem = MenuObject("Opción personalizada").apply {
    setResourceValue(R.drawable.ic_custom)
    menuTextAppearanceStyle = R.style.MenuTextCustom
}

3. Ajustes de animación

Configura parámetros de animación:

val menuConfig = MenuParams(
    actionBarSize = toolbarHeight,
    menuObjects = menuItems,
    animationDelay = 150L,
    animationDuration = 200L,
    backgroundColorAnimationDuration = 250L,
    isClosableOutside = true
)

Funcionalidades avanzadas

Dirección de gravedad

Configura la posición del menú para adaptarce a diferentes idiomas:

// Mostrar a la derecha (por defecto)
val configRight = MenuParams(gravity = MenuGravity.END)

// Mostrar a la izquierda
val configLeft = MenuParams(gravity = MenuGravity.START)

Manejo de eventos

Implementa listeners para interacciones del usuario:

contextMenuFragment.apply {
    // Evento de clic simple
    menuItemClickListener = { view, position ->
        when (position) {
            0 -> performCloseAction()
            1 -> performSendAction()
            2 -> performFavoriteAction()
        }
    }
    // Evento de clic prolongado
    menuItemLongClickListener = { view, index ->
        showToast("Clic prolongado en posición: $index")
    }
}

Adaptación a barra de estado transparente

Para aplicaciones con barra de estado transparente, ajusta la configuración:

val menuConfig = MenuParams(
    actionBarSize = toolbarHeight,
    menuObjects = menuItems,
    isFitsSystemWindow = true,
    isClipToPadding = false
)

Ejemplo práctico: Menú para aplicación social

Implementa un menú completo en una actividad social:

class SocialNetworkActivity : AppCompatActivity() {
    private lateinit var menuFragment: ContextMenuDialogFragment

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_social)
        setupSocialMenu()
    }

    private fun setupSocialMenu() {
        val menuConfig = MenuParams(
            actionBarSize = resources.getDimension(R.dimen.toolbar_height).toInt(),
            menuObjects = createSocialItems(),
            animationDuration = 100L,
            isClosableOutside = true,
            gravity = MenuGravity.END
        )
        menuFragment = ContextMenuDialogFragment.newInstance(menuConfig).apply {
            menuItemClickListener = { _, index -> executeSocialAction(index) }
        }
    }

    private fun createSocialItems(): List<menuobject> {
        return listOf(
            MenuObject("Chatear").apply {
                setResourceValue(R.drawable.ic_chat)
                textColor = ContextCompat.getColor(this@SocialNetworkActivity, R.color.chat_color)
            },
            MenuObject("Conectar").apply {
                setResourceValue(R.drawable.ic_connect)
                textColor = ContextCompat.getColor(this@SocialNetworkActivity, R.color.connect_color)
            },
            MenuObject("Reportar").apply {
                setResourceValue(R.drawable.ic_report)
                textColor = ContextCompat.getColor(this@SocialNetworkActivity, R.color.report_color)
            }
        )
    }

    private fun executeSocialAction(pos: Int) {
        when (pos) {
            0 -> initiateChat()
            1 -> sendConnectionRequest()
            2 -> reportUser()
        }
    }
}</menuobject>

Optimización de rendimiento

1. Gestión de memoria

Prioriza el uso de recursos sobre Bitmaps para reducir el consumo:

menuItem.setResourceValue(R.drawable.ic_resource)  // Recomendado
// menuItem.setBitmapValue(bitmapGrande)          // Evitar para bitmaps grandes

2. Rendimiento de animaciones

Ajusta la duración de animaciones según el dispositivo:

val animDuration = if (isDeviceLowEnd()) 80L else 150L
val menuConfig = MenuParams(animationDuration = animDuration)

3. Control de cantidad de elemantos

Limita el número de ítems para mantener la simplicidad:

val menuItems = buildMenuItems().take(5)  // Máximo 5 elementos

Preguntas frecuentes

¿Cómo cambio la posición de visualización del menú?
Establece el parámetro gravity en MenuGravity.START o MenuGravity.END.

¿Soporta texto multilinea en los ítems?
Actualmente está diseñado para texto de una sola línea; se recomienda limitar el texto a 10 caracteres.

¿Cómo personalizo la altura de los ítems del menú?
La altura coincide por defecto con la ActionBar; modifícala mediante el parámetro actionBarSize.

¿Permite actualizar dinámicamente el contenido del menú?
Es necesario recrear la instancia de ContextMenuDialogFragment para actualizar el contenido.

Compatibilidad de versiones

ContextMenu.Android es compatible con Android 4.4+ (KitKat y versiones superiores), garantizando amplia compatibilidad con dispositivos. La biblioteca está escrita en Kotlin y es totalmente compatible con proyectos Java.