Android0909<十四>（Service、Android线程）

最新推荐文章于 2021-12-19 16:26:22 发布
最新推荐文章于 2021-12-19 16:26:22 发布
阅读量455 收藏
点赞数
分类专栏： android 学习 文章标签： android 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wujie5201/article/details/48312219
版权

Service

利用Service做一个虚拟进度条
ProgressBar进度条，progress可以设置默认的进度
在activity_main.xml中加入进度条

 <ProgressBar
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/progressBar"
        android:layout_gravity="center_horizontal"
        android:progress="50"/>
    <Button
        android:id="@+id/start_download"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始下载"/>

设置线程，通过启动服务来启动线程，线程启动进度，
MyService.java

public class MyService extends Service{
    private int count;
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("运行到了","onCreate");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("运行到了","onDestroy");
    }

    @Override
    public int onStartCommand(final Intent intent, int flags, int startId) {
        Log.d("运行到了","onStartCommand");
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(count<100){
                    if (count>100){
                        count=0;
                    }
                    count++;
                    Intent intent1=new Intent();
                    intent1.setAction(MainActivity.DOWN_LOAD_ACTION);
                    intent1.putExtra("count",count);
                    sendBroadcast(intent1);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        return super.onStartCommand(intent, flags, startId);
    }
}

进行动态注册，在Activity_Manifest.xml中注册

 <service android:name=".MyService"></service>

在MainActivity.java中进行设置监听事件

public class MainActivity extends Activity {
    private Button btn_start_service;
    private Button btn_stop_service;
    private Button btn_start_download;
    private ProgressBar progressBar;
    private MyDownLoadService mDownLoadService;
    public static final String DOWN_LOAD_ACTION="com.service.text";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);     
        btn_start_service= (Button) findViewById(R.id.start_service);
        btn_start_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                startService(intent);
            }
        });
        btn_stop_service= (Button) findViewById(R.id.stop_service);
        btn_stop_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                stopService(intent);
            }
        });

        mDownLoadService=new MyDownLoadService();
        IntentFilter filter=new IntentFilter();
        filter.addAction(DOWN_LOAD_ACTION);
        registerReceiver(mDownLoadService,filter);

        progressBar= (ProgressBar) findViewById(R.id.progressBar);
        btn_start_download= (Button) findViewById(R.id.start_download);
        btn_start_download.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                startService(intent);
            }
        });
    }
    class MyDownLoadService extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            int count=intent.getIntExtra("count", 0);
            progressBar.setProgress(count);
        }
    }
    //解绑,取消广播
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mDownLoadService);
    }
}

这里写图片描述

Service是运行在主线程中，第一次运行时会调用onCreate()、onStartCommand()，当第二次启动时只会调用onStartCommand()，而当只在后台允许一个耗时操作时就要用到IntentService，IntentService本身包含一个线程，包含一个消息队列，会将后续的消息排在队列中，然后等待前面的消息运行结束后，在进行处理后续的消息。

在activity_main.xml中添加一个按钮

 <Button
        android:id="@+id/start_download_intentservice"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始intentservice下载"/>

写一个MyIntentService.java类,继承于IntentService，要在AndroidManifest.xml中注册

<service android:name=".MyIntentService"></service>
public class MyIntentService extends IntentService{
    private int count;
    /**
     * Creates an IntentService.  Invoked by your subclass's constructor.
     *
     * @param name Used to name the worker thread, important only for debugging.
     */
    public MyIntentService(String name) {
        super(name);
    }
    public MyIntentService() {
        this("");
    }
    @Override
   protected void onHandleIntent(Intent intent) {
        Log.d("IntetnService","运行到了OnCreate");
        while(count<100){
            if (count>100){
                count=0;
            }
            count++;
            Intent intent1=new Intent();
            intent1.setAction(MainActivity.DOWN_LOAD_ACTION);
            intent1.putExtra("count",count);
            sendBroadcast(intent1);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Log.d("IntetnService","运行到了onStartCommand");
    }
}

在MainActivity.java中添加点击事件

public class MainActivity extends Activity {
    private Button btn_start_service;
    private Button btn_stop_service;
    private Button btn_start_download;
    private Button btn_intentservice;
    private ProgressBar progressBar;
    private MyDownLoadService mDownLoadService;
    public static final String DOWN_LOAD_ACTION="com.service.text";
    private AlarmManager mAlarmManager;
    private BroadcastReceiverActivity mBroadcast;
    private android.content.ContentResolver resolver;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn_start_service= (Button) findViewById(R.id.start_service);
        btn_start_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                startService(intent);
            }
        });
        btn_stop_service= (Button) findViewById(R.id.stop_service);
        btn_stop_service.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                stopService(intent);
            }
        });

        mDownLoadService=new MyDownLoadService();
        IntentFilter filter=new IntentFilter();
        filter.addAction(DOWN_LOAD_ACTION);
        registerReceiver(mDownLoadService,filter);

        progressBar= (ProgressBar) findViewById(R.id.progressBar);
        btn_start_download= (Button) findViewById(R.id.start_download);
        btn_start_download.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyService.class);
                startService(intent);
            }
        });

        btn_intentservice= (Button) findViewById(R.id.start_download_intentservice);
        btn_intentservice.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent=new Intent(getApplicationContext(),MyIntentService.class);
                startService(intent);
            }
        });
    }
    class MyDownLoadService extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            int count=intent.getIntExtra("count", 0);
            progressBar.setProgress(count);
        }
    }
    //解绑
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mDownLoadService);
    }
}

