devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

自学 android_android studio22.2.1 linux

作者：笔触狂放9 | 2024-08-05 04:35:56

赞

踩

android studio22.2.1 linux

试了两天，不管是deepin 软件仓库自带的eclipse，还是java 版的idea，怎样安装android 都不成功，反正各样的错误。最后到android官网下载了最新的集成开发软件才成功。官网网址

https://developer.android.com/studio     下载了linux 版：android-studio-2022.2.1.20-linux.tar.gz

按照安装文档轻松安装。建议，最好让电脑科学上网，因为有很多个文件是从google网站上下载的。

还有最好不要用虚拟终端输出程序结果。因为速度很慢。找一个旧手机代替，速度快得多。

下面的代码是输入框的内容显示在文本框中。

以下的程序都采用的是Empty Views Activity 模板。

发现android编程，ui界面部分只要把布局编辑器练熟就行了，难的还是代码的事件处理部份。ui的很多控件初学都用不上，只要把三四个常用的搞熟就可以练代码了。

  1. package com.example.wz;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.widget.Button;
  6. import android.widget.EditText;
  7. import android.widget.TextView;
  8.  
  9. public class MainActivity extends AppCompatActivity {
  10.     @Override
  11.     protected void onCreate(Bundle savedInstanceState) {
  12.         super.onCreate(savedInstanceState);
  13.         setContentView(R.layout.activity_main);    //按照布局文件activity_main.xml 显示，估计此方法是不停刷新此文件的内容，所以程序不用再setContentView
  14.  
  15.         Button button=findViewById(R.id.button2);          //android 用findViewById 取得java的控件实例
  16.         EditText editText=findViewById(R.id.editTextText);  //editText 对应的布局编译器中为Plain Text   文本输入框
  17.         TextView textView=findViewById(R.id.textView3);
  18.  
  19.         button.setOnClickListener(view -> {                 //按键的响应
  20.             String s = String.valueOf(editText.getText());   //取文本框输入内容
  21.             textView.setText(s);
  22.         });
  23.     }
  24. }
  1. <uses-permission android:name="android.permission.INTERNET" />
  2. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

如要连接网络，必须在AndroidManifest.xml文件中加上此两句

下面的代码是连接服务器

  1. package com.example.wz;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.widget.Button;
  6. import android.widget.EditText;
  7. import android.widget.TextView;
  8.  
  9. import java.io.IOException;
  10. import java.io.InputStream;
  11. import java.io.ObjectInputStream;
  12. import java.net.Socket;
  13.  
  14. public class MainActivity extends AppCompatActivity {
  15.     @Override
  16.     protected void onCreate(Bundle savedInstanceState) {
  17.         super.onCreate(savedInstanceState);
  18.         setContentView(R.layout.activity_main);    //按照布局文件activity_main.xml 显示，估计此方法是不停刷新此文件的内容，所以程序多次setContentView（）。
  19.  
  20.         Button button=findViewById(R.id.button2);          //android 用findViewById 取得java的控件实例
  21.         EditText editText=findViewById(R.id.editTextText);  //editText 对应的布局编译器中为Plain Text   文本输入框
  22.         TextView textView=findViewById(R.id.textView3);
  23.  
  24.         button.setOnClickListener(view -> {                 //按键的响应
  25.         //    String s = String.valueOf(editText.getText());   //取文本框输入内容
  26.         //   textView.setText("接收数据");
  27.             try {
  28.                 Socket socket=new Socket("192.168.43.61",3000);
  29.                 InputStream inputStream=socket.getInputStream();
  30.                 ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
  31.                String s=objectInputStream.readUTF();
  32.                 textView.setText(s);
  33.                socket.close();
  34.             } catch (IOException e) {
  35.                 throw new RuntimeException(e);
  36.             }
  37.  
  38.         });
  39.     }
  40. }

注意：try  catch语句要注释掉throw new RunimeException(e);这句，否则一有错，程序就退出。有这个基础程序框架，就可以试试把java程序搬到手机上。

还有setContentView（）方法，估计安卓系统是定时不停地刷新桌面显示控件，有点像java的Timer，所以程序不用多次用此方法，一次就行了。

android 线程间传递数据，不能用java 线程的传递方法，如静态类变量就不能用。

  1. package com.example.wz;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.appcompat.app.AppCompatActivity;
  5.  
  6. import android.os.Bundle;
  7. import android.os.Handler;
  8. import android.os.Looper;
  9. import android.os.Message;
  10. import android.widget.Button;
  11. import android.widget.EditText;
  12. import android.widget.TextView;
  13.  
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.io.ObjectInputStream;
  17. import java.net.Socket;
  18.  
  19. public class MainActivity extends AppCompatActivity {
  20.     static Handler handler;
  21.     static TextView textView;
  22.  
  23.     @Override
  24.     protected void onCreate(Bundle savedInstanceState) {
  25.         super.onCreate(savedInstanceState);
  26.         setContentView(R.layout.activity_main);
  27.  
  28.         Button button = findViewById(R.id.button);
  29.         EditText editText = findViewById(R.id.editTextText);
  30.         textView = findViewById(R.id.textView);
  31.  
  32.         Handler.Callback hc=new Handler.Callback() {
  33.             @Override
  34.             public boolean handleMessage(@NonNull Message msg) {     //这里必须调用handle类的镶嵌类Handle.Callback的handleMessage方法。
  35.                 int t=msg.arg1;
  36.                 textView.setText(String.valueOf(t));
  37.                 return false;
  38.             }
  39.         };
  40.         handler =new Handler(Looper.myLooper(),hc);
  41.         button.setOnClickListener(view -> {
  42.             Th th = new Th();
  43.             th.start();
  44.         });
  45.     }
  46. }
  47. class Th extends Thread {
  48.         int t=0;
  49.         public void run() {
  50.             while (true) {
  51.                 Message message = new Message();
  52.                 message.arg1=t;
  53.                 MainActivity.handler.sendMessage(message);
  54.                 t++;
  55.                 try {
  56.                     Thread.sleep(1000);
  57.                 } catch (InterruptedException e) {
  58.                     //         throw new RuntimeException(e);
  59.                 }
  60.             }
  61.         }
  62. }
  63.  
  64.  
  65.  
  66.

此种传递数据的方法，数据的产生和ui显示是异步的。我理解有点像map 的键值对，这个ss就是键，接照键的对应关系，线程先把值存在”map”中，ui再取出此值显示。这样理解好记忆。

安卓的主线程最好只处现ui代码和事件响应代码，其他的java逻辑算法代码都不要放在主线程中，java代码最好放在响应事件的代码块中，或者放在其他子线程中。而且响应事件的代码耗时不能太久，更不能放循环等待的语句，如有这种耗时的代码，必须放在新线程中，用事件响应启动此线程。如按钮单击启动耗时线程。

其实这也是一个android编程通用方法，把ui代码放在主线程中，其他的一切逻辑代码另开一个线程完成，主线程用一个事件响应启动这个新线程，新线程的数据通过上面程序的方法传给主线程完成显示。这样处理事后容易理解看清思路。这是我自己的看法。当然你也可以在主线程中混编，只要能通过不报错。

看jdk学Handle

Handler 允许您发送和处理Message与线程关联的 Runnable 对象MessageQueue。每个 Handler 实例都与一个线程和该线程的消息队列相关联。当您创建一个新的处理程序时，它会绑定到一个Looper. 它会将消息和可运行对象传递到该 Looper 的消息队列，并在该 Looper 的线程上执行它们。

Handler 有两个主要用途：(1) 安排消息和可运行对象在未来某个时间点执行；(2) 将要在与您自己的线程不同的线程上执行的操作排队。

调度消息是通过 post(Runnable)、postAtTime(java.lang.Runnable, long)、 postDelayed(Runnable, Object, long)、sendEmptyMessage(int)、 sendMessage(Message)、sendMessageAtTime(Message, long)和 sendMessageDelayed(Message, long)方法完成的。post版本允许您将 Runnable 对象入队，以便在接收到消息队列时调用它们；sendMessage版本允许您将包含将由MessageHandler 的方法处理的数据包的对象排入队列handleMessage(Message)（要求您实现 Handler 的子类）。

发布或发送到处理程序时，您可以允许项目在消息队列准备就绪后立即处理，或者指定处理前的延迟或处理的绝对时间。后两者允许您实现超时、滴答和其他基于时间的行为。

handle post() 方法，发现只能更新一次，不知道是否正确

