Merge remote-tracking branch 'origin/midiplayer' into appbase

midiplayer/.gitignore

@@ -0,0 +1 @@
+/build

midiplayer/README.md

@@ -0,0 +1,34 @@
+# Midi Player
+
+#### 介绍
+Midi 音乐播放器
+
+#### 软件架构
+适配安卓应用 [AIDE Pro] 的 Gradle 编译结构。
+也适配安卓应用 [AndroidIDE] 的 Gradle 编译结构。
+
+
+#### Gradle 编译说明
+调试版编译命令 ：gradle assembleBetaDebug
+阶段版编译命令 ：bash .winboll/bashPublishAPKAddTag.sh miniplayer
+
+#### 使用说明
+
+#### 参与贡献
+
+1.  Fork 本仓库
+2.  新建 Feat_xxx 分支
+3.  提交代码 : ZhanGSKen(ZhanGSKen<zhangsken@188.com>)
+4.  新建 Pull Request
+
+
+#### 特技
+
+1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
+2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
+3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
+4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
+5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
+6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)
+
+#### 参考文档

midiplayer/build.gradle

@@ -0,0 +1,73 @@
+apply plugin: 'com.android.application'
+apply from: '../.winboll/winboll_app_build.gradle'
+apply from: '../.winboll/winboll_lint_build.gradle'
+
+def genVersionName(def versionName){
+    // 检查编译标志位配置
+    assert (winbollBuildProps['stageCount'] != null)
+    assert (winbollBuildProps['baseVersion'] != null)
+    // 保存基础版本号
+    winbollBuildProps.setProperty("baseVersion", "${versionName}");
+    //保存编译标志配置
+    FileOutputStream fos = new FileOutputStream(winbollBuildPropsFile)
+    winbollBuildProps.store(fos, "${winbollBuildPropsDesc}");
+    fos.close();
+    
+    // 返回编译版本号
+    return "${versionName}." + winbollBuildProps['stageCount']
+}
+
+android {
+    compileSdkVersion 32
+    buildToolsVersion "32.0.0"
+
+    defaultConfig {
+        applicationId "cc.winboll.studio.midiplayer"
+        minSdkVersion 26
+        targetSdkVersion 30
+        versionCode 1
+        // versionName 更新后需要手动设置 
+        // .winboll/winbollBuildProps.properties 文件的 stageCount=0
+        // Gradle编译环境下合起来的 versionName 就是 "${versionName}.0"
+        versionName "15.0"
+        if(true) {
+            versionName = genVersionName("${versionName}")
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+
+dependencies {
+    api fileTree(dir: 'libs', include: ['*.jar'])
+    
+    // SSH
+    api 'com.jcraft:jsch:0.1.55'
+    // Html 解析
+    api 'org.jsoup:jsoup:1.13.1'
+    // 二维码类库
+    api 'com.google.zxing:core:3.4.1'
+    api 'com.journeyapps:zxing-android-embedded:3.6.0'
+    // 应用介绍页类库
+    api 'io.github.medyo:android-about-page:2.0.0'
+    // 吐司类库
+    api 'com.github.getActivity:ToastUtils:10.5'
+    // 网络连接类库
+    api 'com.squareup.okhttp3:okhttp:4.4.1'
+    // AndroidX 类库
+    api 'androidx.appcompat:appcompat:1.1.0'
+    api 'com.google.android.material:material:1.4.0'
+    //api 'androidx.viewpager:viewpager:1.0.0'
+    //api 'androidx.vectordrawable:vectordrawable:1.1.0'
+    //api 'androidx.vectordrawable:vectordrawable-animated:1.1.0'
+    //api 'androidx.fragment:fragment:1.1.0'
+    
+    api 'cc.winboll.studio:libaes:15.9.2'
+    api 'cc.winboll.studio:libapputils:15.8.4'
+    api 'cc.winboll.studio:libappbase:15.8.4'
+}

midiplayer/build.properties

@@ -0,0 +1,8 @@
+#Created by .winboll/winboll_app_build.gradle
+#Tue Sep 02 12:52:51 GMT 2025
+stageCount=1
+libraryProject=
+baseVersion=15.0
+publishVersion=15.0.0
+buildCount=2
+baseBetaVersion=15.0.1

midiplayer/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

midiplayer/src/beta/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" >
+
+    <application>
+
+        <!-- Put flavor specific code here -->
+
+    </application>
+
+</manifest>
+

midiplayer/src/beta/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">MidiPlayer +</string>
+
+</resources>

midiplayer/src/main/AndroidManifest.xml

@@ -0,0 +1,50 @@
+<?xml version='1.0' encoding='utf-8'?>
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    package="cc.winboll.studio.midiplayer">
+
+    <!-- 读取您共享存储空间中的内容 -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+
+    <!-- 修改或删除您共享存储空间中的内容 -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+
+    <!-- 拥有完全的网络访问权限 -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+	<uses-permission android:name="android.permission.RECORD_AUDIO" />
+	<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+	
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:label="@string/app_name"
+        android:theme="@style/MyAppTheme"
+        android:resizeableActivity="true"
+        android:name=".App">
+
+		<activity
+			android:name=".MidiPlayerActivity"
+			android:exported="true">
+			<intent-filter>
+				<action android:name="android.intent.action.MAIN" />
+				<category android:name="android.intent.category.LAUNCHER" />
+			</intent-filter>
+			<!-- 支持打开Midi文件 -->
+			<intent-filter>
+				<action android:name="android.intent.action.VIEW" />
+				<category android:name="android.intent.category.DEFAULT" />
+				<data android:mimeType="audio/midi" />
+				<data android:scheme="file" />
+			</intent-filter>
+		</activity>
+
+        <meta-data
+            android:name="android.max_aspect"
+            android:value="4.0"/>
+
+        <activity android:name=".GlobalApplication$CrashActivity"/>
+
+    </application>
+
+</manifest>

midiplayer/src/main/java/cc/winboll/studio/midiplayer/App.java

@@ -0,0 +1,345 @@
+package cc.winboll.studio.midiplayer;
+
+import android.app.Activity;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageInfo;
+import android.content.res.Resources;
+import android.graphics.Typeface;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.ViewGroup;
+import android.widget.HorizontalScrollView;
+import android.widget.ScrollView;
+import android.widget.TextView;
+import android.widget.Toast;
+import cc.winboll.studio.libappbase.GlobalApplication;
+import com.hjq.toast.ToastUtils;
+import com.hjq.toast.style.WhiteToastStyle;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class App extends GlobalApplication {
+
+    private static Handler MAIN_HANDLER = new Handler(Looper.getMainLooper());
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        
+        // 初始化 Toast 框架
+        ToastUtils.init(this);
+        // 设置 Toast 布局样式
+        //ToastUtils.setView(R.layout.view_toast);
+        ToastUtils.setStyle(new WhiteToastStyle());
+        ToastUtils.setGravity(Gravity.BOTTOM, 0, 200);
+        
+        //CrashHandler.getInstance().registerGlobal(this);
+        //CrashHandler.getInstance().registerPart(this);
+    }
+
+    public static void write(InputStream input, OutputStream output) throws IOException {
+        byte[] buf = new byte[1024 * 8];
+        int len;
+        while ((len = input.read(buf)) != -1) {
+            output.write(buf, 0, len);
+        }
+    }
+
+    public static void write(File file, byte[] data) throws IOException {
+        File parent = file.getParentFile();
+        if (parent != null && !parent.exists()) parent.mkdirs();
+
+        ByteArrayInputStream input = new ByteArrayInputStream(data);
+        FileOutputStream output = new FileOutputStream(file);
+        try {
+            write(input, output);
+        } finally {
+            closeIO(input, output);
+        }
+    }
+
+    public static String toString(InputStream input) throws IOException {
+        ByteArrayOutputStream output = new ByteArrayOutputStream();
+        write(input, output);
+        try {
+            return output.toString("UTF-8");
+        } finally {
+            closeIO(input, output);
+        }
+    }
+
+    public static void closeIO(Closeable... closeables) {
+        for (Closeable closeable : closeables) {
+            try {
+                if (closeable != null) closeable.close();
+            } catch (IOException ignored) {}
+        }
+    }
+
+    public static class CrashHandler {
+
+        public static final UncaughtExceptionHandler DEFAULT_UNCAUGHT_EXCEPTION_HANDLER = Thread.getDefaultUncaughtExceptionHandler();
+
+        private static CrashHandler sInstance;
+
+        private PartCrashHandler mPartCrashHandler;
+
+        public static CrashHandler getInstance() {
+            if (sInstance == null) {
+                sInstance = new CrashHandler();
+            }
+            return sInstance;
+        }
+
+        public void registerGlobal(Context context) {
+            registerGlobal(context, null);
+        }
+
+        public void registerGlobal(Context context, String crashDir) {
+            Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandlerImpl(context.getApplicationContext(), crashDir));
+        }
+
+        public void unregister() {
+            Thread.setDefaultUncaughtExceptionHandler(DEFAULT_UNCAUGHT_EXCEPTION_HANDLER);
+        }
+
+        public void registerPart(Context context) {
+            unregisterPart(context);
+            mPartCrashHandler = new PartCrashHandler(context.getApplicationContext());
+            MAIN_HANDLER.postAtFrontOfQueue(mPartCrashHandler);
+        }
+
+        public void unregisterPart(Context context) {
+            if (mPartCrashHandler != null) {
+                mPartCrashHandler.isRunning.set(false);
+                mPartCrashHandler = null;
+            }
+        }
+
+        private static class PartCrashHandler implements Runnable {
+
+            private final Context mContext;
+
+            public AtomicBoolean isRunning = new AtomicBoolean(true);
+
+            public PartCrashHandler(Context context) {
+                this.mContext = context;
+            }
+
+            @Override
+            public void run() {
+                while (isRunning.get()) {
+                    try {
+                        Looper.loop();
+                    } catch (final Throwable e) {
+                        e.printStackTrace();
+                        if (isRunning.get()) {
+                            MAIN_HANDLER.post(new Runnable(){
+
+                                    @Override
+                                    public void run() {
+                                        Toast.makeText(mContext, e.toString(), Toast.LENGTH_LONG).show();
+                                    }
+                                });
+                        } else {
+                            if (e instanceof RuntimeException) {
+                                throw (RuntimeException)e;
+                            } else {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private static class UncaughtExceptionHandlerImpl implements UncaughtExceptionHandler {
+
+            private static DateFormat DATE_FORMAT = new SimpleDateFormat("yyyy_MM_dd-HH_mm_ss");
+
+            private final Context mContext;
+
+            private final File mCrashDir;
+
+            public UncaughtExceptionHandlerImpl(Context context, String crashDir) {
+                this.mContext = context;
+                this.mCrashDir = TextUtils.isEmpty(crashDir) ? new File(mContext.getExternalCacheDir(), "crash") : new File(crashDir);
+            }
+
+            @Override
+            public void uncaughtException(Thread thread, Throwable throwable) {
+                try {
+
+                    String log = buildLog(throwable);
+                    writeLog(log);
+
+                    try {
+                        Intent intent = new Intent(mContext, CrashActivity.class);
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                        intent.putExtra(Intent.EXTRA_TEXT, log);
+                        mContext.startActivity(intent);
+                    } catch (Throwable e) {
+                        e.printStackTrace();
+                        writeLog(e.toString());
+                    }
+
+                    throwable.printStackTrace();
+                    android.os.Process.killProcess(android.os.Process.myPid());
+                    System.exit(0);
+
+                } catch (Throwable e) {
+                    if (DEFAULT_UNCAUGHT_EXCEPTION_HANDLER != null) DEFAULT_UNCAUGHT_EXCEPTION_HANDLER.uncaughtException(thread, throwable);
+                }
+            }
+
+            private String buildLog(Throwable throwable) {
+                String time = DATE_FORMAT.format(new Date());
+
+                String versionName = "unknown";
+                long versionCode = 0;
+                try {
+                    PackageInfo packageInfo = mContext.getPackageManager().getPackageInfo(mContext.getPackageName(), 0);
+                    versionName = packageInfo.versionName;
+                    versionCode = Build.VERSION.SDK_INT >= 28 ? packageInfo.getLongVersionCode() : packageInfo.versionCode;
+                } catch (Throwable ignored) {}
+
+                LinkedHashMap<String, String> head = new LinkedHashMap<String, String>();
+                head.put("Time Of Crash", time);
+                head.put("Device", String.format("%s, %s", Build.MANUFACTURER, Build.MODEL));
+                head.put("Android Version", String.format("%s (%d)", Build.VERSION.RELEASE, Build.VERSION.SDK_INT));
+                head.put("App Version", String.format("%s (%d)", versionName, versionCode));
+                head.put("Kernel", getKernel());
+                head.put("Support Abis", Build.VERSION.SDK_INT >= 21 && Build.SUPPORTED_ABIS != null ? Arrays.toString(Build.SUPPORTED_ABIS): "unknown");
+                head.put("Fingerprint", Build.FINGERPRINT);
+
+                StringBuilder builder = new StringBuilder();
+
+                for (String key : head.keySet()) {
+                    if (builder.length() != 0) builder.append("\n");
+                    builder.append(key);
+                    builder.append(" :    ");
+                    builder.append(head.get(key));
+                }
+
+                builder.append("\n\n");
+                builder.append(Log.getStackTraceString(throwable));
+
+                return builder.toString(); 
+            }
+
+            private void writeLog(String log) {
+                String time = DATE_FORMAT.format(new Date());
+                File file = new File(mCrashDir, "crash_" + time + ".txt");
+                try {
+                    write(file, log.getBytes("UTF-8"));
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                } 
+            }
+
+            private static String getKernel() {
+                try {
+                    return App.toString(new FileInputStream("/proc/version")).trim();
+                } catch (Throwable e) {
+                    return e.getMessage();
+                }
+            }
+        }
+    }
+
+    public static final class CrashActivity extends Activity {
+
+        private String mLog;
+
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            setTheme(android.R.style.Theme_DeviceDefault);
+            setTitle("App Crash");
+
+            mLog = getIntent().getStringExtra(Intent.EXTRA_TEXT);
+
+            ScrollView contentView = new ScrollView(this);
+            contentView.setFillViewport(true);
+
+            HorizontalScrollView horizontalScrollView = new HorizontalScrollView(this);
+
+            TextView textView = new TextView(this);
+            int padding = dp2px(16);
+            textView.setPadding(padding, padding, padding, padding);
+            textView.setText(mLog);
+            textView.setTextIsSelectable(true);
+            textView.setTypeface(Typeface.DEFAULT);
+            textView.setLinksClickable(true);
+
+            horizontalScrollView.addView(textView);
+            contentView.addView(horizontalScrollView, ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
+
+            setContentView(contentView);
+        }
+
+        private void restart() {
+            Intent intent = getPackageManager().getLaunchIntentForPackage(getPackageName());
+            if (intent != null) {
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                startActivity(intent);
+            }
+            finish();
+            android.os.Process.killProcess(android.os.Process.myPid());
+            System.exit(0);
+        }
+
+        private static int dp2px(float dpValue) {
+            final float scale = Resources.getSystem().getDisplayMetrics().density;
+            return (int) (dpValue * scale + 0.5f);
+        }
+
+        @Override
+        public boolean onCreateOptionsMenu(Menu menu) {
+            menu.add(0, android.R.id.copy, 0, android.R.string.copy)
+                .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
+            return super.onCreateOptionsMenu(menu);
+        }
+
+        @Override
+        public boolean onOptionsItemSelected(MenuItem item) {
+            switch (item.getItemId()) {
+                case android.R.id.copy:
+                    ClipboardManager cm = (ClipboardManager) getSystemService(Context.CLIPBOARD_SERVICE);
+                    cm.setPrimaryClip(ClipData.newPlainText(getPackageName(), mLog));
+                    return true;
+            }
+            return super.onOptionsItemSelected(item);
+        }
+
+        @Override
+        public void onBackPressed() {
+            restart();
+        }
+    }
+}

midiplayer/src/main/java/cc/winboll/studio/midiplayer/AssetMidiCopier.java

@@ -0,0 +1,137 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:56
+ * @Describe 用于将assets/midi目录下的文件拷贝到内部存储
+ */
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.util.Log;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class AssetMidiCopier {
+	public static final String TAG = "AssetMidiCopier";
+
+	private Context mContext;
+
+	public AssetMidiCopier(Context context) {
+		mContext = context;
+	}
+
+	/**
+	 * 拷贝assets/midi目录下所有文件到内部存储的midi文件夹
+	 * @return 拷贝是否成功
+	 */
+	public boolean copyMidiFiles() {
+		AssetManager assetManager = mContext.getAssets();
+		String[] midiFiles;
+
+		try {
+			// 获取assets/midi目录下的所有文件
+			midiFiles = assetManager.list("midi");
+			if (midiFiles == null || midiFiles.length == 0) {
+				Log.d(TAG, "assets/midi目录下没有文件");
+				return false;
+			}
+
+			// 获取内部存储的目标目录（/data/data/包名/files/midi）
+			File targetDir = new File(mContext.getFilesDir(), "midi");
+			if (!targetDir.exists()) {
+				// 创建目录（包括父目录）
+				if (!targetDir.mkdirs()) {
+					Log.e(TAG, "创建目标目录失败: " + targetDir.getAbsolutePath());
+					return false;
+				}
+			}
+
+			// 逐个拷贝文件
+			for (String fileName : midiFiles) {
+				// 跳过目录，只处理文件
+				if (fileName.contains("/")) {
+					continue;
+				}
+
+				// 源文件路径（assets/midi/文件名）
+				String sourcePath = "midi/" + fileName;
+				// 目标文件路径
+				File targetFile = new File(targetDir, fileName);
+
+				// 如果文件已存在，跳过拷贝
+				if (targetFile.exists()) {
+					Log.d(TAG, "文件已存在，跳过: " + fileName);
+					continue;
+				}
+
+				// 执行拷贝
+				if (!copySingleFile(assetManager, sourcePath, targetFile)) {
+					Log.e(TAG, "拷贝文件失败: " + fileName);
+					return false;
+				}
+			}
+
+			Log.d(TAG, "所有MIDI文件拷贝完成，共" + midiFiles.length + "个文件");
+			return true;
+
+		} catch (IOException e) {
+			Log.e(TAG, "拷贝过程发生错误: " + e.getMessage());
+			e.printStackTrace();
+			return false;
+		}
+	}
+
+	/**
+	 * 拷贝单个assets文件到目标路径
+	 */
+	private boolean copySingleFile(AssetManager assetManager, String sourcePath, File targetFile) {
+		InputStream in = null;
+		FileOutputStream out = null;
+
+		try {
+			// 打开assets中的源文件
+			in = assetManager.open(sourcePath);
+			// 创建目标文件输出流
+			out = new FileOutputStream(targetFile);
+
+			// 缓冲区
+			byte[] buffer = new byte[1024];
+			int length;
+			// 读写文件
+			while ((length = in.read(buffer)) != -1) {
+				out.write(buffer, 0, length);
+			}
+
+			// 刷新输出流，确保数据写入
+			out.flush();
+			return true;
+
+		} catch (IOException e) {
+			Log.e(TAG, "拷贝单个文件错误: " + e.getMessage());
+			return false;
+
+		} finally {
+			// 关闭流
+			try {
+				if (in != null) {
+					in.close();
+				}
+				if (out != null) {
+					out.close();
+				}
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	/**
+	 * 获取内部存储中MIDI文件的目录
+	 */
+	public File getMidiTargetDir() {
+		return new File(mContext.getFilesDir(), "midi");
+	}
+}
+

midiplayer/src/main/java/cc/winboll/studio/midiplayer/MainActivity.java

@@ -0,0 +1,78 @@
+package cc.winboll.studio.midiplayer;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.View;
+import androidx.appcompat.widget.Toolbar;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.LogView;
+import com.hjq.toast.ToastUtils;
+import java.io.File;
+
+public class MainActivity extends WinBoLLActivity {
+
+    LogView mLogView;
+
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+		Toolbar toolbar=(Toolbar)findViewById(R.id.toolbar);
+		setSupportActionBar(toolbar);
+
+        mLogView = findViewById(R.id.logview);
+
+        ToastUtils.show("onCreate");
+		copyAssetsMidiFiles();
+    }
+
+	public void onOpenMidiPlayer(View view) {
+		App.getWinBoLLActivityManager().startWinBoLLActivity(this, MidiPlayerActivity.class);
+	}
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mLogView.start();
+    }
+	
+	// 在需要拷贝的地方调用（如Activity的onCreate中）
+	private void copyAssetsMidiFiles() {
+		// 新建拷贝工具类实例
+		final AssetMidiCopier copier = new AssetMidiCopier(this);
+
+		// 开启子线程执行拷贝（避免主线程阻塞）
+		new Thread(new Runnable() {
+				@Override
+				public void run() {
+					final boolean success = copier.copyMidiFiles();
+					// 拷贝结果可通过Handler通知主线程更新UI
+					runOnUiThread(new Runnable() {
+							@Override
+							public void run() {
+								if (success) {
+									// 拷贝成功，获取目标目录
+									File midiDir = copier.getMidiTargetDir();
+									LogUtils.d(TAG, "文件保存路径: " + midiDir.getAbsolutePath());
+									// 可在这里加载MIDI文件
+								} else {
+									// 拷贝失败，提示用户
+								}
+							}
+						});
+				}
+			}).start();
+	}
+	
+}

midiplayer/src/main/java/cc/winboll/studio/midiplayer/MidiParser.java

@@ -0,0 +1,420 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:26
+ * @Describe MIDI文件解析器，用于解析MIDI文件并提取轨道信息
+ */
+import cc.winboll.studio.libappbase.LogUtils;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MidiParser {
+    public static final String TAG = "MidiParser";
+    private static final Charset US_ASCII = Charset.forName("US-ASCII");
+
+    private InputStream mInputStream;
+    private int mTrackCount; // 轨道数量
+    private int mTicksPerBeat; // 每拍的ticks数（从文件头解析）
+
+    public MidiParser(File file) throws IOException {
+        this.mInputStream = new FileInputStream(file);
+    }
+
+    /**
+     * 解析MIDI文件，返回包含轨道和每拍ticks数的结果（支持速度控制）
+     */
+    public MidiPlayer.MidiParseResult parseWithTicks() throws IOException {
+        try {
+            // 1. 验证MIDI文件头（MThd）
+            if (!verifyHeader()) {
+                LogUtils.d(TAG, "不是有效的MIDI文件");
+                return null;
+            }
+
+            // 2. 读取文件头信息（包含每拍ticks数）
+            readHeaderInfo();
+
+            // 3. 解析每个轨道（包含事件的deltaTicks）
+            MidiPlayer.MidiTrack[] tracks = new MidiPlayer.MidiTrack[mTrackCount];
+            for (int i = 0; i < mTrackCount; i++) {
+                tracks[i] = parseTrackWithTicks();
+            }
+
+            // 返回解析结果（轨道数组 + 每拍ticks数）
+            return new MidiPlayer.MidiParseResult(tracks, mTicksPerBeat);
+        } finally {
+            if (mInputStream != null) {
+                mInputStream.close();
+            }
+        }
+    }
+
+    /**
+     * 原始解析方法（兼容旧逻辑）
+     */
+    public MidiTrack[] parse() throws IOException {
+        try {
+            if (!verifyHeader()) {
+                LogUtils.d(TAG, "不是有效的MIDI文件");
+                return null;
+            }
+
+            readHeaderInfo();
+            MidiTrack[] tracks = new MidiTrack[mTrackCount];
+            for (int i = 0; i < mTrackCount; i++) {
+                tracks[i] = parseTrack();
+            }
+            return tracks;
+        } finally {
+            if (mInputStream != null) {
+                mInputStream.close();
+            }
+        }
+    }
+
+    /**
+     * 验证MIDI文件头（必须以"MThd"开头）
+     */
+    private boolean verifyHeader() throws IOException {
+        byte[] header = new byte[4];
+        int read = mInputStream.read(header);
+        if (read != 4) {
+            LogUtils.d(TAG, "文件头读取不完整，读取字节数: " + read);
+            return false;
+        }
+        String headerStr = new String(header, US_ASCII);
+        boolean isValid = "MThd".equals(headerStr);
+        if (!isValid) {
+            LogUtils.d(TAG, "无效的文件头标识: " + headerStr 
+					   + " (十六进制: " + bytesToHex(header) + ")");
+        }
+        return isValid;
+    }
+
+    /**
+     * 读取MIDI文件头信息（提取每拍ticks数）
+     */
+    private void readHeaderInfo() throws IOException {
+        // 1. 读取头长度（4字节，标准MIDI固定为6）
+        int headerLength = readInt();
+        LogUtils.d(TAG, "MIDI文件头长度: " + headerLength);
+
+        // 2. 读取头数据（共6字节）
+        byte[] headerData = new byte[6];
+        int read = mInputStream.read(headerData);
+        if (read != 6) {
+            LogUtils.d(TAG, "文件头数据不完整，预期6字节，实际读取: " + read);
+            throw new IOException("无效的MIDI文件头数据");
+        }
+
+        // 3. 解析头信息（格式类型、轨道数、每拍ticks数）
+        int formatType = ((headerData[0] & 0xFF) << 8) | (headerData[1] & 0xFF);
+        mTrackCount = ((headerData[2] & 0xFF) << 8) | (headerData[3] & 0xFF);
+        mTicksPerBeat = ((headerData[4] & 0xFF) << 8) | (headerData[5] & 0xFF); // 存储每拍ticks数
+
+        LogUtils.d(TAG, "MIDI文件格式: " + formatType);
+        LogUtils.d(TAG, "时间分隔符(每拍 ticks): " + mTicksPerBeat);
+        LogUtils.d(TAG, "解析到轨道数量: " + mTrackCount);
+
+        // 4. 处理扩展头
+        if (headerLength > 6) {
+            long skipped = mInputStream.skip(headerLength - 6);
+            LogUtils.d(TAG, "跳过扩展头字节数: " + skipped);
+        }
+    }
+
+    /**
+     * 解析单个轨道（包含事件的deltaTicks，用于速度控制）
+     */
+    private MidiPlayer.MidiTrack parseTrackWithTicks() throws IOException {
+        // 1. 读取轨道头（MTrk）
+        byte[] trackHeader = new byte[4];
+        int headerRead = mInputStream.read(trackHeader);
+        if (headerRead != 4) {
+            LogUtils.d(TAG, "轨道头读取不完整，实际读取: " + headerRead + "字节");
+            return new MidiPlayer.MidiTrack(new ArrayList<MidiPlayer.MidiEvent>());
+        }
+
+        // 2. 验证轨道头标识
+        String headerStr = new String(trackHeader, US_ASCII);
+        if (!"MTrk".equals(headerStr)) {
+            LogUtils.d(TAG, "无效的轨道头标识: " + headerStr);
+            return new MidiPlayer.MidiTrack(new ArrayList<MidiPlayer.MidiEvent>());
+        }
+
+        // 3. 读取轨道长度
+        int trackLength = readInt();
+        LogUtils.d(TAG, "解析轨道，长度: " + trackLength + "字节");
+
+        // 4. 读取完整轨道数据
+        byte[] trackData = new byte[trackLength];
+        int totalRead = 0;
+        while (totalRead < trackLength) {
+            int bytesRead = mInputStream.read(trackData, totalRead, trackLength - totalRead);
+            if (bytesRead == -1) {
+                LogUtils.d(TAG, "轨道数据读取提前结束，已读取: " + totalRead);
+                break;
+            }
+            totalRead += bytesRead;
+        }
+
+        // 5. 解析轨道事件（包含deltaTicks）
+        List<MidiPlayer.MidiEvent> events = new ArrayList<MidiPlayer.MidiEvent>();
+        if (totalRead == trackLength) {
+            parseEventsWithTicks(events, trackData);
+        } else {
+            LogUtils.d(TAG, "轨道数据不完整，跳过事件解析");
+        }
+
+        return new MidiPlayer.MidiTrack(events);
+    }
+
+    /**
+     * 解析轨道事件（提取deltaTicks，用于计算播放延迟）
+     */
+    private void parseEventsWithTicks(List<MidiPlayer.MidiEvent> events, byte[] trackData) {
+        int offset = 0;
+        while (offset < trackData.length) {
+            // 1. 读取deltaTicks（事件间隔，单位ticks）
+            long deltaTicks = readVariableLength(trackData, offset);
+            int deltaSize = getVariableLengthSize(deltaTicks);
+            offset += deltaSize;
+
+            if (offset >= trackData.length) {
+                break;
+            }
+
+            // 2. 读取事件状态字节
+            int statusByte = trackData[offset] & 0xFF;
+            offset++;
+
+            // 3. 确定事件数据长度
+            int dataLength = getEventDataLength(statusByte);
+            if (offset + dataLength > trackData.length) {
+                LogUtils.d(TAG, "事件数据不完整，状态字节: 0x" + Integer.toHexString(statusByte));
+                break;
+            }
+
+            // 4. 提取事件数据（状态字节+数据字节）
+            byte[] eventData = new byte[1 + dataLength];
+            eventData[0] = (byte) statusByte;
+            System.arraycopy(trackData, offset, eventData, 1, dataLength);
+            offset += dataLength;
+
+            // 5. 存储事件（包含deltaTicks）
+            events.add(new MidiPlayer.MidiEvent(eventData, (int) deltaTicks));
+        }
+
+        LogUtils.d(TAG, "轨道事件解析完成，事件数量: " + events.size());
+    }
+
+    /**
+     * 原始轨道解析方法（兼容旧逻辑）
+     */
+    private MidiTrack parseTrack() throws IOException {
+        // 1. 读取轨道头（MTrk）
+        byte[] trackHeader = new byte[4];
+        int headerRead = mInputStream.read(trackHeader);
+        if (headerRead != 4) {
+            LogUtils.d(TAG, "轨道头读取不完整，实际读取: " + headerRead + "字节");
+            return new MidiTrack();
+        }
+
+        // 2. 验证轨道头标识
+        String headerStr = new String(trackHeader, US_ASCII);
+        if (!"MTrk".equals(headerStr)) {
+            LogUtils.d(TAG, "无效的轨道头标识: " + headerStr 
+					   + " (十六进制: " + bytesToHex(trackHeader) + ")");
+            return new MidiTrack();
+        }
+
+        // 3. 读取轨道长度
+        int trackLength = readInt();
+        LogUtils.d(TAG, "解析轨道，长度: " + trackLength + "字节");
+
+        // 4. 读取完整轨道数据
+        byte[] trackData = new byte[trackLength];
+        int totalRead = 0;
+        while (totalRead < trackLength) {
+            int bytesRead = mInputStream.read(trackData, totalRead, trackLength - totalRead);
+            if (bytesRead == -1) {
+                LogUtils.d(TAG, "轨道数据读取提前结束，已读取: " + totalRead + "，预期: " + trackLength);
+                break;
+            }
+            totalRead += bytesRead;
+        }
+
+        // 5. 解析轨道事件
+        MidiTrack track = new MidiTrack();
+        if (totalRead == trackLength) {
+            parseEvents(track, trackData);
+        } else {
+            LogUtils.d(TAG, "轨道数据不完整，跳过事件解析");
+        }
+
+        return track;
+    }
+
+    /**
+     * 原始事件解析方法（兼容旧逻辑）
+     */
+    private void parseEvents(MidiTrack track, byte[] trackData) {
+        int offset = 0;
+        while (offset < trackData.length) {
+            // 1. 读取可变长度时间戳（MIDI事件时间差）
+            long deltaTime = readVariableLength(trackData, offset);
+            offset += getVariableLengthSize(deltaTime);
+
+            if (offset >= trackData.length) {
+                break;
+            }
+
+            // 2. 读取事件状态字节
+            int statusByte = trackData[offset] & 0xFF;
+            offset++;
+
+            // 3. 确定事件数据长度
+            int dataLength = getEventDataLength(statusByte);
+            if (offset + dataLength > trackData.length) {
+                LogUtils.d(TAG, "事件数据不完整，状态字节: 0x" + Integer.toHexString(statusByte)
+						   + "，剩余字节: " + (trackData.length - offset));
+                break;
+            }
+
+            // 4. 提取完整事件（状态字节+数据字节）
+            byte[] event = new byte[1 + dataLength];
+            event[0] = (byte) statusByte;
+            System.arraycopy(trackData, offset, event, 1, dataLength);
+            offset += dataLength;
+
+            track.addEvent(event);
+        }
+
+        LogUtils.d(TAG, "轨道事件解析完成，事件数量: " + track.getEventCount());
+    }
+
+    /**
+     * 根据状态字节获取事件数据长度
+     */
+    private int getEventDataLength(int statusByte) {
+        int eventType = statusByte >> 4;
+        switch (eventType) {
+            case 0x8: // 音符关闭
+            case 0x9: // 音符开启
+            case 0xA: // 触后
+            case 0xB: // 控制器
+            case 0xE: // 弯音
+                return 2;
+            case 0xC: // 程序变更
+            case 0xD: // 通道触后
+                return 1;
+            case 0xF: // 系统事件
+                if (statusByte == 0xFF) { // 元事件
+                    return 1;
+                } else if (statusByte == 0xF0 || statusByte == 0xF7) { // 系统专属事件
+                    return 0;
+                }
+            default:
+                return 0;
+        }
+    }
+
+    /**
+     * 读取可变长度整数（MIDI事件时间差deltaTicks）
+     */
+    private long readVariableLength(byte[] data, int offset) {
+        long value = 0;
+        int b;
+        int i = 0;
+        do {
+            b = data[offset + i] & 0xFF;
+            value = (value << 7) | (b & 0x7F);
+            i++;
+        } while ((b & 0x80) != 0 && i < 4); // 最多4字节
+        return value;
+    }
+
+    /**
+     * 获取可变长度整数的字节数
+     */
+    private int getVariableLengthSize(long value) {
+        if (value < 0x80) return 1;
+        if (value < 0x4000) return 2;
+        if (value < 0x200000) return 3;
+        return 4;
+    }
+
+    /**
+     * 读取无符号短整型（2字节，大端序）
+     */
+    private int readUnsignedShort() throws IOException {
+        int b1 = mInputStream.read() & 0xFF;
+        int b2 = mInputStream.read() & 0xFF;
+        return (b1 << 8) | b2;
+    }
+
+    /**
+     * 读取整型（4字节，大端序）
+     */
+    private int readInt() throws IOException {
+        int b1 = mInputStream.read() & 0xFF;
+        int b2 = mInputStream.read() & 0xFF;
+        int b3 = mInputStream.read() & 0xFF;
+        int b4 = mInputStream.read() & 0xFF;
+        return (b1 << 24) | (b2 << 16) | (b3 << 8) | b4;
+    }
+
+    /**
+     * 字节数组转十六进制字符串（调试用）
+     */
+    private String bytesToHex(byte[] bytes) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : bytes) {
+            sb.append(String.format("%02X ", b));
+        }
+        return sb.toString().trim();
+    }
+
+    /**
+     * 旧轨道类（兼容旧逻辑）
+     */
+    /*public static class MidiTrack {
+        private List<byte[]> events = new ArrayList<byte[]>();
+        private boolean isMuted = false;
+        private int currentIndex = 0;
+
+        public void addEvent(byte[] event) {
+            events.add(event);
+        }
+
+        public int getEventCount() {
+            return events.size();
+        }
+
+        public void setMute(boolean mute) {
+            isMuted = mute;
+        }
+
+        public boolean hasNextEvent() {
+            return currentIndex < events.size();
+        }
+
+        public byte[] nextEvent() {
+            if (currentIndex < events.size()) {
+                return events.get(currentIndex++);
+            }
+            return null;
+        }
+
+        public void reset() {
+            currentIndex = 0;
+        }
+    }*/
+}
+

midiplayer/src/main/java/cc/winboll/studio/midiplayer/MidiPlayer.java

@@ -0,0 +1,655 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:13
+ * @Describe MidiPlayer
+ */
+import android.content.Context;
+import android.media.midi.MidiDevice;
+import android.media.midi.MidiDeviceInfo;
+import android.media.midi.MidiInputPort;
+import android.media.midi.MidiManager;
+import android.os.Build;
+import android.os.Handler;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import cc.winboll.studio.libappbase.LogUtils;
+
+/**
+ * MIDI播放器核心类，支持加载MIDI文件、连接合成器、控制播放轨道及事件解析
+ * 需Android 6.0（API 23）及以上版本
+ */
+public class MidiPlayer {
+
+    public static final String TAG = "MidiPlayer";
+
+    // 上下文与系统服务
+    private final Context mContext;
+    private MidiManager mMidiManager;
+
+    // MIDI设备与端口
+    private MidiDevice mMidiDevice;
+    private MidiInputPort mInputPort;
+    private boolean isSynthConnected = false;
+
+    // 线程与Handler
+    private ExecutorService mExecutor;
+    private final Handler mHandler = new Handler();
+
+    // 播放数据与状态
+    private MidiTrack[] mTracks;
+    private boolean isPlaying = false;
+    private int mCurrentTrack = -1; // -1表示播放所有轨道
+    private int mTicksPerBeat; // 每拍的ticks数（从MIDI文件解析）
+    private long startTime; // 播放开始时间（用于日志）
+
+    // 音色库管理
+    private final SoundFontManager mSoundFontManager;
+
+    // 连接回调接口
+    public interface OnSynthConnectedListener {
+        void onConnected(boolean success);
+    }
+    private OnSynthConnectedListener mConnectionListener;
+
+
+    /**
+     * MIDI事件类，存储事件数据及时间间隔
+     */
+    public static class MidiEvent {
+        public byte[] data; // 事件指令数据
+        public int deltaTicks; // 与上一事件的时间间隔（ticks）
+
+        public MidiEvent(byte[] data, int deltaTicks) {
+            this.data = data;
+            this.deltaTicks = deltaTicks;
+        }
+    }
+
+
+    /**
+     * MIDI轨道类，包含事件列表及播放状态
+     */
+    public static class MidiTrack {
+        private final List<MidiEvent> events;
+        private boolean isMuted = false;
+        private int currentIndex = 0;
+
+        public MidiTrack(List<MidiEvent> events) {
+            this.events = events;
+        }
+
+        public boolean hasNextEvent() {
+            return currentIndex < events.size();
+        }
+
+        public MidiEvent nextEvent() {
+            return currentIndex < events.size() ? events.get(currentIndex++) : null;
+        }
+
+        public void reset() {
+            currentIndex = 0;
+        }
+
+        public void setMute(boolean mute) {
+            isMuted = mute;
+        }
+
+        public boolean isMuted() {
+            return isMuted;
+        }
+    }
+
+
+    /**
+     * MIDI解析结果类，包含轨道数组与每拍ticks数
+     */
+    public static class MidiParseResult {
+        public MidiTrack[] tracks;
+        public int ticksPerBeat;
+
+        public MidiParseResult(MidiTrack[] tracks, int ticksPerBeat) {
+            this.tracks = tracks;
+            this.ticksPerBeat = ticksPerBeat;
+        }
+    }
+
+
+    // 构造方法
+    public MidiPlayer(Context context) {
+        mContext = context;
+        mSoundFontManager = new SoundFontManager(context);
+        // 初始化MIDI服务（需API 23+）
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            mMidiManager = (MidiManager) context.getSystemService(Context.MIDI_SERVICE);
+        }
+    }
+
+
+    // 设置合成器连接回调
+    public void setOnSynthConnectedListener(OnSynthConnectedListener listener) {
+        mConnectionListener = listener;
+    }
+
+
+    /**
+     * 加载MIDI文件并解析为轨道
+     * @param file MIDI文件
+     * @return 是否加载成功
+     */
+    public boolean loadMidiFile(File file) {
+        try {
+            MidiParser parser = new MidiParser(file);
+            MidiParseResult result = parser.parseWithTicks();
+            mTracks = result.tracks;
+            mTicksPerBeat = result.ticksPerBeat;
+            return mTracks != null && mTracks.length > 0;
+        } catch (IOException e) {
+            LogUtils.d(TAG, "加载MIDI文件失败: " + e.getMessage());
+            return false;
+        }
+    }
+
+
+    /**
+     * 加载音色库文件
+     * @param soundFontFile 音色库文件
+     * @return 是否加载成功
+     */
+    public boolean loadSoundFont(File soundFontFile) {
+        return mSoundFontManager.loadSoundFont(soundFontFile);
+    }
+
+
+    /**
+     * 开始播放MIDI文件
+     */
+    public void start() {
+        LogUtils.d(TAG, "start()");
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            LogUtils.d(TAG, "需Android 6.0及以上版本");
+            notifyConnectionResult(false);
+            return;
+        }
+        if (isPlaying || mTracks == null || mMidiManager == null) {
+            return;
+        }
+
+        isPlaying = true;
+        getExecutor().execute(new Runnable() {
+				@Override
+				public void run() {
+					LogUtils.d(TAG, "开始连接合成器");
+					isSynthConnected = false;
+					connectToSynth();
+
+					// 等待合成器连接（最多3秒）
+					int waitCount = 0;
+					while (!isSynthConnected && waitCount < 30) {
+						try {
+							Thread.sleep(100);
+						} catch (InterruptedException e) {
+							Thread.currentThread().interrupt();
+							break;
+						}
+						waitCount++;
+					}
+
+					if (!isSynthConnected || mInputPort == null) {
+						LogUtils.d(TAG, "合成器连接失败");
+						isPlaying = false;
+						notifyConnectionResult(false);
+						return;
+					}
+
+					notifyConnectionResult(true);
+					playTracksWithSpeedControl();
+				}
+			});
+    }
+
+
+    /**
+     * 带速度控制的轨道播放逻辑
+     */
+    private void playTracksWithSpeedControl() {
+        LogUtils.d(TAG, "开始播放，每拍ticks数: " + mTicksPerBeat);
+        if (mInputPort == null || mTracks == null || mTicksPerBeat <= 0) {
+            return;
+        }
+
+        startTime = System.currentTimeMillis();
+        int trackCount = mTracks.length;
+        long[] trackNextEventTime = new long[trackCount]; // 各轨道下一事件的播放时间（ms）
+
+        // 初始化轨道状态
+        for (int i = 0; i < trackCount; i++) {
+            mTracks[i].reset();
+            trackNextEventTime[i] = 0;
+        }
+
+        // 默认BPM（可通过MIDI文件中的tempo事件动态调整）
+        int bpm = 120;
+        double msPerTick = (60.0 / bpm) * 1000 / mTicksPerBeat;
+
+        // 循环播放事件
+        while (isPlaying) {
+            // 找到最早需要播放的事件时间
+            long earliestTime = Long.MAX_VALUE;
+            for (int i = 0; i < trackCount; i++) {
+                if ((mCurrentTrack == -1 || mCurrentTrack == i) 
+                    && !mTracks[i].isMuted() 
+                    && mTracks[i].hasNextEvent()) {
+                    earliestTime = Math.min(earliestTime, trackNextEventTime[i]);
+                }
+            }
+
+            if (earliestTime == Long.MAX_VALUE) {
+                LogUtils.d(TAG, "所有轨道事件播放完毕");
+                break;
+            }
+
+            // 计算等待时间并休眠
+            long currentTime = System.currentTimeMillis() - startTime;
+            long delay = earliestTime - currentTime;
+            if (delay > 0) {
+                try {
+                    Thread.sleep(delay);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
+
+            // 播放所有到达时间点的事件
+            for (int i = 0; i < trackCount; i++) {
+                if ((mCurrentTrack == -1 || mCurrentTrack == i) 
+                    && !mTracks[i].isMuted() 
+                    && mTracks[i].hasNextEvent() 
+                    && trackNextEventTime[i] == earliestTime) {
+
+                    MidiEvent event = mTracks[i].nextEvent();
+                    if (event != null) {
+                        try {
+                            logMidiEventDetails(i, event);
+                            mInputPort.send(event.data, 0, event.data.length);
+                            // 更新下一事件时间
+                            trackNextEventTime[i] = earliestTime + (long) (event.deltaTicks * msPerTick);
+                        } catch (IOException e) {
+                            LogUtils.d(TAG, "发送事件失败: " + e.getMessage());
+                        }
+                    }
+                }
+            }
+        }
+
+        isPlaying = false;
+        LogUtils.d(TAG, "播放结束");
+    }
+
+
+    /**
+     * 解析MIDI事件并输出详细日志
+     */
+    private void logMidiEventDetails(int trackIndex, MidiEvent event) {
+        // 无效事件增加原始数据日志，便于调试
+        if (event.data == null || event.data.length < 2) {
+            String dataStr = (event.data != null) ? Arrays.toString(event.data) : "null";
+            LogUtils.d(TAG, "轨道[" + trackIndex + "] 无效事件: 数据长度不足 (" 
+					   + (event.data != null ? event.data.length : 0) + "字节)，原始数据: " + dataStr);
+            return;
+        }
+
+        int statusByte = event.data[0] & 0xFF;
+        int eventType = statusByte & 0xF0;
+        int channel = (statusByte & 0x0F) + 1; // 通道号1-16
+
+        StringBuilder log = new StringBuilder();
+        log.append("轨道[").append(trackIndex).append("] 事件类型: ");
+
+        switch (eventType) {
+            case 0x90: // 音符开启
+                if (event.data.length >= 3) {
+                    int pitch = event.data[1] & 0xFF;
+                    int velocity = event.data[2] & 0xFF;
+                    log.append("音符开启 | 通道: ").append(channel)
+                        .append(" | 音高: ").append(pitch).append(" (").append(getNoteName(pitch)).append(")")
+                        .append(" | 力度: ").append(velocity)
+                        .append(" | 间隔ticks: ").append(event.deltaTicks)
+                        .append(" | 播放时间: ").append(System.currentTimeMillis() - startTime).append("ms");
+                } else {
+                    log.append("音符开启 (数据不完整) | 长度: ").append(event.data.length);
+                }
+                break;
+
+            case 0x80: // 音符关闭
+                if (event.data.length >= 3) {
+                    int pitch = event.data[1] & 0xFF;
+                    int velocity = event.data[2] & 0xFF;
+                    log.append("音符关闭 | 通道: ").append(channel)
+                        .append(" | 音高: ").append(pitch).append(" (").append(getNoteName(pitch)).append(")")
+                        .append(" | 力度: ").append(velocity)
+                        .append(" | 间隔ticks: ").append(event.deltaTicks)
+                        .append(" | 播放时间: ").append(System.currentTimeMillis() - startTime).append("ms");
+                } else {
+                    log.append("音符关闭 (数据不完整) | 长度: ").append(event.data.length);
+                }
+                break;
+
+            case 0xB0: // 控制变化
+                if (event.data.length >= 3) {
+                    int controlNumber = event.data[1] & 0xFF;
+                    int controlValue = event.data[2] & 0xFF;
+                    log.append("控制变化 | 通道: ").append(channel)
+                        .append(" | 控制器: ").append(controlNumber).append(" (").append(getControlName(controlNumber)).append(")")
+                        .append(" | 数值: ").append(controlValue);
+                } else {
+                    log.append("控制变化 (数据不完整) | 长度: ").append(event.data.length);
+                }
+                break;
+
+            case 0xC0: // 程序改变（乐器切换）
+                if (event.data.length >= 2) {
+                    int program = event.data[1] & 0xFF;
+                    // 增加乐器编号有效性校验日志
+                    String instrumentName = getInstrumentName(program);
+                    if (program < 0 || program >= 128) {
+                        instrumentName += " (超出GM标准范围0-127)";
+                    }
+                    log.append("程序改变 | 通道: ").append(channel)
+                        .append(" | 乐器编号: ").append(program).append(" (").append(instrumentName).append(")");
+                } else {
+                    log.append("程序改变 (数据不完整) | 长度: ").append(event.data.length);
+                }
+                break;
+
+            case 0xD0: // 通道触后事件
+                log.append("通道触后 | 通道: ").append(channel)
+                    .append(" | 压力值: ").append(event.data[1] & 0xFF);
+                break;
+
+            case 0xF0: // 系统专属事件(SysEx)
+                log.append("系统专属事件(SysEx) | 长度: ").append(event.data.length)
+                    .append(" | 首字节: 0x").append(Integer.toHexString(event.data[0] & 0xFF));
+                break;
+
+            default:
+                log.append("未知类型 (0x").append(Integer.toHexString(eventType)).append(") | 通道: ").append(channel)
+                    .append("，原始数据: ").append(Arrays.toString(event.data));
+                break;
+        }
+
+        LogUtils.d(TAG, log.toString());
+    }
+
+
+    /**
+     * 音高转音符名称（如60→C4）
+     */
+    private String getNoteName(int pitch) {
+        if (pitch < 0 || pitch > 127) return "无效音高";
+        String[] noteNames = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
+        int octave = (pitch / 12) - 1; // C4对应60
+        return noteNames[pitch % 12] + octave;
+    }
+
+
+    /**
+     * MIDI控制器编号转名称
+     */
+    private String getControlName(int controlNumber) {
+        switch (controlNumber) {
+            case 0: return "Bank Select (MSB)";
+            case 1: return "Modulation Wheel";
+            case 7: return "音量控制";
+            case 10: return "声像控制";
+            case 11: return "表达控制";
+            case 64: return "延音踏板";
+            case 121: return "重置所有控制器";
+            default: return "未知控制器";
+        }
+    }
+
+
+    /**
+     * 乐器编号转名称（GM标准）
+     */
+    private String getInstrumentName(int program) {
+        String[] instruments = {
+            "钢琴", "明亮钢琴", "电钢琴", "Honky-tonk钢琴", "电钢琴", "羽管键琴", 
+            "击弦古钢琴", "颤音琴", "竖琴", "管风琴", "手风琴", "acoustic贝斯", 
+            "电贝斯(指弹)", "电贝斯(拨片)", "小提琴", "大提琴"
+        };
+        if (program < 0 || program >= 128) {
+            return "无效编号";
+        }
+        if (program < instruments.length) {
+            return instruments[program];
+        } else {
+            return "乐器 " + program;
+        }
+    }
+
+
+    /**
+     * 连接MIDI合成器
+     */
+    public void connectToSynth() {
+        if (mMidiManager == null) return;
+        closeMidiResources();
+        searchSynthInDevices();
+    }
+
+    /**
+     * 搜索并选择可用的MIDI设备
+     */
+    private void searchSynthInDevices() {
+        MidiDeviceInfo[] devices = mMidiManager.getDevices();
+        if (devices == null || devices.length == 0) {
+            LogUtils.d(TAG, "未检测到MIDI设备");
+            isSynthConnected = false;
+            return;
+        }
+
+        // 优先选择合成器类型（3），其次选择有输入端口的设备
+        MidiDeviceInfo targetDevice = null;
+        for (MidiDeviceInfo device : devices) {
+            if (device.getType() == 3) {
+                targetDevice = device;
+                break;
+            }
+            if (targetDevice == null && device.getInputPortCount() > 0) {
+                targetDevice = device;
+            }
+        }
+
+        if (targetDevice != null) {
+            LogUtils.d(TAG, "尝试打开设备: 设备ID=" + targetDevice.getId() + "，名称=" + targetDevice.getProperties().getString(MidiDeviceInfo.PROPERTY_NAME));
+            mMidiManager.openDevice(targetDevice, new MidiManager.OnDeviceOpenedListener() {
+					@Override
+					public void onDeviceOpened(MidiDevice device) {
+						setupMidiDevice(device);
+					}
+				}, mHandler);
+        } else {
+            LogUtils.d(TAG, "未找到可用设备（无合成器或带输入端口的设备）");
+            isSynthConnected = false;
+        }
+    }
+
+
+    /**
+     * 初始化MIDI设备并打开输入端口
+     */
+    private void setupMidiDevice(MidiDevice device) {
+        if (device == null) {
+            LogUtils.d(TAG, "打开MIDI设备失败: 设备为null");
+            isSynthConnected = false;
+            return;
+        }
+
+        mMidiDevice = device;
+        try {
+            // 从设备信息中获取输入端口数量
+            MidiDeviceInfo deviceInfo = device.getInfo();
+            if (deviceInfo.getInputPortCount() > 0) {
+                mInputPort = device.openInputPort(0);
+                isSynthConnected = (mInputPort != null);
+                LogUtils.d(TAG, isSynthConnected ? "成功打开输入端口（端口0）" : "输入端口为null，打开失败");
+            } else {
+                LogUtils.d(TAG, "设备无输入端口，无法接收MIDI事件");
+                isSynthConnected = false;
+            }
+        } catch (Exception e) {
+            LogUtils.d(TAG, "打开端口失败: " + e.getMessage());
+            isSynthConnected = false;
+        }
+    }
+
+
+    /**
+     * 关闭MIDI设备及端口资源
+     */
+    private void closeMidiResources() {
+        if (mInputPort != null) {
+            try {
+                mInputPort.close();
+            } catch (IOException e) {
+                LogUtils.d(TAG, "关闭输入端口失败: " + e.getMessage());
+            }
+            mInputPort = null;
+        }
+        if (mMidiDevice != null) {
+            try {
+                mMidiDevice.close();
+            } catch (IOException e) {
+                LogUtils.d(TAG, "关闭MIDI设备失败: " + e.getMessage());
+            }
+            mMidiDevice = null;
+        }
+    }
+
+
+    /**
+     * 通知合成器连接结果
+     */
+    private void notifyConnectionResult(final boolean success) {
+        if (mConnectionListener != null) {
+            mHandler.post(new Runnable() {
+					@Override
+					public void run() {
+						mConnectionListener.onConnected(success);
+					}
+				});
+        }
+    }
+
+
+    /**
+     * 设置指定轨道静音状态
+     * @param trackIndex 轨道索引
+     * @param mute 是否静音
+     */
+    public void setTrackMute(int trackIndex, boolean mute) {
+        if (mTracks == null) {
+            LogUtils.d(TAG, "设置静音失败：未加载MIDI轨道");
+            return;
+        }
+        if (trackIndex >= 0 && trackIndex < mTracks.length) {
+            mTracks[trackIndex].setMute(mute);
+            LogUtils.d(TAG, "轨道[" + trackIndex + "] 静音状态: " + (mute ? "已静音" : "正常播放"));
+        } else {
+            LogUtils.d(TAG, "设置静音失败：无效轨道索引 " + trackIndex + "（总轨道数：" + mTracks.length + "）");
+        }
+    }
+
+
+    /**
+     * 切换当前播放轨道（-1表示所有轨道）
+     * @param trackIndex 轨道索引
+     */
+    public void setCurrentTrack(int trackIndex) {
+        if (mTracks == null) {
+            LogUtils.d(TAG, "切换轨道失败：未加载MIDI轨道");
+            return;
+        }
+        // 校验轨道索引有效性
+        if (trackIndex == -1 || (trackIndex >= 0 && trackIndex < mTracks.length)) {
+            mCurrentTrack = trackIndex;
+            LogUtils.d(TAG, "切换当前播放轨道: " + (trackIndex == -1 ? "所有轨道" : "轨道[" + trackIndex + "]"));
+        } else {
+            LogUtils.d(TAG, "切换轨道失败：无效轨道索引 " + trackIndex + "（总轨道数：" + mTracks.length + "）");
+        }
+    }
+
+
+    /**
+     * 获取轨道总数
+     * @return 轨道数量
+     */
+    public int getTrackCount() {
+        return mTracks != null ? mTracks.length : 0;
+    }
+
+
+    /**
+     * 暂停播放
+     */
+    public void pause() {
+        boolean wasPlaying = isPlaying;
+        isPlaying = false;
+        LogUtils.d(TAG, "播放暂停: " + (wasPlaying ? "已暂停当前播放" : "当前未在播放"));
+    }
+
+
+    /**
+     * 停止播放并释放所有资源
+     */
+    public void stop() {
+        boolean wasPlaying = isPlaying;
+        isPlaying = false;
+        isSynthConnected = false;
+        closeMidiResources();
+        if (mExecutor != null) {
+            mExecutor.shutdownNow();
+            mExecutor = null;
+        }
+        LogUtils.d(TAG, "播放停止: " + (wasPlaying ? "已终止播放并释放资源" : "当前未在播放"));
+    }
+
+
+    /**
+     * 获取线程池（单例）
+     */
+    private ExecutorService getExecutor() {
+        if (mExecutor == null || mExecutor.isShutdown() || mExecutor.isTerminated()) {
+            mExecutor = Executors.newSingleThreadExecutor();
+        }
+        return mExecutor;
+    }
+
+
+    /**
+     * 检查合成器是否已连接
+     * @return 连接状态
+     */
+    public boolean isSynthConnected() {
+        return isSynthConnected;
+    }
+
+
+    /**
+     * 获取当前MIDI输入端口
+     * @return 输入端口
+     */
+    public MidiInputPort getInputPort() {
+        return mInputPort;
+    }
+}

midiplayer/src/main/java/cc/winboll/studio/midiplayer/MidiPlayerActivity.java

@@ -0,0 +1,437 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen&豆包大模型<zhangsken@188.com>
+ * @Date 2025/06/29 10:10
+ * @Describe Midi 播放窗口
+ */
+import android.app.Activity;
+import android.content.Context;
+import android.media.midi.MidiInputPort;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.ListView;
+import android.widget.SeekBar;
+import android.widget.TextView;
+import cc.winboll.studio.libappbase.LogUtils;
+import com.hjq.toast.ToastUtils;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class MidiPlayerActivity extends WinBoLLActivity {
+
+    public static final String TAG = "MidiPlayerActivity";
+
+    private MidiPlayer mMidiPlayer;
+    private Button mPlayBtn, mPauseBtn, mStopBtn, mTestBtn;
+    private ListView mTrackListView;
+    private ListView mFileListView;
+    private TrackAdapter mTrackAdapter;
+    private TextView mFileNameTv;
+    private List<File> mMidiFileList = new ArrayList<>();
+
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_midi_player);
+
+        // 初始化控件
+        mPlayBtn = (Button) findViewById(R.id.btn_play);
+        mPauseBtn = (Button) findViewById(R.id.btn_pause);
+        mStopBtn = (Button) findViewById(R.id.btn_stop);
+        mTestBtn = (Button) findViewById(R.id.btn_test);
+        mTrackListView = (ListView) findViewById(R.id.lv_tracks);
+        mFileListView = (ListView) findViewById(R.id.lv_midi_files);
+        mFileNameTv = (TextView) findViewById(R.id.tv_file_name);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            initMidiPlayer();
+            loadMidiFileList();
+            initControlButtons();
+            initTestButton();
+        } else {
+            mFileNameTv.setText("当前设备不支持MIDI播放（需Android 6.0及以上）");
+            disableButtons();
+        }
+
+        copyAssetsMidiFiles();
+    }
+
+    // 初始化测试按钮及1分钟测试逻辑
+    private void initTestButton() {
+        mTestBtn.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					testMidiOutput();
+				}
+			});
+    }
+
+    /**
+     * 1分钟MIDI测试序列：包含多样音符组合，验证输出功能
+     */
+    private void testMidiOutput() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            ToastUtils.show("测试需要Android 6.0及以上");
+            return;
+        }
+
+        if (mMidiPlayer == null) {
+            initMidiPlayer();
+        }
+
+        new Thread(new Runnable() {
+				@Override
+				public void run() {
+					// 确保合成器连接
+					if (!mMidiPlayer.isSynthConnected()) {
+						LogUtils.d(TAG, "测试：连接合成器中...");
+						mMidiPlayer.connectToSynth();
+
+						// 最多等待3秒连接
+						int waitCount = 0;
+						while (!mMidiPlayer.isSynthConnected() && waitCount < 30) {
+							try {
+								Thread.sleep(100);
+							} catch (InterruptedException e) {
+								Thread.currentThread().interrupt();
+								return;
+							}
+							waitCount++;
+						}
+					}
+
+					final MidiInputPort inputPort = mMidiPlayer.getInputPort();
+					if (inputPort == null) {
+						LogUtils.d(TAG, "测试失败：无可用输入端口");
+						runOnUiThread(new Runnable() {
+								@Override
+								public void run() {
+									ToastUtils.show("测试失败：未找到输入端口");
+								}
+							});
+						return;
+					}
+
+					try {
+						runOnUiThread(new Runnable() {
+								@Override
+								public void run() {
+									ToastUtils.show("开始1分钟测试音符...");
+								}
+							});
+
+						// 测试序列定义：[音高, 力度, 时长(毫秒)]
+						int[][] noteSequence = {
+							// 0-10秒：低音区短音符
+							{48, 64, 200}, {50, 64, 200}, {52, 64, 200}, {53, 64, 200},
+							{55, 64, 200}, {57, 64, 200}, {59, 64, 200}, {60, 64, 400},
+
+							// 10-20秒：中音区连音
+							{60, 72, 300}, {62, 72, 300}, {64, 72, 300}, {65, 72, 300},
+							{67, 72, 300}, {69, 72, 300}, {71, 72, 300}, {72, 72, 600},
+
+							// 20-30秒：高音区跳音
+							{72, 80, 150}, {76, 80, 150}, {79, 80, 150}, {84, 80, 300},
+							{79, 80, 150}, {76, 80, 150}, {72, 80, 150}, {69, 80, 450},
+
+							// 30-40秒：和弦组合
+							{60, 64, 400}, {64, 64, 400}, {67, 64, 400}, // C和弦
+							{62, 64, 400}, {65, 64, 400}, {69, 64, 400}, // Dm和弦
+							{64, 64, 400}, {67, 64, 400}, {71, 64, 400}, // Em和弦
+
+							// 40-50秒：渐强长音
+							{55, 40, 1000}, {55, 60, 1000}, {55, 80, 1000}, {55, 100, 1000},
+
+							// 50-60秒：快速音阶
+							{50, 70, 100}, {52, 70, 100}, {53, 70, 100}, {55, 70, 100},
+							{57, 70, 100}, {59, 70, 100}, {60, 70, 100}, {62, 70, 100},
+							{64, 70, 100}, {65, 70, 100}, {67, 70, 100}, {69, 70, 100},
+							{71, 70, 100}, {72, 90, 500}
+						};
+
+						// 发送测试序列
+						for (int[] note : noteSequence) {
+							if (!mMidiPlayer.isSynthConnected()) {
+								LogUtils.d(TAG, "连接已断开，停止测试");
+								break;
+							}
+
+							int pitch = note[0];
+							int velocity = note[1];
+							int duration = note[2];
+
+							// 发送音符开启事件
+							byte[] noteOn = new byte[]{(byte) 0x90, (byte) pitch, (byte) velocity};
+							inputPort.send(noteOn, 0, noteOn.length);
+							//LogUtils.d(TAG, "测试音符：音高=" + pitch + ", 力度=" + velocity + ", 时长=" + duration + "ms");
+
+							// 等待音符时长
+							Thread.sleep(duration);
+
+							// 发送音符关闭事件
+							byte[] noteOff = new byte[]{(byte) 0x80, (byte) pitch, 0};
+							inputPort.send(noteOff, 0, noteOff.length);
+						}
+
+						runOnUiThread(new Runnable() {
+								@Override
+								public void run() {
+									ToastUtils.show("1分钟测试完成");
+								}
+							});
+
+					} catch (final Exception e) {
+						LogUtils.d(TAG, "测试出错：" + e.getMessage());
+						runOnUiThread(new Runnable() {
+								@Override
+								public void run() {
+									ToastUtils.show("测试出错：" + e.getMessage());
+								}
+							});
+					}
+				}
+			}).start();
+    }
+
+    // 拷贝Assets中的MIDI文件到本地
+    private void copyAssetsMidiFiles() {
+        final AssetMidiCopier copier = new AssetMidiCopier(this);
+        new Thread(new Runnable() {
+				@Override
+				public void run() {
+					final boolean success = copier.copyMidiFiles();
+					runOnUiThread(new Runnable() {
+							@Override
+							public void run() {
+								if (success) {
+									File midiDir = copier.getMidiTargetDir();
+									LogUtils.d(TAG, "MIDI文件拷贝成功，路径：" + midiDir.getAbsolutePath());
+									// 重新加载文件列表
+									loadMidiFileList();
+								} else {
+									ToastUtils.show("MIDI文件拷贝失败");
+								}
+							}
+						});
+				}
+			}).start();
+    }
+
+    // 初始化MIDI播放器
+    private void initMidiPlayer() {
+        mMidiPlayer = new MidiPlayer(this);
+        mMidiPlayer.setOnSynthConnectedListener(new MidiPlayer.OnSynthConnectedListener() {
+				@Override
+				public void onConnected(final boolean success) {
+					runOnUiThread(new Runnable() {
+							@Override
+							public void run() {
+								if (success) {
+									ToastUtils.show("MIDI合成器连接成功");
+								} else {
+									ToastUtils.show("未找到MIDI合成器，请安装第三方合成器应用");
+								}
+							}
+						});
+				}
+			});
+    }
+
+    // 加载本地MIDI文件列表
+    private void loadMidiFileList() {
+        File midiDir = new File(getFilesDir(), "midi");
+        if (!midiDir.exists()) {
+            midiDir.mkdirs();
+            mFileNameTv.setText("midi目录已创建，等待文件拷贝...");
+            return;
+        }
+
+        mMidiFileList.clear();
+        File[] files = midiDir.listFiles();
+        if (files != null) {
+            for (File file : files) {
+                String name = file.getName().toLowerCase();
+                if (name.endsWith(".mid") || name.endsWith(".midi")) {
+                    mMidiFileList.add(file);
+                }
+            }
+        }
+
+        if (mMidiFileList.isEmpty()) {
+            mFileNameTv.setText("midi目录中无可用文件");
+        } else {
+            showFileList();
+            mFileNameTv.setText("找到" + mMidiFileList.size() + "个MIDI文件");
+        }
+    }
+
+    // 显示MIDI文件列表
+    private void showFileList() {
+        List<String> fileNameList = new ArrayList<>();
+        for (File file : mMidiFileList) {
+            fileNameList.add(file.getName());
+        }
+
+        ArrayAdapter<String> adapter = new ArrayAdapter<String>(
+			this,
+			android.R.layout.simple_list_item_1,
+			fileNameList
+        );
+        mFileListView.setAdapter(adapter);
+
+        mFileListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+				@Override
+				public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+					mMidiPlayer.stop();
+					File selectedFile = mMidiFileList.get(position);
+					boolean loaded = mMidiPlayer.loadMidiFile(selectedFile);
+					if (loaded) {
+						mFileNameTv.setText("当前文件：" + selectedFile.getName());
+						initTrackList();
+						ToastUtils.show("已加载：" + selectedFile.getName());
+					} else {
+						mFileNameTv.setText("文件加载失败：" + selectedFile.getName());
+					}
+				}
+			});
+    }
+
+    // 初始化轨道列表
+    private void initTrackList() {
+        mTrackAdapter = new TrackAdapter(this, mMidiPlayer);
+        mTrackListView.setAdapter(mTrackAdapter);
+    }
+
+    // 初始化播放控制按钮
+    private void initControlButtons() {
+        mPlayBtn.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					if (mMidiPlayer != null) {
+						mMidiPlayer.start();
+					}
+				}
+			});
+
+        mPauseBtn.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					if (mMidiPlayer != null) {
+						mMidiPlayer.pause();
+					}
+				}
+			});
+
+        mStopBtn.setOnClickListener(new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					if (mMidiPlayer != null) {
+						mMidiPlayer.stop();
+					}
+				}
+			});
+    }
+
+    // 禁用所有按钮（低版本设备）
+    private void disableButtons() {
+        mPlayBtn.setEnabled(false);
+        mPauseBtn.setEnabled(false);
+        mStopBtn.setEnabled(false);
+        mTestBtn.setEnabled(false);
+    }
+
+    // 轨道列表适配器
+    private class TrackAdapter extends android.widget.BaseAdapter {
+        private Context mContext;
+        private MidiPlayer mPlayer;
+
+        public TrackAdapter(Context context, MidiPlayer player) {
+            mContext = context;
+            mPlayer = player;
+        }
+
+        @Override
+        public int getCount() {
+            return mPlayer != null ? mPlayer.getTrackCount() : 0;
+        }
+
+        @Override
+        public Object getItem(int position) {
+            return null;
+        }
+
+        @Override
+        public long getItemId(int position) {
+            return position;
+        }
+
+        @Override
+        public View getView(final int position, View convertView, ViewGroup parent) {
+            View view = getLayoutInflater().inflate(R.layout.item_track, parent, false);
+            TextView trackNameTv = (TextView) view.findViewById(R.id.tv_track_name);
+            final Button muteBtn = (Button) view.findViewById(R.id.btn_mute);
+            SeekBar volumeSb = (SeekBar) view.findViewById(R.id.sb_volume);
+
+            trackNameTv.setText("轨道 " + (position + 1));
+            muteBtn.setText("静音");
+
+            // 静音按钮逻辑
+            muteBtn.setOnClickListener(new View.OnClickListener() {
+					@Override
+					public void onClick(View v) {
+						boolean isMuted = muteBtn.isSelected();
+						mPlayer.setTrackMute(position, !isMuted);
+						muteBtn.setSelected(!isMuted);
+						muteBtn.setText(isMuted ? "静音" : "已静音");
+					}
+				});
+
+            // 音量条（预留逻辑）
+            volumeSb.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
+					@Override
+					public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
+						// 可添加音量控制逻辑（如发送MIDI音量事件）
+					}
+
+					@Override
+					public void onStartTrackingTouch(SeekBar seekBar) {}
+
+					@Override
+					public void onStopTrackingTouch(SeekBar seekBar) {}
+				});
+
+            return view;
+        }
+    }
+
+    // 日志查看按钮点击事件
+    public void onLog(View view) {
+        App.getWinBoLLActivityManager().startLogActivity(this);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        if (mMidiPlayer != null) {
+            mMidiPlayer.stop();
+        }
+    }
+}
+

