标签归档:基础概念

android-Service和Thread的区别

1.服务不是单一的进程。服务没有自己的进程,应用程序可以不同,服务运行在相同的进程中。

2.服务不是线程。可以在线程中工作。

一.在应用中,如果是长时间的在后台运行,而且不需要交互的情况下,使用服务。

同样是在后台运行,不需要交互的情况下,如果只是完成某个任务,之后就不需要运行,而且可能是多个任务,需要长时间运行的情况下使用线程。

二.如果任务占用CPU时间多,资源大的情况下,要使用线程。

 

servie是系统的组件,它由系统进程托管(servicemanager);它们之间的通信类似于client和server,是一种轻量级的ipc通信,这种通信的载体是binder,它是在linux层交换信息的一种ipc。而thread是由本应用程序托管。

 

1). Thread:Thread 是程序执行的最小单元,它是分配CPU的基本单位。可以用Thread 来执行一些异步的操作。

 

2). Service:Service 是android的一种机制,当它运行的时候如果是Local Service,那么对应的Service 是运行在主进程的main 线程上的。如:onCreate,onStart 这些函数在被系统调用的时候都是在主进程的main 线程上运行的。如果是Remote Service,那么对应的Service 则是运行在独立进程的main 线程上。

 

既然这样,那么我们为什么要用Service 呢?其实这跟android 的系统机制有关,我们先拿Thread 来说。Thread 的运行是独立于Activity 的,也就是说当一个Activity 被finish 之后,如果你没有主动停止Thread 或者Thread 里的run 方法没有执行完毕的话,Thread 也会一直执行。因此这里会出现一个问题:当Activity 被finish 之后,你不再持有该Thread 的引用。另一方面,你没有办法在不同的Activity 中对同一Thread 进行控制。

 

举个例子:如果你的Thread 需要不停地隔一段时间就要连接服务器做某种同步的话,该Thread 需要在Activity 没有start的时候也在运行。这个时候当你start 一个Activity 就没有办法在该Activity 里面控制之前创建的Thread。因此你便需要创建并启动一个Service ,在Service 里面创建、运行并控制该Thread,这样便解决了该问题(因为任何Activity 都可以控制同一Service,而系统也只会创建一个对应Service 的实例)。

 

因此你可以把Service 想象成一种消息服务,而你可以在任何有Context 的地方调用Context.startService、Context.stopService、Context.bindService,Context.unbindService,来控制它,你也可以在Service 里注册BroadcastReceiver,在其他地方通过发送broadcast 来控制它,当然这些都是Thread 做不到的。

———————————————————————————

 

广播接收者(BroadcastReceiver)用于接收广播Intent,广播Intent的发送是通过调用Context.sendBroadcast()、Context.sendOrderedBroadcast()来实现的。通常一个广播Intent可以被订阅了此Intent的多个广播接收者所接收,这个特性跟JMS中的Topic消息接收者类似。要实现一个广播接收者方法如下:
第一步:继承BroadcastReceiver,并重写onReceive()方法。
public class IncomingSMSReceiver extends BroadcastReceiver {
@Override public void onReceive(Context context, Intent intent) {
}
}
第二步:订阅感兴趣的广播Intent,订阅方法有两种:
第一种:使用代码进行订阅
IntentFilter filter = new IntentFilter(“android.provider.Telephony.SMS_RECEIVED”);
IncomingSMSReceiver receiver = new IncomingSMSReceiver();
registerReceiver(receiver, filter);
第二种:在AndroidManifest.xml文件中的<application>节点里进行订阅:
<receiver android:name=”.IncomingSMSReceiver”>
<intent-filter>
<action android:name=”android.provider.Telephony.SMS_RECEIVED”/>
</intent-filter>
</receiver>

如果你想别人接收到的短信,达到你不可告人的目的,那么使用BroadcastReceiver
当系统收到短信时,会发出一个广播Intent,Intent的action名称为、

如果要短信终止广播就要配置上你的广播接收者的级别

<intent-filter android:priority=”100″ >
<action android:name=”android.provider.Telephony.SMS_RECEIVED” />
</intent-filter>

android.provider.Telephony.SMS_RECEIVED,该Intent存放了系统接收到的短信内容,我们使用名称“pdus”即可从Intent中获取到短信内容。

在AndroidManifest.xml文件中的<application>节点里对接收到短信的广播Intent进行订阅:
<receiver android:name=”.你的receiver名称”>
<intent-filter><action android:name=”android.provider.Telephony.SMS_RECEIVED”/></intent-filter></receiver>
在AndroidManifest.xml文件中添加以下权限:
<uses-permission android:name=”android.permission.RECEIVE_SMS”/><!– 接收短信权限 –>
<uses-permission android:name=”android.permission.SEND_SMS”/><!– 发送短信权限 –>

广播接收者的响应性

在Android中,每次广播消息到来时都会创建BroadcastReceiver实例并执行onReceive() 方法, onReceive() 方法执行完后,BroadcastReceiver 的实例就会被销毁。当onReceive() 方法在10秒内没有执行完毕,Android会认为该程序无响应。所以在BroadcastReceiver里不能做一些比较耗时的操作,否侧会弹出ANR(Application No Response)错误对话框。如果需要完成一项比较耗时的工作,应该通过发送Intent给Service,由Service来完成。这里不能使用子线程来解决,因为BroadcastReceiver的生命周期很短,子线程可能还没有结束BroadcastReceiver就先结束了。BroadcastReceiver一旦结束,此时BroadcastReceiver所在的进程很容易在系统需要内存时被优先杀死,因为它属于空进程(没有任何活动组件的进程)。如果它的所在进程被杀死,那么正在工作的子线程也会被杀死。所以采用子线程来解决是不可靠的。

