精华内容
下载资源
问答
  • 通过android:process指定的远程服务是运行在一个独立的进程里,比如说接入消息推送之类的,需要建立长连接。 以下默认是local Service 服务适用于不需要和用户交互,又需要长期运行的任务。 服务的运行不...

    通过android:process指定的远程服务是运行在一个独立的进程里,比如说接入消息推送之类的,需要建立长连接。

    默认是本地服务(与创建服务的在同一个进程中)

    • 服务适用于不需要和用户交互,又需要长期运行的任务。

    • 服务的运行不依赖于任何用户界面,即使程序切换到了后台,服务仍能正常运行。

    • 服务并不是运行在一个独立的进程中,而是依赖创建服务时所在的应用程序进程(默认运行在主线程中)。

    • 服务并不会自动创建线程,需要手动开启线程,才能执行耗时操作。

    • 每个服务只会存在一个实例,无论多次startService还是bindService获取到的实例

    • 服务启动了就会一直处于运行状态,除非执行stopService或者stopSelf (调用unbind不会停止service)

    • 需要在AndroidManifest中声明

    既然服务和线程没有任何关系,而且服务工作在主线程中,不能执行耗时操作(无论是按键超时、服务超时、广播超时都会造成ANR);那服务有啥用呢?让服务执行耗时操作需要手动开启线程,线程不也可以长时间运行么?

    官方解释:

    A service is simply a component that can run in the background, even when the user is not interacting with your application, so you should create a service only if that is what you need.
    If you must perform work outside of your main thread, but only while the user is interacting with your application, you should instead create a new thread.

    If you create a Thread or an Executor in an Activity of your app, this leads to unpredictable results, since a simple screen orientation change will disrupt things, since the Activity will no longer be around when the Thread completes its task.You could use AsyncTask to handle this, but what if your app needs this Background Thread to be started from not just an Activity, but a notification or another component?

    In these cases, Android Services are the right Android component to use to match up the Thread’s lifecycle with that of the Service’s lifecycle.

    1、Thread 的运行是独立于Activity的,也就是说当一个Activity被finish之后,如果你没有主动停止Thread或者Thread里的run方法没有执行完毕的话,Thread 也会一直执行。在线程执行完毕,我们可以手动stopself让service结束,避免浪费资源。

    2、当Activity被finish之后,不再持有该Thread的引用,也就不能在不同的Activity中对同一Thread进行控制。而我们可以在任何有Context的地方调用Context.startService、Context.stopService、Context.bindService,Context.unbindService 来操作service。

    Android多线程编程

    Android的单线程模型

    1.不能阻塞UI线程。 所有耗时操作(网络、数据库、大文件等)都应该放在子线程中操作

    2.不能在UI线程之外访问Android UI 。因为更新UI的方法不是线程安全的(更新时会进行线程检查)

    所以一般在子线程中执行耗时操作,再回到主线程( UI线程 )更新UI。(一般通过Handler进行操作)

    Handle模型

    Handle/Message/MessageQueue/Looper 实现线程间交互

    1、每个线程都只有一个MessageQueue,一个Looper

    2、handle.sendMessage()会将message放入当前线程的Messagequeue中,等待执行

    3、looper.loop()遍历MessageQueue中的每个message,执行msg.target.handleMessage(),回调handler的handleMessage()

    详情请见:

    服务的生命周期

    • onCreate() 服务创建的时候调用(只调用一次)

    • onStartCommand() 服务每次启动的时候调用(虽然每次startService都会调用一次,但每个服务都只会存在一个实例)

    • onDestroy() 服务销毁时调用(如果startService & bindService,则要调用stopService & unbindService,才回调onDestroy)

    执行1-2 日志:onCreate -> onStartCommand -> onDestroy

    执行1-1-2 日志:onCreate -> onStartCommand -> onStartCommand -> onDestroy (onStartCommand会执行多次)

    执行3-4 日志:onCreate -> onBind -> onServiceConnected -> onDestroy (直接bindService创建的服务不会执行onStartCommand)

    执行1-3-4-2 日志:onCreate -> onStartCommand -> onBind -> onServiceConnected -> onDestroy (既执行了startService,又执行了bindService)

    执行4 日志:service not Registed exception (没有bind,不能执行unbind)

    执行1-4 日志:service not Registed exception

    执行1-3-4-4 日志:onCreate -> onStartCommand -> onBind -> onServiceConnected -> service not Registed exception (已经unbind之后,未bind,也不能unbind)

    在activity中执行3,退出activity,报错has leaked ServiceConnection,会执行onDestroy

    在activity中执行1,退出activity,不报错,不会执行onDestroy,服务启动了就会一直处于运行状态,除非执行stopService 或者 stopSelf

    当activity 和 service 绑定之后,就可以调用该服务中 binder 提供的方法了

    1. startService
    val intent = Intent(this, MyService::class.java)
    startService(intent)
    
    1. stopService
    val intent = Intent(this, MyService::class.java)
    stopService(intent)
    
    1. bindService
    val intent = Intent(this, MyService::class.java)
    bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
    

    4.unbindService

    unbindService(serviceConnection)
    

    服务的使用

    通过startService 和stopService只是启动和结束服务,但是activity和service并没有建立关联,activity并不能定点让service干什么工作。

    由bindService来建立 activity 和 service 之间的联系,onBind返回的IBinder类向上转型,为service中定义的Binder类,得到了Binder实例,就可以调用Binder中定义的方法。

    var downloadBinder: MyService.DownLoadBinder? = null
    
    val serviceConnection = object  : ServiceConnection{
        override fun onServiceDisconnected(name: ComponentName?) {
            LogUtils.e(" onServiceDisconnected invoke!!!")
        }
    
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            LogUtils.e(" onServiceConnected invoke!!!")
            downloadBinder = service as MyService.DownLoadBinder? //向上转型
            downloadBinder?.startDownLoad() //调用bind的方法
            downloadBinder?.getProgress()
        }
    }
    

    MyService.java

    public class MyService extends Service {
    
        private DownLoadBinder mBinder = new DownLoadBinder();
    
        public static class DownLoadBinder extends Binder {
    
            public void startDownLoad() {
                Log.e("zhen", "startDownLoad");
            }
    
            public void getProgress() {
                Log.e("zhen", "getProgress");
            }
    
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.e("zhen", "onCreate");
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            Log.e("zhen", "onStartCommand");
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            Log.e("zhen", "onBind");
            return mBinder;
        }
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.e("zhen", "onDestroy");
        }
    }
    

    AndroidManifest中注册

    android:exported=“true” 表示允许除当前程序之外的其它程序访问这个服务,默认为true

    android:enabled=“true” 表示启动这个服务,默认为true

    <service android:name=".module.service.MyService"
        android:exported="true"
        android:enabled="true"/>
    
    展开全文
  • Activity是用户和Android程序交互接口。一个Activity相当于一个窗口,这个窗口中可以放置各种控件与用户交互。窗口通常充满屏幕,但也可以小于屏幕而浮于其它窗口之上。功能类似于MVC设计模式中的Controller,但它...

    1.Activity的作用

    Activity是用户和Android程序交互接口。一个Activity相当于一个窗口,这个窗口中可以放置各种控件与用户交互。窗口通常充满屏幕,但也可以小于屏幕而浮于其它窗口之上。功能类似于MVC设计模式中的Controller,但它本身并不是一个用户界面。

    2.Activity的生命周期包含以下7个方法

    创建:onCreate() 

    开始:onStart() 

    恢复:onResume() 

    暂停:onPause()

    停止:onStop()

    销毁:onDestroy()

    重启:onRestart()

    这只是字面上英文的意思,在应用程序中方法其实是两两对应:

    onCreate()  与 onDestroy()  :可以理解为创建应用程序窗口与销毁窗口

    onStart()  与 onStop() :可以理解为程序窗口可见与不可见

    onResume() 与 onPause() :可以理解为程序窗口获得焦点(或者编辑)与失去焦点

    onRestart():是在Activity被onStop后,但是没有被onDestroy,在再次启动此Activity时就调用onRestart(而不再调用onCreate)方法;如果被

    onDestroy了,则是调用onCreate方法。

    3.Activity 启动顺序

    第一个Activity的启动顺序:onCreate() -> onStart() -> onResume()

    第二个Activity的启动顺序:第一个Activity onPause()  第二个Activity onCreate()   -> onStart() -> onResume() -> 第一个Activity onStop()

    返回到第一个Activity启动顺序:第二个Activity onPause() -> 第一个Activity onRestart() -> onStart() -> onResume()->第二个Activity onStop() ->    

    onDestroy()

    另外,Activity在处于onPause、onStop、onDestroy状态下,系统都可以销毁该Activity所在进程,所以我们在处理要保存的数据时,

    最好在onPause方法,因为onStop和onDestroy方法不一定会被调用。

     

    转载于:https://www.cnblogs.com/michaelShao/p/4337633.html

    展开全文
  • 其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件:1.并不依赖于用户可视的UI界面(当然,这一条其实也...

    本地服务(Local Service)

    Service通常总是称之为“后台服务”,其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件:

    1.并不依赖于用户可视的UI界面(当然,这一条其实也不是绝对的,如前台Service就是与Notification界面结合使用的);

    2.具有较长时间的运行特性。

    启动Service

    1.新建一个MyService,并extends一个Service,重写onCreate()、onStartCommand()和onDestroy()方法;
    代码如下:
    public class Myservice extends Service {
        @Override
        public void onCreate() {
            // TODO Auto-generated method stub
            Log.i("info", "Service -- onCreate()");
            super.onCreate();
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            Log.i("info", "Service -- onBind()");
            return null;
        }
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            Log.i("info", "Service -- onStartCommand()");
            return super.onStartCommand(intent, flags, startId);
        }
    
        @Override
        public void onDestroy() {
            Log.i("info", "Service -- onDestroy()");
            super.onDestroy();
        }
    
    }
    2.并且在配置文件 AndroidManifest.xml 中声明
    代码如下:
    <service android:name="com.at.myservice.Mysystemservice" >
    3.在Activity中启动Service/在Acitity中停止Service
    Intent startintent = new Intent(MainActivity.this, Myservice.class);
    startService(intent);
    Intent stopintent = new Intent(MainActivity.this, Myservice.class);
    stopService(intent);
    

    Service的生命周期

    这里写图片描述

    使用startService()启动Service

    其生命周期为

    startService() ->onCreate()- >onStart()->Service running–>(如果调用context.stopService() )->onDestroy() ->Service shut down

    如果Service还没有运行,则android先调用onCreate()然后调用onStart();
    如果Service已经运行,则只调用onStart(),所以一个Service的onStart方法可能会重复调用多次。

    调用stopService的时候直接onDestroy,
    如果是调用者自己直接退出而没有调用stopService的话,Service会一直在后台运行。
    该Service的调用者再启动起来后可以通过stopService关闭Service。

    所以调用startService的生命周期为:onCreate –> onStart(可多次调用) –> onDestroy

    使用bindService()启动Service

    其生命周期为

    indService()->onCreate()->onBind()->Service running–>onUnbind() -> onDestroy() ->Service stop

    onBind将返回给客户端一个IBind接口实例,IBind允许客户端回调服务的方法,比如得到Service运行的状态或其他操作。

    public class MyBinder extends Binder {
            public Mybindservice getService() {
                return Mybindservice.this;
            }
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            // TODO Auto-generated method stub
            Log.i("info", "service -- onbind");
            return new MyBinder();
        }

    这个时候把调用者(Context,例如Activity)会和Service绑定在一起,Context退出了,
    Srevice就会调用onUnbind->onDestroy相应退出。

    Mybindservice service;
    ServiceConnection conn = new ServiceConnection() {
    
            @Override
            // 当服务跟启动源断开的时候 会自动调用
            // 比如当Service崩溃了或者被强行杀死了就调用
            public void onServiceDisconnected(ComponentName name) {
                // TODO Auto-generated method stub
    
            }
    
            @Override
            // 当服务跟启动源连接的时候 会自动调用
            // service改为binder对象
            public void onServiceConnected(ComponentName name, IBinder binder) {
                // TODO Auto-generated method stub
                service = ((MyBinder) binder).getService();
            }
        };

    所以调用bindService的生命周期为:onCreate –> onBind(只一次,不可多次绑定) –> onUnbind –> onDestory。
    一但销毁activity它就结束,如果按home把它放到后台,那他就不退出。

    特点

    这里写图片描述

    用途与注意用法

    耗时操作如

    1.下载文件操作
    2.网络连接操作
    3.音频格式转换操作
    4.文件操作
    5.比较大的数据的初始化操作
    6.sleep函数等等

    解绑Service

    @Override
        protected void onDestroy() {
            stopService(intent2);
            unbindService(conn);
            super.onDestroy();
        }
    展开全文
  • Service通常总是称之为“后台服务”,其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件: 1.并不依赖于...

    Service通常总是称之为“后台服务”,其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件:
    1.并不依赖于用户可视的UI界面(当然,这一条其实也不是绝对的,如前台Service就是与Notification界面结合使用的);
    2.具有较长时间的运行特性。 常见于下载等耗时任务。
    一,service 和其他三个组件一样,在应用时首先需要在AndroidMainfest文件中注册。
    <service android:enabled=[“true” | “false”]
    android:exported=[“true” | “false”]
    android:icon=“drawable resource”
    android:isolatedProcess=[“true” | “false”]
    android:label=“string resource”
    android:name=“string”
    android:permission=“string”
    android:process=“string” >

    android:name对应Service类名,android:permission是权限声明,android:process设置具体的进程名称,android:exported 是service是否可以被外部引用。
    二,service的使用
    service有两种使用方式
    1,startService 和stopService
    开始service
    intentService = new Intent(MainActivity.this,MyService.class);
    intentService.putExtra(“name”,“我是 service!”);
    startService(intentService);
    关闭service stopService(intentService);在Service内部,也可以通过stopSelf(…)方式停止其本身。
    涉及的service生命周期方法有
    @Override
    public void onCreate() {
    super.onCreate();
    Log.e(tag,“in onCreate”);
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
    Log.w(tag, “in onStartCommand”);
    String name = intent.getStringExtra(“name”);
    Log.w(tag, “name:” + name);
    return START_STICKY;
    }
    @Override
    public void onDestroy() {
    Log.e(tag,“onDestroy”);
    super.onDestroy();
    }
    第一次启动startService 生命周期方法调用情况如下:
    2018-12-23 22:13:41.156 2276-2276/com.example.lcq.myapp E/MyService: in onCreate
    2018-12-23 22:13:41.156 2276-2276/com.example.lcq.myapp W/MyService: in onStartCommand
    2018-12-23 22:13:41.157 2276-2276/com.example.lcq.myapp W/MyService: name:我是 service!
    再次点击 start后调用如下
    2018-12-23 22:16:01.469 2276-2276/com.example.lcq.myapp W/MyService: in onStartCommand
    2018-12-23 22:16:01.469 2276-2276/com.example.lcq.myapp W/MyService: name:我是 service!
    由此可见 oncreate 方法只调用一次,而onStartCommand 可多次调用。
    执行stopService方法调用方法如下:
    2018-12-23 22:18:28.528 2276-2276/com.example.lcq.myapp E/MyService: onDestroy
    public int onStartCommand(Intent intent, int flags, int startId) 返回一个int型的值
    具体的可选值及含义如下:
    START_NOT_STICKY:当Service因为内存不足而被系统kill后,接下来未来的某个时间内,即使系统内存足够可用,系统也不会尝试重新创建此Service。除非程序中Client明确再次调用startService(…)启动此Service。
    START_STICKY:当Service因为内存不足而被系统kill后,接下来未来的某个时间内,当系统内存足够可用的情况下,系统将会尝试重新创建此Service,一旦创建成功后将回调onStartCommand(…)方法,但其中的Intent将是null,pendingintent除外。
    START_REDELIVER_INTENT:与START_STICKY唯一不同的是,回调onStartCommand(…)方法时,其中的Intent将是非空,将是最后一次调用startService(…)中的intent。
    2,bind 和unbind方式
    这种方式要借助于ServiceConnection 这个接口将用户绑定后台服务后,可获取后台服务代理对象的回调,我们可以通过该回调,拿到后台服务的代理对象,并调用后台服务定义的方法,也就实现了后台服务和前台的交互,代码试下如下:
    private class MyServiceConnection implements ServiceConnection {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
    Log.w(tag, “in MyServiceConnection onServiceConnected”);
    myBinder = (MyService.MyBinder) service;
    myService = myBinder.getService();
    mBound = true;
    }
    @Override
    public void onServiceDisconnected(ComponentName name) {
    Log.w(tag, “in MyServiceConnection onServiceDisConnected”);
    mBound = false;
    }
    }

    private MyBinder myBinder = new MyBinder();
    public class MyBinder extends Binder {
    public MyService getService() {
    Log.e(tag,“getService”);
    return MyService.this;
    }
    }
    @Override
    public IBinder onBind(Intent intent) {
    Log.e(tag,“in onBind”);
    return myBinder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
    Log.e(tag,“unbind”);
    return super.onUnbind(intent);
    }
    @Override
    public void onDestroy() {
    Log.e(tag,“onDestroy”);
    super.onDestroy();
    }
    首次点击onbind log显示如下:
    2018-12-23 22:39:24.093 2276-2276/com.example.lcq.myapp E/MyService: in onCreate
    2018-12-23 22:39:24.093 2276-2276/com.example.lcq.myapp E/MyService: in onBind
    2018-12-23 22:39:24.094 2276-2276/com.example.lcq.myapp W/MainActivity: in MyServiceConnection onServiceConnected
    2018-12-23 22:39:24.094 2276-2276/com.example.lcq.myapp E/MyService: getService
    再次点击bind 不再执行 周期函数方法,说明MyBindService没有进行任何回调。
    点击unbind 执行如下:
    2018-12-23 22:42:01.418 2276-2276/com.example.lcq.myapp E/MyService: unbind
    2018-12-23 22:42:01.418 2276-2276/com.example.lcq.myapp E/MyService: onDestroy
    通过bind和unbind方法我们可以使用Messager来进行通信,通过Messenger方式返回Binder对象可以不用考虑Clinet - Service是否属于同一个进程的问题,并且,可以实现Client - Service之间的双向通信。极大方便了此类业务需求的实现。
    public class SecondActivity extends BaseActivity {
    private static final String tag =“SecondActivity”;
    private boolean mBound;
    private Messenger mServerMessager;
    private Handler mClientHander = new MyClientHandler();
    private Messenger mClientMessager = new Messenger(mClientHander);
    class MyClientHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
    if(msg.what == MyMessagerService.MSG_FROM_SERVER_TO_CLIENT) {
    Log.e(tag,“receive msg from server”);
    Toast.makeText(SecondActivity.this,“从server 传过来的消息”,Toast.LENGTH_SHORT).show();
    }
    }
    }
    private ServiceConnection sc = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
    Log.e(tag,“onServiceConnected”);
    mServerMessager = new Messenger(service);
    mBound = true;
    }
    @Override
    public void onServiceDisconnected(ComponentName name) {
    mBound= false;
    }
    };
    public void bindService(View view) {
    Log.e(tag,“bindService”);
    Intent intent = new Intent(SecondActivity.this,MyMessagerService.class);
    bindService(intent,sc,Context.BIND_AUTO_CREATE);
    }
    public void unbindService(View view) {
    Log.e(tag,“unbindService”);
    excuteUnbindService();
    }
    public void sendMessager(View view) {
    Log.e(tag,“sendMessager”);
    sendMsg();
    }
    private void sendMsg() {
    if(!mBound) {
    return;
    }
    Message msg = Message.obtain(null, MyMessagerService.MSG_FROM_CLIENT_TO_SERVER,0,0);
    msg.replyTo = mClientMessager;
    try {
    mServerMessager.send(msg);
    } catch (RemoteException e) {
    e.printStackTrace();
    }
    }
    private void excuteUnbindService() {
    if (mBound) {
    unbindService(sc);
    mBound = false;
    }
    }
    }
    service类中的代码如下:
    public class MyMessagerService extends Service {
    public static final String TAG = “MyMessengerService”;
    public static final int MSG_FROM_CLIENT_TO_SERVER = 1;
    public static final int MSG_FROM_SERVER_TO_CLIENT = 2;
    private Messenger mClientMessager;
    private Messenger mSericeMessager = new Messenger(new ServerBinder());
    @Override
    public IBinder onBind(Intent intent) {
    Log.e(TAG,“onBind”);
    return mSericeMessager.getBinder();
    }
    public class ServerBinder extends Handler {
    @Override
    public void handleMessage(Message msg) {
    Log.w(TAG, “thread name:” + Thread.currentThread().getName());
    switch (msg.what) {
    case MSG_FROM_CLIENT_TO_SERVER:
    mClientMessager = msg.replyTo;
    Message toClinetMsg = Message.obtain(null,MSG_FROM_SERVER_TO_CLIENT);
    try {
    Log.w(TAG, “server begin send msg to client”);
    Toast.makeText(MyMessagerService.this,“从Client 传过来的消息”,Toast.LENGTH_SHORT).show();
    mClientMessager.send(toClinetMsg);
    } catch (RemoteException e) {
    e.printStackTrace();
    }
    break;
    default:
    break;
    }
    super.handleMessage(msg);
    }
    }
    @Override
    public boolean onUnbind(Intent intent) {
    Log.e(TAG,“onUnbind”);
    return super.onUnbind(intent);
    }
    @Override
    public void onDestroy() {
    Log.e(TAG,“onDestroy”);
    super.onDestroy();
    }
    }
    首先在service 和activity各定义了一个messager,然后通过bindService 将mServerMessager 通过ServiceConnection 绑定到activity,再点击sendMsg时又将activity的mClientMessager通过mServerMessager send到service,service 获取到mClientMessager后又将mServerMessager send到activity 从而实现了activity和activity的双向通信。
    3,IntentService
    IntentService是专门用来解决Service中不能执行耗时操作这一问题的,创建一个IntentService也很简单,只要继承IntentService并覆写onHandlerIntent函数,在该函数中就可以执行耗时操作了。
    class MyIntentService extends IntentService {
    /**
    * 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);
    }
    @Override
    protected void onHandleIntent(Intent intent) {
    //TODO 在这里执行耗时操作
    }
    }
    4,常见系统服务
    系统服务提供了很多便捷服务,比如查询Wifi、网络状态、查询电量、查询音量、查询包名、查询Application信息等等等相关多的服务,
    1,判断手机是否开启wifi服务
    WifiManager wifi = (WifiManager) getSystemService(WIFI_SERVICE);
    boolean enabled = wm.isWifiEnabled();
    2,获取当前音量和最大音量
    AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
    int current = am.getStreamMaxVolume(AudioManager.STREAM_RING);
    int max = am.getStreamMaxVolume(AudioManager.STREAM_SYSTEM);
    3,判断网络是否连接
    ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
    NetworkInfo info = cm.getActiveNetworkInfo();
    boolean isAvailable = info.isAvailable();

    **5,IntentService
    当你的应用需要下载一个文件或者播放音乐等长期处于后台工作而有没有UI界面的时候,需要用到Service+Thread 开启一个子线程进行耗时的操作,然而你每次都需要自己去写一个Service+Thread来处理长期处于后台而没有UI界面的任务,这样显得很麻烦,没必要每次都去构建一个Service+Thread框架处理长期处于后台的任务,而IntentService就是一个继承Service的基础类,用于处理Intent类型的异步任务请求,当客户端调用android.content.Context#startService(Intent)发送请求时,Service服务被启动,且在其内部构建一个工作线程来处理Intent请求。当工作线程执行结束,Service服务会自动停止。IntentService是一个抽象类,用户必须实现一个子类去继承它,且必须实现IntentService里面的抽象方法onHandleIntent来处理异步任务请求。

    展开全文
  • 以下均对应的相应的文章的链接 Activity Service Broadcast ContentProvider Fragment (不是四大组件之一)
  • Android中Service组件详解

    万次阅读 2011-05-17 15:16:00
    Service是Android四大组件之一,以下是我结合Android Doc和网上资料的学习总结,有不准确的地方请高手指出,互相学习嘛。。。   1.Service是什么 Service是Android四大组件之一,即Android系统的服务(不是...
  • Service是Android四大组件之一,以下是我结合Android Doc和网上资料的学习总结,有不准确的地方请高手指出,互相学习嘛。。。   1.Service是什么 Service是Android四大组件之一,即Android系统的服务(不是...
  • Service是android中实现程序后台运行的解决方案,适合于执行那些不需要和用户交互且要求长期执行的任务,Service有以下几个特点: 1.service运行在后台,前台看不到 2.service不是运行在一个独立的进程中的,而是...
  • Android应用都是由以下四大组件组成的:①Activity、②BroadcastReceiver、③Service、④ContentProvider 1)Activity是最基本的Android应用程序组件,应用程序中,一个Activity通常就是一个单独...
  • Android简单音乐播放器

    2017-05-15 09:02:11
    Service作为Android四大组件之一,通常被称为“后台服务”具体是指其本身的运行并不依赖于用户可视的UI界面,实际应用,Service的适用场景应该具备以下条件: (1)并不依赖于用户可视的UI界面(当然,这一条其实也...
  • Android 事件传递机制总结

    千次阅读 2019-06-15 17:47:55
    Android View虽然不是四大组件,但是其重要程度堪比四大组件。初级工程师到中高级工程师,这些都是很重要的,因为事件分发机制面试也会经常被提及,如果我们能get到要领,并跟面试官深入的交流一下,那么一定会让...
  • Activity作为Android四大组件之一,是我们Android开发中打交道最为频繁的组件之一。而我们实际运用中却没有注意到很多Activity的细节知识点。所以在面试之中如果Activity相关的知识我们不能很好的回答,说明我们...
  • Android程序自启动小结

    千次阅读 2016-08-22 17:43:09
    揭秘:手机软件自启原理 大家都会想知道,这些软件不是我主动运行的,...不过在介绍之前,先要铺垫一下:Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器
  • Android四大组件之一,其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件: 并不依赖于用户可视的UI界面...
  • android应用自启分析与S4启动列表

    千次阅读 2015-05-05 10:46:09
    揭秘:手机软件自启原理 大家都会想知道,这些软件不是我主动运行的,到底是...不过在介绍之前,先要铺垫一下:Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接
  • Android View 虽然不是四大组件,但其并不比四大组件的地位低。而View的核心知识点事件分发机制则是不少刚入门同学的拦路虎。ScrollView嵌套RecyclerView(或者ListView)的滑动冲突这种老大难的问题的理论基础就是...
  • 一些手机软件不是用户主动运行的,那么它到底是如何自己...不过在介绍之前,先要铺垫一下:Android四大基本组件分别是Activity、Service服务、Content Provider内容提供者以及BroadcastReceiver广播接收器,每个组件...
  • 首先,Activity是Android系统中的四大组件之一,可以用于显示View。Activity是一个与用记交互的系统模块,几乎所有的Activity都是和用户进行交互的,但是如果这样就能说Activity主要是用来显示View就不太正确了。 ...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

以下不是android四大组件