Gtalk的功能由于有官方支持，早就弄了跟这个差不多的版本。

另外，这个软件目前是以插件的形式开发，多一个协议就是多一个apk，实现一些intent即可。官方的IM包里面有很多支持，可惜文档没有提及。

Android中文论坛原帖

Ext2.0.2的这次升级主要是针对Air的支持，看来他们的关系是越来越近了，我也借机小试了一下Air。

简单说说Air的开发过程：

1.先要下载jre 和 airSDK

2.jre就不说了，airSDK也是简单的解压一下便可。

可以看看SDK下面的bin目录，一共俩文件，一个adl一个adt，adl是用来测试的，adt使用编辑发布的（ADT怎么让我想起来android了）

3.创建一个普通的目录作为项目目录。OK，可以写页面了。就是写html js flash什么的，都可。

4.编写一个xml文件，名字不限。内容嘛～～～～

看看这个文件，airSDK\templates\descriptor-template.xml 里面有详细的解释，拿过来改改即可，给一个例子：

---

<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://ns.adobe.com/air/application/1.0.M6">
    <id>examples.html.HelloWorld</id>
    <version>0.1</version>
    <filename>HelloWorld</filename>
    <initialWindow>
        <content>HelloWorld.html</content>
        <visible>true</visible>
        <width>400</width>
        <height>200</height>
    </initialWindow>
</application>

---

5.运行airSDK\bin\adl.exe (那个创建的xml文件名)，运行即可。

PS:我一般用eclipse来编辑，用外部命令的工具来运行adl，很方便。

简单的说了一下Air的开发方法后，我们来简单的看一下Ext都对Air提供了什么支持。

1.Ext.air.FileProvider

Ext提供状态保存的功能，在对AIr的支持中Ext实现了一个Provider，这个Provider把状态保存在本地目录的一个文件里。使用方法如下：

---

// Initialize the state provider
Ext.state.Manager.setProvider(new Ext.air.FileProvider({
	file: 'ext.state',
	// if first time running
	defaultState : {
		mainWindow : {
			width:400,
			height:200,
			x:10,
			y:10
		}
	}
}));

---

制定Provider为Ext.air.FileProvider即可，这个操作一般在onReady里面执行。当然需要你先创建一个ext.state文本文件，在程序根目录下即可。这样ext的应用运行时，窗口等大小的调整，位置之类的调整都能保存下来了。很方便。

这里包装的Air代码主要是：

air.File.applicationStorageDirectory.resolvePath

air.FileStream

等

2.Ext.air.NativeWindow

Ext可以调用Air实现Native的窗口。使用方法如下：

---

	var win = new Ext.air.NativeWindow({
		id: 'mainWindow',
		instance: window.nativeWindow,
		minimizeToTray: true,
		trayIcon: 'ext-air/resources/icons/extlogo16.png',
		trayTip: 'Simple Tasks',
		trayMenu : [{
			text: 'Open Simple Tasks',
			handler: function(){
				win.activate();
			}
		}, '-', {
			text: 'Exit',
			handler: function(){
				air.NativeApplication.nativeApplication.exit();
			}
		}]
	});

---

我们可以看到，其中最吸引人的是系统托盘的功能，可以方便的指定系统托盘的各种属性。

这里包装的主要是：

window.runtime.flash.html.HTMLLoader.createRootWindow

air.Screen.mainScreen.visibleBounds

3.Ext.sql.Connection

这个是重头戏，对db的支持，我们知道Air的DB是采用sqlite3来实现的。Ext封装了Air的db操作，简化统一了一些，而且提供了Store的支持，非常强大：

让我们简单看一下用法：

首先取得connection

var conn = Ext.sql.Connection.getInstance();

而后打开db

conn.open('ext.db');//这里的文件如果不存在会自动创建

创建Table

---

        conn.createTable({
            name: 'user',
            key: 'userId',
            fields: [
			    {name: 'userId', type:'string'},
			    {name: 'name', type:'string'},
			    {name: 'pwd', type:'string'},
			    {name: 'email', type:'string'}
			]
    	});