public class IncomingSMSReceiver extends BroadcastReceiver {
@Override public void onReceive(Context context, Intent intent) {
//发送Intent启动服务,由服务来完成比较耗时的操作
Intent service = new Intent(context, XxxService.class);
context.startService(service);
}

除了短信到来广播Intent,Android还有很多广播Intent,如:开机启动、电池电量变化、时间已经改变等广播Intent。
接收电池电量变化广播Intent ,在AndroidManifest.xml文件中的<application>节点里订阅此Intent:
<receiver android:name=”.IncomingSMSReceiver”>
<intent-filter>
<action android:name=”android.intent.action.BATTERY_CHANGED”/>
</intent-filter>
</receiver>

接收开机启动广播Intent,在AndroidManifest.xml文件中的<application>节点里订阅此Intent:
<receiver android:name=”.IncomingSMSReceiver”>
<intent-filter>
<action android:name=”android.intent.action.BOOT_COMPLETED”/>
</intent-filter>
</receiver>
并且要进行权限声明:
<uses-permission android:name=”android.permission.RECEIVE_BOOT_COMPLETED”/>

广播接收者补充

广播分两种
有序广播 按照广播的优先级 发给相对应的广播接收者-1000-1000 激活广播通过onrecve方法处理
无序广播

有序广播有一个特例
sendOrderedBroadcast(intent, receiverPermission, resultReceiver, scheduler, initialCode, initialData, initialExtras);
resultReceiver 广播接受者 如果我们显示的指定了广播接收者
无论如何 都会接受广播 无法通过abortBroadcast();的方法终止广播
比如拨打电话有个out_goingcall 的广播是指定广播接收者的无法通过abortBroadcast()方法终止的,但是是可以将拨打的电话号码数据清空置为null,setResultData(null)就无法拨打电话

 

另外一种特殊的广播sendStickyBroadcast(intent) // 阴魂不散的广播
一般广播事件发送完毕被广播接受者接收到onReceive执行完毕后广播接收者的生命周期就结束了 这个会保持长时间的停留直到广播事件结束完毕
例如系统的Wifi,网卡状态的改变要一定的时间,保证网络状态更新完毕后才结束

代码中注册,如果代码没有执行,就接受不到广播事件

什么时候使用广播,例如sdcard新增图片的时候是无法显示到图库的当sdcard被挂载状态发生改变才会重新加载sdcard的数据

这时可以发送一个sd挂载的通知,通知系统的gallery去获取到新的图片.

Intent intent = newIntent(Intent.ACTION_MEDIA_MOUNTED,Uri.parse(“file://”+Environment.getExternalStorageDirectory()));

sendBroadcast(intent);

Android四大基本组件介绍与生命周期

Android四大基本组件分别是Activity,Service服务,Content Provider内容提供者,BroadcastReceiver广播接收器。

一:了解四大基本组件

Activity :

应用程序中,一个Activity通常就是一个单独的屏幕,它上面可以显示一些控件也可以监听并处理用户的事件做出响应。

Activity之间通过Intent进行通信。在Intent 的描述结构中,有两个最重要的部分:动作和动作对应的数据。

典型的动作类型有:M AIN(activity的门户)、VIEW、PICK、EDIT 等。而动作对应的数据则以URI 的形式进行表示。例如:要查看一个人的联系方式,你需要创建一个动作类型为VIEW 的intent,以及一个表示这个人的URI。

与之有关系的一个类叫IntentFilter。相对于intent 是一个有效的做某事的请求,一个intentfilter 则用于描述一个activity(或者IntentReceiver)能够操作哪些intent。一个activity 如果要显示一个人的联系方式时,需要声明一个IntentFilter,这个IntentFilter 要知道怎么去处理VIEW 动作和表示一个人的URI。IntentFilter 需要在AndroidManifest.xml 中定义。通过解析各种intent,从一个屏幕导航到另一个屏幕是很简单的。当向前导航时,activity 将会调用startActivity(Intent myIntent)方法。然后,系统会在所有安装的应用程序中定义的IntentFilter 中查找,找到最匹配myIntent 的Intent 对应的activity。新的activity 接收到myIntent 的通知后,开始运行。当startActivity 方法被调用将触发解析myIntent 的动作,这个机制提供了两个关键好处:

A、Activities 能够重复利用从其它组件中以Intent 的形式产生的一个请求;

B、Activities 可以在任何时候被一个具有相同IntentFilter 的新的Activity 取代。

AndroidManifest文件中含有如下过滤器的Activity组件为默认启动类当程序启动时系统自动调用它

<intent-filter>
       <action android:name="android.intent.action.MAIN" />
       <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

BroadcastReceive广播接收器:

你的应用可以使用它对外部事件进行过滤只对感兴趣的外部事件(如当电话呼入时,或者数据网络可用时)进行接收并做出响应。广播接收器没有用户界面。然而,它们可以启动一个activity或serice 来响应它们收到的信息,或者用NotificationManager 来通知用户。通知可以用很多种方式来吸引用户的注意力──闪动背灯、震动、播放声音等。一般来说是在状态栏上放一个持久的图标,用户可以打开它并获取消息。

广播类型:

普通广播通过Context.sendBroadcast(Intent myIntent)发送的

有序广播通过Context.sendOrderedBroadcast(intent, receiverPermission)发送的,该方法第2个参数决定该广播的级别,级别数值是在 -1000 到 1000 之间 , 值越大 , 发送的优先级越高;广播接收者接收广播时的级别级别(可通过intentfilter中的priority进行设置设为2147483647时优先级最高),同级别接收的先后是随机的, 再到级别低的收到广播,高级别的或同级别先接收到广播的可以通过abortBroadcast()方法截断广播使其他的接收者无法收到该广播,还有其他构造函数

异步广播通过Context.sendStickyBroadcast(Intent myIntent)发送的,还有sendStickyOrderedBroadcast(intent, resultReceiver, scheduler,  initialCode, initialData, initialExtras)方法,该方法具有有序广播的特性也有异步广播的特性;发送异步广播要: <uses-permission android:name=“android.permission.BROADCAST_STICKY” />权限,接收并处理完Intent后,广播依然存在,直到你调用removeStickyBroadcast(intent)主动把它去掉

注意:发送广播时的intent参数与Contex.startActivity()启动起来的Intent不同,前者可以被多个订阅它的广播接收器调用,后者只能被一个(Activity或service)调用

监听广播Intent步骤:

1>             写一个继承BroadCastReceiver的类,重写onReceive()方法,广播接收器仅在它执行这个方法时处于活跃状态。当onReceive()返回后,它即为失活状态,注意:为了保证用户交互过程的流畅,一些费时的操作要放到线程里,如类名SMSBroadcastReceiver

2>            注册该广播接收者,注册有两种方法程序动态注册和AndroidManifest文件中进行静态注册(可理解为系统中注册)如下:

        静态注册,注册的广播,下面的priority表示接收广播的级别”2147483647″为最高优先级

<receiver android:name=".SMSBroadcastReceiver" >
  <intent-filter android:priority = "2147483647" >
    <action android:name="android.provider.Telephony.SMS_RECEIVED" />
  </intent-filter>
</receiver >

动态注册,一般在Activity可交互时onResume()内注册BroadcastReceiver

IntentFilter intentFilter=new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
registerReceiver(mBatteryInfoReceiver ,intentFilter);

//反注册
unregisterReceiver(receiver);

注意:

1.生命周期只有十秒左右,如果在 onReceive() 内做超过十秒内的事情,就会报ANR(Application No Response) 程序无响应的错误信息,如果需要完成一项比较耗时的工作 , 应该通过发送 Intent 给 Service, 由Service 来完成 . 这里不能使用子线程来解决 , 因为 BroadcastReceiver 的生命周期很短 , 子线程可能还没有结束BroadcastReceiver 就先结束了 .BroadcastReceiver 一旦结束 , 此时 BroadcastReceiver 的所在进程很容易在系统需要内存时被优先杀死 , 因为它属于空进程 ( 没有任何活动组件的进程 ). 如果它的宿主进程被杀死 , 那么正在工作的子线程也会被杀死 . 所以采用子线程来解决是不可靠的

2. 动态注册广播接收器还有一个特点,就是当用来注册的Activity关掉后,广播也就失效了。静态注册无需担忧广播接收器是否被关闭,只要设备是开启状态,广播接收器也是打开着的。也就是说哪怕app本身未启动,该app订阅的广播在触发时也会对它起作用

系统常见广播Intent,如开机启动、电池电量变化、时间改变等广播

Service 服务:

一个Service 是一段长生命周期的,没有用户界面的程序,可以用来开发如监控类程序。

比较好的一个例子就是一个正在从播放列表中播放歌曲的媒体播放器。在一个媒体播放器的应用中,应该会有多个activity,让使用者可以选择歌曲并播放歌曲。然而,音乐重放这个功能并没有对应的activity,因为使用者当然会认为在导航到其它屏幕时音乐应该还在播放的。在这个例子中,媒体播放器这个activity 会使用Context.startService()来启动一个service,从而可以在后台保持音乐的播放。同时,系统也将保持这个service 一直执行,直到这个service 运行结束。另外,我们还可以通过使用Context.bindService()方法,连接到一个service 上(如果这个service 还没有运行将启动它)。当连接到一个service 之后,我们还可以service 提供的接口与它进行通讯。拿媒体播放器这个例子来说,我们还可以进行暂停、重播等操作。

Service使用步骤如下

       1>继承service类

       2>AndroidManifast.xml配置清单文件中<application>节点里对服务进行配置

              <service name=”.SMSService”/>

服务不能自己运行,需要通过Contex.startService()或Contex.bindService()启动服务

通过startService()方法启动的服务于调用者没有关系,即使调用者关闭了,服务仍然运行想停止服务要调用Context.stopService(),此时系统会调用onDestory(),使用此方法启动时,服务首次启动系统先调用服务的onCreate()–>onStart(),如果服务已经启动再次调用只会触发onStart()方法

使用bindService()启动的服务与调用者绑定,只要调用者关闭服务就终止,使用此方法启动时,服务首次启动系统先调用服务的onCreate()–>onBind(),如果服务已经启动再次调用不会再触发这2个方法,调用者退出时系统会调用服务的onUnbind()–>onDestory(),想主动解除绑定可使用Contex.unbindService(),系统依次调用onUnbind()–>onDestory();

Content Provider内容提供者 :

android平台提供了Content Provider使一个应用程序的指定数据集提供给其他应用程序。这些数据可以存储在文件系统中、在一个SQLite数据库、或以任何其他合理的方式,

其他应用可以通过ContentResolver类(见ContentProviderAccessApp例子)从该内容提供者中获取或存入数据.(相当于在应用外包了一层壳),

只有需要在多个应用程序间共享数据是才需要内容提供者。例如,通讯录数据被多个应用程序使用,且必须存储在一个内容提供者中

它的好处:统一数据访问方式。

android系统自带的内容提供者(顶级的表示数据库名,非顶级的都是表名)这些内容提供者在SDK文档的android.provider Java包中都有介绍。见:http://developer.android.com/reference/android/provider/package-summary.html

├────Browser

├────CallLog

├────Contacts

│                ├────Groups

│                ├────People

│                ├────Phones

│                └────Photos

├────Images

│                └────Thumbnails

├────MediaStore

│                ├────Albums

│                ├────Artists

│                ├────Audio

│                ├────Genres

│                └────Playlists

├────Settings

└────Video

 CallLog:地址和接收到的电话信息

 Contact.People.Phones:存储电话号码

 Setting.System:系统设置和偏好设置

使用Content Provider对外共享数据的步骤

1>继承ContentProvider类并根据需求重写以下方法:

复制代码
    public boolean onCreate();//处理初始化操作

       /**
        * 插入数据到内容提供者(允许其他应用向你的应用中插入数据时重写)
        * @param uri
        * @param initialValues 插入的数据
        * @return
        */
       public Uri insert(Uri uri, ContentValues initialValues);

       /**
        * 从内容提供者中删除数据(允许其他应用删除你应用的数据时重写)
        * @param uri
        * @param selection 条件语句
        * @param selectionArgs 参数
        * @return
        */
       public int delete(Uri uri, String selection, String[] selectionArgs);

       /**
        * 更新内容提供者已存在的数据(允许其他应用更新你应用的数据时重写)
        * @param uri
        * @param values 更新的数据
        * @param selection 条件语句
        * @param selectionArgs 参数
        * @return
        */
       public int update(Uri uri, ContentValues values, String selection,
                     String[] selectionArgs);

       /**
        * 返回数据给调用者(允许其他应用从你的应用中获取数据时重写)
        * @param uri
        * @param projection 列名
        * @param selection 条件语句
        * @param selectionArgs 参数
        * @param sortOrder 排序
        * @return
        */
       public Cursor query(Uri uri, String[] projection, String selection,
                     String[] selectionArgs, String sortOrder) ;         

       /**
        * 用于返回当前Uri所代表数据的MIME类型
        * 如果操作的数据为集合类型(多条数据),那么返回的类型字符串应该为vnd.android.cursor.dir/开头
        * 例如要得到所有person记录的Uri为content://com.bravestarr.provider.personprovider/person,
     *   那么返回的MIME类型字符串应该为"vnd.android.cursor.dir/person"
        * 如果操作的数据为单一数据,那么返回的类型字符串应该为vnd.android.cursor.item/开头
        * 例如要得到id为10的person记录的Uri为content://com.bravestarr.provider.personprovider/person/10,
     *   那么返回的MIME类型字符串应该为"vnd.android.cursor.item/person"
        * @param uri
        */
       public String getType(Uri uri)
复制代码

这些方法中的Uri参数,得到后需要进行解析然后做对应处理,Uri表示要操作的数据,包含两部分信息:

       1.需要操作的contentprovider

       2.对contentprovider中的什么数据进行操作,一个Uri格式:结构头://authorities(域名)/路径(要操作的数据,根据业务而定)

              content://com.bravestarr.provider.personprovider/person/10

说明:contentprovider的结构头已经由android规定为content://

authorities用于唯一标识这个contentprovider程序,外部调用者可以根据这个找到他

路径表示我们要操作的数据,路径的构建根据业务而定.路径格式如下:

       要操作person表行号为10的记录,可以这样构建/person/10

       要操作person表的所有记录,可以这样构建/person

2>在AndroidManifest.xml中使用<provider>对ContentProvider进行配置注册(内容提供者注册它自己就像网站注册域名),ContentProvider采用authoritie(原意授权,可理解为域名)作为唯一标识,方便其他应用能找到

复制代码
<application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <!-- authorities属性命名建议:公司名.provider.SomeProvider-->
        <provider android:name=".PersonProvider" android:authorities="com.bravestarr.provider.personprovider"/>
         ...
</application>
复制代码

关于四大基本组件的一个总结:

1>    4大组件的注册

4大基本组件都需要注册才能使用,每个Activity、service、Content Provider内容提供者都需要在AndroidManifest文件中进行配置AndroidManifest文件中未进行声明的activity、服务以及内容提供者将不为系统所见,从而也就不可用,而BroadcastReceive广播接收者的注册分静态注册(在AndroidManifest文件中进行配置)和通过代码动态创建并以调用Context.registerReceiver()的方式注册至系统。需要注意的是在AndroidManifest文件中进行配置的广播接收者会随系统的启动而一直处于活跃状态,只要接收到感兴趣的广播就会触发(即使程序未运行)

AndroidManifest文件中进行注册格式如下:

<activity>元素的name 属性指定了实现了这个activity 的Activity 的子类。icon 和label 属性指向了包含展示给用户的此activity 的图标和标签的资源文件。

<service> 元素用于声明服务

<receiver> 元素用于声明广播接收器

<provider> 元素用于声明内容提供者

2>   4大组件的激活

• 容提供者的激活:当接收到ContentResolver 发出的请求后,内容提供者被激活。而其它三种组件──activity、服务和广播接收器被一种叫做intent 的异步消息所激活

• Activity的激活通过传递一个Intent 对象至Context.startActivity()或Activity.startActivityForResult()以载入(或指定新工作给)一个activity。相应的activity 可以通过调用getIntent() 方法来查看激活它的intent。如果它期望它所启动的那个activity 返回一个结果,它会以调用startActivityForResult()来取代startActivity()。比如说,如果它启动了另外一个Activity 以使用户挑选一张照片,它也许想知道哪张照片被选中了。结果将会被封装在一个Intent 对象中,并传递给发出调用的activity 的onActivityResult() 方法。

• 服务的激活可以通过传递一个Intent 对象至Context.startService()或Context.bindService()前者Android 调用服务的onStart()方法并将Intent 对象传递给它,后者Android 调用服务的onBind()方法将这个Intent 对象传递给它

• 发送广播可以通过传递一个Intent 对象至给Context.sendBroadcast() 、

Context.sendOrderedBroadcast()或Context.sendStickyBroadcast()Android 会调用所有对此广播有兴趣的广播接收器的onReceive()方法,将intent 传递给它们

3>   四大组件的关闭

内容提供者仅在响应ContentResolver 提出请求的时候激活。而一个广播接收器仅在响应广播信息的时候激活。所以,没有必要去显式的关闭这些组件。

Activity关闭:可以通过调用它的finish()方法来关闭一个activity

服务关闭:对于通过startService()方法启动的服务要调用Context.stopService()方法关闭服务,使用bindService()方法启动的服务要调用Contex.unbindService ()方法关闭服务

二:四大组件的生命周期

     介绍生命周期之前,先提一下任务的概念

任务其实就是activity 的栈它由一个或多个Activity组成的共同完成一个完整的用户体验, 换句话说任务就是” 应用程序” (可以是一个也可以是多个,比如假设你想让用户看到某个地方的街道地图。而已经存在一个具有此功能的activity 了,那么你的activity 所需要做的工作就是把请求信息放到一个Intent 对象里面,并把它传递给startActivity()。于是地图浏览器就会显示那个地图。而当用户按下BACK 键的时候,你的activity 又会再一次的显示在屏幕上,此时任务是由2个应用程序中的相关activity组成的)栈底的是启动整个任务的Activity,栈顶的是当前运行的用户可以交互的Activity,当一个activity 启动另外一个的时候,新的activity 就被压入栈,并成为当前运行的activity。而前一个activity 仍保持在栈之中。当用户按下BACK 键的时候,当前activity 出栈,而前一个恢复为当前运行的activity。栈中保存的其实是对象,栈中的Activity 永远不会重排,只会压入或弹出,所以如果发生了诸如需要多个地图浏览器的情况,就会使得一个任务中出现多个同一Activity 子类的实例同时存在。

任务中的所有activity 是作为一个整体进行移动的。整个的任务(即activity 栈)可以移到前台,或退至后台。举个例子说,比如当前任务在栈中存有四个activity──三个在当前activity 之下。当用户按下HOME 键的时候,回到了应用程序加载器,然后选择了一个新的应用程序(也就是一个新任务)。则当前任务遁入后台,而新任务的根activity 显示出来。然后,过了一小会儿,用户再次回到了应用程序加载器而又选择了前一个应用程序(上一个任务)。于是那个任务,带着它栈中所有的四个activity,再一次的到了前台。当用户按下BACK 键的时候,屏幕不会显示出用户刚才离开的activity(上一个任务的根

activity)。取而代之,当前任务的栈中最上面的activity 被弹出,而同一任务中的上一个activity 显示了出来。

Activity栈:先进后出规则

                                                   

Android系统是一个多任务(Multi-Task)的操作系统,可以在用手机听音乐的同时,也执行其他多个程序。每多执行一个应用程序,就会多耗费一些系统内存,当同时执行的程序过多,或是关闭的程序没有正确释放掉内存,系统就会觉得越来越慢,甚至不稳定。

为了解决这个问题, Android 引入了一个新的机制– 生命周期(Life Cycle)。

Android 应用程序的生命周期是由Android 框架进行管理,而不是由应用程序直接控

制。通常,每一个应用程序(入口一般会是一个Activity 的onCreate 方法),都会产生

一个进程(Process)。当系统内存即将不足的时候,会依照优先级自动进行进程(process)的回收。不管是使用者或开发者, 都无法确定的应用程序何时会被回收。所以为了很好的防止数据丢失和其他问题,了解生命周期很重要。

Activity生命周期

                                                          

图3.1activity生命周期图

Activity整个生命周期的4种状态、7个重要方法和3个嵌套循环

1>   四种状态

  1.       活动(Active/Running)状态

当Activity运行在屏幕前台(处于当前任务活动栈的最上面),此时它获取了焦点能响应用户的操作,属于运行状态,同一个时刻只会有一个Activity 处于活动(Active)或运行

(Running)状态

  1.     暂停(Paused)状态

当Activity失去焦点但仍对用户可见(如在它之上有另一个透明的Activity或Toast、AlertDialog等弹出窗口时)它处于暂停状态。暂停的Activity仍然是存活状态(它保留着所有的状态和成员信息并保持和窗口管理器的连接),但是当系统内存极小时可以被系统杀掉

3.      停止(Stopped)状态

完全被另一个Activity遮挡时处于停止状态,它仍然保留着所有的状态和成员信息。只是对用户不可见,当其他地方需要内存时它往往被系统杀掉

4.      非活动(Dead)状态

Activity 尚未被启动、已经被手动终止,或已经被系统回收时处于非活动的状态,要手动终止Activity,可以在程序中调用”finish”方法。

如果是(按根据内存不足时的回收规则)被系统回收,可能是因为内存不足了

内存不足时,Dalvak 虚拟机会根据其内存回收规则来回收内存:

      1. 先回收与其他Activity 或Service/Intent Receiver 无关的进程(即优先回收独

立的Activity)因此建议,我们的一些(耗时)后台操作,最好是作成Service的形式

      2.不可见(处于Stopped状态的)Activity

      3.Service进程(除非真的没有内存可用时会被销毁)

      4.非活动的可见的(Paused状态的)Activity

      5.当前正在运行(Active/Running状态的)Activity

 

2>  7个重要方法,当Activity从一种状态进入另一状态时系统会自动调用下面相应的方

法来通知用户这种变化

当Activity第一次被实例化的时候系统会调用,

整个生命周期只调用1次这个方法

通常用于初始化设置: 1、为Activity设置所要使用的布局文件2、为按钮绑定监听器等静态的设置操作

onCreate(Bundle savedInstanceState);

 

当Activity可见未获得用户焦点不能交互时系统会调用

onStart();

 

当Activity已经停止然后重新被启动时系统会调用

onRestart();

当Activity可见且获得用户焦点能交互时系统会调用

      onResume();

当系统启动另外一个新的Activity时,在新Activity启动之前被系统调用保存现有的Activity中的持久数据、停止动画等,这个实现方法必须非常快。当系统而不是用户自己出于回收内存时,关闭了activity 之后。用户会期望当他再次回到这个activity 的时候,它仍保持着上次离开时的样子。此时用到了onSaveInstanceState(),方法onSaveInstanceState()用来保存Activity被杀之前的状态,在onPause()之前被触发,当系统为了节省内存销毁了Activity(用户本不想销毁)时就需要重写这个方法了,当此Activity再次被实例化时会通过onCreate(Bundle savedInstanceState)将已经保存的临时状态数据传入因为onSaveInstanceState()方法不总是被调用,触发条件为(按下HOME键,按下电源按键关闭屏幕,横竖屏切换情况下),你应该仅重写onSaveInstanceState()来记录activity的临时状态,而不是持久的数据。应该使用onPause()来存储持久数据。

      onPause();

当Activity被新的Activity完全覆盖不可见时被系统调用

      onStop();

当Activity(用户调用finish()或系统由于内存不足)被系统销毁杀掉时系统调用,(整个生命周期只调用1次)用来释放onCreate ()方法中创建的资源,如结束线程等

      onDestroy();

3>  3个嵌套循环

             1.Activity完整的生命周期:从第一次调用onCreate()开始直到调用onDestroy()结束

             2.Activity的可视生命周期:从调用onStart()到相应的调用onStop()

                    在这两个方法之间,可以保持显示Activity所需要的资源。如在onStart()中注册一个广播接收者监听影响你的UI的改变,在onStop() 中注销。

             3.Activity的前台生命周期:从调用onResume()到相应的调用onPause()。

      举例说明:

例1:有3个Acitivity,分别用One,Two(透明的),Three表示,One是应用启动时的主Activity

      启动第一个界面Activity One时,它的次序是

             onCreate (ONE) – onStart (ONE) – onResume(ONE)

      点”打开透明Activity”按钮时,这时走的次序是

             onPause(ONE) – onCreate(TWO) – onStart(TWO) – onResume(TWO)

      再点back回到第一个界面,Two会被杀这时走的次序是

             onPause(TWO) – onActivityResult(ONE) – onResume(ONE) – onStop(TWO) – onDestroy(TWO)

      点”打开全屏Activity”按钮时,这时走的次序是

             onPause(ONE) – onCreate(Three) – onStart(Three) – onResume(Three) – onStop(ONE)

      再点back回到第一个界面,Three会被杀这时走的次序是

             onPause(Three) – onActivityResult(ONE) – onRestart(ONE) – onStart(ONE)- onResume(ONE) – onStop(Three) – onDestroy(Three)

      再点back退出应用时,它的次序是

             onPause(ONE) – onStop(ONE) – onDestroy(ONE)

例2:横竖屏切换时候Activity的生命周期

他切换时具体的生命周期是怎么样的:

1、新建一个Activity,并把各个生命周期打印出来

2、运行Activity,得到如下信息

onCreate–>
onStart–>
onResume–>

3、按crtl+f12切换成横屏时

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

4、再按crtl+f12切换成竖屏时,发现打印了两次相同的log

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>
onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

5、修改AndroidManifest.xml,把该Activity添加android:configChanges=”orientation”,执行步骤3

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>

6、再执行步骤4,发现不会再打印相同信息,但多打印了一行onConfigChanged

onSaveInstanceState–>
onPause–>
onStop–>
onDestroy–>
onCreate–>
onStart–>
onRestoreInstanceState–>
onResume–>
onConfigurationChanged–>

7、把步骤5的android:configChanges=”orientation” 改成 android:configChanges=”orientation|keyboardHidden”,执行步骤3,就只打印onConfigChanged

onConfigurationChanged–>

8、执行步骤4

onConfigurationChanged–>
onConfigurationChanged–>

总结:

1、不设置Activity的android:configChanges时,切屏会重新调用各个生命周期,切横屏时会执行一次,切竖屏时会执行两次

2、设置Activity的android:configChanges=”orientation”时,切屏还是会重新调用各个生命周期,切横、竖屏时只会执行一次

3、设置Activity的android:configChanges=”orientation|keyboardHidden”时,切屏不会重新调用各个生命周期,只会执行onConfigurationChanged方法
总结一下整个Activity的生命周期

补充一点,当前Activity产生事件弹出Toast和AlertDialog的时候Activity的生命周期不会有改变

Activity运行时按下HOME键(跟被完全覆盖是一样的):onSaveInstanceState –> onPause –> onStop,再次进入激活状态时: onRestart –>onStart—>onResume

BroadcastReceive广播接收器生命周期

生命周期只有十秒左右,如果在 onReceive() 内做超过十秒内的事情,就会报ANR(Application No Response) 程序无响应的错误信息

它的生命周期为从回调onReceive()方法开始到该方法返回结果后结束

Service服务生命周期

                                                            

图3.2service生命周期图

Service完整的生命周期:从调用onCreate()开始直到调用onDestroy()结束

Service有两种使用方法:

1>以调用Context.startService()启动,而以调用Context.stopService()结束

2>以调用Context.bindService()方法建立,以调用Context.unbindService()关闭

service重要的生命周期方法

当用户调用startService ()或bindService()时,Service第一次被实例化的时候系统会调用,整个生命周期只调用1次这个方法,通常用于初始化设置。注意:多次调用startService()或bindService()方法不会多次触发onCreate()方法

void onCreate()

当用户调用stopService()或unbindService()来停止服务时被系统调用,(整个生命周期只调用1次)用来释放onCreate()方法中创建的资源

void onDestroy()

通过startService()方法启动的服务

      初始化结束后系统会调用该方法,用于处理传递给startService()的Intent对象。如音乐服务会打开Intent 来探明将要播放哪首音乐,并开始播放。注意:多次调用startService()方法会多次触发onStart()方法

void onStart(Intent intent)

通过bindService ()方法启动的服务

      初始化结束后系统会调用该方法,用来绑定传递给bindService 的Intent 的对象。注意:多次调用bindService()时,如果该服务已启动则不会再触发此方法

IBinder onBind(Intent intent)

用户调用unbindService()时系统调用此方法,Intent 对象同样传递给该方法

boolean onUnbind(Intent intent)

如果有新的客户端连接至该服务,只有当旧的调用onUnbind()后,新的才会调用该方法

void onRebind(Intent intent)

补充:onCreate(Bundle savedInstanceState)与onSaveInstanceState(Bundle savedInstanceState)配合使用,见如下代码,达到显示activity被系统杀死前的状态

复制代码
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (null != savedInstanceState) {
            String _userid = savedInstanceState.getString("StrUserId");
            String _uid = savedInstanceState.getString("StrUid");
            String _serverid = savedInstanceState.getString("StrServerId");
            String _servername = savedInstanceState.getString("StrServerName");
            int _rate = savedInstanceState.getInt("StrRate");
            //updateUserId(_userid);
            //updateUId(_uid);
            //updateServerId(_serverid);
            //updateUserServer(_servername);
            //updateRate(_rate);
        }
    }

    @Override
    protected void onSaveInstanceState(Bundle savedInstanceState) {
        super.onSaveInstanceState(savedInstanceState);
        savedInstanceState.putString("StrUserId", getUserId());
        savedInstanceState.putString("StrUid", getUId());
        savedInstanceState.putString("StrServerId", getServerId());
        savedInstanceState.putString("StrServerName", getServerName());
        savedInstanceState.putInt("StrRate", getRate());
    }
复制代码

 

引发activity摧毁和重建的其他情形

除了系统处于内存不足的原因会摧毁activity之外, 某些系统设置的改变也会导致activity的摧毁和重建. 例如改变屏幕方向(见上例), 改变设备语言设定, 键盘弹出等.

 

Android IntentFilter 匹配原则浅析

1
Intent
分为两大类,显式和隐式。


显式事件,就是指通过
component
Name

属性,明确指定了目标组件的事件。


比如我们新建一个
Intent,指名道姓的说,此事件用于启动名为“com.silenceburn.XXXX”的Activity,那么这就是一个显式事件。


隐式事件,就是指没有
component
Name

属性,没有明确指定目标组件的事件。


比如系统向所有监控通话情况的程序发送的“来电话了!”的事件,由于系统不确定谁会处理这个事件,因此系统不会明确指定目标组件,也就是说没有目标组件,那么这就是个隐式的事件。


此处只是简介显式和隐式事件,更精确详细的描述请查阅
SDK文档,我们只需要记住一点,两种事件的最大区别是
component Name

属性是否为空。

 

2

事件过滤策略

IntentFilter


系统在传送显式事件时非常方便,因为如果把
Intent比作一封信,那么component Name就是一个详细的收件人地址,系统可以精确的把显式事件送达目标组件。

 


而传送隐式事件时,就比较麻烦了。因为这封信的信封上,没有写收信地址!


那怎么办呢?系统做了一个艰难的决定,就是把信拆开看看。通过信件内容里面的线索,去寻找合适的收件人。


比如信中的线索描述到:“收信人是男性,快
30岁了,未婚,喜欢玩游戏”,那么系统就在小区里面去找这样的人。

 


非常值得庆幸的事情是,这个小区的人素质非常高,每户人家都写了点自我介绍在门口,


比如张三写道:“我是男性,
90后,未婚,喜欢玩游戏”,李四写道:“我是女性,快30岁了,未婚,喜欢逛街”等等等等。


有了每户人家的自我介绍,系统就能很快的定位真正的收件人了!

 


上面是一个类比的例子,不过
android系统处理隐式事件的策略,基本上就是上述这种模式了。

 


首先系统会通过观察
Intent的内容(打开信件看内容),取得匹配线索,系统所需的线索是如下三种

 action

 data (both URI and
data type)

 category

 


其次,系统中每个组件,如果想收取隐式事件,则必须声明自己的
IntentFilter(自我介绍,我对什么样的信件感兴趣)。


至于怎么写
IntentFilter,已经相当明了了,那就是应该是这样写:

我是组件XXXX,我想要接收这样的隐式事件:它的ACTION必须是
XXX,它的
category
必须是
YYYY

,它包含的
data必须是ZZZZ “


如果组件不声明
IntentFilter,那么所有的隐式事件都不会发送给该组件。(注意,这并不影响向该组件发送显式事件。)

 


对于系统中发生的每个隐式事件,系统都会尝试将
action, data , category
和系统中各个组件声明的
IntentFilter
去进行匹配,以找到合适的接收者。

3.IntentFilter匹配原则


对于显式事件,系统可以精确送达。对于隐式事件,系统分析事件的
action, data , category
内容,并和各个组件声明的
IntentFilter进行匹配,找出匹配的组件进行送达。actioncategory没什么好说的,再此我将最复杂的data匹配展开来进行描述一下:


首先务必认识到,
data是一个相对复杂的要素。

dataURI来描述和定位,URI由三部分组成,

scheme://host:port/path     

模式
://
主机:端口/路径


此外在事件中,还可以设置
dataMIME类型,作为事件的datatype属性。为了描述方便,下文将IntentFilter简写为filter,请大家注意。


首先明确一个匹配原则,就是对于
URI的匹配,只比较filter中声明的部分。


部分匹配原则:只要
filter中声明的部分匹配成功,就认为整个URI匹配成功。


举例来说,
    content://com.silenceburn.SdCardTester:1000/mydata/private/


filter定义为 
content://com.silenceburn.SdCardTester:1000/    


是可以匹配的。


注意
filter中并没有定义path部分,但是依然可以匹配成功,因为filter不声明的部分不进行比较。


换句话讲,任何符合
content://com.silenceburn.SdCardTester:1000/的事件,无论path是什么,都可以匹配成功。


接下来是真正的
data部分的,也就是URI的匹配规则如下:

1.

如果
dataURIdatatype为空,则
filter
URItype也必须为空,才能匹配成功

2.

如果
dataURI不为空,但是datatype为空,则
filter
必须定义
URI并匹配成功,且type为空,才能匹配成功

3.

如果
dataURI为空,但是datatype不为空,则
filter
必须
URI为空,定义type并匹配成功,才能匹配成功

4.

如果
dataURIdata都不为空,则
filter
URItype都必须定义并匹配成功,才能匹配成功。对于URI部分,有一个特殊处理,就是即使filter没有定义URIcontentfile两种URI也作为既存的URI存在。

 


通过上文的描述,大家就可以明白为什么在注册
SD卡插拔接收器时,不但需要

IntentFilter intentFilter = new
IntentFilter(Intent.ACTION_MEDIA_MOUNTED);

             
intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_STARTED);

             
intentFilter.addAction(Intent.ACTION_MEDIA_SCANNER_FINISHED);

             
intentFilter.addAction(Intent.ACTION_MEDIA_REMOVED);

             
intentFilter.addAction(Intent.ACTION_MEDIA_UNMOUNTED);

             
intentFilter.addAction(Intent.ACTION_MEDIA_BAD_REMOVAL);


而且需要添加

      
intentFilter.addDataScheme(“file”);


注册应用安装卸载事件时不但需要

      
IntentFilter intentFilter = new IntentFilter();

             
intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED);

             
intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);

             
intentFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);