这里写图片描述

Android线程

这里写图片描述
这里写图片描述
这里写图片描述

利用线程更新UI界面,Hanler()

UI界面只允许主线程来更改UI界面绘制，不允许其他线程来更改界面的绘制，给否则会报错抛出异常。因此就需要想要更改UI界面的线程将要更改界面的消息通过Message传递给主线程，由主线程来完成界面的绘制，当有多条消息时，主线程会将这些消息放在一个消息队列中，等待主线程的处理，通过Handler将消息转递给主线程，然后通过Handler的handleMessage() 方法来对消息进行处理。

Message msg=new Message();
msg.obj=count+"秒";
msg.what=TIME_DESC;
mhandler.sendMessage(msg);

Handler

 private Handler mhandler=new Handler(){
        public void handleMessage(Message msg){
            Log.d("秒数",""+count+msg);
            switch(msg.what){
                case TIME_DESC:
                    String time= (String) msg.obj;
                    btn_handler.setText(time);
                    break;
            }
        }
    };

这里就以倒计时定时器为例，界面activity_main.xml

 <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="倒计时"/>
        <Button
            android:id="@+id/btn_handler"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="60秒"/>

MainActivity.java

public class MainActivity extends Activity {
    private int count=60;
    private static  final  int TIME_DESC=0x23;
    private Button btn_handler;
    private Handler mhandler=new Handler(){
        public void handleMessage(Message msg){
            Log.d("秒数",""+count+msg);
            switch(msg.what){
                case TIME_DESC:
                    String time= (String) msg.obj;
                    btn_handler.setText(time);
                    break;
            }
        }
    };
   @Override
    protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         btn_handler= (Button) findViewById(R.id.btn_handler);
         btn_handler.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                count=60;
                Toast.makeText(getApplication(),"开始倒计时",Toast.LENGTH_SHORT).show();
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while (count>0){
                            count--;
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            Message msg=new Message();
                            msg.obj=count+"秒";
                            msg.what=TIME_DESC;
                            mhandler.sendMessage(msg);
                            Log.d("秒数",""+count+msg);
                        }
                    }
                }).start();
            }
        });
 }

这里写图片描述

但这样写代码会有写繁琐，为了简洁，采用另外一种方法可以达到同样效果，前者使通过主线程里的封装好的Looper()方法来管理消息队列，这里我们可以通过一个自定义的Thread类来对消息进行管理,从而简洁了监听事件里的代码。

MainActivity.java中的按钮事件监听事件

public class MainActivity extends Activity {
    private int count=60;
    private static  final  int TIME_DESC=0x23;
    private Button btnhandler;
    private Handler handler=new Handler(){
        public void handleMessage(Message msg){
            Log.d("秒数",""+count+msg);
           switch(msg.what){
               case TIME_DESC:
                  count--;
                   btnhandler.setText(count+"秒");
                   if (count>0){
                       try {
                           Thread.sleep(1000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       handler.sendEmptyMessage(TIME_DESC);
                   }
                   break;
           }
        }
    };
     @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnhandler= (Button) findViewById(R.id.btnhandler);
        btnhandler.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                count=60;
                handler.sendEmptyMessage(TIME_DESC);           
            }
        });
     }
}

这里写图片描述