此方法代码很简单

  1. package com.example.wz;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.appcompat.app.AppCompatActivity;
  5.  
  6. import android.os.Bundle;
  7. import android.os.Handler;
  8. import android.os.Looper;
  9. import android.os.Message;
  10. import android.widget.Button;
  11. import android.widget.EditText;
  12. import android.widget.TextView;
  13.  
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.io.ObjectInputStream;
  17. import java.net.Socket;
  18.  
  19. public class MainActivity extends AppCompatActivity {
  20.     static Handler handler=new Handler();
  21.     static TextView textView;
  22.     @Override
  23.     protected void onCreate(Bundle savedInstanceState) {
  24.         super.onCreate(savedInstanceState);
  25.         setContentView(R.layout.activity_main);
  26.  
  27.         Button button = findViewById(R.id.button);
  28.         EditText editText = findViewById(R.id.editTextText);
  29.         textView = findViewById(R.id.textView);
  30.  
  31.         button.setOnClickListener(view -> {
  32.             Th th = new Th();
  33.             th.start();
  34.         });
  35.     }
  36. }
  37. class Th extends Thread {
  38.         public void run() {
  39.              MainActivity.handler.post(()->{
  40.                  MainActivity.textView.setText("hello nanning");
  41.              });
  42.         }
  43. }
  44.  
  45.  
  46.  
  47.

这里的handle实例必须放在主线程中，其实把它想成java场景中的静态类变量就好理解了。

如要循环，可以这样处理，但又不能加Thread.sleep()延时

  1.   class Th extends Thread {                       //刚实验，此post方法只能更新一次ui。如加循环，报错
  2.                 public void run () {
  3.                     while(true) {
  4.                         h.post(new Runnable() {
  5.                             public void run() {
  6.                                 textView.setText(String.valueOf(1));
  7.                             }
  8.                         });
  9.                             h.post(new Runnable() {
  10.                                 public void run() {
  11.                                     textView.setText(String.valueOf(2));
  12.                                 }
  13.                             });
  14.                     }
  15.             }
  16.         }

这个post方法虽然只能执行一次更新ui,也可编写许多场景的程序了。如连接服务器一次读取数据，输入网址读取网页文件，查询一次文件目录，如是线程不停传递数据则不能用此方法。

利用handle.post()连接服务器读取一次数据

  1. package com.example.wz;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.os.Bundle;
  6. import android.os.Handler;
  7. import android.os.Looper;
  8. import android.os.Message;
  9. import android.widget.Button;
  10. import android.widget.EditText;
  11. import android.widget.TextView;
  12.  
  13. import java.io.IOException;
  14. import java.io.InputStream;
  15. import java.io.ObjectInputStream;
  16. import java.net.Socket;
  17.  
  18. public class MainActivity extends AppCompatActivity {
  19.     static Handler h = new Handler();
  20.     static TextView textView;
  21.  
  22.     @Override
  23.     protected void onCreate(Bundle savedInstanceState) {
  24.         super.onCreate(savedInstanceState);
  25.         setContentView(R.layout.activity_main);
  26.  
  27.         Button button = findViewById(R.id.button);
  28.         EditText editText = findViewById(R.id.editTextText);
  29.         textView = findViewById(R.id.textView);
  30.  
  31.         button.setOnClickListener(view -> {
  32.             Th th = new Th();
  33.             th.start();
  34.         });
  35.     }
  36. }
  37. class Th extends Thread {                      //刚实验，此post方法只能更新一次ui。如加循环，报错
  38.     public void run() {
  39.         Socket socket= null;
  40.         String s;
  41.         try {
  42.             socket = new Socket("192.168.2.8",3000);
  43.             InputStream inputStream=socket.getInputStream();
  44.             ObjectInputStream objectInputStream=new 
  45.             ObjectInputStream(inputStream);
  46.             s=objectInputStream.readUTF();
  47.             MainActivity.h.post(new Runnable() {
  48.             public void run() {
  49.                 MainActivity.textView.setText(s);
  50.             }
  51.         });
  52.             objectInputStream.close();
  53.         } catch (IOException e) {
  54.             //      throw new RuntimeException(e);
  55.         }
  56.     }
  57. }
  58.  
  59.

手机要是上网，必须要在全局文件中加这俩句

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

=========================================================================

android  文件

参考出处：https://blog.csdn.net/huweiliyi/category_8913738.html

raw目录
asserts目录
data/data/包名
sdcard目录
其中raw下的和asserts下的文件可以以资源文件的形式读取，这些目录的数据只能读取，不能写入，两者目录下的文件在打包后会原封不动的保存在apk包中，不会被编译成二进制。
data/data/包名和sdcard目录文件可读可写。其中data/data/包名目录不需要申请权限,sdcard目录需要申请权限
读取文件要在全局文件中加这两句

<!--文件读写权限-->
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

data/data/(包名) 目录文件读写
将数据以普通文件的形式保存在 /data/data/包名中，该方法不需要申请权限。
存放在数据区(/data/data/包名)的文件可以使用openFileOutput和openFileInput进行操作。这两个类只能在主线程中使用。

data/data/包名/shared_prefs    存放SharedPreferences数据 

data/data/包名/databases        存放数据库数据

data/data/包名/files            存放普通数据

data/data/包名/cache             存放缓存文件

开发IDE 右边有一个Device File  Explorer   用它可以浏览手机的整个目录结构

可以用它看/data/data/ 有啥文件，再读取。

建立文件，发现只能在/data/data/本包名/下创建文件，在其他地方都报错。所以就不存在查找其他目录内容的必要，反正生成的文件必定在自己本程序的包名下。

还发现android的openFileOutput 不能在子线程中使用，只能在主线程中用。所以android的主线程也可编辑非ui代码。但主线程各种代码太多太杂，不好理解分析。网上一大批文章代码，本可以顺序写的，却搞几个类或方法跳过去跳过来，让人看的思路都中断了。

还有如用ide中的Device File  Explorer检验是否生成文件，执行程序后必须断开连接手机终端usb，再连接才会正确显示。

  1. package com.example.wz;
  2.  
  3. import static android.content.Context.MODE_PRIVATE;
  4. import androidx.appcompat.app.AppCompatActivity;
  5. import android.os.Bundle;
  6. import android.os.Handler;
  7. import android.widget.Button;
  8. import android.widget.EditText;
  9. import android.widget.TextView;
  10.  
  11. import java.io.File;
  12. import java.io.FileNotFoundException;
  13. import java.io.FileOutputStream;
  14. import java.io.IOException;
  15. public class MainActivity extends AppCompatActivity {
  16.     static Handler handler=new Handler();
  17.     static TextView textView;
  18.     @Override
  19.     protected void onCreate(Bundle savedInstanceState) {
  20.         super.onCreate(savedInstanceState);
  21.         setContentView(R.layout.activity_main);
  22.  
  23.         Button button = findViewById(R.id.button);
  24.         EditText editText = findViewById(R.id.editTextText);
  25.         textView = findViewById(R.id.textView);
  26.  
  27.         button.setOnClickListener(view -> {
  28.             Th th = new Th();
  29.             th.start();
  30.         });
  31.     }
  32. }
  33. class Th extends Thread {
  34.         public void run() {
  35.             String text = "hello nanning";
  36.             FileOutputStream fileOutputStream = null;
  37.             try {
  38.                 fileOutputStream = new FileOutputStream("/data/data/com.example.wz/2.txt");
  39.                fileOutputStream.write(text.getBytes());    //绝对路径
  40.                fileOutputStream.close();
  41.             MainActivity.handler.post(()->{
  42.                  MainActivity.textView.setText("file over");
  43.              });
  44.             } catch (IOException e) {
  45.                 throw new RuntimeException(e);
  46.             }
  47.         }
  48. }
  49.  
  50.  
  51.  
  52.

所以，现在发现想给手机编一个程序，自由上传下载图片到手机的图库是不可能的，因为android的权限太多太大。自编程序只有在自己的包内操作的权限。所以想到手机root解锁，是不是就是把全手机的文件都改成可以读写？

注意用openFileOutput  openFileInput  的路径名是相对路径，不能用绝对路径，否则报错。

android 文件类 FileOutputStream  FileInputStream   用绝对路径
            openFileOutput   openFileInput     用相对路径
文件存储只能在这两个目录下进行
data/data/包名          //不要读取权限
sdcard目录              //要读取权限

openFile*  两个类的权限：
           MODE_PRIVATE            //默认：私有
           MODE_APPEND             //在文件中追加
           MODE_WORLD_READABLE     //其他程序可以读
           MODE_WORLD_WRITEABLE    //其他程序可以写
android 文件方法：                  //文件路径都是相对路径
          openFileInput
          openFileOutput
          getFileStreamPath        //取文件路径
          deleteFile               //删除
          fileList                 // 列出本包files的文件

=======================================================

activity

直观理解，activity就是手机屏幕的一个窗口。