---

取得一个Table

var userDao = conn.getTable('user','userId');

查询

var users = userDao.select();//这里可以写条件式

添加

---

var newuser = {
    userId : 'sshw',
    name : 'sshwsfc',
    pwd : 'test',
    email : 'sshwsfc@gmail.com'
} 

userDao.insert(newuser);

---

感觉使用上还是蛮不错的，大家可以一点点试试看。

值得一提的是，在源码中发现Connection这里设计成了工厂的模式，Connection是一个伪接口，实现除了Air的还有GoogleGear的，会根据所处环境选择，灰常的好。

功能还在研究中，有心得了一点点给大家分享，

PS:打算搞一个iphone的信息管理软件练练手。反正都是sqlite的

不打算从py的语法基础说起了,直接说说对django的心得:

接触django首先需要了解可能就是他那个model，建立一个model就什么都有了，这对于搞java得人员来说还是挺有吸引力的（当然貌似对于动态语言这都是小儿科），那么让我们先看一个model的例子：

偷懒了，直接拿django-admin里面的User出来了

class User(models.Model): 
    username = models.CharField(_('username'), maxlength=30, unique=True, validator_list=[validators.isAlphaNumeric])) 
    first_name = models.CharField(_('first name'), maxlength=30, blank=True) 
    last_name = models.CharField(_('last name'), maxlength=30, blank=True) 
    email = models.EmailField(_('e-mail address'), blank=True) 
    password = models.CharField(_('password'), maxlength=128)) 
    class Meta: 
        ordering = ('username',)

每个属性就是一个库表的字段，定义起来非常简单明了，models里面提供了很多种类的Field类似上面的EmailField。不同的Field有不同的设置，可以看相应的原来来了解相关的设置．

在model class内部还有一个class Meta，这个Class的属性制定了这个表的一些存取策略，例如这里的ordering。MetaClass里面的属性可以用model的_meta属性取得。OK，那么这样一个model怎么就能实现对数据库表的灵活操作了呢。让我们来看看吧。

首先先分析一下/django/django/db/models/base.py这个文件，其中包含了models.Model这类的定义：

看看class定义的第一行吧，第一行就够我琢磨一阵子的了：

class Model(object):
    __metaclass__ = ModelBase

Model采用了new style class定义，关于这个内容大家可以放狗看一下，第一行是一个__metaclass__属性的定义，该属性的值是ModelBase，这是一个类。__metaclass__的意思是，指定一个class，这个class的实例就是本class，相信您已经晕了。那么就拿这个Model的例子来说明一下，如果没有__metaclass__这个属性，产生一个实例就是正常的流程，有了这个属性流程会有改变：

首先调用BaseModel.__new__(cls, name, bases, attrs)这个方法，回返回的值是一个class类型，然后用这个class来创建实例。其实BaseModel就是Model的元类，来制定Model这个类的最终样子。关于元类的更多信息请看这里

那么我们的目光一下转移到BaseModel这个类上，我有种直觉，Meta这个class最后可以用_meta来取就是在这里做的手脚，看一下BaseModel的定义吧，有点长：