子线程更新UI界面使通过子线程给主线程传递消息来更改UI界面，还可以互换一下，子线程可以接收来自主线程的消息。通过调用自定义的线程里的来让主线程发送消息，因此需要先调用启动线程的方法来启动线程里的Handler()来发送消息。

自定义的Thrad，MyThread .java写成内部类

class MyThread extends Thread{
    @Override
    public void run() {
        Looper.prepare();
        mHandler=new Handler(){
            @Override
            public void handleMessage(Message msg) {
                Log.d("handler","接收到了主线程的消息");
            }
        };
        Looper.loop();
    }
}

MainActivity.java

public class MainActivity extends Activity {
    private Button btnhandler;
    private int count=60;
    private static  final  int TIME_DESC=0x23;
    private Handler handler=new Handler(){
        public void handleMessage(Message msg){
            Log.d("秒数",""+count+msg);
           switch(msg.what){
               case TIME_DESC:
                  count--;
                   btnhandler.setText(count+"秒");
                   if (count>0){
                       try {
                           Thread.sleep(1000);
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       handler.sendEmptyMessage(TIME_DESC);
                   }
                   break;
           }
        }
    };
    private Button btnHandler;
    private Handler mHandler;
    class MyThread extends Thread{
    @Override
    public void run() {
        Looper.prepare();
        mHandler=new Handler(){
            @Override
            public void handleMessage(Message msg) {
                Log.d("handler","接收到了主线程的消息");
            }
        };
        Looper.loop();
    }
}
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnHandler= (Button) findViewById(R.id.btnHandler);
        btnHandler.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
               mHandler.sendEmptyMessage(0);

            }
        });

        btnhandler= (Button) findViewById(R.id.btnhandler);
        btnhandler.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                count=60;
                handler.sendEmptyMessage(TIME_DESC);
                MyThread thread=new MyThread();
                thread.start();
            }
        });
    }
}
AsyncTask

这里写图片描述

为了子线程更好地对UI进行操作，Android还提提供了Handler之外一种工具AsyncTast。AsyncTast制定了三个参数，Params在执行AsyncTast时传入，可用于后台中进行的任务，Progress后台执行任务时，需要在界面上显示当前的进度，则使用这里的泛型作为进度单位，Result当任务执行完成后，需要对结果进行返回。

AsyncTask的泛型类型

　　这三个类型被用于一个异步任务，如下：

　　1. Params，启动任务执行的输入参数

　　2. Progress，后台任务执行的百分比

　　3. Result，后台计算的结果类型

4个步骤

　　　　当一个异步任务被执行，任务经过四各步骤：

　　　　1．onPreExecute()，在UI线程上调用任务后立即执行。这步通常被用于设置任务，例如在用户界面显示一个进度条。

　　　　2．doInBackground(Params…)，后台线程执行onPreExecute()完后立即调用，这步被用于执行较长时间的后台计算。异步任务的参数也被传到这步。计算的结果必须在这步返回，将传回到上一步。在执行过程中可以调用publishProgress(Progress…)来更新任务的进度。

　　　　3．onProgressUpdate(Progress…),一次呼叫 publishProgress(Progress…)后调用 UI线程。执行时间是不确定的。这个方法用于当后台计算还在进行时在用户界面显示进度。例如：这个方法可以被用于一个进度条动画或在文本域显示记录。

　　　　4．onPostExecute(Result), 当后台计算结束时，调用 UI线程。后台计算结果作为一个参数传递到这步。

任务实例必须创建在 UI线程

线程规则

　　有一些线程规则必须去遵守，这个类才会正确的工作:任务实例必须创建在 UI线程

execute(Params…)必须在UI线程上调用

不要手动调用onPreExecute(), onPostExecute(Result), doInBackground(Params…), onProgressUpdate(Progress…)

　　　　这个任务只执行一次（如果执行第二次将会抛出异常）

一个简单的自定义的AsyncTast,MyDownLoadService.java

class MyTask extends AsyncTask<String,String ,String>{
    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        btn_progressBar.setText(s);
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        int count1=Integer.parseInt(values[0]);
        mprogressBar.setProgress(count1);
    }

    @Override
    protected String doInBackground(String... params) {
        while(count1<101){
            count1++;
            publishProgress(""+count1);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return "下载已完成";
    }
}

依旧以下载进度条为例。MainActivity.java