而且需要

      
intentFilter.addDataScheme(“package”);


原因就在
Data的匹配。


最后,该文章是经过我在互联网中,某个文章中提取和加工而来,首先感谢原作者的精心设计,原文地址如下:
http://blog.csdn.net/silenceburn/article/details/6083375

Android BroadcastReceiver 简介

Android BroadcastReceiver 简介

在 Android 中使用 Activity, Service, Broadcast, BroadcastReceiver

活动(Activity) – 用于表现功能

服务(Service) – 相当于后台运行的 Activity

广播(Broadcast) – 用于发送广播

广播接收器(BroadcastReceiver) – 用于接收广播

Intent – 用于连接以上各个组件,并在其间传递消息

BroadcastReceiver

在Android中,Broadcast是一种广泛运用的在应用程序之间传输信息的机制。而BroadcastReceiver是对发送出来的 Broadcast进行过滤接受并响应的一类组件。下面将详细的阐述如何发送Broadcast和使用BroadcastReceiver过

滤接收的过程:

首先在需要发送信息的地方,把要发送的信息和用于过滤的信息(如Action、Category)装入一个Intent对象,然后通过调用 Context.sendBroadcast()、sendOrderBroadcast()或sendStickyBroadcast()方法,把 Intent对象以广播方式发送出去。

当Intent发送以后,所有已经注册的BroadcastReceiver会检查注册时的IntentFilter是否与发送的Intent相匹配,若 匹配则就会调用BroadcastReceiver的onReceive()方法。所以当我们定义一个BroadcastReceiver的时候,都需要 实现onReceive()方法。

注册BroadcastReceiver有两种方式:

一种方式是,静态的在AndroidManifest.xml中用<receiver>标签生命注册,并在标签内用<intent- filter>标签设置过滤器。

另一种方式是,动态的在代码中先定义并设置好一个 IntentFilter对象,然后在需要注册的地方调 Context.registerReceiver()方法,如果取消时就调用Context.unregisterReceiver()方法。如果用动 态方式注册的BroadcastReceiver的Context对象被销毁时,BroadcastReceiver也就自动取消注册了。

另外,若在使用sendBroadcast()的方法是指定了接收权限,则只有在AndroidManifest.xml中用<uses- permission>标签声明了拥有此权限的BroascastReceiver才会有可能接收到发送来的Broadcast。

同样,若在注册BroadcastReceiver时指定了可接收的Broadcast的权限,则只有在包内的AndroidManifest.xml中 用<uses-permission>标签声明了,拥有此权限的Context对象所发送的Broadcast才能被这个 BroadcastReceiver所接收。

动态注册:

IntentFilter intentFilter = new IntentFilter();

intentFilter.addAction(String);–为 BroadcastReceiver指定action,使之用于接收同action的广播 registerReceiver(BroadcastReceiver,intentFilter);

一般:在onStart中注册,onStop中取消unregisterReceiver

发送广播消息:extends Service

指定广播目标Action:Intent Intent = new Intent(action-String)

–指定了此action的receiver会接收此广播

需传递参数(可选) putExtra();

发送:sendBroadcast(Intent);

iOS数据持久化存储总结

本文中的代码托管在github上:https://github.com/WindyShade/DataSaveMethods
相对复杂的App仅靠内存的数据肯定无法满足,数据写磁盘作持久化存储是几乎每个客户端软件都需要做的。简单如“是否第一次打开”的BOOL值,大到游戏的进度和状态等数据,都需要进行本地持久化存储。这些数据的存储本质上就是写磁盘存文件,原始一点可以用iOS本身支持有NSFileManager这样的API,或者干脆C语言fwrite/fread,Cocoa Touch本身也提供了一些存储方式,如NSUserDefaults,CoreData等。总的来说,iOS平台数据持久存储方法大致如下所列:

  • Raw File APIs
  • UserDefault
  • NSCoding => NSKeyedArchived
  • Plist File
  • SQLite(使用C语言)
  • CoreData

一、Raw File APIs

ObjC是C的一个超集,所以最笨的方法我们可以直接用C作文件读写来实现数据存储:
1. 写入文件

    // File path
    const char * pFilePath = [_path cStringUsingEncoding:NSUTF8StringEncoding];

    // Create a new file
    FILE * pFile = fopen(pFilePath, "w+");

    if (pFile == NULL) {
        NSLog(@"Open File ERROR!");
        return;
    }

    const char * content = [_textField.text cStringUsingEncoding:NSUTF8StringEncoding];
    fwrite(content, sizeof(content), 1, pFile);
    fclose(pFile);

