音频播放器浮窗+通知栏播放器控制

最新推荐文章于 2024-08-26 11:27:17 发布
最新推荐文章于 2024-08-26 11:27:17 发布
阅读量2.3k 收藏 9
点赞数 1
分类专栏： Android自定义控件 Kotlin 文章标签： 音视频 悬浮窗 音乐播放器 通知栏播放器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nsacer/article/details/121138138
版权

一、最终效果如图

二、音频播放器浮窗实现

原理：

1、创建单例类FloatPlayer，内部创建浮窗播放器的布局，通过MediaPlayer去实现音频的播放。并暴露出开启、显示、隐藏、关闭浮窗播放器的方法供外部调用。

2、因为是通过Window.addView()、removeView()方法在每个页面去显示、隐藏浮窗播放器（这种方法优点：不用申请系统弹窗权限。缺点：每个页面都要处理。），需要在页面的基类BaseActivity里边的onResume()、onPause()方法里调用FloatPlayer的显示（判断是否启动了播放器，若启动则显示，否则不显示）、隐藏方法。

0、布局文件

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:id="@+id/csRootFloatPlayer"
    android:layout_width="168dp"
    android:layout_height="48dp">

    <com.example.floatplayer.PlayerBgView
        android:id="@+id/bgViewPlayer"
        android:layout_width="168dp"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:layout_height="48dp"/>

    <com.google.android.material.imageview.ShapeableImageView
        android:id="@+id/sivPlayerCover"
        android:layout_width="@dimen/player_icon_width"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:scaleType="centerCrop"
        android:src="@mipmap/ic_player_cover"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintDimensionRatio="1"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:shapeAppearance="@style/imgStyleCircle" />

    <ImageView
        android:id="@+id/ivPlayerControl"
        android:layout_width="@dimen/player_icon_width"
        android:layout_height="0dp"
        android:layout_marginStart="@dimen/player_icon_margin_start"
        android:contentDescription="@null"
        android:src="@drawable/ic_baseline_play_arrow_24"
        app:layout_constraintBottom_toBottomOf="@+id/sivPlayerCover"
        app:layout_constraintDimensionRatio="1"
        app:layout_constraintStart_toEndOf="@+id/sivPlayerCover"
        app:layout_constraintTop_toTopOf="@+id/sivPlayerCover"
        app:tint="@color/float_play_icon" />

    <ImageView
        android:id="@+id/ivPlayerNext"
        android:layout_width="@dimen/player_icon_width"
        android:layout_height="0dp"
        android:layout_marginStart="@dimen/player_icon_margin_start"
        android:contentDescription="@null"
        android:src="@drawable/ic_baseline_skip_next_24"
        app:layout_constraintBottom_toBottomOf="@+id/sivPlayerCover"
        app:layout_constraintDimensionRatio="1"
        app:layout_constraintStart_toEndOf="@+id/ivPlayerControl"
        app:layout_constraintTop_toTopOf="@+id/sivPlayerCover"
        app:tint="@color/float_play_icon" />

    <ImageView
        android:id="@+id/ivPlayerClose"
        android:layout_width="@dimen/player_icon_width"
        android:layout_height="@dimen/player_icon_width"
        android:layout_marginStart="@dimen/player_icon_margin_start"
        android:contentDescription="@null"
        android:src="@drawable/ic_baseline_close_24"
        app:layout_constraintBottom_toBottomOf="@+id/sivPlayerCover"
        app:layout_constraintStart_toEndOf="@+id/ivPlayerNext"
        app:layout_constraintTop_toTopOf="@+id/sivPlayerCover"
        app:tint="@color/float_play_icon" />

</androidx.constraintlayout.widget.ConstraintLayout>

圆形封面图样式style：imgStyleCircle

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!--ShapeImageView圆形图-->
    <style name="imgStyleCircle">
        <item name="cornerFamily">rounded</item>
        <item name="cornerSize">50%</item>
    </style>
</resources>

1、FloatPlayer

