Android on 个人记录 | 随心所意，记录点滴

MacBook重新打包jar

Mon, 30 Nov 2020 11:50:12 +1000

	jar -xvf X.jar

重新打jar包

	jar -cvf X.jar ./

替换META-INF/MANIFEST.MF文件，到打包后的X.jar包中。用上一个命令打出的包，MANIFEST.MF文件中是没有入口类的信息的，需要更新正确的清单文件(非可执行文件可以省略这一步)

	jar umf META-INF/MANIFEST.MF X.jar

ProtoBuffer中文转码

Sat, 31 Oct 2020 11:50:12 +1000

许多时候需要查看日志中的中文字符，但是protobuf中某字段为中文的话，打印出来为8进制字符。若要打印为中文，可用以下代码：

import com.google.protobuf.TextFormat;

public class NormalProtobufDeserializer implements IProtobufDeserializer{
    @Override
    public String deserial(byte[] data) {
        String ret = "";
        try{
            NormalDeserializer.NormalMessage normalMessage = NormalDeserializer.NormalMessage.parseFrom(data);
            //ret = normalMessage.toString(); 此时为8进制，如"\241\242\243\244\245"
            ret = TextFormat.printToUnicodeString(normalMessage);
        }catch (Throwable throwable){
 
        }
        return ret;
    }

若已经打印出八进制”\241\242\243\244\245”，可以用以下代码转成中文：

public static void printProtoBuf(String dataStr) {
        if (!dataStr.contains("\\")) {
            System.out.println("未识别：" + dataStr);
        } else {
            //不属于八进制内容的字符
            StringBuilder oldBuffer = new StringBuilder();
            //属于八进制的内容，转成十六进制后缓存在这里
            StringBuilder hexBuffer = new StringBuilder();
            for (int i = 0; i < dataStr.length(); i++) {
                char c = dataStr.charAt(i);
                if (c != '\\') {
                    oldBuffer.append(c);
                }
                //反斜杠往后3个为一组，组成了一个八进制数。例如\20710,其实是207组成了一个八进制数
                else {
                    char c1 = dataStr.charAt(i + 1);
                    char c2 = dataStr.charAt(i + 2);
                    char c3 = dataStr.charAt(i + 3);
                    if(c1 == 'n' && c2 == '\\'){
                        i += 1;
                        oldBuffer.append("\n");
                    }else if(c1 == 't' && c2 == '\\'){
                        i += 1;
                        oldBuffer.append("\t");
                    }else if(c1 == 'f' && c2 == '\\'){
                        i += 1;
                        oldBuffer.append("\f");
                    }else {
                        i += 3;
                        //将八进制转换为十进制，再转换为十六进制
                        String hex = Integer.toHexString((Integer.valueOf("" + c1 + c2 + c3, 8)));
                        //先缓存住，直到凑够三个字节
                        hexBuffer.append(hex);
                        String hexString = hexBuffer.toString();
                        //utf8编码中，三个字节为一个汉字
                        if (hexString.length() == 6) {
                            //凑够三个字节了，转成汉字后放入oldBuffer中
                            oldBuffer.append(hexStr2Str(hexString));
                            //凑够一个汉字了，清空缓存
                            hexBuffer = new StringBuilder();
                        }
                    }
                }
            }
            System.out.println("解码后：" + oldBuffer.toString());
        }
    }

Parameter ‘directory‘ is not a directory

Wed, 21 Oct 2020 12:52:14 +1000

将AndroidStudio项目复制了一份，运行时报错：

Execution failed for task ':app:dataBindingGenBaseClassesDebug'.      
Parameter 'directory' is not a directory

按照stackoverflow的方法， invalidata Cache/Restart 或者删除 .gradle 文件夹，都不好使最终解决办法是在命令行执行编译一遍：

./gradlew assembleDebug --rerun-tasks

完成后重新在AndroidStudio中运行就可以了。

混淆映射mapping压缩

Tue, 25 Aug 2020 10:51:14 +0800

我们项目里终会有一些不需要混淆的符号，比如一些第三方包，一些jni调用，一些自动解析的model,这些不混淆的符号也会在mapping里生在相同不变的符号映射，其实这些符号映射是不需要也能正常解码错误代码的，去掉这些未混淆的符号就能给mapping文件瘦身，当文件超级大时，可以把android源生sdk取消混淆，第三方开源库也能取消，只把自己开发的核心功能保留混淆，这样去掉未混淆之符号时，mapping会达到极为精简的地步。

使用shell可以很轻松的去掉未混淆的符号：

find ./ -name mapping.txt | xargs cat | awk '{if($2!=$4) print $0}'>./newmapping.txt

Android颜色计算

Tue, 13 Nov 2018 12:53:25 +0800

/**
 * 合并颜色，支持argb8888 
 * @param fg 前景色
 * @param bg 背景色
 */
 public static int blendColor(int fg, int bg) {
 int scr = Color.red(fg);
 int scg = Color.green(fg);
 int scb = Color.blue(fg);
 int sa = fg >>> 24;
 int dcr = Color.red(bg);
 int dcg = Color.green(bg);
 int dcb = Color.blue(bg);
 int color_r = dcr * (0xff - sa) / 0xff + scr * sa / 0xff;
 int color_g = dcg * (0xff - sa) / 0xff + scg * sa / 0xff;
 int color_b = dcb * (0xff - sa) / 0xff + scb * sa / 0xff;
 return ((color_r << 16) + (color_g << 8) + color_b) | (0xff000000);
}