主activity 启动新的activity

  1. package com.example.wz;
  2.  
  3. import static android.content.Context.MODE_PRIVATE;
  4. import androidx.appcompat.app.AppCompatActivity;
  5.  
  6. import android.content.Intent;
  7. import android.os.Bundle;
  8. import android.os.Handler;
  9. import android.view.View;
  10. import android.widget.Button;
  11. import android.widget.EditText;
  12. import android.widget.TextView;
  13.  
  14. import java.io.File;
  15. import java.io.FileNotFoundException;
  16. import java.io.FileOutputStream;
  17. import java.io.IOException;
  18. public class MainActivity extends AppCompatActivity {
  19.     static Handler handler=new Handler();
  20.     static TextView textView;
  21.     @Override
  22.     protected void onCreate(Bundle savedInstanceState) {
  23.         super.onCreate(savedInstanceState);
  24.         setContentView(R.layout.activity_main);
  25.  
  26.         Button button = findViewById(R.id.button);
  27.         EditText editText = findViewById(R.id.editTextText);
  28.         textView = findViewById(R.id.textView);
  29.  
  30.             button.setOnClickListener(view -> {
  31.             Intent  intent=new Intent(MainActivity.this,MainActivity2.class);  //启动新的activity 
  32.             startActivity(intent);
  33.         });
  34.     }
  35. }
  36.  
  37.  
  38.  
  39.  
  40.

建立好子activity Java程序和xml配置文件，再用intent启动 intent第一个参数为按钮所在程序的程序名，  第二个参数为要启动的程序名。所以用intent 可以跳到任何窗口，包括从子窗口跳回主窗口。为什么要加.this 和.class  , 可以是规定吧。

如果不怕复杂，可以把事件响应独立来写

  1. View.OnClickListener listener=new View.OnClickListener() {
  2.             @Override
  3.             public void onClick(View view) {
  4.                 Intent intent=new Intent(MainActivity2.this,MainActivity.class);
  5.                 startActivity(intent);
  6.             }
  7.         };
  8.         button.setOnClickListener(listener);

intent  可以调用android系统的程序

下面的代码是调用android 的内置拨号程序，调用内置程序，不用自编activity。系统自动调出已固定的拨号activity。

  1. package com.example.call;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.content.Intent;
  6. import android.net.Uri;
  7. import android.os.Bundle;
  8. import android.widget.Button;
  9. import android.widget.TextView;
  10.  
  11. public class MainActivity extends AppCompatActivity {
  12.  
  13.     @Override
  14.     protected void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.activity_main);
  17.  
  18.         Button button=findViewById(R.id.button);
  19.         TextView textView=findViewById(R.id.editTextText);   //输入电话号码
  20.         
  21.         button.setOnClickListener(view -> {
  22.             String s=textView.getText().toString();
  23.             Intent intent=new Intent(Intent.ACTION_DIAL, Uri.parse("tel://"+s));
  24.             startActivity(intent);  //利用intent 调用android内置拨号程序
  25.         });
  26.     }
  27. }

到这里，就可以很好理解为什么在用某个不用钱的程序时，突然点出拚多多的程序。

activity 之间通过bundle互传数据

主窗口：

  1. package com.example.wz;
  2.  
  3. import static android.content.Context.MODE_PRIVATE;
  4.  
  5. import androidx.annotation.Nullable;
  6. import androidx.appcompat.app.AppCompatActivity;
  7.  
  8. import android.annotation.SuppressLint;
  9. import android.content.Intent;
  10. import android.media.MediaPlayer;
  11. import android.os.Bundle;
  12. import android.os.Handler;
  13. import android.view.View;
  14. import android.widget.Button;
  15. import android.widget.EditText;
  16. import android.widget.ImageView;
  17. import android.widget.TextView;
  18.  
  19.  
  20. public class MainActivity extends AppCompatActivity {
  21.     static Handler handler=new Handler();
  22.     @Override
  23.     protected void onCreate(Bundle savedInstanceState) {
  24.         super.onCreate(savedInstanceState);
  25.         setContentView(R.layout.activity_main);
  26.  
  27.         Button button = findViewById(R.id.button);
  28.         @SuppressLint({"MissingInflatedId", "LocalSuppress"})
  29.         TextView textView=findViewById(R.id.textView);
  30.         button.setOnClickListener(view -> {
  31.             Bundle bundle=new Bundle();
  32.             String name="wz";
  33.             bundle.putString("name",name);
  34.             Intent intent=new Intent(MainActivity.this,MainActivity2.class);//切换到第二窗口
  35.             intent.putExtras(bundle);
  36.             startActivity(intent);
  37.         });
  38.         Intent intent=getIntent();                            //提取第二窗口传递的数据
  39.         String name1=intent.getStringExtra("kk");
  40.         textView.setText(name1);
  41.     }
  42. }
  43.  
  44.  
  45.  
  46.  
  47.

子窗口

  1. package com.example.wz;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.annotation.SuppressLint;
  6. import android.content.Intent;
  7. import android.os.Bundle;
  8. import android.widget.Button;
  9. import android.widget.TextView;
  10.  
  11. public class MainActivity2 extends AppCompatActivity {
  12.     String name;
  13.     @Override
  14.     protected void onCreate(Bundle savedInstanceState) {
  15.         super.onCreate(savedInstanceState);
  16.         setContentView(R.layout.activity_main2);
  17.         Intent intent=getIntent();                         //提取主窗口传递的数据
  18.         name=intent.getStringExtra("name");
  19.         TextView textView=findViewById(R.id.textView2);
  20.         textView.setText(name);
  21.  
  22.         @SuppressLint({"MissingInflatedId", "LocalSuppress"})
  23.         Button button=findViewById(R.id.button2);
  24.         button.setOnClickListener(view -> {
  25.             Intent intent1=new Intent(MainActivity2.this,MainActivity.class);  //切换到主窗口
  26.             Bundle bundle=new Bundle();                                          //绑定的数据
  27.             bundle.putString("kk","wl");
  28.             intent1.putExtras(bundle);
  29.             startActivity(intent1);
  30.         });
  31.     }
  32. }

用这个方法，不用调用带返回数据的startactivity方法。

android 系统内置了很多常用的activity。如打电话的activity，

--------------------------------------------------------------------------------------------------------------------------------

android  图片的接收，删除，显示，图片列表显示

图片存储有两种方式，一种是存于自身程序包内，一种是存于像册，下面的程序是处理存在程序包中的情况。

如程序都在一个窗口中显示，就不用考虑activity的问题

图片存储路径：/data/data/包名/

16fb5910fde24230815fcfb9f3f9ae56.png

接收图片的手机与发送图片的电脑,必须在同一个局域网中

 代码：

  1. package com.example.call;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.app.Activity;
  5. import android.content.Context;
  6. import android.graphics.Bitmap;
  7. import android.graphics.BitmapFactory;
  8. import android.os.Bundle;
  9. import android.widget.Button;
  10. import android.widget.EditText;
  11. import android.widget.ImageView;
  12. import android.widget.TextView;
  13. import java.io.FileOutputStream;
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.io.ObjectInputStream;
  17. import java.net.Socket;
  18.  
  19. public class MainActivity extends Activity {
  20.     TextView textView;
  21.     @SuppressLint("MissingInflatedId")
  22.     protected void onCreate(Bundle savedInstanceState) {
  23.         super.onCreate(savedInstanceState);
  24.         setContentView(R.layout.activity_main);
  25.  
  26.         Button button = findViewById(R.id.button);
  27.         button.setText("接收");
  28.         Button button2=findViewById(R.id.button2);
  29.         button2.setText("播放");
  30.         Button button3=findViewById(R.id.button14);
  31.         button3.setText("目录");
  32.         Button button4=findViewById(R.id.button3);
  33.         button4.setText("删除");
  34.  
  35.         textView=findViewById(R.id.textView);
  36.         ImageView imageView = findViewById(R.id.imageView);
  37.         imageView.setImageResource(R.drawable.ic_launcher_background);
  38.         EditText editText=findViewById(R.id.editTextText);
  39.  
  40.         button4.setOnClickListener(view -> {
  41.             String name=editText.getText().toString();
  42.             textView.setText(name);
  43.             deleteFile(name);
  44.         });
  45.  
  46.         button3.setOnClickListener(view -> {
  47.             String[] s=fileList();
  48.             String o=null;
  49.             for(String k:s){
  50.                 o=o+k+"   ";
  51.             }
  52.             textView.setText(o);
  53.         });
  54.  
  55.         button2.setOnClickListener(view -> {
  56.             String name=editText.getText().toString();
  57.             textView.setText(name);
  58.             Bitmap myBitmap = BitmapFactory.decodeFile("/data/data/com.example.call/files/"+name);
  59.             imageView.setImageBitmap(myBitmap);
  60.  
  61.         });
  62.  
  63.         button.setOnClickListener(view -> {
  64.  
  65.         try {
  66.             Socket socket=new Socket("192.168.43.61",3000);
  67.             InputStream inputStream=socket.getInputStream();
  68.             ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
  69.             String name=objectInputStream.readUTF();
  70.             byte[] b= (byte[]) objectInputStream.readObject();
  71.             FileOutputStream fileOutputStream=openFileOutput(name,Context.MODE_PRIVATE);
  72.             fileOutputStream.write(b);
  73.             fileOutputStream.close();
  74.             socket.close();
  75.  
  76.         } catch (IOException e) {
  77.           //  throw new RuntimeException(e);
  78.             textView.setText("net 错误");
  79.         } catch (ClassNotFoundException e) {
  80.            // throw new RuntimeException(e);
  81.         }
  82.         });
  83.     }
  84. }