import android.animation.ObjectAnimator
import android.animation.ValueAnimator
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.graphics.PixelFormat
import android.media.MediaPlayer
import android.os.Build
import android.transition.TransitionManager
import android.util.TypedValue
import android.view.Gravity
import android.view.LayoutInflater
import android.view.View
import android.view.WindowManager
import android.view.animation.LinearInterpolator
import android.widget.Toast
import androidx.constraintlayout.widget.ConstraintSet
import androidx.core.app.NotificationCompat
import com.example.floatplayer.databinding.FloatPlayerViewBinding

class FloatPlayer private constructor() {

    //播放器是否活动
    private var isPlayerActive = false

    //悬浮窗是否正在显示
    private var isShowing = false
    private lateinit var bindingFloatPlayer: FloatPlayerViewBinding
    private val mCsApply = ConstraintSet()
    private val mCsReset = ConstraintSet()
    private var mContext: Context? = null

    //播放状态（默认不播放）
    private var isPlaying = false

    //控件展开状态(默认展开)
    private var isExpansion = true
    private lateinit var animCoverRotation: ObjectAnimator
    private var mediaPlayer: MediaPlayer? = null

    //音乐列表
    private val mMusicList = arrayListOf(R.raw.shanghai, R.raw.withoutyou)
    private var mMusicPosition = 0
    var mPlayControlReceiver: PlayerActionBroadCastReceiver = PlayerActionBroadCastReceiver()
    private lateinit var mNotificationManager: NotificationManager

    companion object {

        const val notificationMediaId = 10010
        const val notificationChannelMedia = "MediaNotification"

        @Volatile
        private var instance: FloatPlayer? = null

        fun getInstance() = instance ?: synchronized(this) {
            instance ?: FloatPlayer().also { instance = it }
        }
    }

    init {

        initNotificationManager()

        initView()
    }