2. 读取文件

    // File path
    const char * pFilePath = [_path cStringUsingEncoding:NSUTF8StringEncoding];

    // Create a new file
    FILE * pFile = fopen(pFilePath, "r+");

    if (pFile == NULL) {
        NSLog(@"Open File ERROR!");
        return;
    }

    int fileSize = ftell(pFile);
    NSLog(@"fileSize: %d", fileSize);

    char * content[20];

    fread(content, 20, 20, pFile);

    NSString * aStr = [NSString stringWithFormat:@"%s", &content];

    if (aStr != nil && ![aStr isEqualToString:@""]) {
        _textField.text = aStr;
    }

    fclose(pFile);

二、NSUserDefaults

但是既然在iOS平台作开发,我们当然不至于要到使用C的原生文件接口这种地步,下面就介绍几种iOS开发中常用的数据本地存储方式。使用起来最简单的大概就是Cocoa提供的NSUserDefaults了,Cocoa会为每个app自动创建一个数据库,用来存储App本身的偏好设置,如:开关音效,音量调整之类的少量信息。NSUserDefaults是一个单例,生命后期由App掌管,使用时用 [NSUserDefaults standardUserDefaults] 接口获取单例对象。NSUserDefaults本质上是以Key-Value形式存成plist文件,放在App的Library/Preferences目录下,对于已越狱的机器来说,这个文件是不安全的,所以**千万不要用NSUserDefaults来存储密码之类的敏感信息**,用户名密码应该使用**KeyChains**来存储。

1.写入数据

        // 获取一个NSUserDefaults对象
        NSUserDefaults * aUserDefaults = [NSUserDefaults standardUserDefaults];
        // 插入一个key-value值
        [aUserDefaults setObject:_textField.text forKey:@"Text"];

        // 这里是为了把设置及时写入文件,防止由于崩溃等情况App内存信息丢失
        [aUserDefaults synchronize];

2.读取数据

    NSUserDefaults * aUserDefaults = [NSUserDefaults standardUserDefaults];
                // 获取一个key-value值
    NSString * aStr = [aUserDefaults objectForKey:@"Text"];

使用起来很简单吧,它的接口跟 NSMutableDictionary 一样,看它的头文件,事实上在内存里面也是用dictionary来存的。写数据的时候记得用 synchronize 方法写入文件,否则 crash了数据就丢了。

三、Plist

上一节提到NSUserDefaults事实上是存成Plist文件,只是Apple帮我们封装好了读写方法而已。NSUserDefaults的缺陷是存储只能是Library/Preferences/<Application BundleIdentifier>.plist 这个文件,如果我们要自己写一个Plist文件呢? 使用NSFileManger可以很容易办到。事实上Plist文件是XML格式的,如果你存储的数据是Plist文件支持的类型,直接用NSFileManager的writToFile接口就可以写入一个plist文件了。 ### Plist文件支持的数据格式有: NSString, NSNumber, Boolean, NSDate, NSData, NSArray, 和NSDictionary. 其中,Boolean格式事实上以[NSNumber numberOfBool:YES/NO];这样的形式表示。NSNumber支持float和int两种格式。

读写Plist文件

1. 首先创建plist文件:

                // 文件的路径
                NSString * _path = [[NSTemporaryDirectory() stringByAppendingString:@"save.plist"] retain];
                // 获取一个NSFileManger
          NSFileManager * aFileManager = [NSFileManager defaultManager];
          if (![aFileManager fileExistsAtPath:_path]){
                // 文件不存在,创建之
                NSMutableDictionary * aDefaultDict = [[NSMutableDictionary alloc] init];
                                        // 插入一个值,此时数据仍存在内存里
                [aDefaultDict setObject:@"test" forKey:@"TestText"];

                                        // 使用NSMutableDictionary的写文件接口自动创建一个Plist文件
                if (![aDefaultDict writeToFile:_path atomically:YES]) {
                    NSLog(@"OMG!!!");
                }

                [aDefaultDict release];
            }

2. 写入文件

                // 写入数据
        NSMutableDictionary * aDataDict = [NSMutableDictionary dictionaryWithContentsOfFile:_path];
        [aDataDict setObject:_textField.text forKey:@"TestText"];
            if (![aDataDict writeToFile:_path atomically:YES]) {
                NSLog(@"OMG!!!");
            }

3. 读取文件

                 NSMutableDictionary * aDataDict = [NSMutableDictionary dictionaryWithContentsOfFile:_path];
            NSString * aStr = [aDataDict objectForKey:@"TestText"];
            if (aStr != nil && aStr.length > 0) {
                _textField.text = aStr;
            }

四、NSCoding + NSKeyedArchiver

上面介绍的几种方法中,直接用C语言的接口显然是最不方便的,拿出来的数据还得自己进行类型转换。NSUserDefaults和Plist文件支持常用数据类型,但是不支持自定义的数据对象,好像Cocoa提供了NSCoding和NSKeyArchiver两个工具类,可以把我们自定义的对象编码成二进制数据流,然后存进文件里面,下面的Sample为了简单我直接用cocoa的接口写成plist文件。 如果要使用这种方式进行存储,首先自定义的对象要继承NSCoding的delegate。

        @interface WSNSCodingData : NSObject<NSCoding>

然后继承两个必须实现的方法encodeWithCoder:和initWithCoder:

        - (void)encodeWithCoder:(NSCoder *)enoder {
            [enoder encodeObject:data forKey:kDATA_KEY];
        }

        - (id)initWithCoder:(NSCoder *)decoder {
            data = [[decoder decodeObjectForKey:kDATA_KEY] copy];
                        return [self init];
        }

这里data是我自己定义的WSNSCodingData这个数据对象的成员变量,由于数据在使用过程中需要持续保存在内存中,所以类型为copy,或者retain也可以,记得在dealloc函数里面要realease。这样,我们就定义了一个可以使用NSCoding进行编码的数据对象。

保存数据:

        - (void)saveData {
            if (aData == nil) {
                aData = [[WSNSCodingData alloc] init];
            }

            aData.data = _textField.text;

            NSLog(@"save data...%@", aData.data);
                        // 这里init的NSMutableData是临时用来存储数据的
            NSMutableData   * data = [[NSMutableData alloc] init];
                        // 这个NSKeyedArchiver则是进行编码用的
            NSKeyedArchiver * archiver = [[NSKeyedArchiver alloc] initForWritingWithMutableData:data];
            [archiver encodeObject:aData forKey:DATA_KEY];
            [archiver finishEncoding];
                        // 编码完成后的NSData,使用其写文件接口写入文件存起来
            [data writeToFile:_path atomically:YES];
            [archiver release];
            [data release];

            NSLog(@"save data: %@", aData.data);
        }

读取数据:

        - (void)loadData {
            NSLog(@"load file: %@", _path);
            NSData * codedData = [[NSData alloc] initWithContentsOfFile:_path];
            if (codedData == nil) return;

                        // NSKeyedUnarchiver用来解码
            NSKeyedUnarchiver * unarchiver = [[NSKeyedUnarchiver alloc] initForReadingWithData:codedData];
                        // 解码后的数据被存在一个WSNSCodingData数据对象里面
            aData = [[unarchiver decodeObjectForKey:DATA_KEY] retain];
            [unarchiver finishDecoding];
            [unarchiver release];

            [codedData release];

            if (aData.data != nil) {
                _textField.text = aData.data;
            }
        }

所以其实使用NSCoding和NSKeyedArchiver事实上也是写plist文件,只不过对复杂对象进行了编码使得plist支持更多数据类型而已。

五、 SQLite

如果App涉及到的数据多且杂,还涉及关系查询,那么毋庸置疑要使用到数据库了。Cocoa本身提供了CoreData这样比较重的数据库框架,下一节会讲到,这一节讲一个轻量级的数据库——SQLite。 SQLite是C写的的,做iOS开发只需要在工程里面加入需要的框架和头文件就可以用了,只是我们得用C语言来进行SQLite操作。 关于SQLite的使用参考了这篇文章:http://mobile.51cto.com/iphone-288898.htm但是稍微有点不一样。

1. 在编写SQLite代码之前,我们需要引入SQLite3头文件:

        #import <sqlite3.h>

2. 然后给工程加入 libsqlite3.0.dylib 框架。 3. 然后就可以开始使用了。首先是打开数据库:

                - (void)openDB {
                    NSArray * documentsPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory
                                                                                , NSUserDomainMask
                                                                                , YES);
                    NSString * databaseFilePath = [[documentsPaths objectAtIndex:0] stringByAppendingPathComponent:@"mydb"];

                    // SQLite存的最终还是文件,如果没有该文件则会创建一个
                    if (sqlite3_open([databaseFilePath UTF8String], &_db) == SQLITE_OK) {
                        NSLog(@"Successfully open database.");
                        // 如果没有表则创建一个表
                        [self creatTable];
                    }
                }

3.关闭数据库,在dealloc函数里面调用:

                - (void)closeDB {
                    sqlite3_close(_db);
                }

4.创建一个表:

                - (void)creatTable {
                    char * errorMsg;
                    const char * createSql="create table if not exists datas (id integer primary key autoincrement,name text)";

                    if (sqlite3_exec(_db, createSql, NULL, NULL, &errorMsg) == SQLITE_OK) {
                        NSLog(@"Successfully create data table.");
                    }
                    else {
                        NSLog(@"Error: %s",errorMsg);
                        sqlite3_free(errorMsg);
                    }
                }

5. 写入数据库

                - (void)saveData {
                    char * errorMsg;
                        // 向 datas 表中插入 name = _textFiled.text 的数据
                    NSString * insertSQL = [NSString stringWithFormat:@"insert into datas (name) values('%@')", _textField.text];

                        // 执行该 SQL 语句
                    if (sqlite3_exec(_db, [insertSQL cStringUsingEncoding:NSUTF8StringEncoding], NULL, NULL, &errorMsg)==SQLITE_OK) {
                        NSLog(@"insert ok.");
                    }
                }

6. 读取数据库

                - (void)loadData {
                    [self openDB];

                    const char * selectSql="select id,name from datas";
                    sqlite3_stmt * statement;
                    if (sqlite3_prepare_v2(_db, selectSql, -1, &statement, nil)==SQLITE_OK) {
                        NSLog(@"select ok.");
                    }

                    while (sqlite3_step(statement) == SQLITE_ROW) {
                        int _id = sqlite3_column_int(statement, 0);
                        NSString * name = [[NSString alloc] initWithCString:(char *)sqlite3_column_text(statement, 1) encoding:NSUTF8StringEncoding];
                        NSLog(@"row>>id %i, name %@",_id,name);

                        _textField.text = name;
                    }

                    sqlite3_finalize(statement);
                }

五、CoreData

大型数据存储和管理。 XCode自带有图形化工具,可以自动生成数据类型的代码。 最终存储格式不一定存成SQLite,可以是XML等形式。 (未完待续。。。)

宏定义的黑魔法 – 宏菜鸟起飞手册

Happy define :)宏定义在C系开发中可以说占有举足轻重的作用。底层框架自不必说,为了编译优化和方便,以及跨平台能力,宏被大量使用,可以说底层开发离开define将寸步难行。而在更高层级进行开发时,我们会将更多的重心放在业务逻辑上,似乎对宏的使用和依赖并不多。但是使用宏定义的好处是不言自明的,在节省工作量的同时,代码可读性大大增加。如果想成为一个能写出漂亮优雅代码的开发者,宏定义绝对是必不可少的技能(虽然宏本身可能并不漂亮优雅XD)。但是因为宏定义对于很多人来说,并不像业务逻辑那样是每天会接触的东西。即使是能偶尔使用到一些宏,也更多的仅仅只停留在使用的层级,却并不会去探寻背后发生的事情。有一些开发者确实也有探寻的动力和意愿,但却在点开一个定义之后发现还有宏定义中还有其他无数定义,再加上满屏幕都是不同于平时的代码,既看不懂又不变色,于是乎心生烦恼,怒而回退。本文希望通过循序渐进的方式,通过几个例子来表述C系语言宏定义世界中的一些基本规则和技巧,从0开始,希望最后能让大家至少能看懂和还原一些相对复杂的宏。考虑到我自己现在objc使用的比较多,这个站点的读者应该也大多是使用objc的,所以有部分例子是选自objc,但是本文的大部分内容将是C系语言通用。

入门

如果您完全不知道宏是什么的话,可以先来热个身。很多人在介绍宏的时候会说,宏嘛很简单,就是简单的查找替换嘛。嗯,只说对了的一半。C中的宏分为两类,对象宏(object-like macro)和函数宏(function-like macro)。对于对象宏来说确实相对简单,但却也不是那么简单的查找替换。对象宏一般用来定义一些常数,举个例子:

//This defines PI
#define M_PI        3.14159265358979323846264338327950288

继续阅读宏定义的黑魔法 – 宏菜鸟起飞手册

AndroidUI设计之 布局管理器 – 详细解析布局实现

 父容器与本容器属性 : android_layout…属性是本容器的属性, 定义在这个布局管理器的LayoutParams内部类中, 每个布局管理器都有一个LayoutParams内部类, Android:… 是父容器用来控制子组件的属性. 如android:layout_gravity 是控制组件本身的对齐方式, android:gravity是控制本容器子组件的对齐方式;

 

布局管理器都是以ViewGroup为基类派生出来的; 使用布局管理器可以适配不同手机屏幕的分辨率,尺寸大小;

 

布局管理器之间的继承关系

 


 

在上面的UML图中可以看出, 绝对布局 帧布局 网格布局 相对布局 线性布局直接继承ViewGroup,表格布局继承的LinearLayout;

 

一. 线性布局(LinearLayout)

 

1. 线性布局作用 

 

作用 : 线性布局会将容器中的组件一个一个排列起来, LinearLayout可以控制组件 横向 或者 纵向 排列, 通过android:orientation属性控制;

不换行属性 : 线性布局中的组件不会自动换行, 如果组件一个一个排列到尽头之后, 剩下的组件就不会显示出来;

 

2. LinearLayout常用属性

 

(1)基线对齐

 

xml属性 : android:baselineAligned

设置方法 : setBaselineAligned(boolean b)

作用 : 如果该属性为false, 就会阻止该布局管理器与其子元素的基线对齐;

 

(2)设分隔条 

 

xml属性 : android:divider

设置方法 : setDividerDrawable(Drawable)

作用 : 设置垂直布局时两个按钮之间的分隔条;

 

(3)对齐方式(控制内部子元素)  

 

xml属性 : android:gravity

设置方法 : setGravity(int)

作用 : 设置布局管理器内组件(子元素)的对齐方式

支持的属性

top, bottom, left, right, 

center_vertical(垂直方向居中), center_horizontal(水平方向居中),

fill_vertical(垂直方向拉伸), fill_horizontal(水平方向拉伸), 

center, fill, 

clip_vertical, clip_horizontal; 

可以同时指定多种对齐方式 : 如 left|center_vertical 左侧垂直居中;

 

(4)权重最小尺寸 

 

xml属性 : android:measureWithLargestChild

设置方法 : setMeasureWithLargestChildEnable(boolean b);

作用 : 该属性为true的时候, 所有带权重的子元素都会具有最大子元素的最小尺寸;

 

(5) 排列方式

 

xml属性 : android:orientation;