public class MainActivity extends Activity {
    private Button btn_progressBar;
    private ProgressBar mprogressBar;
    private int count1=0;
     @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mprogressBar= (ProgressBar) findViewById(R.id.progressBar2);
        btn_progressBar= (Button) findViewById(R.id.btn_progressBar);
        btn_progressBar.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                MyTask task=new MyTask();
                task.execute("去执行吧");
            }
        });
        class MyTask extends AsyncTask<String,String ,String>{
    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        btn_progressBar.setText(s);
    }

    @Override
    protected void onProgressUpdate(String... values) {
        super.onProgressUpdate(values);
        int count1=Integer.parseInt(values[0]);
        mprogressBar.setProgress(count1);
    }

    @Override
    protected String doInBackground(String... params) {
        while(count1<101){
            count1++;
            publishProgress(""+count1);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return "下载已完成";
    }
}

}

activity_main.xml

<ProgressBar
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/progressBar2" />
    <Button
        android:id="@+id/btn_progressBar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="开始"/>

这里写图片描述

wujie5201
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android四大组件Service之两种的多线程启动方式
小磊's blog
11-22 3768
由于Service常常用于处理比较耗时的后台服务，在不适用多线程时，所有的组件服务都是在主线程中执行的，必然会影响用户体验和整体性能，下面是两种启动Service线程的方式。 第一种方法：在Service服务代码的onstartConmmand启动函数中创建一个继承了Thread的实例对象，并使用start()启动线程 Activity代码： package com.exampl
Android学习0906<十一>（ViewPager，fragment碎片）
wujie5201的博客
09-07 1093
ViewPagerViewPager实现的是布局之间滑动的效果，因为Viewpager是继承于v4.support jar包的，因此需要导入包，Android Studio的导包的具体步骤如下：File->Project Structure->Modules->app->Dependencies 首先要在XML中写入Viewpager， <android.support.v4
Android四大组件之Service
sunbinkang的博客
11-11 3150
一、Service的含义 Android四大组件之一：Service是一个可以在后台执行长时间运行操作而不提供用户界面的应用组件； 服务是Android中实现程序后台的解决方案，不依赖任何用户界面，即使程序被切换到后台，或者用户打开了另外一个应用程序，服务还能保持运行，服务非常适合那些不需要和用户交互而且还要求长期运行的任务。 服务像Activity那样也是默认运行在主线程中，如果有耗时任务还是要在服务内部创建子线程，不然程序会ANR。（默认是耗时操作超...
关于Android Service真正的完全详解，你需要知道的一切
热门推荐
zejian的博客
10-07 22万+
Service 1.Service基础知识概述   Service(服务)是一个一种可以在后台执行长时间运行操作而没有用户界面的应用组件。服务可由其他应用组件启动（如Activity），服务一旦被启动将在后台一直运行，即使启动服务的组件（Activity）已销毁了。 此外，组件可以绑定到服务，以与之进行交互，甚至是执行进程间通信 (IPC)。 例如，服务可以处理网络事务、播放音乐，执行文件
Android Service(服务)/进程/线程—服务(Service)
FanFF的博客
12-19 4770
Android Service(服务)、进程、线程的区别； Service(服务)运行在哪个进程；Service(服务)运行在哪个线程
基于AIDL编程实现Android远程Service服务
道阻且长，行则将至。
12-04 3367
文章目录Android本地Service异步消息处理机制服务与活动的通信Android远程ServiceBinder与AIDL基础AIDL Service服务端 Service 作为 Android 四大组件之一，应用非常广泛。 远程服务与本地服务最大的区别是：远程 Service 与调用者不在同一个进程里（即远程 Service 是运行在另外一个进程）；而本地服务则是与调用者运行在同一个进程里。二者区别的详细区别如下图： Android本地Service 先来看看 Android 普通 Service
android Service中多线程交互
08-26
在Android线程模型中，主线程（UI线程）拥有一个默认的消息队列，由Looper类管理。这个消息队列负责接收Handler发送的消息，并按照顺序分发到对应的Handler进行处理。子线程如果需要与主线程交互，就需要自建消息...
<电子书籍>Android开发艺术探索
06-01
1. **Android系统架构**：Android系统分为四个主要层次：Linux内核层、系统库层、应用程序框架层和应用程序层。了解这些层次的功能和交互对于优化应用性能至关重要。 2. **Activity生命周期**：Activity是Android...
Android、教程<经典> 10 Android通用应用
04-04
这个教程系列——“Android、教程<经典> 10 Android通用应用”旨在帮助开发者深化对Android平台的理解，提升开发效率，构建更高质量的应用。以下是对这个系列教程中可能涉及的一些核心知识点的详细解释： 1. **...
Android四大组件之Service(服务)实例详解
09-02
- Service并不保证线程模型，如果需要在Service中执行耗时操作，应使用工作线程，避免阻塞主线程。 - 长时间运行的Service可能会消耗较多资源，因此应该合理设计Service，避免不必要的内存占用和CPU使用。 - 使用...
Android进程和线程详解
03-23
缺省情况下，一个应用的所有组件(Activity，Service等)运行在同一个进程和线程中(称为“主”线程)。如果在启动一个应用程序组件时，这个应用已经有进程在运行(因为有应用的其它组件存在)，那么这个应用程序组件将...
Android0828<十>（自定义的AlertDialog，Popup Window，Notification）
wujie5201的博客
08-29 1068
自定义Dialog 和Shape 自定义的Dialog需要先建立一个drawable放Shape来设置dialog的颜色、边框、和圆角，以下是几个属性 corners圆角率<corners android:bottomLeftRadius="10dp"左下角为半径为10dp的圆角 android:topLeftRadius="10dp"左上角为半径为10dp的圆角 android:topRig
Android学习0819<三>（Activity的操作）
wujie5201的博客
08-19 939
FrameLayout–帧布局 相当于动画的一帧一帧的覆盖原来的控件 <?xml version="1.0" encoding="utf-8"?> <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layou
Android学习0826<八>（GridView、Spinner、AutoCompleteTextView、Gallery、ExpandableListView）
wujie5201的博客
08-26 681
GridView ListView是将数据信息以列表的形式展示，而且只有一列，而GridView是以表格的形式将数据展示出来，需要用到自定义的Adapter， 用numColumns来表示列数android:numColumns="3" activity_gridView.xml <?xml version="1.0" encoding="utf-8"?> <LinearLayout xml
Android0911<十六>（Android里的网络连接）
wujie5201的博客
09-12 670
网络连接查看网络状态ConnectivityManager、Context 查看当前的网络状态是应用能否上网的前提，ConnectivityManager类就是用来返回关于网络连接状态的查询的类。它还通知应用程序时，网络连接的变化。通过Context.getSystemService(Context.CONNECTIVITY_SERVICE).得到一个实例。而Context是一个可以得到应用网络
Android0914<十八>（()Android网络连接HttpConnection、Volley，xUtils）（待更ing）
wujie5201的博客
09-14 666
HttpConnection HttpClient 是一个接口，因此无法创建它的实例，通常情况下都会创建一个DefaultHttpClient的实例，如下: HttpClient client=new DefaultHttpClient();//生成client方法；DoGet 接下来就是发起一条Get请求，就可以创建一个HttpGet对象，并传入目标网络地址，然后调用HttpClient的
Android0917<二十一>（自定义的View、绘制简单图形、Bitmap）(二)
wujie5201的博客
09-17 618
绘制简单图形 MyPath.java public class MyPath extends View{ private int width; private int height; private Paint mPaint; private Paint mPaintText; private Path mPath; private Path mP
Android0915<十九>（多媒体、SoundPool、MediaRecorder、SurfaceView,简单地使用摄像头）
wujie5201的博客
09-16 606
SoundPool SoundPool类管理和播放音频资源的应用。因为MediaPlayer在播放音乐时会资源占用量较高、延迟时间较长、不支持多个音频同时播放等。，但有时一些系统提示音很小，就没有必要用MediaPlayer去播放，就用到了SoundPool.SoundPool载入音乐文件使用了独立的线程，不会阻塞UI主线程的操作。SoundPool主要用于播放一些较短的声音片段，与MediaP
Android0907<十二>（文件存储，SharePreferences，getCacheDir、Environment，SQLite数据库存储）
wujie5201的博客
09-08 545
文件存储 将数据写入并存储到文件中 文件存储是将数据存储到指定的文件中，用的是Context类中openFileOutput()方法，传的两个参数中第一个为文件名称，第二个为文件的操作模式，默认的模式为MODE_PRIVATE，还有一个是MODE_APPEND，前者是后来写入的内容会将前面写入的内容覆盖掉，后者是将新写入的内容追加到原来的文件内容中 try {
Android Service那些事1
最新发布
08-08
本文主要探讨了Android中的Service组件，特别是关注IntentService、普通Service以及它们与Handler和Looper的关系。首先，让我们回顾一下预备知识，需要对Android中的Handler和HandlerThread有所理解，这两个概念在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值