    private fun initNotificationManager() {

        mNotificationManager = FloatApp.appContext
            .getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            mNotificationManager.createNotificationChannel(
                NotificationChannel(
                    notificationChannelMedia,
                    "播放器", NotificationManager.IMPORTANCE_DEFAULT
                )
            )
        }
    }

    //显示播放控件
    fun show(context: Context) {
        if (!isPlayerActive) return
        mContext = context
        initMediaPlayer()
        bindingFloatPlayer.root.visibility = View.VISIBLE
        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
        windowManager.addView(bindingFloatPlayer.root, createLayoutParam(context))
        isShowing = true
    }

    fun dismiss() {
        if (!isShowing || mContext == null) return
        bindingFloatPlayer.root.visibility = View.INVISIBLE
        val windowManger = mContext!!.getSystemService(Context.WINDOW_SERVICE) as WindowManager
        windowManger.removeView(bindingFloatPlayer.root)
        isShowing = false
        mContext = null
    }

    //开启展示播放控件
    fun open(context: Context) {
        if (!isPlayerActive) {
            isPlayerActive = true
            show(context)
        }
    }

    //是否正在播放
    fun playing(): Boolean {
        return mediaPlayer?.isPlaying == true
    }

    //播放/暂停切换
    fun playSwitch() {
        if (mediaPlayer == null) return
        bindingFloatPlayer.ivPlayerControl.performClick()
    }

    //切换下一首
    fun playNext() {
        if (hasNext()) {
            bindingFloatPlayer.ivPlayerNext.performClick()
        } else {
            showToast("没有更多了")
        }
    }

    //关闭播放控件
    fun close() {
        if (!isPlayerActive || mContext == null) return
        destroyMediaPlayer()
        dismiss()
        isPlayerActive = false
    }

    //创建LayoutParam
    private fun createLayoutParam(context: Context): WindowManager.LayoutParams {

        val layoutParam = WindowManager.LayoutParams()
        layoutParam.width = WindowManager.LayoutParams.WRAP_CONTENT
        layoutParam.height = WindowManager.LayoutParams.WRAP_CONTENT
        //弹窗层级
        layoutParam.type = WindowManager.LayoutParams.TYPE_APPLICATION
        layoutParam.gravity = Gravity.START or Gravity.BOTTOM
        //背景透明
        layoutParam.format = PixelFormat.TRANSPARENT
        layoutParam.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
        layoutParam.x =
            TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP, 24f,
                context.resources.displayMetrics
            ).toInt()
        layoutParam.y =
            TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP, 80f,
                context.resources.displayMetrics
            ).toInt()
        return layoutParam
    }

    //初始化控件
    private fun initView() {

        bindingFloatPlayer =
            FloatPlayerViewBinding.inflate(LayoutInflater.from(FloatApp.appContext))
        mCsApply.clone(bindingFloatPlayer.root)
        mCsReset.clone(bindingFloatPlayer.root)

        bindingFloatPlayer.sivPlayerCover.setOnClickListener {
            playExpansionStatusSwitch(!isExpansion)
            bindingFloatPlayer.bgViewPlayer.doAnimation()
        }

        bindingFloatPlayer.ivPlayerControl.setOnClickListener {
            playControlStatusSwitch(!isPlaying)
            updateNotification()
        }

        bindingFloatPlayer.ivPlayerNext.setOnClickListener {
            mediaPlayNext()
        }

        bindingFloatPlayer.ivPlayerClose.setOnClickListener {
            playControlStatusSwitch(false)
            cancelNotificationMedia()
            close()
        }

        initRotationAnimator(bindingFloatPlayer.sivPlayerCover)
    }

    //初始化音频播放器
    private fun initMediaPlayer() {

        if (mediaPlayer != null) return
        mediaPlayer = MediaPlayer.create(FloatApp.appContext, mMusicList[0])
        mediaPlayer!!.setOnCompletionListener {
            mediaPlayNext()
        }
        mediaPlayer!!.setOnErrorListener { _, _, _ ->
            mediaPlayError()
            true
        }
    }

    //销毁MediaPlayer
    private fun destroyMediaPlayer() {
        mediaPlayer?.stop()
        mediaPlayer?.release()
        mediaPlayer = null
    }

    //是否还有下一首
    private fun hasNext(): Boolean {
        return mMusicList.isNotEmpty() && mMusicPosition < mMusicList.size - 1
    }

    //创建音频播放器
    private fun mediaPlayNext() {

        if (!hasNext()) {
            showToast("没有更多了")
        } else {

            mediaPlayer?.stop()
            mediaPlayer?.release()

            mMusicPosition++
            mediaPlayer = MediaPlayer.create(
                FloatApp.appContext,
                mMusicList[mMusicPosition]
            )
            mediaPlayer!!.start()
            playControlStatusSwitch(true)
            updateNotification()
        }
    }

    private fun showToast(message: String) {
        if (mContext == null) return
        Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show()
    }

    //开始播放音频
    private fun mediaPlayStart() {
        if (mediaPlayer?.isPlaying == true) return
        mediaPlayer?.start()
    }

    //暂停播放音频
    private fun mediaPlayPause() {
        if (mediaPlayer?.isPlaying == true) {
            mediaPlayer?.pause()
        }
    }

    //播放出错
    private fun mediaPlayError() {
        showToast("播放出错")
        mediaPlayer?.reset()
    }


    //播放按钮状态控制
    private fun playControlStatusSwitch(startPlay: Boolean) {

        if (startPlay) {
            startCoverAnim()
            mediaPlayStart()
        } else {
            stopCoverAnim()
            mediaPlayPause()
        }
        bindingFloatPlayer.ivPlayerControl.setImageResource(
            if (startPlay) R.drawable.ic_baseline_pause_24
            else R.drawable.ic_baseline_play_arrow_24
        )
        isPlaying = startPlay
    }

    //初始化旋转动画
    private fun initRotationAnimator(target: View) {
        //顺时针
        animCoverRotation = ObjectAnimator.ofFloat(target, "rotation", 0f, 360f)
        //3s一圈
        animCoverRotation.duration = 6000
        animCoverRotation.repeatMode = ValueAnimator.RESTART
        animCoverRotation.repeatCount = ValueAnimator.INFINITE
        animCoverRotation.interpolator = LinearInterpolator()
    }

    //开始播放
    private fun startCoverAnim() {

        if (animCoverRotation.isPaused) {
            animCoverRotation.resume()
        } else {
            animCoverRotation.start()
        }
    }

    //取消播放
    private fun stopCoverAnim() {
        animCoverRotation.pause()
    }

    /**
     * 封面点击切换状态
     * @param expansion 展开
     * */
    private fun playExpansionStatusSwitch(expansion: Boolean) {
        if (expansion == isExpansion) return
        if (expansion) playViewExpansion() else playViewShrink()
        isExpansion = expansion
    }

    //展开播放控件
    private fun playViewExpansion() {
        TransitionManager.beginDelayedTransition(bindingFloatPlayer.root)
        mCsReset.applyTo(bindingFloatPlayer.root)
    }

    //收缩播放控件
    private fun playViewShrink() {
        TransitionManager.beginDelayedTransition(bindingFloatPlayer.root)
        mCsApply.setVisibility(R.id.ivPlayerClose, View.GONE)
        mCsApply.setVisibility(R.id.ivPlayerNext, View.GONE)
        mCsApply.setVisibility(R.id.ivPlayerControl, View.GONE)
        mCsApply.applyTo(bindingFloatPlayer.root)
    }

    //更新播放器通知UI
    private fun updateNotification() {

        val notificationCompatAction = NotificationCompat.Action.Builder(
            if (playing()) R.drawable.ic_baseline_pause_24
            else R.drawable.ic_baseline_play_arrow_24,
            "switch",
            PendingIntent.getBroadcast(
                FloatApp.appContext,
                111,
                Intent(PlayerActionBroadCastReceiver.actionSwitch),
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
                    PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
                else PendingIntent.FLAG_UPDATE_CURRENT
            )
        ).build()

        val nextPendingIntent = PendingIntent.getBroadcast(
            FloatApp.appContext, 222,
            Intent(PlayerActionBroadCastReceiver.actionNext),
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
                PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
            else PendingIntent.FLAG_UPDATE_CURRENT
        )

        val notification =
            NotificationCompat.Builder(FloatApp.appContext, notificationChannelMedia)
                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
                .setSmallIcon(R.mipmap.ic_launcher)
                .addAction(notificationCompatAction)
                .addAction(R.drawable.ic_baseline_skip_next_24, "next", nextPendingIntent)
                .setStyle(androidx.media.app.NotificationCompat.MediaStyle())
                .setContentTitle("这是标题")
                .setContentText("这是内容这是内容")
                .build()
        mNotificationManager.notify(notificationMediaId, notification)
    }

    //取消掉通知栏播放器
    private fun cancelNotificationMedia() {
        mNotificationManager.cancel(notificationMediaId)
    }
}