设置方法 : setOrientation(int i);

作用 : 设置布局管理器内组件排列方式, 设置为horizontal(水平),vertical(垂直), 默认为垂直排列;

 

3. LinearLayout子元素控制

 

LinearLayout的子元素, 即LinearLayout中的组件, 都受到LinearLayout.LayoutParams控制, 因此LinearLayout包含的子元素可以执行下面的属性.

 

(1) 对齐方式

 

xml属性 : android:layout_gravity;

作用 : 指定该元素在LinearLayout(父容器)的对齐方式, 也就是该组件本身的对齐方式, 注意要与android:gravity区分, ;

 

(2) 所占权重

 

xml属性 : android:layout_weight;

作用 : 指定该元素在LinearLayout(父容器)中所占的权重, 例如都是1的情况下, 那个方向(LinearLayout的orientation方向)长度都是一样的;

 

4. 控制子元素排列 与 在父元素中排列

 

控制本身元素属性与子元素属性

设备组件本身属性 : 带layout的属性是设置本身组件属性, 例如 android:layout_gravity设置的是本身的对其方式; 

设置子元素属性 : 不带layout的属性是设置其所包含的子元素, 例如android:gravity 设置的是该容器子组件的对齐方式;

LayoutParams属性 : 所有的布局管理器都提供了相应的LayoutParams内部类, 这些内部类用于控制该布局本身, 如 对齐方式 layout_gravity, 所占权重 layout_weight, 这些属性用于设置本元素在父容器中的对齐方式;

容器属性 : 在android:后面没有layout的属性基本都是容器属性, android:gravity作用是指定指定本元素包含的子元素的对齐方式, 只有容器才支持这个属性;

 

5. 常见用法

 

(1) 获取LinearLayout的宽高

 

a. 组件外无法获取组件宽高 

下面的两种情况都是针对 View.getHeight() 和 View.getWidth() 方法

组件外无法获取 : 调用View.getHeight()View.getWidth()方法 是获取不到组件的宽度和高度的, 这两个方法返回的是0, Android的运行机制决定了无法在组件外部使用getHeight()和getWidth()方法获取宽度和高度;

组件内可以获取 : 在自定义的类中可以在View的类中通过调用这两个方法获取该View子类组件的宽和高;

 

b. 组件外部获取View对象宽高方法 

 

外部获取 : 使用View.getMeasuredWidth()View.getMeasuredHeight()方法可以获取组件的宽和高, 在调用这个方法之前, 必须先调用View.measure()方法, 才可以, 否则也获取不到组件的宽高;

注意(特例) : 如果组件宽度或高度设置为 fill_parent, 使用 getMeasuredHeight() 等方法获取宽度和高度的时候, 并且组件中含有子元素时, 所获取的实际值是这些组件所占的最小宽度和最小高度.(没看懂)

 

示例:

 

  1. View view = getLayoutInflater().inflate(R.layout.main, null);
  2. LinearLayout layout = (LinearLayout) view.findViewById(R.id.linearlayout);
  3. //调用测量方法, 调用了该方法之后才能通过getMeasuredHeight()等方法获取宽高
  4. layout.measure(00);
  5. //获取宽度
  6. int width = layout.getMeasuredWidth();
  7. //获取高度
  8. int height = layout.getMeasuredHeight();

 

 

c. 获取布局文件中组件的宽高 

 

从LayoutParams中获取 : 调用View.getLayoutParams().width 和 View.getLayoutParams().height 获取宽高, 如果宽高被设定为 fill_parent, match_parent, warp_content 时, 这两个两边直接回返回 FILL_PARENT, MATCH_PARENT, WARP_CONTENT常量值;

规律 : 从View.getLayoutParams()中获取 width, height 值, 在布局xml文件中设置的是什么, 获取的时候就得到的是什么;

 

(2) 在LinearLayout中添加分隔线

 

a. 使用ImageView添加(低版本3.0以下)

 

垂直布局 横向宽度填满 : 如果布局是vertical, 那么设置一个ImageView宽度fill_parent, 高度2dp, 设置一个背景色;

水平布局 纵向高度填满 : 如果布局时horizontal, 那么设置一个ImageView宽度2dp, 高度fill_parent, 设置一个背景色;

 

 

  1. <ImageView
  2.     android:layout_width=“fill_parent”
  3.     android:layout_height=“2dp”
  4.     android:background=“#F00”/>

 

b. 使用xml属性添加(3.0以上版本)

 

设置LinearLayout标签的 android:showDividers属性, 该属性有四个值 : 

none :不显示分隔线;

beginning : 在LinearLayout开始处显示分隔线;

middle : 在LinearLayout中每两个组件之间显示分隔线;

end : 在LinearLayout结尾处显示分隔线;

 

设置android:divider属性, 这个属性的值是一个Drawable的id;

 

c. 使用代码添加(3.0以上版本)

 

设置显示分隔线样式 : linearLayout.setShowDividers(), 设置android:showDividers属性;

设置分隔线图片 : linearLayout.setDividerDrawable(), 设置android:divider属性;

 

6. 实际案例

 

(1) 按钮排列 

 

       

 

要点

底部 + 水平居中 对齐属性 : 左边的LinearLayout的android:gravity 属性为bottom|center_horizontal

右部 + 垂直居中 对齐属性 : 右边的LinearLayout的android:gravity 属性为right|center_vertical;

 

代码

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3.     android:layout_width=“fill_parent”
  4.     android:layout_height=“fill_parent”
  5.     android:orientation=“vertical”
  6.     android:gravity=“bottom|center_horizontal”>
  7.     <Button
  8.         android:layout_width=“wrap_content”
  9.         android:layout_height=“wrap_content”
  10.         android:text=“按钮1”/>
  11.     <Button
  12.         android:layout_width=“wrap_content”
  13.         android:layout_height=“wrap_content”
  14.         android:text=“测试按钮2”/>
  15.     <Button
  16.         android:layout_width=“wrap_content”
  17.         android:layout_height=“wrap_content”
  18.         android:text=“按钮3”/>
  19.     <Button
  20.         android:layout_width=“wrap_content”
  21.         android:layout_height=“wrap_content”
  22.         android:text=“测试按钮4”/>
  23.     <Button
  24.         android:layout_width=“wrap_content”
  25.         android:layout_height=“wrap_content”
  26.         android:text=“按钮5”/>
  27. </LinearLayout>

子元素对齐 : 通过修改 android:gravity 属性来控制LinearLayout中子元素的排列情况;

左边的图的属性为 bottom|center_horizontal , 右边的android:gravity的属性值为 right|center_vertical;

 

(2) 三个按钮各自对齐

 

三个水平方向的按钮, 分别左对齐, 居中对齐, 右对齐 :

 


 

要点

水平线性布局 : 最顶层的LinearLayout的orientation是horizontal水平的;

等分三个线性布局 : 第二层的LinearLayout的orientation是vertical垂直的, 并且宽度是fill_parent , 依靠权重分配宽度;

设置按钮对齐方式 : 按钮的android:layout_gravity属性根据需求 left, center, right, 默认为left;

 

代码 : 

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3.     android:layout_width=“fill_parent”
  4.     android:layout_height=“fill_parent”
  5.     android:orientation=“horizontal”  >
  6.     <LinearLayout
  7.         android:layout_width=“fill_parent”
  8.         android:layout_weight=“1”
  9.         android:layout_height=“wrap_content”
  10.         android:orientation=“vertical”
  11.         android:background=“#f00”>
  12.         <Button android:layout_width=“wrap_content”
  13.             android:layout_height=“wrap_content”
  14.             android:text=“按钮1”/>
  15.     </LinearLayout>
  16.     <LinearLayout
  17.         android:layout_width=“fill_parent”
  18.         android:layout_weight=“1”
  19.         android:layout_height=“wrap_content”
  20.         android:orientation=“vertical”
  21.         android:background=“#0f0”>
  22.         <Button android:layout_width=“wrap_content”
  23.             android:layout_height=“wrap_content”
  24.             android:text=“按钮2”
  25.             android:layout_gravity=“center”/>
  26.     </LinearLayout>
  27.     <LinearLayout
  28.         android:layout_width=“fill_parent”
  29.         android:layout_weight=“1”
  30.         android:layout_height=“wrap_content”
  31.         android:orientation=“vertical”
  32.         android:background=“#00f”>
  33.         <Button android:layout_width=“wrap_content”
  34.             android:layout_height=“wrap_content”
  35.             android:text=“按钮3”
  36.             android:layout_gravity=“right”/>
  37.     </LinearLayout>
  38. </LinearLayout>

 

二. 相对布局RelativeLayout

 

相对布局容器中, 子组件的位置总是相对兄弟组件,父容器来决定的;

 

1. RelativeLayout支持的属性

 

(1) 对齐方式

 

xml属性 : android:gravity;

设置方法 : setGravity(int);

作用 : 设置布局容器内子元素的对齐方式, 注意与android:layout_gravity区分, 后者是设置组件本身元素对齐方式;

 

(2) 忽略对齐方式

 

xml属性 : android:ignoreGravity;

设置方法 : setIgnoreGravity(int);

作用 : 设置该组件不受gravity属性影响, 因为gravity属性影响容器内所有的组件的对齐方式, 设置了之后, 该组件就可以例外;

 

2. LayoutParams属性

 

(1) 只能设置boolean值的属性

 

这些属性都是相对父容器的, 确定是否在父容器中居中(水平, 垂直), 是否位于父容器的 上下左右 端;

 

是否水平居中 : android:layout_centerHorizontal;

是否垂直居中 : android:layout_centerVertical;

是否位于中央 : android:layout_centerInParent;

 

是否底端对齐 : android:layout_alignParentBottom;

是否顶端对齐 : android:layout_alignParentTop;

是否左边对齐 : android:layout_alignParentLeft;

是否右边对齐 : android:layout_alignParentRight;

 

(2) 只能设置其它组件id的属性

 

位于所给id组件左侧 : android:layout_toLeftOf;

位于所给id组件右侧 : android:layout_toRightOf;

位于所给id组件的上边 : android:layout_above;

位于所给id组件的下方 : android:layout_below;

 

与所给id组件顶部对齐 : android:layout_alignTop;

与所给id组件底部对齐 : android:layout_alignBottom;

与所给id组件左边对齐 : android:layout_alignLeft;

与所给id组件右边对齐 : android:layout_alignRight;

 

3. 梅花布局效果 

 

五个按钮排成梅花形状, 梅花处于正中心, 效果图如下 :

 

 

 

两个按钮, 如果只有 android:layout_above=”@+id/bt1″ 会是这种情况 : 


加上 android:layout_alignLeft=”@+id/bt1″就会成为这种情况 : 


 

 

要点

注意每个组件的属性, 先要确定方位, 在进行对齐, 组件左边界对齐, 组件上边界对齐;

 

代码 : 

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <RelativeLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3.     android:layout_width=“fill_parent”
  4.     android:layout_height=“fill_parent” >
  5.     <Button
  6.         android:id=“@+id/bt1”
  7.         android:layout_width=“wrap_content”
  8.         android:layout_height=“wrap_content”
  9.         android:text=“按钮1”
  10.         android:layout_centerInParent=“true”/>
  11.     <Button
  12.         android:id=“@+id/bt2”
  13.         android:layout_width=“wrap_content”
  14.         android:layout_height=“wrap_content”
  15.         android:text=“按钮2”
  16.         android:layout_above=“@+id/bt1”
  17.         android:layout_alignLeft=“@+id/bt1”/>
  18.     <Button
  19.         android:id=“@+id/bt3”
  20.         android:layout_width=“wrap_content”
  21.         android:layout_height=“wrap_content”
  22.         android:text=“按钮3”
  23.         android:layout_centerInParent=“true”
  24.         android:layout_below=“@+id/bt1”
  25.         android:layout_alignLeft=“@+id/bt1”/>
  26.     <Button
  27.         android:id=“@+id/bt4”
  28.         android:layout_width=“wrap_content”
  29.         android:layout_height=“wrap_content”
  30.         android:text=“按钮4”
  31.         android:layout_centerInParent=“true”
  32.         android:layout_toLeftOf=“@+id/bt1”
  33.         android:layout_alignTop=“@+id/bt1”/>
  34.     <Button
  35.         android:id=“@+id/bt5”
  36.         android:layout_width=“wrap_content”
  37.         android:layout_height=“wrap_content”
  38.         android:text=“按钮5”
  39.         android:layout_centerInParent=“true”
  40.         android:layout_toRightOf=“@+id/bt1”
  41.         android:layout_alignTop=“@+id/bt1”/>
  42. </RelativeLayout>

 

 

4. 相对布局常用方法

(1) 获取屏幕中一个组件的位置

 

创建数组 : 要先创建一个整型数组, 数组大小2位; 这个数组传入getLocationOnScreen()方法;

将位置信息传入数组 : 可以调用View.getLocationOnScreen()方法, 返回的是一个数组 int[2], int[0] 是横坐标, int[1] 是纵坐标;

 

 

  1. //获取组件
  2. Button b = (Button) this.findViewById(R.id.Button01);
  3. //创建数组, 将该数组传入getLocationOnScreen()方法
  4. int locations[] = new int[2];
  5. //获取位置信息
  6. b.getLocationOnScreen(locations);
  7. //获取宽度
  8. int width = locations[0];
  9. //获取高度
  10. int height = locations[1];

 

(2) LayoutParams的使用设置所有属性

 

属性设置方法少 : Android SDK中View类只提供了很少用于设置属性的方法,大多数属性没有直接对应的获得和设置属性值的方法, 看起来貌似不是很好用;

使用LayoutParams设置属性值 : Android中可以对任何属性进行设置, 这里我们需要一个LayoutParams对象, 使用这个LayoutParams.addRule()方法, 可以设置所有组件的属性值; 设置完之后调用View.setLayoutParams()方法, 传入刚才创建的LayoutParams对象, 并更新View的相应的LayoutParams属性值, 向容器中添加该组件;

 

代码中动态设置布局属性

a. 创建LayoutParams对象

b. 调用LayoutParams对象的addRule()方法设置对应属性;

c. 调用View.setLayoutParams()方法将设置好的LayoutParams对象设置给组件;

d. 调用addView方法将View对象设置到布局中去;

 

使用代码设置android:layout_toRightOf 和 android:layout_below属性 : 

 

 

  1. //装载布局文件
  2. RelativeLayout relativeLayout = (RelativeLayout) getLayoutInflater().inflate(R.layout.relative, null);
  3. //装载要动态添加的布局文件
  4. Button button = (Button) relativeLayout.findViewById(R.id.bt1);
  5. //创建一个LayoutParams对象
  6. LayoutParams layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
  7. //设置android:layout_toRightOf属性
  8. layoutParams.addRule(RelativeLayout.RIGHT_OF, R.id.bt2);
  9. //设置android:layout_below
  10. layoutParams.addRule(RelativeLayout.BELOW, R.id.bt2);
  11. //更新Button按钮的属性
  12. button.setLayoutParams(layoutParams);
  13. //向布局中动态添加按钮
  14. relativeLayout.addView(button);

 

 

三. 帧布局FrameLayout

帧布局容器为每个组件创建一个空白区域, 一个区域成为一帧, 这些帧会根据FrameLayout中定义的gravity属性自动对齐;

 