    /** Calculates the constrast between two colors, using the algorithm provided by the WCAG v2. */
    public static float computeContrastBetweenColors(int bg, int fg) {
        float bgR = Color.red(bg) / 255f;
        float bgG = Color.green(bg) / 255f;
        float bgB = Color.blue(bg) / 255f;
        bgR = (bgR < 0.03928f) ? bgR / 12.92f : (float) Math.pow((bgR + 0.055f) / 1.055f, 2.4f);
        bgG = (bgG < 0.03928f) ? bgG / 12.92f : (float) Math.pow((bgG + 0.055f) / 1.055f, 2.4f);
        bgB = (bgB < 0.03928f) ? bgB / 12.92f : (float) Math.pow((bgB + 0.055f) / 1.055f, 2.4f);
        float bgL = 0.2126f * bgR + 0.7152f * bgG + 0.0722f * bgB;
        
        float fgR = Color.red(fg) / 255f;
        float fgG = Color.green(fg) / 255f;
        float fgB = Color.blue(fg) / 255f;
        fgR = (fgR < 0.03928f) ? fgR / 12.92f : (float) Math.pow((fgR + 0.055f) / 1.055f, 2.4f);
        fgG = (fgG < 0.03928f) ? fgG / 12.92f : (float) Math.pow((fgG + 0.055f) / 1.055f, 2.4f);
        fgB = (fgB < 0.03928f) ? fgB / 12.92f : (float) Math.pow((fgB + 0.055f) / 1.055f, 2.4f);
        float fgL = 0.2126f * fgR + 0.7152f * fgG + 0.0722f * fgB;
 
        return Math.abs((fgL + 0.05f) / (bgL + 0.05f));
    }
	//判断是否是深色
	isDark = computeContrastBetweenColors(color,Color.WHITE) > 3f;

Android硬件加速后单个Bitmap可以显示的最大尺寸

Tue, 14 Nov 2017 18:56:12 +0800

private void getGLESTextureLimitBelowLollipop() {  
    int[] maxSize = new int[1];  
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, maxSize, 0);  
    Toast.makeText(this," " + maxSize[0],Toast.LENGTH_LONG).show();  
}