2、BaseActivity

import androidx.appcompat.app.AppCompatActivity

open class BaseActivity: AppCompatActivity() {

    override fun onResume() {
        super.onResume()
        FloatPlayer.getInstance().show(this)
    }

    override fun onPause() {
        super.onPause()
        FloatPlayer.getInstance().dismiss()
    }
}

三、通知栏播放器实现

原理：创建 NotificationCompat.MediaStyle() 样式的通知，需要引入依赖：

implementation 'androidx.media:media:1.3.0'

并且给通知添加Action，用来和页面的播放起实现操作的联动。

如何创建通知，如下：

//创建通知
    private fun createNotification() {

        val notificationCompatAction = NotificationCompat.Action.Builder(
            if (FloatPlayer.getInstance().playing()) R.drawable.ic_baseline_pause_24
            else R.drawable.ic_baseline_play_arrow_24,
            "switch",
            PendingIntent.getBroadcast(
                this,
                111,
                Intent(PlayerActionBroadCastReceiver.actionSwitch),
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
                    PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
                else PendingIntent.FLAG_UPDATE_CURRENT
            )
        ).build()

        val nextPendingIntent = PendingIntent.getBroadcast(
            this, 222,
            Intent(PlayerActionBroadCastReceiver.actionNext),
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
                PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
            else PendingIntent.FLAG_UPDATE_CURRENT
        )

        val notification = NotificationCompat.Builder(
            this,
            FloatPlayer.notificationChannelMedia
        )
            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
            .setSmallIcon(R.mipmap.ic_launcher)
            .addAction(notificationCompatAction)
            .addAction(R.drawable.ic_baseline_skip_next_24, "next", nextPendingIntent)
            .setStyle(androidx.media.app.NotificationCompat.MediaStyle())
            .setContentTitle("这是标题")
            .setContentText("这是内容这是内容")
            .setLargeIcon(BitmapFactory.decodeResource(resources, R.mipmap.ic_player_cover))
            .build()

        val notificationManager =
            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            notificationManager.createNotificationChannel(
                NotificationChannel(
                    FloatPlayer.notificationChannelMedia,
                    "播放器", NotificationManager.IMPORTANCE_DEFAULT
                )
            )
        }
        notificationManager.notify(FloatPlayer.notificationMediaId, notification)
    }