midiplayer/src/main/java/cc/winboll/studio/midiplayer/MidiTrack.java

@@ -0,0 +1,78 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:24
+ * @Describe Midi轨道类，用于存储和管理单条Midi轨道的事件
+ */
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class MidiTrack {
+	public static final String TAG = "MidiTrack";
+
+	// 轨道事件列表（存储Midi事件字节数组）
+	private List<byte[]> mEvents = new ArrayList<>();
+	// 事件迭代器（用于播放时遍历事件）
+	private Iterator<byte[]> mEventIterator;
+	// 轨道是否静音
+	private boolean isMuted = false;
+
+	public MidiTrack() {
+	}
+
+	/**
+	 * 添加Midi事件到轨道
+	 */
+	public void addEvent(byte[] event) {
+		mEvents.add(event);
+	}
+
+	/**
+	 * 重置轨道播放状态（回到起始位置）
+	 */
+	public void reset() {
+		mEventIterator = mEvents.iterator();
+	}
+
+	/**
+	 * 判断是否有下一个事件
+	 */
+	public boolean hasNextEvent() {
+		// 如果静音，返回false不播放事件
+		if (isMuted) {
+			return false;
+		}
+		// 初始化迭代器（首次使用或重置后）
+		if (mEventIterator == null) {
+			reset();
+		}
+		return mEventIterator.hasNext();
+	}
+
+	/**
+	 * 获取下一个Midi事件
+	 */
+	public byte[] nextEvent() {
+		if (mEventIterator == null) {
+			reset();
+		}
+		return mEventIterator.next();
+	}
+
+	/**
+	 * 设置轨道静音状态
+	 */
+	public void setMute(boolean mute) {
+		isMuted = mute;
+	}
+
+	/**
+	 * 获取轨道事件数量
+	 */
+	public int getEventCount() {
+		return mEvents.size();
+	}
+}
+