class ModelBase(type):
    "Metaclass for all models"
    def __new__(cls, name, bases, attrs):
        # If this isn't a subclass of Model, don't do anything special.

        if name == 'Model' or not filter(lambda b: issubclass(b, Model), bases):    #1
            return super(ModelBase, cls).__new__(cls, name, bases, attrs)

        # Create the class.

        new_class = type.__new__(cls, name, bases, {'__module__': attrs.pop('__module__')})    #2

        new_class.add_to_class('_meta', Options(attrs.pop('Meta', None)))     #3

        new_class.add_to_class('DoesNotExist', types.ClassType('DoesNotExist', (ObjectDoesNotExist,), {}))

        # Build complete list of parents                                      #4
        for base in bases:
            # TODO: Checking for the presence of '_meta' is hackish.
            if '_meta' in dir(base):
                new_class._meta.parents.append(base)
                new_class._meta.parents.extend(base._meta.parents)

        model_module = sys.modules[new_class.__module__]

        if getattr(new_class._meta, 'app_label', None) is None:
            # Figure out the app_label by looking one level up.
            # For 'django.contrib.sites.models', this would be 'sites'.
            new_class._meta.app_label = model_module.__name__.split('.')[-2]  #5

        # Bail out early if we have already created this class.
        m = get_model(new_class._meta.app_label, name, False)                 #6
        if m is not None:
            return m

        # Add all attributes to the class.
        for obj_name, obj in attrs.items():
            new_class.add_to_class(obj_name, obj)                             #7

        # Add Fields inherited from parents
        for parent in new_class._meta.parents:
            for field in parent._meta.fields:
                # Only add parent fields if they aren't defined for this class.
                try:
                    new_class._meta.get_field(field.name)
                except FieldDoesNotExist:
                    field.contribute_to_class(new_class, field.name)          #8

        new_class._prepare()

        register_models(new_class._meta.app_label, new_class)                 #9
        # Because of the way imports happen (recursively), we may or may not be
        # the first class for this model to register with the framework. There
        # should only be one class for each model, so we must always return the
        # registered version.
        return get_model(new_class._meta.app_label, name, False)              #10

简单分析一下这个代码：

1. 检查class是否为Model的子类，不是的话，不做任何处理，直接传给父类处理，也就相当于正常的处理了class，注意super在多重继承的时候应该严格使用

2. 用type来创建类，创建的就是正常的ModelClass

3. 这句很重要，add_to_class是Model里面的class方法，这个方法其实就是传入name和value，给Model添加class属性.看到了，原来神奇的_meta就是这么来的. 提到add_to_class方法，简单看一下它的代码：

    def add_to_class(cls, name, value):
        if name == 'Admin':
            assert type(value) == types.ClassType, "%r attribute of %s model must be a class, not a %s object" % (name, cls.__name__, type(value))
            value = AdminOptions(**dict([(k, v) for k, v in value.__dict__.items() if not k.startswith('_')]))
        if hasattr(value, 'contribute_to_class'):
            value.contribute_to_class(cls, name)
        else:
            setattr(cls, name, value)
    add_to_class = classmethod(add_to_class)

4. Meta的集成，Option的这个类提供继承方法

5. 取得applabel，就是把model的名字分割取到数第二个，我很喜欢-2这样的设定

6. get_model方法取得缓存里面的东西。

7. 把所有的class attr拿出来搞一遍，一般的属性就setattr弄回去了，要是这个属性有contribute_to_class这个callable属性，那就执行之（Admin的处理完全也可以这样，其实我们常用的objects就是用这个方法弄的）

8. 每个Field调用自己的contribute_to_class方法来进行特殊的处理

9. 进入缓存，，暂且叫缓存吧，里面的东西大家看看很简单 文件在 /django/django/db/models/loading.py 里面还是有很多内容的

10.看注释说的很清楚了，我们一定要在缓存里面拿model。

其中需要指出的是，new_class._prepare() 这个方法，简单列出片段：

    def _prepare(cls):
        # Creates some methods once self._meta has been populated.
        opts = cls._meta
        opts._prepare(cls)

        ．．．．

        dispatcher.send(signal=signals.class_prepared, sender=cls)

中间省略了一些代码，不是我没看懂的就是没意思的，关键要看这个dispatcher呀。这里是监听者模式，dispatcher.send(signal=signals.class_prepared, sender=cls)放松了一个包含特定信号的事件，让监听的人可以做相应的处理。这样的信号还有很多种，我们可以很简单的截获信号，处理相应的内容。也许您还记得，在我们创建db的时候，会提示创建一个超级用户，其实就是用这个方法来弄的。

那我为什么要把这个单独拿出来说呢，因为监听这个事件的人不是别人，是"objects"！！！在文件/django/django/db/models/manager.py的开头就有这样的代码：