1. 绘制霓虹灯布局

 

绘制一个霓虹灯效果的层叠布局, 如下图 : 

 


 

要点 : 

后挡前 : 后面的View组件会遮挡前面的View组件,越在前面, 被遮挡的概率越大;

界面居中 : 将所有的TextView组件的对齐方式 android:layout_gravity 设置为center;

正方形 : 所有的TextView都设置android:height 和 android:width 属性, 用来设置其宽高, 这里设置成正方形, 宽高一样, 后面的组件比前面的边长依次少40;

颜色 : 每个TextView的背景都设置成不一样的;

 

代码 : 

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <FrameLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3.     android:layout_width=“match_parent”
  4.     android:layout_height=“match_parent” >
  5.     <TextView
  6.         android:id=“@+id/tv_1”
  7.         android:layout_width=“wrap_content”
  8.         android:layout_height=“wrap_content”
  9.         android:layout_gravity=“center”
  10.         android:width=“320px”
  11.         android:height=“320px”
  12.         android:background=“#f00”/>
  13.     <TextView
  14.         android:id=“@+id/tv_2”
  15.         android:layout_width=“wrap_content”
  16.         android:layout_height=“wrap_content”
  17.         android:layout_gravity=“center”
  18.         android:width=“280px”
  19.         android:height=“280px”
  20.         android:background=“#0f0”/>
  21.     <TextView
  22.         android:id=“@+id/tv_3”
  23.         android:layout_width=“wrap_content”
  24.         android:layout_height=“wrap_content”
  25.         android:layout_gravity=“center”
  26.         android:width=“240px”
  27.         android:height=“240px”
  28.         android:background=“#00f”/>
  29.     <TextView
  30.         android:id=“@+id/tv_4”
  31.         android:layout_width=“wrap_content”
  32.         android:layout_height=“wrap_content”
  33.         android:layout_gravity=“center”
  34.         android:width=“200px”
  35.         android:height=“200px”
  36.         android:background=“#ff0”/>
  37.     <TextView
  38.         android:id=“@+id/tv_5”
  39.         android:layout_width=“wrap_content”
  40.         android:layout_height=“wrap_content”
  41.         android:layout_gravity=“center”
  42.         android:width=“160px”
  43.         android:height=“160px”
  44.         android:background=“#f0f”/>
  45.     <TextView
  46.         android:id=“@+id/tv_6”
  47.         android:layout_width=“wrap_content”
  48.         android:layout_height=“wrap_content”
  49.         android:layout_gravity=“center”
  50.         android:width=“120px”
  51.         android:height=“120px”
  52.         android:background=“#0ff”/>
  53. </FrameLayout>

 

.

作者 :万境绝尘 

转载请注明出处 : http://blog.csdn.net/shulianghan/article/details/18964835

.

 

2. 使用代码使上面的霓虹灯效果动起来

 

(1) 图片效果 

 


 

(2) 颜色资源

 

创建颜色资源, 在跟节点<resources>下面创建<color>子节点, color属性标签 name 自定义, 子文本为颜色代码;

 

(3) 定时器控制handler

 

创建Handler对象, 实现handleMessage()方法, 在这个方法中循环设置 TextView对象的颜色变量, 使用color[(i + currentColor)%colors.length]每调用一次, 就将所有的TextView颜色依次调换一次;

在onCreate()方法中, 开启一个定时器Timer, 每隔0.2s就调用一个handler中的方法, 这样动态的霓虹灯代码就显示出来了.

 

(4) 代码

 

颜色资源代码 : 

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <resources>
  3.     <color name = “color1”>#f00</color>
  4.     <color name = “color2”>#0f0</color>
  5.     <color name = “color3”>#00f</color>
  6.     <color name = “color4”>#ff0</color>
  7.     <color name = “color5”>#f0f</color>
  8.     <color name = “color6”>#0ff</color>
  9. </resources>

 

 

代码 : 

 

 

  1. package com.example.framelayout;
  2. import java.util.Timer;
  3. import java.util.TimerTask;
  4. import android.app.Activity;
  5. import android.os.Bundle;
  6. import android.os.Handler;
  7. import android.os.Message;
  8. import android.widget.TextView;
  9. public class MainActivity extends Activity {
  10.     //这个变量用来控制霓虹灯颜色变化
  11.     private int currentColor = 0;
  12.     //颜色对应的资源id
  13.     final int[] colors = new int[]{
  14.             R.color.color1,
  15.             R.color.color2,
  16.             R.color.color3,
  17.             R.color.color4,
  18.             R.color.color5,
  19.             R.color.color6
  20.     };
  21.     //View组件对应的资源id
  22.     final int[] names = new int[]{
  23.             R.id.tv_1,
  24.             R.id.tv_2,
  25.             R.id.tv_3,
  26.             R.id.tv_4,
  27.             R.id.tv_5,
  28.             R.id.tv_6
  29.     };
  30.     //组件数组
  31.     TextView[] views = new TextView[names.length];
  32.     //定义这个Handler, 为了在定时器中固定调用handleMessage方法
  33.     Handler handler = new Handler(){
  34.         public void handleMessage(Message msg) {
  35.             if(msg.what == 0x123){
  36.                 for(int i = 0; i < names.length; i ++){
  37.                     views[i].setBackgroundResource(colors[(i + currentColor) % names.length]);
  38.                 }
  39.                 currentColor ++;
  40.             }
  41.         };
  42.     };
  43.     @Override
  44.     public void onCreate(Bundle savedInstanceState) {
  45.         super.onCreate(savedInstanceState);
  46.         setContentView(R.layout.frame);
  47.         //初始化组件数组
  48.         for(int i = 0; i < names.length; i ++){
  49.             views[i] = (TextView) findViewById(names[i]);
  50.         }
  51.         //每隔0.2秒更换一次颜色
  52.         new Timer().schedule(new TimerTask() {
  53.             @Override
  54.             public void run() {
  55.                 handler.sendEmptyMessage(0x123);
  56.             }
  57.         }, 0200);
  58.     }
  59. }

 

3. 三个水平方向的按钮分别左对齐,居中对齐,右对齐

 


 

要点 : 给FrameLayout中的三个按钮分别设置 不同的layout_gravity,left ,center_horizontal,right, 就能设置成上图的样式;

 

代码 : 

 

 

  1. <?xml version=“1.0” encoding=“utf-8”?>
  2. <FrameLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  3.     android:layout_width=“match_parent”
  4.     android:layout_height=“match_parent” >
  5.     <Button
  6.         android:layout_width=“wrap_content”
  7.         android:layout_height=“wrap_content”
  8.         android:text=“按钮1”
  9.         android:layout_gravity=“left”/>
  10.     <Button
  11.         android:layout_width=“wrap_content”
  12.         android:layout_height=“wrap_content”
  13.         android:text=“按钮2”
  14.         android:layout_gravity=“center_horizontal”/>
  15.     <Button
  16.         android:layout_width=“wrap_content”
  17.         android:layout_height=“wrap_content”
  18.         android:text=“按钮3”
  19.         android:layout_gravity=“right”/>
  20. </FrameLayout>

 

 

四. 表格布局TableLayout

 

1. 表格布局的一些概念

 

继承关系 : 表格布局继承了LinearLayout, 其本质是线性布局管理器; 

控制组件 : 表格布局采用 行, 列 形式管理子组件, 但是并不需要声明有多少 行列, 只需要添加TableRow 和 组件 就可以控制表格的行数和列数, 这一点与网格布局有所不同, 网格布局需要指定行列数;

增加行的方法

a. TableRow增加行列 : 向TableLayout中添加一个TableRow,一个TableRow就是一个表格行, 同时TableRow也是容器, 可以向其中添加子元素, 每添加一个组件, 就增加了一列;

b. 组件增加行 : 如果直接向TableLayout中添加组件, 就相当于直接添加了一行;

 

列宽 : TableLayout中, 列的宽度由该列最宽的单元格决定, 整个表格的宽度默认充满父容器本身;

 

2. 单元格行为方式 

 

(1) 行为方式概念

 

a. 收缩 :Shrinkable, 如果某列被设为Shrinkable, 那么该列所有单元格宽度可以被收缩, 保证表格能适应父容器的宽度;

b. 拉伸 :Stretchable, 如果某列被设为Stretchable, 那么该列所有单元格的宽度可以被拉伸, 保证表格能完全填满表格剩余空间;

d. 隐藏 :Collapsed, 如果某列被设置成Collapsed, 那么该列所有单元格会被隐藏;

 

(2) 行为方式属性

 

a. 隐藏

xml属性 : android:collapsedColumns;

设置方法 : setColumnCollapsed(int, boolean);

作用 : 设置需要被隐藏的列的序号, 在xml文件中, 如果隐藏多列, 多列序号间用逗号隔开;

 

b. 拉伸

xml属性 : android:stretchColumns;

设置方法 : setStretchAllColumns(boolean);

作用 : 设置允许被拉伸的列的序列号, xml文件中多个序列号之间用逗号隔开;

 

c. 收缩

xml属性 : android:shrinkableColumns;

设置方法 : setShrinkableAllColumns(boolean);

作用 : 设置允许被收缩的列的序号, xml文件中, 多个序号之间可以用逗号隔开;

 

3. 表格布局实例

 


 

实现要点

独自一行按钮 : 向TableLayout中添加按钮, 这个按钮就会独自占据一行;

收缩按钮: 在TableLayout标签中,设置android:stretchable属性标签, 属性值是要收缩的列, 注意,列标从0开始;

拉伸按钮 : 在TableLayout标签中,设置android:shrinkable属性标签, 属性值是要拉伸的列, 注意, 列表从0开始;

 

代码 : 

 

 

  1. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  2.     xmlns:tools=“http://schemas.android.com/tools”
  3.     android:orientation=“vertical”
  4.     android:layout_width=“match_parent”
  5.     android:layout_height=“match_parent” >
  6.     <!– LinearLayout默认是水平的, 这里设置其方向为垂直 –>
  7.     <!– 表格布局, 第2列允许收缩, 第3列允许拉伸, 注意这里行列的计数都是从0开始的 –>
  8.     <TableLayout
  9.         android:layout_width=“fill_parent”
  10.         android:layout_height=“wrap_content”
  11.         android:shrinkColumns=“1”
  12.         android:stretchColumns=“2”>
  13.         <!– 向TableLayout中直接添加组件, 独占一行 –>
  14.         <Button
  15.             android:layout_width=“fill_parent”
  16.             android:layout_height=“wrap_content”
  17.             android:text=“独自一行的按钮”/>
  18.         <TableRow>
  19.             <Button
  20.                 android:layout_width=“wrap_content”
  21.                 android:layout_height=“wrap_content”
  22.                 android:text=“普通的按钮”/>
  23.             <Button
  24.                 android:layout_width=“wrap_content”
  25.                 android:layout_height=“wrap_content”
  26.                 android:text=“收缩的按钮”/>
  27.             <Button
  28.                 android:layout_width=“wrap_content”
  29.                 android:layout_height=“wrap_content”
  30.                 android:text=“拉伸的按钮”/>
  31.         </TableRow>
  32.     </TableLayout>
  33.     <!– 第二个按钮会隐藏掉 –>
  34.     <TableLayout
  35.         android:layout_width=“fill_parent”
  36.         android:layout_height=“wrap_content”
  37.         android:collapseColumns=“1”>
  38.         <Button
  39.             android:layout_width=“fill_parent”
  40.             android:layout_height=“wrap_content”
  41.             android:text=“独自一行的按钮”/>
  42.         <TableRow >
  43.             <Button
  44.                 android:layout_width=“wrap_content”
  45.                 android:layout_height=“wrap_content”
  46.                 android:text=“普通按钮1”/>
  47.             <Button
  48.                 android:layout_width=“wrap_content”
  49.                 android:layout_height=“wrap_content”
  50.                 android:text=“普通按钮2”/>
  51.             <Button
  52.                 android:layout_width=“wrap_content”
  53.                 android:layout_height=“wrap_content”
  54.                 android:text=“普通按钮3”/>
  55.         </TableRow>
  56.     </TableLayout>
  57.     <!– 指定第二列和第三列可以被拉伸 –>
  58.     <TableLayout
  59.         android:layout_height=“wrap_content”
  60.         android:layout_width=“fill_parent”
  61.         android:stretchColumns=“1,2”>
  62.         <Button
  63.             android:layout_width=“fill_parent”
  64.             android:layout_height=“wrap_content”
  65.             android:text=“独自占一行的按钮”/>
  66.         <TableRow >
  67.             <Button
  68.                 android:layout_width=“wrap_content”
  69.                 android:layout_height=“wrap_content”
  70.                 android:text=“普通按钮1”/>
  71.             <Button
  72.                 android:layout_width=“wrap_content”
  73.                 android:layout_height=“wrap_content”
  74.                 android:text=“拉伸的按钮”/>
  75.             <Button
  76.                 android:layout_width=“wrap_content”
  77.                 android:layout_height=“wrap_content”
  78.                 android:text=“拉伸的按钮”/>
  79.         </TableRow>
  80.         <TableRow >
  81.             <Button
  82.                 android:layout_width=“wrap_content”
  83.                 android:layout_height=“wrap_content”
  84.                 android:text=“普通的按钮”/>
  85.             <Button
  86.                 android:layout_width=“wrap_content”
  87.                 android:layout_height=“wrap_content”
  88.                 android:text=“拉伸的按钮”/>
  89.         </TableRow>
  90.     </TableLayout>
  91. </LinearLayout>

 

五. 网格布局

 

1. 网格布局介绍

 

网格布局时Android4.0版本才有的, 在低版本使用该布局需要导入对应支撑库;

GridLayout将整个容器划分成rows * columns个网格, 每个网格可以放置一个组件. 还可以设置一个组件横跨多少列, 多少行. 不存在一个网格放多个组件情况;

 

2. 网格布局常用属性

 

(1) 设置对齐模式

 

xml属性 : android:alignmentMode;

设置方法 : setAlignmentMode(int);

作用 : 设置网格布局管理器的对齐模式

 

(2) 设置列数

 

xml属性 : android:columnCount;

设置方法 : setColumnCount(int);

作用 : 设置该网格布局的列数;

 

(3) 设置是否保留列序列号

 

xml属性 : android:columnOrderPreserved;

设置方法 : setColumnOrderPreserved(boolean);

作用 : 设置网格容器是否保留列序列号;

 

(4) 设置行数

 

xml属性 : android:rowCount;

设置方法 : setRowCount(int);

作用 : 设置该网格的行数;

 

(5) 设置是否保留行序列号

 

xml属性 : android:rowOrderPreserved;

设置方法 : setRowOrderPreserved(int);

作用 : 设置该网格容器是否保留行序列号;

 

(6) 页边距

 

xml属性 : android:useDefaultMargins;

设置方法 : setUseDefaultMargins(boolean);

作用 : 设置该布局是否使用默认的页边距;

 

3. GridLayout的LayoutParams属性

 

(1) 设置位置列

 

xml属性 : android:layout_column;

作用 : 设置子组件在GridLayout的哪一列;

 

(2) 横向跨列

 

xml属性 : android:layout_columnSpan;

作用 : 设置该子组件在GridLayout中横向跨几列;

 

(3) 占据空间方式

 

xml属性 : android:layout_gravity;

设置方法 : setGravity(int);