midiplayer/src/main/java/cc/winboll/studio/midiplayer/SoundFontManager.java

@@ -0,0 +1,59 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:12
+ * @Describe SoundFontManager
+ */
+import android.content.Context;
+import android.util.Log;
+import cc.winboll.studio.libappbase.LogUtils;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+// 简化版：实际需使用SoundFont解析库（如Audiokit、FluidSynth）
+public class SoundFontManager {
+
+    public static final String TAG = "SoundFontManager";
+
+	private Context mContext;
+    private File mSoundFontFile;
+
+    public SoundFontManager(Context context) {
+        mContext = context;
+    }
+
+    // 加载SoundFont文件（.sf2格式）
+    public boolean loadSoundFont(File file) {
+        if (!file.exists() || !file.getName().endsWith(".sf2")) {
+            LogUtils.d(TAG, "无效的SoundFont文件");
+            return false;
+        }
+        // 复制到应用私有目录（可选）
+        try {
+            File dest = new File(mContext.getFilesDir(), "custom_soundfont.sf2");
+            FileInputStream fis = new FileInputStream(file);
+            FileOutputStream fos = new FileOutputStream(dest);
+            byte[] buffer = new byte[1024];
+            int len;
+            while ((len = fis.read(buffer)) != -1) {
+                fos.write(buffer, 0, len);
+            }
+            fis.close();
+            fos.close();
+            mSoundFontFile = dest;
+            return true;
+        } catch (IOException e) {
+            LogUtils.d(TAG, "复制SoundFont失败: " + e.getMessage());
+            return false;
+        }
+    }
+
+    // 获取加载的SoundFont路径（供合成器使用）
+    public String getSoundFontPath() {
+        return mSoundFontFile != null ? mSoundFontFile.getAbsolutePath() : null;
+    }
+}
+