def ensure_default_manager(sender):
    cls = sender
    if not hasattr(cls, '_default_manager'):
        # Create the default manager, if needed.
        try:
            cls._meta.get_field('objects')
            raise ValueError, "Model %s must specify a custom Manager, because it has a field named 'objects'" % cls.__name__
        except FieldDoesNotExist:
            pass
        cls.add_to_class('objects', Manager())

dispatcher.connect(ensure_default_manager, signal=signals.class_prepared)

定义了一个callable，然后监听signals.class_prepared信号，呵呵，连上了吧，只要Class准备好了，就调用这个方法。简单判断有没有_default_manager'属性和meta里面的objects后，开始插入objects。cls.add_to_class('objects', Manager()) 很熟悉吧，前面讲过不多说了。

PS：写到这里不由得感叹，为啥同样是往Class里面加入东东，要搞这么多的花样呢，我以前也写过一个Rails配置加载过程的分析文档，虽然一个简单的加载配置就把所有动态语言玩个遍，但是这也太不规范了吧，可能不这么玩就不算“动态”语言了吧，哈哈。

终于Model的Class造好了，相信大家以后造自己的Class也能玩出更多的花样。那么可以开始下一步了。我到老家后再写吧，打算讲讲神奇的objects，也就是Manager，其实就是玩QuerySet。。那里有很多的__xxx__方法，很好很强大

2007年11月12日(北美时间), Android的APP SDK公布, 开始了google手机的开发大赛. 我们致力于Android的开发文档翻译, 开发技术交流等工作, 希望为Android平台在中国的推广贡献自己的力量.

    String tokenName = null;
    if ( transitionName != null ) {
      if ( ! parent.hasChild( transitionName ) ) {
        tokenName = transitionName;
      } else {
        int i = 2;
        tokenName = transitionName + Integer.toString( i );
        while ( parent.hasChild( tokenName ) ) {
          i++;
          tokenName = transitionName + Integer.toString( i );
        }
      }
    } else { // no transition name
      int size = ( parent.getChildren()!=null ? parent.getChildren().size()+1 : 1 );
      tokenName = Integer.toString(size);
    }
    return tokenName; 

这里"token"那里来？这个token名字，你自己可以根据命名规则得到 。看到这里应该很明了了

token的命名规则；首先根据transitionName的名字命名，这个transitionName的名字是你自己的写的你不可能不知道。 如果transitionName的名字重名了，加自然数区分 当然，如果transitionName没有名字，用分支的个数+1作为名字。

应该比较清楚了。

PS：这个是qq聊天记录的整理版，所以说话比较诡异。为的是记录下来避免忘记，也感谢群里的朋友。发现互相解决问题是提高水平的一个捷径。。

现来说Rails里面如何加载config的吧。

在java里面config绝对是一个resource文件，然后通过读取配置的工具加入进来，在分析处理。

在ROR里面完全不是这么回事。

1.首先大家要了解的是，在我们启动 ruby script/server 的时候，rails做了一系列的处理，最后他执行了environment.rb

Rails::Initializer.run do  | config |     
   #  这里能插入我们自己的配置。    
   #  config. 之类    
end   

这里的config其实是Initializer内部的一个变量，掌控全局的配置信息，我们可以使用这个config来配置我们想要的。Rails::Initializer.run的源码是这样的，yield再一次显示了他的威力，让我们在配置文件中得以配置config。然后实例化了一个initializer 之后，把config作为参数传入了。

def  self.run(command  =  :process, configuration  =  Configuration.new)    
   yield  configuration  if  block_given?    
  initializer  =  new configuration    
  initializer.send(command)    
  initializer    
end   

我们接着往下走，可以看到initializer 做了一系列的初始化工作，包括load_path的设定，路由的初始化，和activerecord的初始化。我们关心的还是配置如何起作用，那么来看看environments目录下面的配置文件是如何导入的吧。

def  load_environment    
  silence_warnings do   
    config  =  configuration    
    constants  =  self. class .constants    
    eval(IO.read(configuration.environment_path), binding)    
    (self. class .constants  -  constants).each do  | const |     
      Object.const_set(const, self. class .const_get(const))    
    end   
  end   
