audio notificaciones - Cómo reproducir un sonido de notificación de Android




donde encuentran (9)

Me preguntaba cómo podría reproducir un sonido de notificación sin reproducirlo en el flujo de medios. Ahora mismo puedo hacerlo a través del reproductor multimedia, sin embargo, no quiero que se reproduzca como un archivo multimedia, quiero que se reproduzca como una notificación o alerta o un tono de llamada. heres un ejemplo de cómo se ve mi código en este momento:

MediaPlayer mp = new MediaPlayer();
mp.reset();
mp.setDataSource(notificationsPath+ (String) apptSounds.getSelectedItem());
mp.prepare();
mp.start();

Answers

Puede usar Notification and NotificationManager para mostrar la notificación que desea. Luego puede personalizar el sonido que desea reproducir con su notificación.


Intent intent = new Intent(this, MembersLocation.class);
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    intent.putExtra("type",type);
    intent.putExtra("sender",sender);
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent,
            PendingIntent.FLAG_ONE_SHOT);

    String channelId = getString(R.string.default_notification_channel_id);

    Uri Emergency_sound_uri=Uri.parse("android.resource://"+getPackageName()+"/raw/emergency_sound");
   // Uri Default_Sound_uri= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    if(type.equals("emergency"))
    {
        playSound=Emergency_sound_uri;
    }
    else
    {
        playSound= Settings.System.DEFAULT_NOTIFICATION_URI;
    }

    NotificationCompat.Builder notificationBuilder =
            new NotificationCompat.Builder(this, channelId)
                    .setSmallIcon(R.drawable.ic_notification)
                    .setContentTitle(title)
                    .setContentText(body)
                    .setSound(playSound, AudioManager.STREAM_NOTIFICATION)
                    .setAutoCancel(true)
                    .setColor(getColor(R.color.dark_red))
                    .setPriority(NotificationCompat.PRIORITY_HIGH)
                    .setContentIntent(pendingIntent);

   // notificationBuilder.setOngoing(true);//for Android notification swipe delete disabling...

    NotificationManager notificationManager =
            (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);

    // Since android Oreo notification channel is needed.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        NotificationChannel channel = new NotificationChannel(channelId,
                "Channel human readable title",
                NotificationManager.IMPORTANCE_HIGH);
        AudioAttributes att = new AudioAttributes.Builder()
                .setUsage(AudioAttributes.USAGE_NOTIFICATION)
                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
                .build();
        channel.setSound(Emergency_sound_uri, att);
        if (notificationManager != null) {
            notificationManager.createNotificationChannel(channel);
        }
    }

    if (notificationManager != null) {
        notificationManager.notify(0 /* ID of notification */, notificationBuilder.build());
    }
}

Creo que el concepto de "sonido de notificación" es incorrecto para la interfaz de usuario de Android.

El comportamiento esperado de Android es usar la Notificación estándar para alertar al usuario. Si reproduces un sonido de notificación sin el ícono de la barra de estado, consigues confundir al usuario ("¿Qué fue ese sonido? ¿No hay un ícono aquí, quizás tengo problemas de audición?").

Cómo configurar el sonido en una notificación es, por ejemplo, aquí: Configuración de sonido para la notificación


Ha pasado un tiempo desde su pregunta, pero ... ¿Ha intentado configurar el tipo de transmisión de audio?

mp.setAudioStreamType(AudioManager.STREAM_NOTIFICATION);

Debe hacerse antes de prepararse.


Ahora puede hacer esto al incluir el sonido al crear una notificación en lugar de llamar el sonido por separado.

//Define Notification Manager
NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

//Define sound URI
Uri soundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(getApplicationContext())
        .setSmallIcon(icon)
        .setContentTitle(title)
        .setContentText(message)
        .setSound(soundUri); //This sets the sound to play

//Display notification
notificationManager.notify(0, mBuilder.build());

Prueba esto:

public void ringtone(){
    try {
        Uri notification = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
        Ringtone r = RingtoneManager.getRingtone(getApplicationContext(), notification);
        r.play();
     } catch (Exception e) {
         e.printStackTrace();
     }
}