private void getGLESTextureLimitEqualAboveLollipop() {  
    EGL10 egl = (EGL10) EGLContext.getEGL();  
    EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);  
    int[] vers = new int[2];  
    egl.eglInitialize(dpy, vers);  
    int[] configAttr = {  
            EGL10.EGL_COLOR_BUFFER_TYPE, EGL10.EGL_RGB_BUFFER,  
            EGL10.EGL_LEVEL, 0,  
            EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,  
            EGL10.EGL_NONE  
    };  
    EGLConfig[] configs = new EGLConfig[1];  
    int[] numConfig = new int[1];  
    egl.eglChooseConfig(dpy, configAttr, configs, 1, numConfig);  
    if (numConfig[0] == 0) {// TROUBLE! No config found.  
    }  
    EGLConfig config = configs[0];  
    int[] surfAttr = {  
            EGL10.EGL_WIDTH, 64,  
            EGL10.EGL_HEIGHT, 64,  
            EGL10.EGL_NONE  
    };  
    EGLSurface surf = egl.eglCreatePbufferSurface(dpy, config, surfAttr);  
    final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;  // missing in EGL10  
    int[] ctxAttrib = {  
            EGL_CONTEXT_CLIENT_VERSION, 1,  
            EGL10.EGL_NONE  
    };  
    EGLContext ctx = egl.eglCreateContext(dpy, config, EGL10.EGL_NO_CONTEXT, ctxAttrib);  
    egl.eglMakeCurrent(dpy, surf, surf, ctx);  
    int[] maxSize = new int[1];  
    GLES10.glGetIntegerv(GLES10.GL_MAX_TEXTURE_SIZE, maxSize, 0);  
    egl.eglMakeCurrent(dpy, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE,  
            EGL10.EGL_NO_CONTEXT);  
    egl.eglDestroySurface(dpy, surf);  
    egl.eglDestroyContext(dpy, ctx);  
    egl.eglTerminate(dpy);  
  
    Toast.makeText(this," " + maxSize[0],Toast.LENGTH_LONG).show();  
}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {  
    getGLESTextureLimitEqualAboveLollipop();  
} else {  
    getGLESTextureLimitBelowLollipop();  
}

Fresco修改decoder，解决超大图显示模糊的问题。

Tue, 31 Oct 2017 16:35:39 +0800

private void setImageUrl() {
    ImageRequest request = ImageRequestBuilder.newBuilderWithSource(Uri.parse(model.getImage()))
            .setImageDecodeOptions(Utils.getFileTypeIsGif(model.getImage()) ? null ://null表示使用原有默认decoder
                    ImageDecodeOptions.newBuilder()
                            .setCustomImageDecoder(new ImageDecoder() {
                                @Override
  public CloseableImage decode(EncodedImage encodedImage, int length, QualityInfo qualityInfo, ImageDecodeOptions options) {
                                    Bitmap bitmap = null;
 if (encodedImage.getHeight() > Utils.dip2px(manager.getContext(), 150)) {
                                        int height = Utils.dip2px(manager.getContext(), 150);
 int width = Utils.getWidth(manager.getContext());
  width = width > encodedImage.getWidth() ? encodedImage.getWidth() : width;
  SkiaImageRegionDecoder inDecoder = new SkiaImageRegionDecoder();
  Rect region = new Rect();
  region.left = (encodedImage.getWidth() - width) / 2;
  region.right = region.left + width;
  region.top = (encodedImage.getHeight() - height) / 2;
  region.bottom = region.top + height;
 try {
                                            inDecoder.init(manager.getContext(), Uri.parse("file://" + FrescoUtils.getImageFileOnDisk(Uri.parse(model.getImage())).getAbsolutePath()));
  bitmap = inDecoder.decodeRegion(region, 1);
  } catch (Exception e) {
                                            LogInfo.LogOut(e);
  }
                                    }
                                    if (bitmap == null) {//TODO 此处最好使用原有默认decoder
                                        bitmap = BitmapFactory.decodeStream(encodedImage.getInputStream());
  }
                                    return new CloseableStaticBitmap(
                                            bitmap,
  SimpleBitmapReleaser.getInstance(),
  ImmutableQualityInfo.FULL_QUALITY,
  0);

  }
                            })
                            .build())
            .build();
  DraweeController controller = Fresco.newDraweeControllerBuilder()
            .setImageRequest(request)
            .setAutoPlayAnimations(Utils.getFileTypeIsGif(model.getImage()))
            .setOldController(image.getController())
            .setControllerListener(new BaseControllerListener())
            .build();
  image.setController(controller);
}

学习正则表达式

Wed, 16 Aug 2017 12:25:29 +0800

本文为转载，原文地址

什么是正则表达式? 🔗

正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子.

一个正则表达式是在一个主体字符串中从左到右匹配字符串时的一种样式. 例如"Regular expression"是一个完整的句子, 但我们常使用缩写的术语"regex"或"regexp". 正则表达式可以用来替换文本中的字符串,验证形式,提取字符串等等.