四、通知栏播放器和浮窗播放器联动实现

实现原理：

1、播放器的操作通过更新同一个id的通知，去更新通知播放器的UI显示。

2、定义广播接收器：PlayerActionBroadCastReceiver，接收到对应操作的广播之后FloatPlayer相应操作，通知栏播放器的操作，在上边（三）中定义的Action当中的PendingIntent发送对应操作的广播。

广播接收器 PlayerActionBroadCastReceiver 如下：

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent

/**
 * 通知栏播放控制按钮通知播放器操作
 * */
class PlayerActionBroadCastReceiver : BroadcastReceiver() {

    companion object {

        const val actionSwitch = "floatPlayer.switch"
        const val actionNext = "floatPlayer.next"
    }

    override fun onReceive(context: Context, intent: Intent) {
        when (intent.action) {
            actionSwitch -> {
                FloatPlayer.getInstance().playSwitch()
            }
            actionNext -> {
                FloatPlayer.getInstance().playNext()
            }
        }
    }
}

 页面注册广播

//注册控制接受receiver
    private fun registerPlayControlReceiver() {

        val intentFilter = IntentFilter()
        intentFilter.addAction(PlayerActionBroadCastReceiver.actionSwitch)
        intentFilter.addAction(PlayerActionBroadCastReceiver.actionNext)
        registerReceiver(FloatPlayer.getInstance().mPlayControlReceiver, intentFilter)
    }

页面取消注册广播

//取消注册receiver
    private fun cancelPlayControlReceiver() {
        unregisterReceiver(FloatPlayer.getInstance().mPlayControlReceiver)
    }

最后

播放器动画背景View，因为 ConstraintSet 通过显示，隐藏控件展现的动画显示在真机显示有瑕疵，所以自定义背景动画View，下边是PlayerBgView代码

import android.animation.TypeEvaluator
import android.animation.ValueAnimator
import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.util.AttributeSet
import android.view.View
import androidx.interpolator.view.animation.FastOutSlowInInterpolator

/**
 * 播放器自定义的背景View：因为Constraint动画有显示瑕疵
 * */
class PlayerBgView(context: Context?, attrs: AttributeSet?) : View(context, attrs) {

    //控件宽度
    private var mWidth = 0f

    //背景圆形半径（控件高度一半）
    private var mRadius = 0f

    //动画执行中的终点坐标
    private var mPositionEndX = 0f
    private var mPaint: Paint? = null

    //是否展开状态
    private var bExpend = true

    //背景颜色
    private val mColorBG = Color.parseColor("#D7D7D7")

    //动画时长
    private val mTimeAnim = 400L

    //展开后终点坐标x，固定
    private var mEndX = 0f

    init {
        initPaint()
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        mWidth = w.toFloat()
        mRadius = h / 2f
        mPositionEndX = mWidth - mRadius
        mEndX = mPositionEndX
        measurePaintStrokeWidth(h.toFloat())
    }

    private fun initPaint() {
        mPaint = Paint()
        mPaint!!.isAntiAlias = true
        mPaint!!.style = Paint.Style.FILL
        mPaint!!.color = mColorBG
        mPaint!!.strokeCap = Paint.Cap.ROUND
    }