作用 : 设置该组件采用何种方式占据该网格的空间;

 

(4) 设置行位置

 

xml属性 : android:layout_row;

作用 : 设置该子组件在GridLayout的第几行;

 

(5) 设置横跨行数

 

xml属性 : android:layout_rowSpan;

作用 : 设置该子组件在GridLayout纵向横跨几行;

 

4. 实现一个计算机界面

 

 

 


 

(1) 布局代码

 

设置行列 : 设置GridLayout的android:rowCount为6, 设置android:columnCount为4, 这个网格为 6行 * 4列 的;

设置横跨四列 : 设置TextView和按钮横跨四列android:layout_columnSpan 为4, 列的合并 就是占了一行;

textView的一些设置

设置textView中的文本与边框有5像素间隔 : android:padding = “5px”;

 

代码 : 

 

 

  1. <GridLayout xmlns:android=“http://schemas.android.com/apk/res/android”
  2.     xmlns:tools=“http://schemas.android.com/tools”
  3.     android:layout_width=“match_parent”
  4.     android:layout_height=“match_parent”
  5.     android:rowCount=“6”
  6.     android:columnCount=“4”
  7.     android:id=“@+id/root”>
  8.     <!–
  9.         定义一个  6行 * 4列 GridLayout, 在里面定义两个组件
  10.         两个组件都横跨4列, 单独占一行
  11.      —>
  12.     <TextView
  13.         android:layout_width=“match_parent”
  14.         android:layout_height=“wrap_content”
  15.         android:layout_columnSpan=“4”
  16.         android:textSize=“50sp”
  17.         android:layout_marginLeft=“4px”
  18.         android:layout_marginRight=“4px”
  19.         android:padding=“5px”
  20.         android:layout_gravity=“right”
  21.         android:background=“#eee”
  22.         android:textColor=“#000”
  23.         android:text=“0”/>
  24.     <Button
  25.         android:layout_width=“match_parent”
  26.         android:layout_height=“wrap_content”
  27.         android:layout_columnSpan=“4”
  28.         android:text=“清除”/>
  29. </GridLayout>

 

(2) Activity代码

 

将组件设置给GridLayout网格流程

指定组件所在行 : GridLayout.SpecrowSpec = GridLayout.spec(int)

指定组件所在列 : GridLayout.SpeccolumnSpec = GridLayout.spec(int);

创建LayoutParams对象 : GridLayout.LayoutParams params =new GridLayout.LayoutParams(rowSpec, columnSpec);

指定组件占满容器 : params.setGravity(Gravity.FILL);

将组件添加到布局中 : gridLayout.addView(view, params);

 

代码 : 

 

 

  1. package com.example.caculator;
  2. import android.app.Activity;
  3. import android.os.Bundle;
  4. import android.view.Gravity;
  5. import android.widget.Button;
  6. import android.widget.GridLayout;
  7. import android.widget.GridLayout.LayoutParams;
  8. import android.widget.GridLayout.Spec;
  9. public class MainActivity extends Activity {
  10.     private GridLayout gridLayout;
  11.     //需要放到按钮上的字符串
  12.     String chars[] = new String[]{
  13.         “7”“8”“9”“/”,
  14.         “4”“5”“6”“*”,
  15.         “1”“2”“3”“-“,
  16.         “.”“0”“=”“+”
  17.     };
  18.     @Override
  19.     public void onCreate(Bundle savedInstanceState) {
  20.         super.onCreate(savedInstanceState);
  21.         setContentView(R.layout.activity_main);
  22.         gridLayout = (GridLayout) findViewById(R.id.root);
  23.         for(int i = 0; i < chars.length; i ++){
  24.             Button button = new Button(this);
  25.             button.setText(chars[i]);
  26.             button.setTextSize(40);
  27.             //指定组件所在行
  28.             Spec rowSpec = GridLayout.spec(i / 4 + 2);
  29.             //指定组件所在列
  30.             Spec columnSpec = GridLayout.spec(i % 4);
  31.             //生成LayoutParams对象
  32.             LayoutParams layoutParams = new LayoutParams(rowSpec, columnSpec);
  33.             //指定组件充满网格
  34.             layoutParams.setGravity(Gravity.FILL);
  35.             //将组件设置给GridLayout
  36.             gridLayout.addView(button, layoutParams);
  37.         }
  38.     }
  39. }

 

 

六. 绝对布局 AbsoluteLayout

 

1. 绝对布局介绍 

 

绝对布局特点 : 在绝对布局中,组件位置通过x, y坐标来控制, 布局容器不再管理组件位置, 大小, 这些都可以自定义; 

绝对布局使用情况 : 绝对布局不能适配不同的分辨率, 屏幕大小, 这种布局已经过时, 如果只为一种设备开发这种布局的话, 可以考虑使用这种布局;

 

2. 绝对布局的属性

 

android:layout_x: 指定组件的x坐标;

android:layout_y: 指定组件的y坐标;

 

android:layout_width 是指定宽度是否充满父容器, 或者仅仅包含子元素的,

android:width : 指定组件的宽度, 可以指定一个 数字 + 单位 , 如 100px 或者 100dp; 同理 android:layout_height 和 android:height;

 

3. 各种单位介绍

 

px : 像素, 每个px对应屏幕上的一个点;

dip/dp : device independent pixels, 设备的独立像素, 这种单位基于屏幕密度, 在每英寸160点的显示器上 1dp = 1px, 随着屏幕密度改变, dp 与 px 换算会发生改变;

sp : scale pixels, 比例像素, 处理字体的大小, 可以根据用户字体大小进行缩放;

in : 英寸, 标准长度单位

mm : 毫米, 标准长度单位

pt : 磅, 标准长度单位, 1/72英寸;

 

 

七. Android 分辨率 dip 与 px 转换

 


 

 

1. 术语介绍

 

px : pixel, 像素, 屏幕分辨率就是像素, 分辨率用 宽度 * 长度 表示, 分辨率不是长宽比, Android中一般不直接处理分辨率;

density : 密度, 是以分辨率为基础, 沿长宽方向排列的像素,密度低的屏幕像素少,密度高的屏幕像素多; 如果以像素为单位, 同一个按钮在高密度屏幕 要比 在低密度屏幕要大.

dip : device independent pixel, 设备独立像素, 程序用dip来定义界面元素,dip与实际密度无关.

 

2. 屏幕密度与大小

 

手机屏幕密度分类 : 高 hdpi 240 , 中 mdpi 160, 小 ldpi 120, 在res下有对应密度的标签资源, 注意这些资源与屏幕大小无关;

手机屏幕大小分类 : 大屏幕 4.8英寸以上, 普通屏幕 3.0 ~ 4.0英寸, 小屏幕 2.6 ~ 3.0英寸;

基准屏幕 : 正常尺寸, 与中密度120dpi,HAVG 320 * 480 是基准屏幕, 中密度 px == dip;

 

3. dip 与 px 换算

 

dip -> px :px = dip * (densityDpi / 160);

px -> dip :dip = px / (densityDpi / 160);

 

在中密度 mdpi 下, dip == px;

在高密度 hdpi 下, px > dip;

在低密度 ldpi 下, px < dip;

 

获取密度 :DisplayMetrics dm = getResources().getDisplayMetrics();

密度 : int density =dm.densityDpi;

像素 :dm.widthPixel * dm.heightPixel;  

 

 

七. 获取View对象宽高

 

如果在Activity中直接调用View组件的宽高, 获得的宽高一定是0;

重写 onWindowFocusChanged() .方法, 在这个方法中获取宽高, 就能成功获取到view组件的准确宽高值;

参考 : http://blog.csdn.net/sodino/article/details/10086633

 

 

作者 :万境绝尘 

转载请注明出处 : http://blog.csdn.net/shulianghan/article/details/18964835

 

Android Animation总结

3.0以前,android支持两种动画模式,tween animation,frame animation,在android3.0中又引入了一个新的动画系统:property animation,这三种动画模式在SDK中被称为property animation,view animation,drawable animation。 可通过NineOldAndroids项目在3.0之前的系统中使用Property Animation

1. View Animation(Tween Animation)

View Animation(Tween Animation):补间动画,给出两个关键帧,通过一些算法将给定属性值在给定的时间内在两个关键帧间渐变。

View animation只能应用于View对象,而且只支持一部分属性,如支持缩放旋转而不支持背景颜色的改变。

而且对于View animation,它只是改变了View对象绘制的位置,而没有改变View对象本身,比如,你有一个Button,坐标(100,100),Width:200,Height:50,而你有一个动画使其变为Width:100,Height:100,你会发现动画过程中触发按钮点击的区域仍是(100,100)-(300,150)。

View Animation就是一系列View形状的变换,如大小的缩放,透明度的改变,位置的改变,动画的定义既可以用代码定义也可以用XML定义,当然,建议用XML定义。

可以给一个View同时设置多个动画,比如从透明至不透明的淡入效果,与从小到大的放大效果,这些动画可以同时进行,也可以在一个完成之后开始另一个。

用XML定义的动画放在/res/anim/文件夹内,XML文件的根元素可以为<alpha>,<scale>,<translate>,<rotate>,interpolator元素或<set>(表示以上几个动画的集合,set可以嵌套)。默认情况下,所有动画是同时进行的,可以通过startOffset属性设置各个动画的开始偏移(开始时间)来达到动画顺序播放的效果。

可以通过设置interpolator属性改变动画渐变的方式,如AccelerateInterpolator,开始时慢,然后逐渐加快。默认为AccelerateDecelerateInterpolator。

定义好动画的XML文件后,可以通过类似下面的代码对指定View应用动画。

ImageView spaceshipImage = (ImageView)findViewById(R.id.spaceshipImage);
Animation hyperspaceJumpAnimation=AnimationUtils.loadAnimation(this, R.anim.hyperspace_jump);
spaceshipImage.startAnimation(hyperspaceJumpAnimation);

2. Drawable Animation(Frame Animation)

Drawable Animation(Frame Animation):帧动画,就像GIF图片,通过一系列Drawable依次显示来模拟动画的效果。在XML中的定义方式如下:

复制代码
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
    android:oneshot="true">
    <item android:drawable="@drawable/rocket_thrust1" android:duration="200" />
    <item android:drawable="@drawable/rocket_thrust2" android:duration="200" />
    <item android:drawable="@drawable/rocket_thrust3" android:duration="200" />
</animation-list>
复制代码

必须以<animation-list>为根元素,以<item>表示要轮换显示的图片,duration属性表示各项显示的时间。XML文件要放在/res/drawable/目录下。示例:

复制代码
protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        imageView = (ImageView) findViewById(R.id.imageView1);
        imageView.setBackgroundResource(R.drawable.drawable_anim);
        anim = (AnimationDrawable) imageView.getBackground();
    }

    public boolean onTouchEvent(MotionEvent event) {
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            anim.stop();
            anim.start();
            return true;
        }
        return super.onTouchEvent(event);
    }
复制代码

我在实验中遇到两点问题:

  1. 要在代码中调用Imageview的setBackgroundResource方法,如果直接在XML布局文件中设置其src属性当触发动画时会FC。
  2. 在动画start()之前要先stop(),不然在第一次动画之后会停在最后一帧,这样动画就只会触发一次。
  3. 最后一点是SDK中提到的,不要在onCreate中调用start,因为AnimationDrawable还没有完全跟Window相关联,如果想要界面显示时就开始动画的话,可以在onWindowFoucsChanged()中调用start()。

3. Property Animation

属性动画,这个是在Android 3.0中才引进的,以前学WPF时里面的动画机制好像就是这个,它更改的是对象的实际属性,在View Animation(Tween Animation)中,其改变的是View的绘制效果,真正的View的属性保持不变,比如无论你在对话中如何缩放Button的大小,Button的有效点击区域还是没有应用动画时的区域,其位置与大小都不变。而在Property Animation中,改变的是对象的实际属性,如Button的缩放,Button的位置与大小属性值都改变了。而且Property Animation不止可以应用于View,还可以应用于任何对象。Property Animation只是表示一个值在一段时间内的改变,当值改变时要做什么事情完全是你自己决定的。

在Property Animation中,可以对动画应用以下属性:

  • Duration:动画的持续时间
  • TimeInterpolation:属性值的计算方式,如先快后慢
  • TypeEvaluator:根据属性的开始、结束值与TimeInterpolation计算出的因子计算出当前时间的属性值
  • Repeat Count and behavoir:重复次数与方式,如播放3次、5次、无限循环,可以此动画一直重复,或播放完时再反向播放
  • Animation sets:动画集合,即可以同时对一个对象应用几个动画,这些动画可以同时播放也可以对不同动画设置不同开始偏移
  • Frame refreash delay:多少时间刷新一次,即每隔多少时间计算一次属性值,默认为10ms,最终刷新时间还受系统进程调度与硬件的影响

3.1 Property Animation的工作方式

对于下图的动画,这个对象的X坐标在40ms内从0移动到40 pixel.按默认的10ms刷新一次,这个对象会移动4次,每次移动40/4=10pixel。

也可以改变属性值的改变方法,即设置不同的interpolation,在下图中运动速度先逐渐增大再逐渐减小

下图显示了与上述动画相关的关键对象

ValueAnimator  表示一个动画,包含动画的开始值,结束值,持续时间等属性。

ValueAnimator封装了一个TimeInterpolator,TimeInterpolator定义了属性值在开始值与结束值之间的插值方法。

ValueAnimator还封装了一个TypeAnimator,根据开始、结束值与TimeIniterpolator计算得到的值计算出属性值。

ValueAnimator根据动画已进行的时间跟动画总时间(duration)的比计算出一个时间因子(0~1),然后根据TimeInterpolator计算出另一个因子,最后TypeAnimator通过这个因子计算出属性值,如上例中10ms时:

首先计算出时间因子,即经过的时间百分比:t=10ms/40ms=0.25

经插值计算(inteplator)后的插值因子:大约为0.15,上述例子中用了AccelerateDecelerateInterpolator,计算公式为(input即为时间因子):