想象你正在写一个应用, 然后你想设定一个用户命名的规则, 让用户名包含字符,数字,下划线和连字符,以及限制字符的个数,好让名字看起来没那么丑. 我们使用以下正则表达式来验证一个用户名:

以上的正则表达式可以接受 john_doe, jo-hn_doe, john12_as. 但不匹配Jo, 因为它包含了大写的字母而且太短了.

目录 🔗

1. 基本匹配
2. 元字符
3. 简写字符集
4. 前后关联约束(前后预查)
- 4.1 ?=… 前置约束(存在)
- 4.2 ?!… 前置约束-排除
- 4.3 ?<= … 后置约束-存在
- [4.4 ? the, 它表示一个规则: 由字母t开始,接着是h,再接着是e.

“the” => The fat cat sat on the mat.

升级到Android Studio 3.0 Beta 1后编译错误解决

Thu, 10 Aug 2017 10:55:19 +0800

如果现有的 Android Studio 项目使用的是 Android plugin 3.0.0 的 Alpha 版本（如 3.0.0-alpha9），那么迁移到 Android plugin 3.0.0-beta1 并进行项目同步时，可能会收到以下错误：Gradle project refresh failed。

解决方法：

从菜单栏中选择 Build > Clean Project，需要为每个项目执行一次这个操作。然后，可以通过从工具栏中单击同步项目，使用 Gradle 将项目文件同步。

官方解决方案链接

记录AndroidStudio升级2.3后DataBinding与Realm注解冲突问题

Thu, 22 Jun 2017 19:45:12 +0800

现象： 2.3后不支持apt了，所以旧版本Realm编译不通过。

升级Realm后，DataBinding编译失败，报找不到BR错误。

借助kotlin使用kapt “com.android.databinding:compiler:2.3.3"编译后，Realm的相应注解没有被解析，报is not part of the schema for this Realm错误

最终解决：所有用到注解的三方库，都得加上解释器： annotationProcessor “com.android.databinding:compiler:2.3.3” annotationProcessor ‘org.greenrobot:eventbus-annotation-processor:3.0.1’ annotationProcessor “io.realm:realm-annotations-processor:3.3.2”

参考 1.https://stackoverflow.com/questions/38642712/enable-annotation-processors-option-in-android-studio-2-2 2.https://stackoverflow.com/questions/40940253/realm-and-android-databinding 3.https://developer.android.com/topic/libraries/data-binding/index.html

搜索中文汉字的正则表达式

Sun, 18 Jun 2017 16:16:38 +0800

^((?!(*|//)).)+[\u4e00-\u9fa5]

Android手机上传下载文件夹

Fri, 16 Jun 2017 12:13:28 +0800

批量从/sdcard/files目录下载文件到电脑：adb shell ls /sdcard/files/* | tr “\n\r” " " | xargs -n1 adb pull

注意：如果permission denied，则先执行adb root，再执行adb remount,如果你不知道什么是root，那么就不要操作了。

将整个目录下的文件上传到手机：adb push . /sdcard/files

Android打开最近任务列表代码

Thu, 18 May 2017 16:17:18 +0800

Class serviceManagerClass;
try {
    serviceManagerClass = Class.forName("android.os.ServiceManager");
  Method getService = serviceManagerClass.getMethod("getService",
  String.class);
  IBinder retbinder = (IBinder) getService.invoke(
            serviceManagerClass, "statusbar");
  Class statusBarClass = Class.forName(retbinder
            .getInterfaceDescriptor());
  Object statusBarObject = statusBarClass.getClasses()[0].getMethod(
            "asInterface", IBinder.class).invoke(null,
 new Object[]{retbinder});
  Method clearAll = statusBarClass.getMethod("toggleRecentApps");
  clearAll.setAccessible(true);
  clearAll.invoke(statusBarObject);
} catch (Exception e) {
    e.printStackTrace();
}

Activity的启动过程拦截Intent参数

Tue, 18 Apr 2017 18:14:10 +0800

import  android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HookUtil {

    private Class proxyActivity;

 private Context context;

 public HookUtil(Context context) {
        try {
            this.proxyActivity = Class.forName("class");
  } catch (ClassNotFoundException e) {
            e.printStackTrace();
  }
        this.context = context;
  }

    public void hookSystemHandler() {
        try {

            Class activityThreadClass = Class.forName("android.app.ActivityThread");
  Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");
  currentActivityThreadMethod.setAccessible(true);
  //获取主线程对象
  Object activityThread = currentActivityThreadMethod.invoke(null);
  //获取mH字段
  Field mH = activityThreadClass.getDeclaredField("mH");
  mH.setAccessible(true);
  //获取Handler
  Handler handler = (Handler) mH.get(activityThread);
  //获取原始的mCallBack字段
  Field mCallBack = Handler.class.getDeclaredField("mCallback");
  mCallBack.setAccessible(true);
  //这里设置了我们自己实现了接口的CallBack对象
  mCallBack.set(handler, new ActivityThreadHandlerCallback(handler));

  } catch (Exception e) {
            e.printStackTrace();
  }
    }

    public void hookAms() {

        //一路反射，直到拿到IActivityManager的对象
  try {
            Class ActivityManagerNativeClss = Class.forName("android.app.ActivityManagerNative");
  Field defaultFiled = ActivityManagerNativeClss.getDeclaredField("gDefault");
  defaultFiled.setAccessible(true);
  Object defaultValue = defaultFiled.get(null);
  //反射SingleTon
  Class SingletonClass = Class.forName("android.util.Singleton");
  Field mInstance = SingletonClass.getDeclaredField("mInstance");
  mInstance.setAccessible(true);
  //到这里已经拿到ActivityManager对象
  Object iActivityManagerObject = mInstance.get(defaultValue);

  //开始动态代理，用代理对象替换掉真实的ActivityManager，瞒天过海
  Class IActivityManagerIntercept = Class.forName("android.app.IActivityManager");

  AmsInvocationHandler handler = new AmsInvocationHandler(iActivityManagerObject);

  Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{IActivityManagerIntercept}, handler);

  //现在替换掉这个对象
  mInstance.set(defaultValue, proxy);

  } catch (Exception e) {
            e.printStackTrace();
  }
    }

    private class ActivityThreadHandlerCallback implements Handler.Callback {

        private Handler handler;

 private ActivityThreadHandlerCallback(Handler handler) {
            this.handler = handler;
  }

        @Override
  public boolean handleMessage(Message msg) {
            Log.i("HookAmsUtil", "handleMessage");
  //替换之前的Intent
  if (msg.what == 100) {
                Log.i("HookAmsUtil", "lauchActivity");
  handleLauchActivity(msg);
  }

            handler.handleMessage(msg);
 return true;  }

        private void handleLauchActivity(Message msg) {
            Object obj = msg.obj;//ActivityClientRecord
  try {
                Field intentField = obj.getClass().getDeclaredField("intent");
  intentField.setAccessible(true);
  Intent proxyInent = (Intent) intentField.get(obj);
  Intent realIntent = proxyInent.getParcelableExtra("oldIntent");
 if (realIntent != null) {
                    proxyInent.setComponent(realIntent.getComponent());
  }
            } catch (Exception e) {
                Log.i("HookAmsUtil", "lauchActivity falied");
  }

        }
    }

    public class AmsInvocationHandler implements InvocationHandler {

        private Object iActivityManagerObject;

 public AmsInvocationHandler(Object iActivityManagerObject) {
            this.iActivityManagerObject = iActivityManagerObject;
  }

        @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

            Log.i("HookUtil", method.getName());
 if ("startActivity".contains(method.getName())) {
                Log.e("HookUtil", "Activity已经开始启动");
  //换掉
  Intent intent = null;
 int index = 0;
 for (int i = 0; i < args.length; i++) {
                    Object arg = args[i];
 if (arg instanceof Intent) {
                        //说明找到了startActivity的Intent参数
  intent = (Intent) args[i];
  //这个意图是不能被启动的，因为Acitivity没有在清单文件中注册
  index = i;
 if (intent != null) {
                            Bundle extras = intent.getExtras();
 if (extras != null && extras.keySet() != null) {
                                for (String key : extras.keySet()) {
                                    Log.d("HookUtil", "intent.extras.key=" + key + ",value=" + extras.get(key));
  }
                            }
                            Log.d("HookUtil", extras + "");
  }
                    }
                }

                //伪造一个代理的Intent，代理Intent启动的是proxyActivity
  if (context != null && proxyActivity != null) {
                    Intent proxyIntent = new Intent();
  ComponentName componentName = new ComponentName(context, proxyActivity);
  proxyIntent.setComponent(componentName);
  proxyIntent.putExtra("oldIntent", intent);
  args[index] = proxyIntent;
  }
            }

            return method.invoke(iActivityManagerObject, args);
  }
    }
}

在Application中的onCreate函数中插桩

RxAndroid学习笔记

Fri, 14 Apr 2017 16:15:15 +0800

学习RX的原因各有不同，但是目的都一样，就是学会使用RX。想要学会使用RX，最好理解Rx的编程思想。

官方网站：http://reactivex.io/ 官方对RX的解释：ReactiveX is a library for composing asynchronous and event-based programs by using observable sequences.

RxJava文档的中文翻译 https://mcxiaoke.gitbooks.io/rxdocs

比较精华的文章《给Android开发者的RxJava详解》 by:扔物线《深入浅出RxJava》 by:大头鬼《谜之RxJava》 by:Gemini 《RxJava之旅》 by:Chuckiefan 《给初学者的RxJava2.0教程》系列 by:Season_zlc

RX官方解释为响应式编程。而Chuckiefan指出理解响应式编程首先要养成一切皆数据流的编程思维、理解异步编程和观察者模式，并将响应式编程与面向过程编程和面向对象编程并列。可见，如果不理解其编程思想，很难熟练运用RX。

Season_zlc的水管理论通俗易懂，建议认真阅读。

Notification播放apk中自带raw音频

Wed, 15 Mar 2017 09:45:54 +0800

本场景为自定义Notification的声音
根本解决方式是修改notification的sound

notification.sound =Uri sound;
//或者
NotificationCompat.Builder.setSound(Uri sound)

Uri的规范可以参考 http://www.ietf.org/rfc/rfc2396.txt 以下为示例

Uri sound=Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.notificationsound );  
//或者
Uri sound=Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + getPackageName() + "/raw/notificationsound"); 
//或者
Uri sound=Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + getPackageName() + "/"+R.raw.notificationsound); 
//或者从铃声管理器获取 
Uri sound= RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

也可以将一个无声音的音频文件指定给notification使其静音，然后启用MediaPlayer播放铃声。播放代码如下：

try {
  Context context = Application.getInstance();
  MediaPlayer mediaPlayer;
  if (rawId > 0) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            mediaPlayer = MediaPlayer.create(context, rawId);
		} else {
		  int sessionId = ((AudioManager) context.getSystemService(Context.AUDIO_SERVICE)).generateAudioSessionId();
		  AudioAttributes audioAttributes = new AudioAttributes.Builder()
				  .setUsage(AudioAttributes.USAGE_NOTIFICATION)
				  .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
				  .setLegacyStreamType(AudioManager.STREAM_NOTIFICATION)
				  .build();
		  mediaPlayer = MediaPlayer.create(context, rawId, audioAttributes, sessionId);
		}
    } else {
        mediaPlayer = MediaPlayer.create(context, RingtoneManager.getActualDefaultRingtoneUri(context, RingtoneManager.TYPE_NOTIFICATION));
    }
	 //使用MediaPlayer.create(context, R.raw.mingdao)这种方式创建的MediaPlayer已经prepare完成，且不能修改AudioStreamType
	 //mediaPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);  
	 mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
        @Override
		public void onCompletion(MediaPlayer mediaPlayer) {
            mediaPlayer.release();
	}
    });
	mediaPlayer.start();
} catch (Exception e) {
    e.printStackTrace();
}

初衷

Wed, 01 Aug 2007 13:51:14 +0800

个人记录网建设初衷 🔗

自2007年毕业工作以来，起初使用notepad记录工作心得。
2008年伊始，对比了多家博客，采用百度空间开始记录博客，可惜百度空间于2012年关闭。
2012-2017年期间使用印象笔记,可惜其较为封闭，不方便共享于众网友同仁。
2017年开始了，鉴于百度空间关闭的前车之鉴，所以自建博客，用以共勉。
2020年了，改用hugo，使用静态网站。