    //设置画笔宽度为视图高度
    private fun measurePaintStrokeWidth(height: Float) {
        mPaint?.strokeWidth = height
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)
        drawBg(canvas)
    }

    private fun drawBg(canvas: Canvas) {
        canvas.drawCircle(mRadius, mRadius, mRadius, mPaint!!)
        if (mPositionEndX == 0f) return
        canvas.drawLine(mRadius, mRadius, mPositionEndX, mRadius, mPaint!!)
    }

    fun doAnimation() {
        if (bExpend) doShrinkAnimation() else doExpandAnimation()
        bExpend = !bExpend
    }

    //展开动画
    private fun doExpandAnimation() {
        val animator = ValueAnimator.ofObject(PositiveEvaluator(), mRadius, mEndX)
        animator.addUpdateListener { valueAnimator: ValueAnimator ->
            mPositionEndX = valueAnimator.animatedValue as Float
            invalidate()
        }
        animator.duration = mTimeAnim
        animator.interpolator = FastOutSlowInInterpolator()
        animator.start()
    }

    private inner class PositiveEvaluator : TypeEvaluator<Float> {
        override fun evaluate(v: Float, startValue: Float, endValue: Float): Float {
            return startValue + v * (endValue - startValue)
        }
    }

    //收缩动画
    private fun doShrinkAnimation() {
        val animator = ValueAnimator.ofObject(NegativeEvaluator(), mRadius, mEndX)
        animator.addUpdateListener { valueAnimator: ValueAnimator ->
            mPositionEndX = valueAnimator.animatedValue as Float
            invalidate()
        }
        animator.duration = mTimeAnim
        animator.interpolator = FastOutSlowInInterpolator()
        animator.start()
    }

    private inner class NegativeEvaluator : TypeEvaluator<Float> {
        override fun evaluate(v: Float, startValue: Float, endValue: Float): Float {
            return endValue - v * (endValue - startValue)
        }
    }
}