Si alguien todavía está buscando una solución a esto, encontré una respuesta en Cómo reproducir el tono de llamada / alarma en Android

try {
    Uri notification = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    Ringtone r = RingtoneManager.getRingtone(getApplicationContext(), notification);
    r.play();
} catch (Exception e) {
    e.printStackTrace();
}

Puede cambiar TYPE_NOTIFICATION a TYPE_ALARM, pero querrá realizar un seguimiento de su Ringtone r para dejar de reproducirlo ... por ejemplo, cuando el usuario haga clic en un botón o algo así.


Yo tenía más o menos la misma pregunta. Después de investigar un poco, creo que si quieres reproducir el "sonido de notificación" predeterminado del sistema, tienes que mostrar una notificación y decirle que use el sonido predeterminado. Y hay algo que decir para el argumento en algunas de las otras respuestas que si está reproduciendo un sonido de notificación, también debería presentar algún mensaje de notificación.

Sin embargo, hay un pequeño ajuste de la API de notificación y puede acercarse a lo que desea. Puede mostrar una notificación en blanco y luego eliminarla automáticamente después de unos segundos. Creo que esto funcionará para mí; tal vez funcionará para ti.

He creado un conjunto de métodos de conveniencia en com.globalmentor.android.app.Notifications.java que te permiten crear un sonido de notificación como este:

Notifications.notify(this);

El LED también parpadeará y, si tiene permiso de vibración, se producirá una vibración. Sí, aparecerá un icono de notificación en la barra de notificaciones, pero desaparecerá después de unos segundos.

En este punto, puede darse cuenta de que, dado que la notificación desaparecerá de todos modos, también podría tener un mensaje de texto desplegable en la barra de notificaciones; puedes hacer eso así:

Notifications.notify(this, 5000, "This text will go away after five seconds.");

Hay muchos otros métodos de conveniencia en esta clase. Puede descargar toda la biblioteca desde su repositorio Subversion y compilarla con Maven. Depende de la biblioteca globalmentor-core , que también se puede construir e instalar con Maven.


Como lo menciona Dave Webb, el Blog del desarrollador de Android tiene un artículo que cubre esto. Su solución preferida es rastrear las instalaciones de la aplicación en lugar de los dispositivos, y eso funcionará bien en la mayoría de los casos de uso. La publicación del blog te mostrará el código necesario para que funcione, y te recomiendo que lo consultes.

Sin embargo, la publicación del blog continúa discutiendo soluciones si necesita un identificador de dispositivo en lugar de un identificador de instalación de la aplicación. Hablé con alguien en Google para obtener una aclaración adicional sobre algunos elementos en caso de que necesite hacerlo. Esto es lo que descubrí sobre los identificadores de dispositivos que NO se mencionan en la publicación de blog mencionada anteriormente:

  • ANDROID_ID es el identificador de dispositivo preferido. ANDROID_ID es perfectamente confiable en versiones de Android <= 2.1 o> = 2.3. Solo 2.2 tiene los problemas mencionados en el post.
  • Varios dispositivos de varios fabricantes se ven afectados por el error ANDROID_ID en 2.2.
  • Por lo que he podido determinar, todos los dispositivos afectados tienen el mismo ANDROID_ID , que es 9774d56d682e549c . Que también es el mismo ID de dispositivo reportado por el emulador, por cierto.
  • Google cree que los OEM han solucionado el problema para muchos o la mayoría de sus dispositivos, pero pude verificar que a partir de abril de 2011, al menos, todavía es bastante fácil encontrar dispositivos que tengan el ANDROID_ID roto.

Basándome en las recomendaciones de Google, implementé una clase que generará un UUID único para cada dispositivo, utilizando ANDROID_ID como semilla cuando sea apropiado, recurriendo a TelephonyManager.getDeviceId () según sea necesario, y si eso falla, recurrir a un UUID único generado aleatoriamente esto se mantiene en los reinicios de la aplicación (pero no en las reinstalaciones de la aplicación).