上传图片

  1. import java.io.*;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4.  
  5. public class Main {
  6.     public static void main(String[] args) throws IOException {
  7.         String s="/home/wzpc/3.jpg";
  8.         File file=new File(s);
  9.         String  name=file.getName();
  10.         FileInputStream fileInputStream=new FileInputStream(file);
  11.         byte[] b=new byte[fileInputStream.available()];
  12.         fileInputStream.read(b);
  13.  
  14.         ServerSocket serverSocket=new ServerSocket(3000);
  15.         Socket socket=serverSocket.accept();
  16.         OutputStream outputStream=socket.getOutputStream();
  17.         ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
  18.         objectOutputStream.writeUTF(name);
  19.         objectOutputStream.flush();
  20.         objectOutputStream.writeObject(b);
  21.         objectOutputStream.flush();
  22.         socket.close();
  23.         fileInputStream.close();
  24. }
  25. }
  26.  
  27.  
  28.  
  29.

实.物图

c45343bc8918424c93c681b82d7a7cd8.jpg

android 四个核心组件：Activity   Service   Content.Provider   BroadcastReceiver

在 activity 主程序的onCreate(Bundel    bundle)中，可以直接引用android  的Actitvty，Intent，Content三个类的全部方法。如Content类的openFileoutput().  不用创造实例。可以这样写：this.方法名。

android.App.Activity  继承与android.Content.Context.    所以这两个类的方法都可以直接引用

onCreate(Bundle) 是初始化 Activity 的地方。 最重要的是，在这里您通常会使用定义 UI 的布局资源调用 setContentView(int)，并使用 findViewById(int) 检索该 UI 中需要以编程方式交互的小部件

onPause() 是处理用户暂停与 Activity 的主动交互的地方。 此时应提交用户所做的任何更改（通常提交给保存数据的 ContentProvider）。 在此状态下，活动在屏幕上仍然可见。

要与 Context.startActivity() 一起使用，所有 Activity 类都必须在其包的 AndroidManifest.xml 中具有相应的 <activity> 声明。
 

现在理一下：view            UI的各个组成部件，如按钮的外观，event 事件响应

                    activity          由多个view组*成activity窗口。

                     Intent            主要是切换activity窗口

                     Context.Provider      主要是用来保存数据

ContentProvider的作用是为不同的应用之间数据共享，提供统一的接口，我们知道安卓系统中应用内部的数据是对外隔离的，要想让其它应用能使用自己的数据（例如通讯录）这个时候就用到了ContentProvider。

android 数据库

查询数据库图片，音乐，视频

"_data"    在数据库中代表文件的全路径名，它是非常重要的列名。

下面程序的cursor 的数值就是查询后数据的集合，采用循环一行一行读取列(_data)的值。

  1. package com.example.test1;
  2.  
  3. import static android.content.ContentValues.TAG;
  4. import androidx.appcompat.app.AppCompatActivity;
  5. import android.annotation.SuppressLint;
  6. import android.content.ContentResolver;
  7. import android.database.Cursor;
  8. import android.graphics.Bitmap;
  9. import android.graphics.BitmapFactory;
  10. import android.net.Uri;
  11. import android.os.Bundle;
  12. import android.provider.MediaStore;
  13. import android.util.Log;
  14. import android.widget.ImageView;
  15. import android.widget.TextView;
  16.  
  17. public class MainActivity extends AppCompatActivity {
  18.  
  19.     @SuppressLint("Range")
  20.     @Override
  21.     protected void onCreate(Bundle savedInstanceState) {
  22.         super.onCreate(savedInstanceState);
  23.         setContentView(R.layout.activity_main);
  24.  
  25.         TextView textView = findViewById(R.id.textView2);
  26.         ImageView imageView = findViewById(R.id.imageView);
  27.  
  28.         ContentResolver contentResolver = getContentResolver();     //读数据库
  29.         Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  30.       //  音频MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  31.      //   视频MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  32.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  33.      //   int t = cursor.getColumnCount();                               //数据库 列数量
  34.      //   String[] columnNames = cursor.getColumnNames();                //数据库全部 列名字  如query()方法的第二参数已限制列名，则columnnames=第二参数名，现在就是_data
  35.     //    int t1 = cursor.getColumnIndex("_data");                    //返回给定 列名称的从零开始的索引，如果该列不存在，则返回-1。
  36.      //   int t2 = cursor.getCount();                                    //数据库的总行数;
  37.  
  38.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  39.  
  40.        /*    for (String Name : columnNames) {                          //name数据库的某一列，columnnames 全部列名
  41.                 Log.d(TAG, "----------------------------");
  42.                 Log.d(TAG, "name--> " + Name + " value--> " + cursor.getString(cursor.getColumnIndex(Name)));
  43.                 Log.d(TAG, "----------------------------");
  44.             }*/
  45.             //因为只查询了一列"_data",可以这样简写
  46.             Log.d(TAG, "----------------------------");          //在电脑的Run框中显示输出
  47.             Log.d(TAG, "name-->_data "  + " value--> " + cursor.getString(cursor.getColumnIndex("_data")));   //显示数据库中图片的路径，根据索引反查索引值
  48.             Log.d(TAG, "----------------------------");
  49.         }
  50.         Bitmap bitmap = BitmapFactory.decodeFile("/storage/emulated/0/Pictures/Screenshots/Screenshot_20230701_101256_com.tencent.mobileqq.jpg");  //显示图片
  51.         imageView.setImageBitmap(bitmap);
  52.     }
  53. }

run框显示

7b32a9d608854b429111350bee0de706.png
 

Uri:

   Uri uri = MediaStore.Images.Media.INTERNAL_CONTENT_URI; 
图片MediaStore.Images.Media.EXTERNAL_CONTENT_URI
音频MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
视频MediaStore.Video.Media.EXTERNAL_CONTENT_URI

   