赵彼得
关注
专栏目录
Android简答题知识点总结
半夏微凉科技
04-29 317
Android简答题知识点总结 1.Android系统架构，四大组件，主要五种常用布局、Activity的生命周期以及生命周期的四种状态； 2.Activity与Service的区别、Service的生命周期以及启动Service的方式； 3.显示Intent和隐式Intent区别以及相关Intent的理解和传递参数有哪些; 4.Android中如何进行单元测试等等相关知识点
Android音乐播放器（含notification通知栏操作，自动获取本地音乐操作）
05-02
Android基本操作之音乐播放器的部署（含通知栏操作、notification、service、获取本地音乐列表）
Android 音乐播放器悬浮窗
XuWei1213的博客
11-03 2231
之前的项目中写了个音乐播放器，这里记录下悬浮窗相关的东西。 废话不多说，先上个效果图 1、自定义悬浮框布局 根据效果图可以看到悬浮窗 布局由一张封面图，一个圆形进度条以及4个按钮组成。 布局内容就不写了，很简单。 悬浮窗控件 ：FloatLayout继承自FrameLayout，引入布局文件。 初始化 windowManager mWindowManager = (Window...
Android悬浮窗源码：可拖动悬浮歌词
最新发布
weixin_36001279的博客
08-26 827
本文还有配套的精品资源，点击获取 简介：Android悬浮窗（悬浮Activity）是一种常见的需求，尤其用于显示悬浮歌词或控制面板。本源码项目提供了可拖动悬浮窗的实现方案，涉及WindowManager服务、自定义布局、触摸事件处理和权限管理等知识点。通过 FloatingActivity 和 DraggableLayout 类，开发者可以轻松...
Android音乐播放器项目（含Widget小挂件、Notification通知栏）
04-03
Android音乐播放器项目（含Widget小挂件、Notification通知栏）代码详解博客：https://blog.csdn.net/jal517486222/article/details/88994863
带通知栏的安卓音乐播放器
08-11
实现了类似天天动听的通知栏管理音乐功能，有上一首、下一首、播放、暂停、关闭应用，实现中用到了IntentService、BroadcastReceiver、Application、Notification等，对安卓进阶很有帮助，当然项目只是个demo，还有很多地方没处理好，如果你想做个完整的音乐播放器应用，可以拿他作基础
Android音乐后台播放（含通知栏操作）
06-06
支持音乐后台播放，通知栏播放暂停等。博客地址：https://blog.csdn.net/qq_37077360/article/details/80570684
Android 原生锁屏页面音乐控制
alpgao的博客
04-03 3367
Android5.0 提出了全新的MediaSession概念用于播放器与控制器之间进行交互，它取代之前的RemoteControlClient，并提供了更为灵活的客户端受控端模型。 但是MediaSession框架只能在安卓5系统上使用，如何兼容低版本呢? Google在support-v4(21以上版本)中也提供了MediaSessionCompact兼容包。通过它可以告诉Android系统与...
iOS开发--AVPlayer实现音乐播放器
热门推荐
李聪的博客
12-28 1万+
这是一篇教学Blog. 重点不完全在播放器上, 目的是通过这个过程掌握以下知识点: 单例block传值多线程代理传值通知观察者网络请求数据解析多控件布局开发模式和框架设计 今天敲一个音乐播放器, 音乐源我就不共享了, 涉及到版权保护, 别问我的源是哪儿来的. 不告诉你们
【原创】从头开始，使用安卓系统WebView做一个功能强大的Epub阅读器（五）
mzy24511cs的博客
06-04 3245
上一章传送：https://blog.csdn.net/mzy24511cs/article/details/80563448。这一章专门讲一下阅读器的各种工具栏。1、背景音乐。这个工具简单,用MediaPlayer实现播放、暂停就可以了。再加一个旋转动画。唯一需要注意的是需要和其他的音视频播放做互斥。2、底部工具栏。这个功能稍微多一点。亮度调节，这个太简单略过。设置主题背景和夜间模式，将各种背景...
android音频播放控件
02-20
基于android平台的音频播放自定义控件，使用简单易操作
Android代码-音乐播放器消息通知栏切歌栏效果NotificationBroadcastReceiver.zip
08-02
音乐播放器消息通知栏切歌栏效果NotificationBroadcastReceiver.zip
Android实现简单音乐播放控件
08-27
主要为大家详细介绍了Android实现简单音乐播放控件，提供一个类似网易播放控件的默认界面，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
android 悬浮窗音乐控制面板 源码及apk
01-18
android悬浮窗音乐控制面板例子，给你一点阳光，希望你能灿烂辉煌，给你一块砖，希望你能炼成玉，来吧，相信自己。
android 通知栏播放器,Android 播放器通知栏样式适配
weixin_34138397的博客
05-26 500
一、获取通知栏主题颜色由于调用系统的属性，获取颜色在某些手机上是不兼容的。因此采用先创建一个系统通知栏对象，然后迭代其中的 View 获取对应的颜色。代码如下：import android.app.Notification;import android.content.Context;import android.support.v4.app.NotificationCompat;import a...
Android 通知栏，锁屏播放音乐，类似音乐播放器
xing_xiangrong的博客
04-08 6168
项目中需要用到播放音频的功能，想做一个类似酷狗、酷我这样的音频播放功能，在通知栏和锁屏时都可以操控音乐，开发中发现oppo reno手机在锁屏时不显示通知栏，研究了整整一天终于解决，特作记录，给遇到同样问题的童鞋做个参考。 整体功能实现思路如下： 1.播放音乐时启动前台服务，在服务中创建播放器和通知并且创建广播,音频的播控通过广播来操控，实现跨模块； 2.在切换音频源、播放、暂停的时候通过重新创建通知来实现通知的界面更新； 3.在关闭音频功能时关掉通知，释放播放器。 细节，以下只做简单说明，.
Android 音乐APP（五）音乐通知栏、后台播放音乐
2401_84011114的博客
04-04 965
**通知点击广播接收器 跳转到栈顶的Activity ,而不是new 一个新的Activity*/@OverrideBLog.d(TAG,“通知栏点击”);然后运行，运行之后点击通知栏，再看日志打印，如下所示：③ 通知栏业务处理在上面已经实现了通知栏的点击监听了，下面就要开始进行业务逻辑的处理了。先解决通知栏的点击业务处理，再解决通知栏按钮的点击处理，打开AndroidManager，注意这是之前我自己写的，不是系统的。在里面增加/***//**得到当前Activity。
android 以音频播放器为例实现通知栏显示通知，并实现切歌、暂停、播放，并实现加载网络图片，并实现关闭第三方APP音频
。度的博客
03-15 4281
首先先给大家看下效果 接下来我们看下具体如何实施 1、首先我们创建一个音频的单例对象，这样能保证每次在播放的的音频是唯一的（类名如：MediaPlayerUtil.java） package xxx; import android.media.AudioManager; import android.media.MediaPlayer; import android.util.Log...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值