Tenga en cuenta que para los dispositivos que tienen que retroceder en la ID del dispositivo, la ID única se mantendrá en los restablecimientos de fábrica. Esto es algo a tener en cuenta. Si necesita asegurarse de que un restablecimiento de fábrica restablecerá su ID única, puede considerar la posibilidad de recurrir directamente al UUID aleatorio en lugar de la ID del dispositivo.

Nuevamente, este código es para una ID de dispositivo, no una ID de instalación de la aplicación. Para la mayoría de las situaciones, un ID de instalación de la aplicación es probablemente lo que estás buscando. Pero si necesita una ID de dispositivo, entonces el siguiente código probablemente funcione para usted.

import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;

import java.io.UnsupportedEncodingException;
import java.util.UUID;

public class DeviceUuidFactory {

    protected static final String PREFS_FILE = "device_id.xml";
    protected static final String PREFS_DEVICE_ID = "device_id";
    protected volatile static UUID uuid;

    public DeviceUuidFactory(Context context) {
        if (uuid == null) {
            synchronized (DeviceUuidFactory.class) {
                if (uuid == null) {
                    final SharedPreferences prefs = context
                            .getSharedPreferences(PREFS_FILE, 0);
                    final String id = prefs.getString(PREFS_DEVICE_ID, null);
                    if (id != null) {
                        // Use the ids previously computed and stored in the
                        // prefs file
                        uuid = UUID.fromString(id);
                    } else {
                        final String androidId = Secure.getString(
                            context.getContentResolver(), Secure.ANDROID_ID);
                        // Use the Android ID unless it's broken, in which case
                        // fallback on deviceId,
                        // unless it's not available, then fallback on a random
                        // number which we store to a prefs file
                        try {
                            if (!"9774d56d682e549c".equals(androidId)) {
                                uuid = UUID.nameUUIDFromBytes(androidId
                                        .getBytes("utf8"));
                            } else {
                                final String deviceId = (
                                    (TelephonyManager) context
                                    .getSystemService(Context.TELEPHONY_SERVICE))
                                    .getDeviceId();
                                uuid = deviceId != null ? UUID
                                    .nameUUIDFromBytes(deviceId
                                            .getBytes("utf8")) : UUID
                                    .randomUUID();
                            }
                        } catch (UnsupportedEncodingException e) {
                            throw new RuntimeException(e);
                        }
                        // Write the value out to the prefs file
                        prefs.edit()
                                .putString(PREFS_DEVICE_ID, uuid.toString())
                                .commit();
                    }
                }
            }
        }
    }

    /**
     * Returns a unique UUID for the current android device. As with all UUIDs,
     * this unique ID is "very highly likely" to be unique across all Android
     * devices. Much more so than ANDROID_ID is.
     * 
     * The UUID is generated by using ANDROID_ID as the base key if appropriate,
     * falling back on TelephonyManager.getDeviceID() if ANDROID_ID is known to
     * be incorrect, and finally falling back on a random UUID that's persisted
     * to SharedPreferences if getDeviceID() does not return a usable value.
     * 
     * In some rare circumstances, this ID may change. In particular, if the
     * device is factory reset a new device ID may be generated. In addition, if
     * a user upgrades their phone from certain buggy implementations of Android
     * 2.2 to a newer, non-buggy version of Android, the device ID may change.
     * Or, if a user uninstalls your app on a device that has neither a proper
     * Android ID nor a Device ID, this ID may change on reinstallation.
     * 
     * Note that if the code falls back on using TelephonyManager.getDeviceId(),
     * the resulting ID will NOT change after a factory reset. Something to be
     * aware of.
     * 
     * Works around a bug in Android 2.2 for many devices when using ANDROID_ID
     * directly.
     * 
     * @see http://code.google.com/p/android/issues/detail?id=10603
     * 
     * @return a UUID that may be used to uniquely identify your device for most
     *         purposes.
     */
    public UUID getDeviceUuid() {
        return uuid;
    }
}




android audio notifications