查询文件名，和文件路径。文件名：_display_name     文件路径 : _data

  1. Cursor cursor = contentResolver.query(uri,new String[]{"_display_name","_data"}, null, null, null, null);  //查询
  2.                     String[] s=cursor.getColumnNames();
  3.                     String o=null;
  4.                     for(String k:s){
  5.                         o=o+k+"  ";
  6.                     }
  7.                     Log.d(TAG, "----------------------------");
  8.                     Log.d(TAG,o);
  9.                     while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  10.                         Log.d(TAG,cursor.getString(cursor.getColumnIndex("_display_name")));
  11.                         Log.d(TAG,cursor.getString(cursor.getColumnIndex("_data")));   //显示数据库中图片的路径，根据索引反查索引值
  12.                     }
  13.                     Log.d(TAG, "----------------------------");

  查询数据库步骤：query（）方法的第二个参数是字符串数组，它的元素就是数据库要查询的列名字，如_data  ,_display_name。  query方法生成的Cursor  就是要查询的列的全部行的值。提取每行采用 moveToNext（）方法，取出每行的值采用：先用列名提取列在每行中的索引(getColumnIndex(列名）），再用此索引号倒查此索引的值。 

经验证，新产生的照片，如刚拍的照片，会立即填加在数据库的末端。用这个方法，可以提取出刚拍的照片。     

cursor.moveToLast();                //跳到数据库最后一行
Log.d(TAG,cursor.getString(cursor.getColumnIndex("_data")));//显示最后一行的data指向的最近写入数据库的照片。

浏览手机全部照片

  1. package com.example.test1;
  2. import androidx.appcompat.app.AppCompatActivity;
  3. import android.annotation.SuppressLint;
  4. import android.content.ContentResolver;
  5. import android.database.Cursor;
  6. import android.graphics.Bitmap;
  7. import android.graphics.BitmapFactory;
  8. import android.net.Uri;
  9. import android.os.Bundle;
  10. import android.provider.MediaStore;
  11. import android.widget.Button;
  12. import android.widget.ImageView;
  13. import android.widget.TextView;
  14. import java.util.ArrayList;
  15.  
  16. public class MainActivity extends AppCompatActivity {
  17.     int n=0;
  18.     @SuppressLint("Range")
  19.     @Override
  20.     protected void onCreate(Bundle savedInstanceState) {
  21.         super.onCreate(savedInstanceState);
  22.         setContentView(R.layout.activity_main);
  23.  
  24.         TextView textView = findViewById(R.id.textView2);
  25.         ImageView imageView = findViewById(R.id.imageView);
  26.         Button button=findViewById(R.id.button3);
  27.  
  28.         ContentResolver contentResolver = getContentResolver();     //读数据库
  29.         Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  30.       //  音频MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  31.      //   视频MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  32.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  33.         ArrayList<String> al=new ArrayList<>();
  34.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  35.             String s=cursor.getString(cursor.getColumnIndex("_data"));
  36.             al.add(s);                                             //把数据库全部的图片路径存入ArrayList中
  37.         }
  38.     //    textView.setText(String.valueOf(al.size()));
  39.         button.setOnClickListener(view -> {                        //按钮按一下，浏览一张图片
  40.             n++;
  41.             Bitmap bitmap=BitmapFactory.decodeFile(al.get(n));
  42.             imageView.setImageBitmap(bitmap);
  43.         });
  44.     }
  45. }

感觉这个小程序的图片浏览加载速度快与手机的图片浏览app。

自动播放手机数据库图片

此程序相当重要，涉及到线程之间的数据交换，ui的定时更新

  1. package com.example.test1;
  2. import androidx.annotation.NonNull;
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import android.annotation.SuppressLint;
  5. import android.content.ContentResolver;
  6. import android.database.Cursor;
  7. import android.graphics.Bitmap;
  8. import android.graphics.BitmapFactory;
  9. import android.net.Uri;
  10. import android.os.Bundle;
  11. import android.os.Handler;
  12. import android.os.Looper;
  13. import android.os.Message;
  14. import android.provider.MediaStore;
  15. import android.widget.Button;
  16. import android.widget.ImageView;
  17. import android.widget.TextView;
  18. import java.util.ArrayList;
  19.  
  20. public class MainActivity extends AppCompatActivity {
  21.     int n=0;
  22.     @SuppressLint("Range")
  23.     @Override
  24.     protected void onCreate(Bundle savedInstanceState) {
  25.         super.onCreate(savedInstanceState);
  26.         setContentView(R.layout.activity_main);
  27.  
  28.         TextView textView = findViewById(R.id.textView2);
  29.         ImageView imageView = findViewById(R.id.imageView);
  30.         Button button=findViewById(R.id.button3);
  31.  
  32.         ContentResolver contentResolver = getContentResolver();     //读数据库
  33.         Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  34.       //  音频MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  35.      //   视频MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  36.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  37.         ArrayList<String> al=new ArrayList<>();
  38.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  39.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  40.             al.add(s);                                             //把数据库全部的图片路径存入ArrayList
  41.         }
  42.  
  43.         Handler.Callback hc=new Handler.Callback() {
  44.             @Override
  45.             public boolean handleMessage(@NonNull Message msg) {     //这里必须调用handle类的镶嵌类Handle.Callback的handleMessage方法。
  46.                 int t=msg.arg1;
  47.                 Bitmap bitmap = BitmapFactory.decodeFile(al.get(t));
  48.                 imageView.setImageBitmap(bitmap);
  49.                 return false;
  50.             }
  51.         };
  52.         Handler handler =new Handler(Looper.myLooper(),hc);
  53.  
  54.         new Thread(()->{
  55.             while(true) {
  56.                     Message message = new Message();
  57.                     message.arg1=n;
  58.                     handler.sendMessage(message);
  59.                     n++;
  60.                     try {
  61.                         Thread.sleep(1000);
  62.                     } catch (InterruptedException e) {
  63.                         //         throw new RuntimeException(e);
  64.                     }
  65.             }
  66.         }).start();
  67.     }
  68. }

此程序可以作为ui循环或定时更新的模板。

编程发现：android 主方法线程中，不能用for循环等方法为ui的各种显示控件赋值来完成ui的更新

必须采用上述hendle类来完成。

为什么要这样，我理解是因为android的主线程不能有占长时间运行的代码。如果必须有这种长耗时代码，必须把这种代码移到一新线程中。再把数据通过message传回主线程

android 读取数据库的权限问题

华为畅享20 ART-AL00m     用的是android 10 ，除了在全局文件中加入权限外，还要在

application段中加入这句
android:requestLegacyExternalStorage="true"
如果不在程序中加入动态权限，那么一定要在手机的设置中开启你的程序的存储权限。

华为nova8  不用加这句可运行。加了也不影响。还有如果发现程序不运行，多是手机的存储权限关闭，在手机设置中开启就可以了。nova8 很少有关闭权限的情况，畅享20经常发生。

android  数据库音频

以上介绍了几种播放方式，可以说各有优劣。
本文写的不够详细，只是大概的介绍一下几种播放方式。在此做下简单的总结。

对于延迟度要求不高，并且希望能够更全面的控制音乐的播放，MediaPlayer比较适合
声音短小，延迟度小，并且需要几种声音同时播放的场景，适合使用SoundPool
对于简单的播放，不需要复杂控制的播放，可以给使用AsyncPlayer，所有操作均在子线程不阻塞UI
播放大文件音乐，如WAV无损音频和PCM无压缩音频，可使用更底层的播放方式AudioTrack。它支持流式播放，可以读取(可来自本地和网络)音频流，却播放延迟较小。
ps：据我测试AudioTrack直接支持WAV和PCM，其他音频需要解码成PCM格式才能播放。(其他无损格式没有尝试，有兴趣可以使本文提供的例子测试一下)
.jet的音频比较少见(有的游戏中在使用)，可使用专门的播放器JetPlayer播放
对于系统类声音的播放和操作，Ringtone更适合(主要是掌握好RingtoneManager)
————————————————
版权声明：本文为CSDN博主「一个有梦想的屌丝程序员」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u013366008/article/details/76577372

  1. package com.example.wz;
  2. import android.annotation.SuppressLint;
  3. import android.media.MediaPlayer;
  4. import android.net.Uri;
  5. import android.os.Bundle;
  6. import androidx.appcompat.app.AppCompatActivity;
  7.  
  8. public class MainActivity extends AppCompatActivity {
  9.     MediaPlayer mediaPlayer;                 //必须onCreate()方法前先定义MediaPlayer，否则华为手机只能播放音乐1-2秒就停止，不知道为啥
  10.     @SuppressLint({"MissingInflatedId", "Range"})
  11.     protected void onCreate(Bundle savedInstanceState) {
  12.         super.onCreate(savedInstanceState);
  13.         setContentView(R.layout.activity_main);
  14.  
  15.         Uri u=Uri.parse("/storage/emulated/0/qqmusic/song/阳山伟伟 - 星辰 (Original Mix) [mqms2].flac");
  16.         mediaPlayer = MediaPlayer.create(this.getApplicationContext(),u);
  17.         mediaPlayer.start();
  18.     }
  19. }
  20.  
  21.  
  22.  
  23.  
  24.  
  25.  
必须onCreate()方法前先定义MediaPlayer，否则华为手机只能播放音乐1-2秒就停止，不知道为啥,这个解决方法是在网络发现的。其他手机没有试过。

播放音频要在全局文件中加入这两种权限

    <uses-permission android:name="android.permission.INTERNET" />   
    <uses-permission android:name="android.permission.WAKE_LOCK" />
还有一点，因为所以程序都没有写动态权限，所以必须要在手机的设置中为程序赋予读写存储的权限
    
下面是android官网使用的代码，最好用这种代码，因为上面的三行代码在畅享20中不能运行。

主线程使用这种prepare（）方式为同步播放，影响ui的更新，最好另起一子线程

  1.     Uri myUri = ....; // initialize Uri here
  2.     MediaPlayer mediaPlayer = new MediaPlayer();
  3.     mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  4.     mediaPlayer.setDataSource(getApplicationContext(), myUri);
  5.     mediaPlayer.prepare();
  6.     mediaPlayer.start();

另起一子线程播放

  1.  new Thread(()->{
  2.             Uri u=Uri.parse(al.get(2));
  3.             mediaPlayer = new MediaPlayer();
  4.             mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  5.             try {
  6.                 mediaPlayer.setDataSource(getApplicationContext(),u);
  7.                 mediaPlayer.prepare();  //同步播发，影响ui的更新，如采用同步播放音乐，最好另开一子线程
  8.                 mediaPlayer.start();
  9.             } catch (IOException e) {
  10.                 throw new RuntimeException(e);
  11.             }
  12.         }).start();

主线程异步播放

官网代码

  1.     public class MyService extends Service implements MediaPlayer.OnPreparedListener {
  2.         private static final String ACTION_PLAY = "com.example.action.PLAY";
  3.         MediaPlayer mediaPlayer = null;
  4.  
  5.         public int onStartCommand(Intent intent, int flags, int startId) {
  6.             ...
  7.             if (intent.getAction().equals(ACTION_PLAY)) {
  8.                 mediaPlayer = ... // initialize it here
  9.                 mediaPlayer.setOnPreparedListener(this);
  10.                 mediaPlayer.prepareAsync(); // prepare async to not block main thread
  11.             }
  12.         }
  13.  
  14.         /** Called when MediaPlayer is ready */
  15.         public void onPrepared(MediaPlayer player) {
  16.             player.start();
  17.         }
  18.     }