midiplayer/src/main/java/cc/winboll/studio/midiplayer/WinBoLLActivity.java

@@ -0,0 +1,60 @@
+package cc.winboll.studio.midiplayer;
+
+/**
+ * @Author ZhanGSKen<zhangsken@188.com>
+ * @Date 2025/06/29 10:40
+ * @Describe WinBoLLActivity
+ */
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.MenuItem;
+import androidx.appcompat.app.AppCompatActivity;
+import cc.winboll.studio.libappbase.GlobalApplication;
+import cc.winboll.studio.libappbase.LogUtils;
+import cc.winboll.studio.libappbase.winboll.IWinBoLLActivity;
+
+public class WinBoLLActivity extends AppCompatActivity implements IWinBoLLActivity {
+
+    public static final String TAG = "WinBoLLActivity";
+
+    @Override
+    public Activity getActivity() {
+        return this;
+    }
+
+    @Override
+    public String getTag() {
+        return TAG;
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        LogUtils.d(TAG, String.format("onResume %s", getTag()));
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        /*if (item.getItemId() == R.id.item_log) {
+		 GlobalApplication.getWinBoLLActivityManager().startLogActivity(this);
+		 return true;
+		 } else if (item.getItemId() == R.id.item_home) {
+		 GlobalApplication.getWinBoLLActivityManager().startWinBoLLActivity(getApplicationContext(), MainActivity.class);
+		 return true;
+		 }*/
+        // 在switch语句中处理每个ID，并在处理完后返回true，未处理的情况返回false。
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    protected void onPostCreate(Bundle savedInstanceState) {
+        super.onPostCreate(savedInstanceState);
+        GlobalApplication.getWinBoLLActivityManager().add(this);
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        GlobalApplication.getWinBoLLActivityManager().registeRemove(this);
+    }
+}

midiplayer/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -0,0 +1,34 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportHeight="108"
+    android:viewportWidth="108">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="78.5885"
+                android:endY="90.9159"
+                android:startX="48.7653"
+                android:startY="61.0927"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+        android:strokeColor="#00000000"
+        android:strokeWidth="1" />
+</vector>

midiplayer/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportHeight="108"
+    android:viewportWidth="108">
+    <path
+        android:fillColor="#26A69A"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeColor="#33FFFFFF"
+        android:strokeWidth="0.8" />
+</vector>

midiplayer/src/main/res/layout/activity_main.xml

@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	xmlns:app="http://schemas.android.com/apk/res-auto"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:orientation="vertical">
+
+	<com.google.android.material.appbar.AppBarLayout
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
+
+		<androidx.appcompat.widget.Toolbar
+			android:id="@+id/toolbar"
+			android:layout_width="match_parent"
+			android:layout_height="?attr/actionBarSize"
+			app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>
+
+	</com.google.android.material.appbar.AppBarLayout>
+
+	<LinearLayout
+		android:orientation="vertical"
+		android:layout_width="match_parent"
+		android:layout_height="0dp"
+		android:layout_weight="1.0"
+		android:gravity="center_vertical|center_horizontal">
+
+		<TextView
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="MidiPlayer"
+			android:textAppearance="?android:attr/textAppearanceLarge"/>
+
+		<Button
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="OpenMidiPlayer"
+			android:onClick="onOpenMidiPlayer"/>
+
+	</LinearLayout>
+
+	<LinearLayout
+		android:orientation="vertical"
+		android:layout_width="match_parent"
+		android:layout_height="0dp"
+		android:layout_weight="1.0">
+
+		<cc.winboll.studio.libappbase.LogView
+			android:layout_width="match_parent"
+			android:layout_height="match_parent"
+			android:id="@+id/logview"/>
+
+	</LinearLayout>
+
+</LinearLayout>
+

midiplayer/src/main/res/layout/activity_midi_player.xml

@@ -0,0 +1,91 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:layout_width="match_parent"
+	android:layout_height="match_parent"
+	android:orientation="vertical">
+
+	<TextView
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:padding="8dp"
+		android:text="MIDI文件列表"
+		android:background="@android:color/darker_gray"/>
+
+	<ListView
+		android:id="@+id/lv_midi_files"
+		android:layout_width="match_parent"
+		android:layout_height="0dp"
+		android:layout_weight="1"/>
+
+	<TextView
+		android:id="@+id/tv_file_name"
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:padding="8dp"
+		android:text="未选择文件"
+		android:background="@android:color/holo_blue_light"/>
+
+	<TextView
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:padding="8dp"
+		android:text="轨道控制"
+		android:background="@android:color/darker_gray"/>
+
+	<ListView
+		android:id="@+id/lv_tracks"
+		android:layout_width="match_parent"
+		android:layout_height="0dp"
+		android:layout_weight="1"/>
+
+	<LinearLayout
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:gravity="center"
+		android:padding="16dp"
+		android:orientation="horizontal">
+
+		<Button
+			android:id="@+id/btn_play"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="播放"/>
+
+		<Button
+			android:id="@+id/btn_pause"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="暂停"/>
+
+		<Button
+			android:id="@+id/btn_stop"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="停止"/>
+
+	</LinearLayout>
+	<LinearLayout
+		android:layout_width="match_parent"
+		android:layout_height="wrap_content"
+		android:gravity="center"
+		android:padding="16dp"
+		android:orientation="horizontal">
+		
+		<Button
+			android:id="@+id/btn_test"
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="测试音符"
+			android:layout_below="@id/btn_stop"/>
+
+		<Button
+			android:layout_width="wrap_content"
+			android:layout_height="wrap_content"
+			android:text="Log"
+			android:onClick="onLog"/>
+
+	</LinearLayout>
+
+</LinearLayout>
+

midiplayer/src/main/res/layout/item_track.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center_vertical"
+    android:orientation="horizontal"
+    android:padding="16dp">
+
+    <TextView
+        android:id="@+id/tv_track_name"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"
+        android:text="轨道 1" />
+
+    <Button
+        android:id="@+id/btn_mute"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="静音" />
+
+    <Button
+        android:id="@+id/btn_solo"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="8dp"
+        android:text="独奏" />
+
+    <SeekBar
+        android:id="@+id/sb_volume"
+        android:layout_width="120dp"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="16dp"
+        android:max="100"
+        android:progress="80" />
+</LinearLayout>
+

midiplayer/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

midiplayer/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

midiplayer/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#009688</color>
+    <color name="colorPrimaryDark">#00796B</color>
+    <color name="colorAccent">#FF9800</color>
+</resources>

midiplayer/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<resources>
+    <string name="app_name">MidiPlayer</string>
+    
+</resources>

midiplayer/src/main/res/values/styles.xml

@@ -0,0 +1,11 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="MyAppTheme" parent="Theme.AppCompat.Light.NoActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+</resources>

midiplayer/src/stage/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools" >
+
+    <application>
+
+        <!-- Put flavor specific code here -->
+
+    </application>
+
+</manifest>
+

midiplayer/src/stage/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <!-- Put flavor specific strings here -->
+
+</resources>

settings.gradle-demo

@@ -57,3 +57,7 @@
 // NumTable 项目编译设置
 //include ':numtable'
 //rootProject.name = "numtable"
+
+// MidiPlayer 项目编译设置
+//include ':midiplayer'
+//rootProject.name = "midiplayer"