end   

IO.read(configuration.environment_path) ，，这里就不使用什么回调不回调了，而是干脆IO拿出来eval一把，这里也是吃了一惊，这样也可以呀~~~~~~~然后，我们可以看看，他处理常量的方法，把自己配置文件中的常量全部放入Object里面，起到全局常量的目的。

最绝的还是initialize_framework_settings，使用了有一个ruby的技巧。

ruby 代码

def  initialize_framework_settings    
  configuration.frameworks.each do  | framework |     
    base_class  =  framework.to_s.camelize.constantize.const_get( " Base " )    
   
    configuration.send(framework).each do  | setting, value |     
      base_class.send( " #{setting}= " , value)    
    end   
  end   
end   

configuration.frameworks里面存放的是rails个个组件的名字，比方说active_record之类。然后把这个名字大写转换，然后用constantize取得ActiveRecord这个Module(注意，这些东西都在activesupport里面呢，activesupport/lib/active_support/core_ext/string/inflections.rb )。然后用const_get取得这个模块的Base类，也就是ActiveRecord::Base这个类了（下面都叫做Base类），所有的Rails的组件都是这个命名规则改天我们自己想要做一个Rails的组件加进来，也可以这样（但是要稍微修改一个源码）。

然后，我们吧config里面的内容给Base类。configuration.send(framework)是调用一个组件名称的方法，比方说active_record，就是去的config里面的active_record属性（这是最基本的），通过后面的do我们可以看到config返回的是一个hash，然后把hash中每一个key作为变量，value为传入值，传入Base类。。。这里大家应该没什么问题了，看看我们的config文件是怎么写的吧。

ruby 代码

#  Settings specified here will take precedence over those in config/environment.rb    
   
#  In the development environment your application's code is reloaded on    
#  every request.  This slows down response time but is perfect for development    
#  since you don't have to restart the webserver when you make code changes.    
config.cache_classes  =  false   
   
#  Log error messages when you accidentally call methods on nil.    
config.whiny_nils  =  true   
   
#  Enable the breakpoint server that script/breakpointer connects to    
config.breakpoint_server  =  true   
   
#  Show full error reports and disable caching    
config.action_controller.consider_all_requests_local  =  true   
config.action_controller.perform_caching              =  false   
config.action_view.cache_template_extensions          =  false   
config.action_view.debug_rjs                          =  true   
   
#  Don't care if the mailer can't send    
config.action_mailer.raise_delivery_errors  =  false   

哦，看着很晕吧，config就是我们的配置对象，按照我们上面的说法，config.action_view之类framework的变量应该是一个hash才对呀，如果是hash的话，不应该用这样的方式传入，可能会用 config.action_view = {:debug_rjs => true}来传入。

OK.我们来看这个变量到底是什么样的hash。

ruby 代码

def  initialize    
  .    
  .    
   for  framework  in  default_frameworks    
    self.send( " #{framework}= " , OrderedOptions.new)    
  end   
end   

在初始化这些变量的时候，Rails给他赋值为OrderedOptions.new。这个特殊的类型可能就是关键。

ruby 代码

class  OrderedOptions  <  OrderedHash  # :nodoc:    
   def  [] = (key, value)    
    super(key.to_sym, value)    
  end   
      
   def  [](key)    
    super(key.to_sym)    
  end   
   
   def  method_missing(name,  * args)    
     if  name.to_s  =~   / (. * ) = $ /     
      self[$ 1 .to_sym]  =  args.first    
     else    
      self[name]    
    end   
  end   
end   

看到其中的玄妙了么，method_missing~~~！！ 如果调用一个**=的方法 ，就像当用传入一个HASH的值，key就是方法的名字。

也就是：config.action_view.debug_rjs  = true 相当于config.action_view[:debug_rjs] = true

OK ，大体上描述了一下，可以看到简单的一个Rails初始化已经给我们展示了几乎全部ruby的靓丽之处，这能说明，这个亮点肯定是贯穿rails的基本，在以后的深入研究中我们就能看到了。