主线程异步播放实用代码

  1.   Uri u=Uri.parse(al.get(1));
  2.         mediaPlayer = new MediaPlayer();
  3.         mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  4.         try {
  5.             mediaPlayer.setDataSource(this.getApplicationContext(),u);
  6.             mediaPlayer.prepareAsync();          //这句必须放在setDataSource的后面，否则报错
  7.         } catch (IOException e) {
  8.             throw new RuntimeException(e);
  9.         }
  10.         mediaPlayer.setOnPreparedListener(mediaPlayer1 -> { //音乐异步准备完成播放，为什么是mediaPlay1,不清楚，程序自动显示的
  11.             mediaPlayer.start();
  12.         });

顺序播放数据库所有音乐，此程序相当重要，主要理解监控音乐是否完成的线程

  1. package com.example.test1;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4. import android.annotation.SuppressLint;
  5. import android.content.ContentResolver;
  6. import android.database.Cursor;
  7. import android.media.AudioManager;
  8. import android.media.MediaPlayer;
  9. import android.net.Uri;
  10. import android.os.Bundle;
  11. import android.provider.MediaStore;
  12. import android.widget.Button;
  13. import android.widget.ImageView;
  14. import android.widget.TextView;
  15. import java.io.IOException;
  16. import java.util.ArrayList;
  17.  
  18. public class MainActivity extends AppCompatActivity {
  19.     static int is=0;                  //音乐播放完成标志位
  20.     MediaPlayer[] mp;
  21.     MediaPlayer mediaPlayer;
  22.     int n=0;
  23.     @SuppressLint("Range")
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.activity_main);
  28.  
  29.         TextView textView = findViewById(R.id.textView2);
  30.         ImageView imageView = findViewById(R.id.imageView);
  31.         Button button=findViewById(R.id.button3);
  32.  
  33.         ContentResolver contentResolver = getContentResolver();     //读数据库
  34.       //  Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  35.         Uri uri=MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  36.      //   视频MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  37.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  38.         ArrayList<String> al=new ArrayList<>();
  39.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  40.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  41.             al.add(s);                                             //把数据库全部的图片路径存入ArrayList
  42.         }
  43.         class Th extends Thread{
  44.             public void run() {
  45.                 is=0;                         //播放开始 清标志位
  46.                 mediaPlayer = new MediaPlayer();
  47.                 mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  48.                 try {
  49.                     mediaPlayer.setDataSource(al.get(n));
  50.                     mediaPlayer.prepareAsync();          //这句必须放在setDataSource的后面，否则报错
  51.                 } catch (IOException e) {
  52.                     throw new RuntimeException(e);
  53.                 }
  54.                 mediaPlayer.setOnPreparedListener(mediaPlayer1 -> { //音乐异步准备完成播放，为什么是mediaPlay1,不清楚，程序自动显示的
  55.                     mediaPlayer.start();
  56.                 });
  57.                 mediaPlayer.setOnCompletionListener(mediaPlayer1 -> {
  58.                     is=1;        //播放完成置标志位
  59.                 });
  60.             }
  61.         }
  62.  
  63.         button.setOnClickListener(view ->{    //按键启动播放音乐
  64.             Th th=new Th();
  65.             th.start();
  66.         });
  67.     //------重点---------------------------------------------------------
  68.         new Thread(()->{                //新开一线程，一直监控标志位is
  69.             while(true) {               //is=1,表示音乐播放完成，播放线程已关闭
  70.                 if (is == 1) {
  71.                     n++;                //跳到下一首音乐路径
  72.                     Th th = new Th();   //新开一播放音乐线程
  73.                     th.start();
  74.                 }
  75.                 try {
  76.                     Thread.sleep(2000);   //防线程误启动时间，也是两首音乐的间隔时间
  77.                 } catch (InterruptedException e) {
  78.                     throw new RuntimeException(e);
  79.                 }
  80.             }
  81.  
  82.         }).start();
  83.     }
  84. }

android 视频

在Android中，我们有三种方式来实现视频的播放：

1、使用其自带的播放器。指定Action为ACTION_VIEW,Data为Uri，Type为其MIME类型。

2、使用VideoView来播放。在布局文件中使用VideoView结合MediaController来实现对其控制。

3、使用MediaPlayer类和SurfaceView来实现，这种方式很灵活。

播放数据库视频

自动顺序播放手机全部视频

  1. package com.example.test1;
  2.  
  3. import static android.content.ContentValues.TAG;
  4. import androidx.appcompat.app.AppCompatActivity;
  5. import android.annotation.SuppressLint;
  6. import android.content.ContentResolver;
  7. import android.database.Cursor;
  8. import android.media.AudioManager;
  9. import android.media.MediaPlayer;
  10. import android.net.Uri;
  11. import android.os.Bundle;
  12. import android.provider.MediaStore;
  13. import android.util.Log;
  14. import android.view.SurfaceHolder;
  15. import android.view.SurfaceView;
  16. import android.widget.Button;
  17. import java.io.IOException;
  18. import java.util.ArrayList;
  19.  
  20. public class MainActivity extends AppCompatActivity {
  21.     SurfaceHolder surfaceHolder;
  22.      int n=0;
  23.      static int is=0;
  24.     MediaPlayer mediaPlayer;
  25.     @SuppressLint("Range")
  26.     @Override
  27.     protected void onCreate(Bundle savedInstanceState) {
  28.         super.onCreate(savedInstanceState);
  29.         setContentView(R.layout.activity_main);
  30.         @SuppressLint({"WrongViewCast", "MissingInflatedId", "LocalSuppress"})
  31.         SurfaceView surfaceView=findViewById(R.id.surfaceView);
  32.         Button button=findViewById(R.id.button3);
  33.  
  34.         ContentResolver contentResolver = getContentResolver();     //读数据库
  35.         //  Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  36.         //  Uri uri=MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  37.         Uri uri=MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  38.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  39.         ArrayList<String> al=new ArrayList<>();
  40.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  41.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  42.             al.add(s);                                             //把数据库全部的图片路径存入ArrayList
  43.             Log.d(TAG,s);
  44.         }
  45.  
  46.         Runnable r=()->{
  47.             is=0;
  48.             mediaPlayer = new MediaPlayer();
  49.             mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  50.             try {
  51.                 mediaPlayer.setDataSource(al.get(n));
  52.                 mediaPlayer.prepare();
  53.             } catch (IOException e) {
  54.                 throw new RuntimeException(e);
  55.             }
  56.             surfaceHolder = surfaceView.getHolder(); //播放视频增加这两句
  57.             mediaPlayer.setDisplay(surfaceHolder);   //播放视频增加这两句
  58.             mediaPlayer.start();
  59.             mediaPlayer.setOnCompletionListener(mediaPlayer1 -> {
  60.                 is=1;
  61.                 mediaPlayer.release();           //释放，关闭mediaPlay
  62.             });
  63.         };
  64.  
  65.         button.setOnClickListener(view -> {       //启动开始播放
  66.             Thread thread=new Thread(r);
  67.             thread.start();
  68.             });
  69.         new Thread(()->{
  70.             while(true){
  71.                 if(is==1){
  72.                     n++;
  73.                     Thread thread=new Thread(r);
  74.                     thread.start();
  75.                 }
  76.                 try {
  77.                     Thread.sleep(2000);
  78.                 } catch (InterruptedException e) {
  79.                     throw new RuntimeException(e);
  80.                 }
  81.             }
  82.         }).start();
  83.     }
  84. }

新开子窗口用于显示视频，activity 之间传递文件路径名

主窗口代码

  1.  
  2. package com.example.test1;
  3.  
  4. import static android.content.ContentValues.TAG;
  5. import androidx.appcompat.app.AppCompatActivity;
  6. import android.annotation.SuppressLint;
  7. import android.content.ContentResolver;
  8. import android.content.Intent;
  9. import android.database.Cursor;
  10. import android.media.MediaPlayer;
  11. import android.net.Uri;
  12. import android.os.Bundle;
  13. import android.provider.MediaStore;
  14. import android.util.Log;
  15. import android.view.SurfaceHolder;
  16. import android.view.SurfaceView;
  17. import android.widget.Button;
  18. import java.util.ArrayList;
  19.  
  20. public class MainActivity extends AppCompatActivity {
  21.     SurfaceHolder surfaceHolder;
  22.     int n=0;
  23.     static int is=0;
  24.     MediaPlayer mediaPlayer;
  25.     @SuppressLint("Range")
  26.     @Override
  27.     protected void onCreate(Bundle savedInstanceState) {
  28.         super.onCreate(savedInstanceState);
  29.         setContentView(R.layout.activity_main);
  30.         @SuppressLint({"WrongViewCast", "MissingInflatedId", "LocalSuppress"})
  31.         SurfaceView surfaceView=findViewById(R.id.surfaceView);
  32.         Button button=findViewById(R.id.button3);
  33.  
  34.         ContentResolver contentResolver = getContentResolver();     //读数据库
  35.         //  Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  36.         //  Uri uri=MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  37.         Uri uri=MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  38.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);  //查询
  39.         ArrayList<String> al=new ArrayList<>();
  40.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  41.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  42.             al.add(s);                                             //把数据库全部的图片路径存入ArrayList
  43.             Log.d(TAG,s);
  44.         }
  45.  
  46.         button.setOnClickListener(view -> {
  47.             n++;
  48.             Bundle bundle=new Bundle();
  49.             String path=al.get(n);          //为子窗口传递显示文件路径
  50.             bundle.putString("lj",path);
  51.             Intent intent=new Intent(MainActivity.this,Sp.class);
  52.             intent.putExtras(bundle);
  53.             startActivity(intent);
  54.  
  55.         });
  56.     }
  57. }
  58.