(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;

最后根据TypeEvaluator计算出在10ms时的属性值:0.15*(40-0)=6pixel。上例中TypeEvaluator为FloatEvaluator,计算方法为 :

public Float evaluate(float fraction, Number startValue, Number endValue) {
    float startFloat = startValue.floatValue();
    return startFloat + fraction * (endValue.floatValue() - startFloat);
}

参数分别为上一步的插值因子,开始值与结束值。

3.2 ValueAnimator

ValueAnimator包含Property Animation动画的所有核心功能,如动画时间,开始、结束属性值,相应时间属性值计算方法等。应用Property Animation有两个步聚:

  1. 计算属性值
  2. 根据属性值执行相应的动作,如改变对象的某一属性。

ValuAnimiator只完成了第一步工作,如果要完成第二步,需要实现ValueAnimator.onUpdateListener接口,这个接口只有一个函数onAnimationUpdate(),在这个函数中会传入ValueAnimator对象做为参数,通过这个ValueAnimator对象的getAnimatedValue()函数可以得到当前的属性值如:

复制代码
ValueAnimator animation = ValueAnimator.ofFloat(0f, 1f);
animation.setDuration(1000);
animation.addUpdateListener(new AnimatorUpdateListener() {
    @Override
    public void onAnimationUpdate(ValueAnimator animation) {
        Log.i("update", ((Float) animation.getAnimatedValue()).toString());
    }
});
animation.setInterpolator(new CycleInterpolator(3));
animation.start();
复制代码

此示例中只是向Logcat输出了一些信息,可以改为想做的工作。

Animator.AnimatorListener

复制代码
onAnimationStart()

onAnimationEnd()

onAnimationRepeat()

//当动画被取消时调用,同时会调用onAnimationEnd().
onAnimationCancel()
复制代码

ValueAnimator.AnimatorUpdateListener

onAnimationUpdate()  //通过监听这个事件在属性的值更新时执行相应的操作,对于ValueAnimator一般要监听此事件执行相应的动作,不然Animation没意义,在ObjectAnimator(继承自ValueAnimator)中会自动更新属性,如无必要不必监听。在函数中会传递一个ValueAnimator参数,通过此参数的getAnimatedValue()取得当前动画属性值。

可以继承AnimatorListenerAdapter而不是实现AnimatorListener接口来简化操作,这个类对AnimatorListener中的函数都定义了一个空函数体,这样我们就只用定义想监听的事件而不用实现每个函数却只定义一空函数体。

复制代码
ObjectAnimator oa=ObjectAnimator.ofFloat(tv, "alpha", 0f, 1f);
oa.setDuration(3000);
oa.addListener(new AnimatorListenerAdapter(){
    public void on AnimationEnd(Animator animation){
        Log.i("Animation","end");
    }
});
oa.start();
复制代码

3.3 ObjectAnimator

继承自ValueAnimator,要指定一个对象及该对象的一个属性,当属性值计算完成时自动设置为该对象的相应属性,即完成了Property Animation的全部两步操作。实际应用中一般都会用ObjectAnimator来改变某一对象的某一属性,但用ObjectAnimator有一定的限制,要想使用ObjectAnimator,应该满足以下条件:

  • 对象应该有一个setter函数:set<PropertyName>(驼峰命名法)
  • 如上面的例子中,像ofFloat之类的工场方法,第一个参数为对象名,第二个为属性名,后面的参数为可变参数,如果values…参数只设置了一个值的话,那么会假定为目的值,属性值的变化范围为当前值到目的值,为了获得当前值,该对象要有相应属性的getter方法:get<PropertyName>
  • 如果有getter方法,其应返回值类型应与相应的setter方法的参数类型一致。

如果上述条件不满足,则不能用ObjectAnimator,应用ValueAnimator代替。

复制代码
tv=(TextView)findViewById(R.id.textview1);
btn=(Button)findViewById(R.id.button1);
btn.setOnClickListener(new OnClickListener() {
  @Override
  public void onClick(View v) {
    ObjectAnimator oa=ObjectAnimator.ofFloat(tv, "alpha", 0f, 1f);
    oa.setDuration(3000);
    oa.start();
  }
});
复制代码

把一个TextView的透明度在3秒内从0变至1。

根据应用动画的对象或属性的不同,可能需要在onAnimationUpdate函数中调用invalidate()函数刷新视图。

3.4 通过AnimationSet应用多个动画

AnimationSet提供了一个把多个动画组合成一个组合的机制,并可设置组中动画的时序关系,如同时播放,顺序播放等。

以下例子同时应用5个动画:

  1. 播放anim1;
  2. 同时播放anim2,anim3,anim4;
  3. 播放anim5。
AnimatorSet bouncer = new AnimatorSet();
bouncer.play(anim1).before(anim2);
bouncer.play(anim2).with(anim3);
bouncer.play(anim2).with(anim4)
bouncer.play(anim5).after(amin2);
animatorSet.start();

3.5 TypeEvalutors

根据属性的开始、结束值与TimeInterpolation计算出的因子计算出当前时间的属性值,android提供了以下几个evalutor:

  • IntEvaluator:属性的值类型为int;
  • FloatEvaluator:属性的值类型为float;
  • ArgbEvaluator:属性的值类型为十六进制颜色值;
  • TypeEvaluator:一个接口,可以通过实现该接口自定义Evaluator。

自定义TypeEvalutor很简单,只需要实现一个方法,如FloatEvalutor的定义:

复制代码
public class FloatEvaluator implements TypeEvaluator {
    public Object evaluate(float fraction, Object startValue, Object endValue) {
        float startFloat = ((Number) startValue).floatValue();
        return startFloat + fraction * (((Number) endValue).floatValue() - startFloat);
    }
}
复制代码

根据动画执行的时间跟应用的Interplator,会计算出一个0~1之间的因子,即evalute函数中的fraction参数,通过上述FloatEvaluator应该很好看出其意思。

3.6 TimeInterplator

Time interplator定义了属性值变化的方式,如线性均匀改变,开始慢然后逐渐快等。在Property Animation中是TimeInterplator,在View Animation中是Interplator,这两个是一样的,在3.0之前只有Interplator,3.0之后实现代码转移至了TimeInterplator。Interplator继承自TimeInterplator,内部没有任何其他代码。

  • AccelerateInterpolator          加速,开始时慢中间加速
  • DecelerateInterpolator         减速,开始时快然后减速
  • AccelerateDecelerateInterolator    先加速后减速,开始结束时慢,中间加速
  • AnticipateInterpolator        反向 ,先向相反方向改变一段再加速播放
  • AnticipateOvershootInterpolator    反向加回弹,先向相反方向改变,再加速播放,会超出目的值然后缓慢移动至目的值
  • BounceInterpolator         跳跃,快到目的值时值会跳跃,如目的值100,后面的值可能依次为85,77,70,80,90,100
  • CycleIinterpolator         循环,动画循环一定次数,值的改变为一正弦函数:Math.sin(2 * mCycles * Math.PI * input)
  • LinearInterpolator         线性,线性均匀改变
  • OvershottInterpolator        回弹,最后超出目的值然后缓慢改变到目的值
  • TimeInterpolator           一个接口,允许你自定义interpolator,以上几个都是实现了这个接口

3.7 当Layout改变时应用动画

ViewGroup中的子元素可以通过setVisibility使其Visible、Invisible或Gone,当有子元素可见性改变时(VISIBLE、GONE),可以向其应用动画,通过LayoutTransition类应用此类动画:

transition.setAnimator(LayoutTransition.DISAPPEARING, customDisappearingAnim);

通过setAnimator应用动画,第一个参数表示应用的情境,可以以下4种类型:

  • APPEARING        当一个元素在其父元素中变为Visible时对这个元素应用动画
  • CHANGE_APPEARING    当一个元素在其父元素中变为Visible时,因系统要重新布局有一些元素需要移动,对这些要移动的元素应用动画
  • DISAPPEARING       当一个元素在其父元素中变为GONE时对其应用动画
  • CHANGE_DISAPPEARING   当一个元素在其父元素中变为GONE时,因系统要重新布局有一些元素需要移动,这些要移动的元素应用动画.

第二个参数为一Animator。

mTransitioner.setStagger(LayoutTransition.CHANGE_APPEARING, 30);

此函数设置动画延迟时间,参数分别为类型与时间。

3.8 Keyframes

keyFrame是一个 时间/值 对,通过它可以定义一个在特定时间的特定状态,即关键帧,而且在两个keyFrame之间可以定义不同的Interpolator,就好像多个动画的拼接,第一个动画的结束点是第二个动画的开始点。KeyFrame是抽象类,要通过ofInt(),ofFloat(),ofObject()获得适当的KeyFrame,然后通过PropertyValuesHolder.ofKeyframe获得PropertyValuesHolder对象,如以下例子:

复制代码
Keyframe kf0 = Keyframe.ofInt(0, 400);
Keyframe kf1 = Keyframe.ofInt(0.25f, 200);
Keyframe kf2 = Keyframe.ofInt(0.5f, 400);
Keyframe kf4 = Keyframe.ofInt(0.75f, 100);
Keyframe kf3 = Keyframe.ofInt(1f, 500);
PropertyValuesHolder pvhRotation = PropertyValuesHolder.ofKeyframe("width", kf0, kf1, kf2, kf4, kf3);
ObjectAnimator rotationAnim = ObjectAnimator.ofPropertyValuesHolder(btn2, pvhRotation);
rotationAnim.setDuration(2000);
复制代码

上述代码的意思为:设置btn对象的width属性值使其:

  • 开始时 Width=400
  • 动画开始1/4时 Width=200
  • 动画开始1/2时 Width=400
  • 动画开始3/4时 Width=100
  • 动画结束时 Width=500
第一个参数为时间百分比,第二个参数是在第一个参数的时间时的属性值。
定义了一些Keyframe后,通过PropertyValuesHolder类的方法ofKeyframe一个PropertyValuesHolder对象,然后通过ObjectAnimator.ofPropertyValuesHolder获得一个Animator对象。
用下面的代码可以实现同样的效果(上述代码时间值是线性,变化均匀):
ObjectAnimator oa=ObjectAnimator.ofInt(btn2, "width", 400,200,400,100,500);
oa.setDuration(2000);
oa.start();

3.9 Animating Views

在View Animation中,对View应用Animation并没有改变View的属性,动画的实现是通过其Parent View实现的,在View被drawn时Parents View改变它的绘制参数,draw后再改变参数invalidate,这样虽然View的大小或旋转角度等改变了,但View的实际属性没变,所以有效区域还是应用动画之前的区域,比如你把一按钮放大两倍,但还是放大这前的区域可以触发点击事件。为了改变这一点,在Android 3.0中给View增加了一些参数并对这些参数增加了相应的getter/setter函数(ObjectAnimator要用这些函数改变这些属性):

  • translationX,translationY: View相对于原始位置的偏移量
  • rotation,rotationX,rotationY: 旋转,rotation用于2D旋转角度,3D中用到后两个
  • scaleX,scaleY: 缩放比
  • x,y: View的最终坐标,是View的left,top位置加上translationX,translationY
  • alpha: 透明度
跟位置有关的参数有3个,以X坐标为例,可以通过getLeft(),getX(),getTranslateX()获得,若有一Button btn2,布局时其坐标为(40,0):
复制代码
//应用动画之前
btn2.getLeft();    //40
btn2.getX();    //40
btn2.getTranslationX();    //0
//应用translationX动画
ObjectAnimator oa=ObjectAnimator.ofFloat(btn2,"translationX", 200);
oa.setDuration(2000);
oa.start();
/*应用translationX动画后
btn2.getLeft();    //40
btn2.getX();    //240
btn2.getTranslationX();    //200
*/
//应用X动画,假设没有应用之前的translationX动画
ObjectAnimator oa=ObjectAnimator.ofFloat(btn2, "x", 200);
oa.setDuration(2000);
oa.start();
/*应用X动画后
btn2.getLeft();    //40
btn2.getX();    //200
btn2.getTranslationX();    //160
*/
复制代码
无论怎样应用动画,原来的布局时的位置通过getLeft()获得,保持不变;
  X是View最终的位置;
  translationX为最终位置与布局时初始位置这差。
  所以若就用translationX即为在原来基础上移动多少,X为最终多少
  getX()的值为getLeft()与getTranslationX()的和
  对于X动画,源代码是这样的:
case X:
       info.mTranslationX = value - mView.mLeft;
       break;

Property Animation也可以在XML中定义

  • <set> – AnimatorSet
  • <animator> – ValueAnimator
  • <objectAnimator> – ObjectAnimator
XML文件应放大/res/animator/中,通过以下方式应用动画:
AnimatorSet set = (AnimatorSet) AnimatorInflater.loadAnimator(myContext, R.anim.property_animator);
set.setTarget(myObject);
set.start();

3.10 ViewPropertyAnimator

如果需要对一个View的多个属性进行动画可以用ViewPropertyAnimator类,该类对多属性动画进行了优化,会合并一些invalidate()来减少刷新视图,该类在3.1中引入。

以下两段代码实现同样的效果:

PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("x", 50f);
PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("y", 100f);
ObjectAnimator.ofPropertyValuesHolder(myView, pvhX, pvyY).start();
myView.animate().x(50f).y(100f);

Android-Looper类介绍

   Android中的Looper类,是用来封装消息循环和消息队列的一个类,用于在android线程中进行消息处理。handler其实可以看做是一个工具类,用来向消息队列中插入消息的。

(1) Looper类用来为一个线程开启一个消息循环。

默认情况下android中新诞生的线程是没有开启消息循环的。(主线程除外,主线程系统会自动为其创建Looper对象,开启消息循环。)

Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper,对应一个MessageQueue。

(2) 通常是通过Handler对象来与Looper进行交互的。Handler可看做是Looper的一个接口,用来向指定的Looper发送消息及定义处理方法。

默认情况下Handler会与其被定义时所在线程的Looper绑定,比如,Handler在主线程中定义,那么它是与主线程的Looper绑定。

mainHandler = new Handler() 等价于new Handler(Looper.myLooper()).

Looper.myLooper():获取当前线程的looper对象,类似的 Looper.getMainLooper() 用于获取主线程的Looper对象。

(3) 在非主线程中直接new Handler() 会报如下的错误:

E/AndroidRuntime( 6173): Uncaught handler: thread Thread-8 exiting due to uncaught exception

E/AndroidRuntime( 6173): java.lang.RuntimeException: Can’t create handler inside thread that has not called Looper.prepare()

原因是非主线程中默认没有创建Looper对象,需要先调用Looper.prepare()启用Looper。

(4) Looper.loop(); 让Looper开始工作,从消息队列里取消息,处理消息。

注意:写在Looper.loop()之后的代码不会被执行,这个函数内部应该是一个循环,当调用mHandler.getLooper().quit()后,loop才会中止,其后的代码才能得以运行。

(5) 基于以上知识,可实现主线程给子线程(非主线程)发送消息。

把下面例子中的mHandler声明成类成员,在主线程通过mHandler发送消息即可。

Android官方文档中Looper的介绍:

Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one, call prepare() in the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.

Most interaction with a message loop is through the Handler class.

This is a typical example of the implementation of a Looper thread, using the separation of prepare() and loop() to create an initial Handler to communicate with the Looper.

class LooperThread extends Thread {
      public Handler mHandler;
      
      public void run() {
          Looper.prepare();
          
          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };
          
          Looper.loop();
      }
}

转自:
http://vinny-w.iteye.com/blog/1334641

详解android:scaleType属性

Android:scaleType是控制图片如何resized/moved来匹对ImageView的size。

ImageView.ScaleType / android:scaleType值的意义区别:

CENTER /center  按图片的原来size居中显示,当图片长/宽超过View的长/宽,则截取图片的居中部分显示

CENTER_CROP / centerCrop  按比例扩大图片的size居中显示,使得图片长(宽)等于或大于View的长(宽)

CENTER_INSIDE / centerInside  将图片的内容完整居中显示,通过按比例缩小或原来的size使得图片长/宽等于或小于View的长/宽

FIT_CENTER / fitCenter  把图片按比例扩大/缩小到View的宽度,居中显示

FIT_END / fitEnd   把图片按比例扩大/缩小到View的宽度,显示在View的下部分位置

FIT_START / fitStart  把图片按比例扩大/缩小到View的宽度,显示在View的上部分位置

FIT_XY / fitXY  把图片不按比例扩大/缩小到View的大小显示

MATRIX / matrix 用矩阵来绘制,动态缩小放大图片来显示。

** 要注意一点,Drawable文件夹里面的图片命名是不能大写的