android音乐播放器app源码

Android 高仿的音乐播放器APP源码，仿的哪个播放器忘记了，界面年直去很漂亮，功能方面可在线播放一些音乐，里面有抽屉行为控件，操作时自动将触摸位置转换为屏幕坐标。

在音乐播放的幻灯片显示方面，在Z轴上正向移动camera的视角，实际效果为放大图片。如果在Y轴上移动，则图片上下移动；X轴上对应图片左右移动。在Y轴上旋转，对应图片竖向向里翻转。如果在X轴上旋转，则对应图片横向向里翻转。

文件：590m/f/25127180-500761347-4105c0（访问密码：551685）

以下内容无关：

-------------------------------------------分割线---------------------------------------------

数据在写入的情况下 Cow 才有存在的意义。当借用的数据被修改时，在不破坏原有数据的情况下，克隆一个副本并且在副本上进行修改；这是一种惰性的策略，在真正需要修改时才产生克隆的操作，而并不预先克隆。

关键函数

to_mut(), 获取所有权数据的可变引用，无所有权时从借用数据中克隆
into_owned(), 提取所有权数据。
使用
官方示例
官方描述了三种情况

借用数据，但是未调用 to_mut()，故不存在 clone 操作
借用数据，调用 to_mut(), 发生 clone 操作
所有权数据，调用 to_mut(), 不存在 clone 操作，因为具有该数据的所有权
use std::borrow::Cow;

fn abs_all(input: &mut Cow<[i32]>) {
for i in 0…input.len() {
let v = input[i];
if v < 0 {
// Clones into a vector if not already owned.
input.to_mut()[i] = -v;
}
}
}

// No clone occurs because input doesn’t need to be mutated.
let slice = [0, 1, 2];
let mut input = Cow::from(&slice[…]);
abs_all(&mut input);

// Clone occurs because input needs to be mutated.
let slice = [-1, 0, 1];
let mut input = Cow::from(&slice[…]);
abs_all(&mut input);

// No clone occurs because input is already owned.
let mut input = Cow::from(vec![-1, 0, 1]);
abs_all(&mut input);
观察所有权的变化
写了个地址打印函数，以此来观察所有权的变化。

fn print_addr(s: &str) {
println!("{}", s);
let mut p = s.as_ptr();
for ch in s.chars() {
println!("\t{:p}\t{}", p, ch);
p = p.wrapping_add(ch.len_utf8());
}
}
借用修改取出所有权
对借用的数据进行修改操作（有可能不会修改，见下文），操作完成后取出所有权 是最常见的用法

以下是一般的借用数据从修改至获取所有权数据的过程，通过新产生的地址可以看出来存在 clone 操作

{
let s = String::from(“AB”);
print_addr(&s);
let mut cow = Cow::Borrowed(&s);
cow.to_mut().insert_str(1, “cd”);
let sr = cow.into_owned();
print_addr(&sr);
}

// AB
// 0x7fb694c05af0 A
// 0x7fb694c05af1 B
// AcdB
// 0x7fb694c05b00 A
// 0x7fb694c05b01 c
// 0x7fb694c05b02 d
// 0x7fb694c05b03 B
上面的代码注释 to_mut() 行后，相当于不会有获取所有权的需求，这个时候是不应该做修改的，into_owned() 应该弃用转而使用 as_str() 这类没有所有权变化的操作.

{
let s = String::from(“AB”);
print_addr(&s);
let mut cow = Cow::Borrowed(&s);
// cow.to_mut().insert_str(1, “cd”); // 这一行是运行时决定的
let sr = cow.as_str(); // 看后续的使用，若是后续也只是读操作可以使用 as_str()
print_addr(&sr);
}
在所有权数据上进行修改
在对已具有所有权数据上操作时，字符串的地址未发生改变，未发生 clone 操作

insert_str 为两个 memcpy 操作，故首地址不会发生变化

{
let s1 = String::from(“cd”);
print_addr(&s1);
let mut cow1: Cow<’_, String> = Cow::Owned(s1);
cow1.to_mut().insert_str(0, “AB”);
let sr1 = cow1.into_owned();
print_addr(&sr1);
}

// cd
// 0x7fb694c05b10 c
// 0x7fb694c05b11 d
// ABcd
// 0x7fb694c05b10 A
// 0x7fb694c05b11 B
// 0x7fb694c05b12 c
// 0x7fb694c05b13 d
实现
Cow 是一个枚举值，包含了一个借用和所有。可以使用 Cow 的类型需要实现了 ToOwned trait。

ToOwned trait 同样包含了所有权或借用的操作。

需要实现 Borrow 借用 trait
可以从借用的数据中创建所有权数据或者克隆
相关 trait
pub trait ToOwned {
type Owned: Borrow; // 需要实现 Borrow triat

pub fn to_owned(&self) -> Self::Owned;  // 所有权创建
pub fn clone_into(&self, target: &mut Self::Owned) { ... }

}

pub trait Borrow where
Borrowed: ?Sized, {
pub fn borrow(&self) -> &Borrowed;
}
Borrow 借用 triat 泛型实现

impl<T: ?Sized> Borrow for T {
fn borrow(&self) -> &T {
self
}
}
to_owned 创建所有权的泛型实现如下，取决该类型是否实现 Clone tait

impl ToOwned for T
where
T: Clone,
{
type Owned = T;
fn to_owned(&self) -> T {
self.clone()
}
}
方法
to_mut()
获取所有权的可变引用

已获取所有权直接返回引用
借用数据的情况先调用 to_owned() 获取克隆副本的所有权，并且做一个检查
ref 关键字指示模式匹配为借用而不是移动。
::Owned 表示 B 类型实现了 ToOwned trait，现使用该 trait 中的 Owned 类型，本质就是B类型本身，但是限制了实现 trait

pub fn to_mut(&mut self) -> &mut ::Owned {
match *self {
Borrowed(borrowed) => {
*self = Owned(borrowed.to_owned());
match *self {
Borrowed(…) => unreachable!(),
Owned(ref mut owned) => owned,
}
}
Owned(ref mut owned) => owned,
}
}
into_owned()
取出 Cow 中的所有权数据，当为获取所有权时，进行 clone 操作

pub fn into_owned(self) -> ::Owned {
match self {
Borrowed(borrowed) => borrowed.to_owned(),
Owned(owned) => owned,
}
}
deref
由于 Cow 也实现了 Deref trait, 支持解引用强制多态，实现如下。

impl<B: ?Sized + ToOwned> Deref for Cow<’_, B> {
type Target = B;

fn deref(&self) -> &B {
    match *self {
        Borrowed(borrowed) => borrowed,
        Owned(ref owned) => owned.borrow(),
    }
}

}
上面代码的 print_addr 的参数既可以是 &str, 也可以为 &Cow.

参考