子窗口代码

  1. package com.example.test1;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.appcompat.app.AppCompatActivity;
  5. import android.annotation.SuppressLint;
  6. import android.content.Intent;
  7. import android.media.AudioManager;
  8. import android.media.MediaPlayer;
  9. import android.os.Bundle;
  10. import android.view.SurfaceHolder;
  11. import android.view.SurfaceView;
  12. import java.io.IOException;
  13.  
  14. public class Sp extends AppCompatActivity {
  15.     SurfaceHolder surfaceHolder;
  16.     MediaPlayer mediaPlayer;
  17.     @Override
  18.     protected void onCreate(Bundle savedInstanceState) {
  19.         super.onCreate(savedInstanceState);
  20.         setContentView(R.layout.activity_sp);
  21.         @SuppressLint({"MissingInflatedId", "LocalSuppress"})
  22.         SurfaceView surfaceView=findViewById(R.id.surfaceView2);
  23.  
  24.         Intent intent=getIntent();
  25.         String path=intent.getStringExtra("lj");    //取得主窗口传递的路径
  26.  
  27.         mediaPlayer = new MediaPlayer();
  28.         mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  29.  
  30.         try {
  31.             mediaPlayer.setDataSource(path);
  32.             mediaPlayer.prepareAsync();
  33.         } catch (IOException e) {
  34.             throw new RuntimeException(e);
  35.         }
  36.         surfaceHolder = surfaceView.getHolder(); //播放视频增加这两句
  37.         surfaceHolder.addCallback(new SurfaceHolder.Callback() {    //最好用callback此方法显示，否则太多报错
  38.             @Override
  39.             public void surfaceCreated(@NonNull SurfaceHolder surfaceHolder) {
  40.                 mediaPlayer.setDisplay(surfaceHolder);   //播放视频增加这两句
  41.             }
  42.             @Override
  43.             public void surfaceChanged(@NonNull SurfaceHolder surfaceHolder, int i, int i1, int i2) {
  44.             }
  45.             @Override
  46.             public void surfaceDestroyed(@NonNull SurfaceHolder surfaceHolder) {
  47.             }
  48.             });
  49.         mediaPlayer.setOnPreparedListener(mediaPlayer1 -> {
  50.             mediaPlayer.start();
  51.         });
  52.         mediaPlayer.setOnCompletionListener(mediaPlayer1 -> {
  53.             mediaPlayer.release();
  54.         });
  55.  
  56.     }
  57. //-------------------返回关闭视频---------------------------------------
  58.     public void onBackPressed() {     //监听返回键，如返回则关闭视频
  59.         super.onBackPressed();
  60.         mediaPlayer.release();
  61.     }
  62.  
  63. }

顺序播放或者按文件序号点播视频

  1.  
  2. package com.example.test1;
  3.  
  4. import static android.content.ContentValues.TAG;
  5. import androidx.appcompat.app.AppCompatActivity;
  6. import android.annotation.SuppressLint;
  7. import android.content.ContentResolver;
  8. import android.content.Intent;
  9. import android.database.Cursor;
  10. import android.media.MediaPlayer;
  11. import android.net.Uri;
  12. import android.os.Bundle;
  13. import android.provider.MediaStore;
  14. import android.util.Log;
  15. import android.view.KeyEvent;
  16. import android.view.SurfaceHolder;
  17. import android.view.SurfaceView;
  18. import android.view.View;
  19. import android.widget.Button;
  20. import android.widget.EditText;
  21. import android.widget.TextView;
  22.  
  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.Map;
  26.  
  27. public class MainActivity extends AppCompatActivity {
  28.     SurfaceHolder surfaceHolder;
  29.     String outpath;
  30.     String outname;
  31.     String xs;
  32.     int n=0;
  33.     int no=0;
  34.     MediaPlayer mediaPlayer;
  35.     TextView textView;
  36.     EditText editText;
  37.     ArrayList<String> al;
  38.     Bundle bundle=new Bundle();
  39.     @SuppressLint("Range")
  40.     @Override
  41.     protected void onCreate(Bundle savedInstanceState) {
  42.         super.onCreate(savedInstanceState);
  43.         setContentView(R.layout.activity_main);
  44.  
  45.         Button button=findViewById(R.id.button3);
  46.         editText=findViewById(R.id.editTextText);
  47.         editText.setText("");
  48.         textView=findViewById(R.id.textView2);
  49.         textView.setText("");
  50.  
  51.         ContentResolver contentResolver = getContentResolver();     //读数据库
  52.         //  Uri uri =MediaStore.Images.Media.EXTERNAL_CONTENT_URI;    //读外部存储数据库       _data  代表图片文件的全路径
  53.         //  Uri uri=MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  54.         Uri uri=MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  55.         Cursor cursor = contentResolver.query(uri, new String[]{"_data","_display_name"}, null, null, null, null);  //查询
  56.         al=new ArrayList<>();
  57.         Map<Integer,String> map=new HashMap<>();
  58.  
  59.         while (cursor.moveToNext()) {                                  //  移到数据库的下一行。
  60.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  61.             String name=cursor.getString(cursor.getColumnIndex("_display_name"));
  62.             al.add(s);
  63.             outname=outname+name+"   ";
  64.             xs=xs+String.valueOf(no)+":  "+name+"  ";
  65.             map.put(no,s);
  66.             no++;
  67.         }
  68.         textView.setText(xs);
  69. //----------按键启动顺序播放-----------------------------------------
  70.         button.setOnClickListener(view -> {
  71.             n++;
  72.        //     Bundle bundle=new Bundle();
  73.             String path=al.get(n);
  74.             bundle.putString("lj",path);
  75.             Intent intent=new Intent(MainActivity.this,Sp.class);
  76.             intent.putExtras(bundle);
  77.             startActivity(intent);
  78.         });
  79. //-----------按键监听，实现输入文件序号单个播放---------------------------------------------------------------
  80.         editText.setOnKeyListener(new View.OnKeyListener() {        //正对输入框editText的按键监听
  81.             @Override
  82.             public boolean onKey(View v, int keyCode, KeyEvent event) {
  83.                 if(event.getAction() == KeyEvent.ACTION_DOWN) {
  84.                     switch (keyCode) {
  85.                         case KeyEvent.KEYCODE_ENTER:                 //监控 按下回车键
  86.                             String in= editText.getText().toString();
  87.                             int index=Integer.valueOf(in);
  88.                             String path= map.get(index);
  89.                             bundle.putString("lj",path);
  90.                             Intent intent=new Intent(MainActivity.this,Sp.class);
  91.                             intent.putExtras(bundle);
  92.                             startActivity(intent);
  93.                             return true;
  94.                     }
  95.                 }
  96.                 return false;
  97.             }
  98.         });
  99.     }
  100. }
  101.

子窗口代码不变

使用发现，利用新线程监控播放线程不稳定

改进后的顺序音乐播放

  1. package com.example.test1;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.appcompat.app.AppCompatActivity;
  5.  
  6. import android.annotation.SuppressLint;
  7. import android.content.AsyncQueryHandler;
  8. import android.content.ContentResolver;
  9. import android.database.Cursor;
  10. import android.media.AudioManager;
  11. import android.media.MediaPlayer;
  12. import android.net.Uri;
  13. import android.os.Bundle;
  14. import android.os.Handler;
  15. import android.os.Looper;
  16. import android.os.Message;
  17. import android.provider.MediaStore;
  18. import android.view.View;
  19. import android.widget.Button;
  20. import android.widget.EditText;
  21. import android.widget.TextView;
  22.  
  23. import java.io.IOException;
  24. import java.util.ArrayList;
  25.  
  26. public class Yy extends AppCompatActivity {
  27.     TextView textView;
  28.     TextView textView1;
  29.     EditText editText;
  30.     Button button1;
  31.     Button button2;
  32.     Button button3;
  33.     Button button4;
  34.     int n = 0;
  35.     int is = 0;
  36.     ArrayList<String> al = new ArrayList<>();
  37.     MediaPlayer mediaPlayer = new MediaPlayer();
  38.  
  39.     @SuppressLint({"MissingInflatedId", "Range"})
  40.     @Override
  41.     protected void onCreate(Bundle savedInstanceState) {
  42.         super.onCreate(savedInstanceState);
  43.         setContentView(R.layout.activity_yy);
  44.  
  45.         textView = findViewById(R.id.textView2);
  46.         textView1 = findViewById(R.id.textView3);
  47.         textView1.setTextSize(24);
  48.         editText = findViewById(R.id.editTextText);
  49.         editText.setText("");
  50.         button1 = findViewById(R.id.button6);
  51.         button1.setText("顺序播放");
  52.         button2 = findViewById(R.id.button7);
  53.         button2.setText("停止选播");
  54.         button3 = findViewById(R.id.button8);
  55.         button3.setText("进一首");
  56.         button4 = findViewById(R.id.button9);
  57.         button4.setText("退一首");
  58.  
  59.         ContentResolver contentResolver = getContentResolver();
  60.         Uri uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  61.         Cursor cursor = contentResolver.query(uri, new String[]{"_data"}, null, null, null, null);
  62.         String o = null;
  63.  
  64.         while (cursor.moveToNext()) {
  65.             @SuppressLint("Range")
  66.             String s = cursor.getString(cursor.getColumnIndex("_data"));
  67.             al.add(s);
  68.             o = o + s + "   ";
  69.         }
  70.         textView.setText(o);
  71.         textView1.setText("音乐序号"+String.valueOf(cursor.getCount()));
  72.  
  73.  //------顺序全部播放--------------------------------------------------------
  74.         button1.setOnClickListener(new View.OnClickListener() {
  75.             @Override
  76.             public void onClick(View view) {
  77.  
  78.                 Handler.Callback hc = new Handler.Callback() {
  79.                     @Override
  80.                     public boolean handleMessage(@NonNull Message message) {
  81.                         int t=message.arg1;
  82.                         textView1.setText("音乐序号："+String.valueOf(t));
  83.                         mediaPlayer = new MediaPlayer();
  84.                         mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  85.                         try {
  86.                             mediaPlayer.setDataSource(al.get(t));
  87.                             mediaPlayer.prepareAsync();          //这句必须放在setDataSource的后面，否则报错
  88.  
  89.                         } catch (IOException e) {
  90.                             throw new RuntimeException(e);
  91.                         }
  92.                         mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
  93.                             @Override
  94.                             public void onPrepared(MediaPlayer mediaPlayer) {
  95.                                 mediaPlayer.start();
  96.                             }
  97.                         });
  98.                         return false;
  99.                     }
  100.                 };
  101.  
  102.                 Handler handler=new Handler(Looper.getMainLooper(),hc);
  103.  
  104.                 new Thread(()->{
  105.                     Message message = new Message();
  106.                     message.arg1 = n;
  107.                     handler.sendMessage(message);
  108.                     while(true){
  109.                         if(mediaPlayer!=null) {
  110.                             mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
  111.                                 @Override
  112.                                 public void onCompletion(MediaPlayer mediaPlayer) {
  113.                                     n++;
  114.                                     Message message = new Message();
  115.                                     message.arg1 = n;
  116.                                     handler.sendMessage(message);
  117.  
  118.                                 }
  119.                             });
  120.                         }
  121.                     }
  122.                 }).start();
  123.             }
  124.         });
  125.  
  126. //---------暂停音乐播放，并选播，填如要开始播放的序号------------------------
  127.          button2.setOnClickListener(view -> {
  128.              if(mediaPlayer.isPlaying()){
  129.                  mediaPlayer.release();
  130.              }
  131.              String in=editText.getText().toString();
  132.              n=Integer.valueOf(in);
  133.          });
  134. //----------进一首开始顺序播放---------------------------------------------
  135.          button3.setOnClickListener(view -> {
  136.              if(mediaPlayer.isPlaying()){
  137.                  mediaPlayer.release();
  138.              }
  139.                      Handler.Callback hc = new Handler.Callback() {
  140.                          @Override
  141.                          public boolean handleMessage(@NonNull Message message) {
  142.                              int t=message.arg1;
  143.                              textView1.setText("音乐序号："+String.valueOf(t));
  144.                              mediaPlayer = new MediaPlayer();
  145.                              mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  146.                              try {
  147.                                  mediaPlayer.setDataSource(al.get(t));
  148.                                  mediaPlayer.prepareAsync();          //这句必须放在setDataSource的后面，否则报错
  149.  
  150.                              } catch (IOException e) {
  151.                                  throw new RuntimeException(e);
  152.                              }
  153.                              mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
  154.                                  @Override
  155.                                  public void onPrepared(MediaPlayer mediaPlayer) {
  156.                                      mediaPlayer.start();
  157.                                  }
  158.                              });
  159.                              return false;
  160.                          }
  161.                      };
  162.  
  163.                      Handler handler=new Handler(Looper.getMainLooper(),hc);
  164.  
  165.                      new Thread(()->{
  166.                          n=n+1;
  167.                          Message message = new Message();
  168.                          message.arg1 = n;
  169.                          handler.sendMessage(message);
  170.  
  171.                          while(true){
  172.                              if(mediaPlayer!=null) {
  173.                                  mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
  174.                                      @Override
  175.                                      public void onCompletion(MediaPlayer mediaPlayer) {
  176.                                          n++;
  177.                                          Message message = new Message();
  178.                                          message.arg1 = n;
  179.                                          handler.sendMessage(message);
  180.                                          n++;
  181.                                      }
  182.                                  });
  183.                              }
  184.                          }
  185.                      }).start();
  186.  
  187.              });
  188.  //-----------退一首开始顺序播放--------------------------------------------------
  189.        button4.setOnClickListener(view -> {
  190.            if(mediaPlayer.isPlaying()){
  191.                mediaPlayer.release();
  192.            }
  193.            Handler.Callback hc = new Handler.Callback() {
  194.                @Override
  195.                public boolean handleMessage(@NonNull Message message) {
  196.                    int t=message.arg1;
  197.                    textView1.setText("音乐序号："+String.valueOf(t));
  198.                    mediaPlayer = new MediaPlayer();
  199.                    mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
  200.                    try {
  201.                        mediaPlayer.setDataSource(al.get(t));
  202.                        mediaPlayer.prepareAsync();          //这句必须放在setDataSource的后面，否则报错
  203.  
  204.                    } catch (IOException e) {
  205.                        throw new RuntimeException(e);
  206.                    }
  207.                    mediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
  208.                        @Override
  209.                        public void onPrepared(MediaPlayer mediaPlayer) {
  210.                            mediaPlayer.start();
  211.                        }
  212.                    });
  213.                    return false;
  214.                }
  215.            };
  216.  
  217.            Handler handler=new Handler(Looper.getMainLooper(),hc);
  218.  
  219.            new Thread(()->{
  220.                n=n-1;
  221.                Message message = new Message();
  222.                message.arg1 = n;
  223.                handler.sendMessage(message);
  224.                while(true){
  225.                    if(mediaPlayer!=null) {
  226.                        mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
  227.                            @Override
  228.                            public void onCompletion(MediaPlayer mediaPlayer) {
  229.                                n++;
  230.                                Message message = new Message();
  231.                                message.arg1 = n;
  232.                                handler.sendMessage(message);
  233.                                n++;
  234.                            }
  235.                        });
  236.                    }
  237.                }
  238.            }).start();
  239.  
  240.        });
  241. //-=====================================================================================
  242.     }
  243.  
  244.  
  245.         @Override
  246.         public void onBackPressed () {
  247.             super.onBackPressed();
  248.             mediaPlayer.release();
  249.             mediaPlayer = null;
  250.         }
  251.  
  252. }

android 按键事件响应

返回键响应
  1. //-------------------返回关闭视频---------------------------------------
  2.     public void onBackPressed() {     //监听返回键，如返回则关闭视频
  3.         super.onBackPressed();
  4.         mediaPlayer.release();
  5.     }

文本输入框的按键响应

  1.  editText.setOnKeyListener(new View.OnKeyListener() {    //针对文本输入框的按键事件
  2.             @Override
  3.             public boolean onKey(View view, int i, KeyEvent keyEvent) {   
  4.                 if(keyEvent.getAction()==KeyEvent.ACTION_DOWN){   //当按键按下
  5.                     if(i==KeyEvent.KEYCODE_ENTER){                //当键值为回车键
  6.                         textView.setText("ok");
  7.                     }
  8.                 }
  9.                 return false;
  10.             }
  11.         });

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/930846
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号