android 知识积累

R.id.stringid
R.string.valuestr
R.layout.sssd
R.java 是资源文件的映射类

R类为每份资源定义一个内部类

android:id="@+id/ok" 在R类中id内部类中新增一个ok的属性 R.id.ok变量
(Button)findViewById(R.id.ok)可以获取对应的控件

android:label = "@string/test"
android清单文件  AndroidManifest.xml 整个应用的全局描述文件 每个项目中必须存在的文件
定义权限 uses-permission 

android应用由一个或多个基本组件所组成(activity-用户交互组件和view-显示UI组件 用户实实在在看到的组件 需要放入activity)
view要显示则应该调用activity中的setContentView(R.layout.<资源文件名称>)方法 参数是需要显示的View对象
也可以通过findViewById(R.id.<UI对应的ID>)

大部分的视图组件放入到 android.widget 和 android.view中

Button btn = new Button(this); 通过new可以创建所有的View组件 参数都是this
btn.setOnClickListener(new OnClickListener(){
        @Override
        public void onClick(View v){
        
        }
})
--线形布局
<LinearLayout android:id="@+id/ok" android:orientation:"vertical" android:layout_width="fill_parent" 
              android:height="fill_parent"> wrap_content 和fill_parent
android:gravity设置所有组件对其方式

RelativeLayout相对布局
android:background="@drawable/bk"

GridLayout

--控件分类
TextView EditText 属性几乎可以共用 
android:textSize="10pt"
android:inputType="number"设置输入的类型是数字的

Button RadioGroup RadioButton CheckBox
RadioGroup点击条目时响应的方法 setOnCheckedChangeListener

ListView ListActivity --继承列表activity继承ListActivity类
ListView GridView Spinner 都是容器而 adapter是加载项  和内容和显示的样式有关

Adapter常见实现类有 ArrayAdapter SimpleAdapter SimpleCursorAdapter BaseAdapter
android:orientation="vertical"
list.setOnItemClickListener(new OnItemClickListener(){
	     @Override
       public void onItemClick(){
       
       }
});
android:layout_height="240dp" 可以设置具体的大小
android:layout_width="240dp"

"@string/status"

ListActivity是Activity当中需要继承的  ListView是XML中的List关联标签

事件 分为 注册事件和回调事件 setXxxListener就是注册事件 
事件源(Button) 事件 事件监听器
KeyEvent.KEYCODE_A 表示键盘中的A键
setLongClickListener长时间点击事件

因为事件的监听一般只写一次 因此一般使用匿名内部类
通常建议使用匿名内部类作为监听器
btn.setOnClickListener(new OnClickListener(){
         @Override
         public void onClick(View v){
         }
});

同样也可以直接绑定到标签中
<Button android:onClick="doOnClick" /> 在Activity类中定义doOnClick方法 
public void doOnClick(View source)

Activity主要作用是完成界面初始化的工作

Handler消息传递机制
只允许UI线程处理UI组件
继承Handler类  覆盖的方法有handleMessage

与Handler相关的类有 Message Looper MessageQueue ;

Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg){
               Bundle bundle = msg.getData();
               bundle.getString("paramString");
               bundle.getInt("paramInt");
               bundle.putString("paramName","paramValue");
        }
};
Bundle bundle = new Bundle();
bundle.putString("paramName","paramValue");
bundle.putInt();

SELECT * FROM TEXMPAPER ;

Toast.makeText(this,content,short).show();

progressBar.setProgress(i);
ListActivity ListView
TabActivity TabHost

Activity必须在AndroidManifest.xml中注册

多个Activity组成Activity栈当前活动的Activity位于栈顶
继承Activity类 并重写onCreate方法 在被创建时调用

在Activity中启动另一个Activity方法 startActivity(Intent)
Intent intent = new Intent(OneActivity.this,TwoActivity.class);
startActivity(Intent) --从OneActivity跳转到TwoActivity
调用finish方法结束某个Activity

使用Bundle用于不同Activity之间数据传递
Intent提供的方法
putExtras(Bundle);
Bundle getExtras();
--在Activity中获取意图
Intent intent = getIntent();
Bundle bundle = intent.getExtras();

Activity四种加载模式 standard(每次都会创建新的Activity实例) singletop(如果栈顶有该Activity实例则不创建新Activity实例) 
singletask(同一个Task只有一个Activity实例) singleinstance(永远只会创建一个Activity实例)

AndroidManifest.xml中的<intent-filter/>定义了第一次调用的Activity 
--所有activity必须要在清单文件中声明 否则不起作用
<activity android:name=".OneActivity">

资源文件分两类 可以用R资源清单类访问的 一般在res目录下 和 不能用R清单类进行访问的资源 一般在assets目录下

可以通过Resource类进行获取对应的资源文件的实际值

Resource res = getResources();
--获取字符串资源
String str = res.getText(R.string.strId);
--获取图片资源
Drawable draw = res.getDrawable(R.drawable.logoId);
--获取数组类型资源
int[] intArr = res.getIntArray(R.array.arrayId);

在XML中使用资源信息

@resource_type/resource_name 如 @id/stringId  

<resources>
	<color name='red'>#dddd</color>  @color/red
  <string name='key'>value</color> @string/key
</resources>

<array name="array_a">
  <item>@string/key</item> --可以引用其他资源信息
  <item>item2</item>
</array>

getResources().getStringArray(R.array.array_a); --获得字符串数组

<ListView android:entries="@array/array_a">

BitMap相当于一张位图

绘图关键类 Canvas Paint

SharedPreferences主要保存简单的Key-Value键值对
SharedPreferences是一个借口 只能通过Context调用的getSharedPreferences(name,mode)来获得SharedPreferences实例
读SharedPreferences数据用sharedPreferences.getString("xxx",null) 或者 getInt()
写数据 则用 Editor editor = sharedPreferences.edit();
editor.putString("xxx","valueString");
editor.putInt("xxx","valueInt");
--弹出一个小的提示框
Toast.makeText(this,"显示内容",Toast.LENGTH_LONG).show();

Android中的应用程序的包名来作为该应用程序的标示
--获得其他应用程序的SharedPreferences
Context context = createPackageContext("应用程序对应的包名",Context.CONTEXT_IGNORE_SECURITY);
context.getSharedPreferences("count",CONTEXT.MODE_WORLD_READABLE);

--File存储
FileInputStream openFileInput(String name) ;
FileOutputStream openFileOutput(String name) ;

SD卡的地址File file = Environment.getExternalStorageDirectory() ;
如果要在SD卡读写数据必须要在清单文件(AndroidManifest.xml)文件定义权限
--SD卡中创建和删除文件的权限
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS">
--SD卡中写入数据的权限
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE">


注册Provider

<provider android:name=".DDDProvider" android:authorities="uri.dd" android:exported="true"> uri.dd是Uri域名
android:exported用于指定是否可以被其他应用程序调用

uri --> content://uri.dd/word/2     访问uri.dd下的 word的数据为2的数据

ContentResolver会通过uri找到对应的ContentProvider来进行CRUD操作

A调用ContentResolver对应的insert方法时对调用uri对应的ContentProvider来进行insert操作

编写自己的XxxContentProvider需要继承ContentProvider类 重写 insert query update delete等方法  
然后配置ContentProvider 

Uri uri = Uri.parse("content://uri.dd/");

ContentResolver resolver = getContentResolver();
resolver.query(uri,param..);
ContentResolver所有的方法的第一个参数是uri

ContentObserver用于监听ContentProvider的数据变化

定义Service的子类 然后在清单文件中定义该Service Service只运行于后台
<service android:name=".XxxService">
         <intent-filter>
             <action android:name="xxxx.xxx.service">
         </intent-filter>
</service>
启动Service
final Intent intent = new Intent();
intent.setAction("xxxx.xxx.service");
startService(intent);

停止Service
stopService(intent);

AIDL Service 跨进程之间的通信

AIDL定义的源代码必须要以.aidl结尾

cat.aidl

package ddd

interface ICat{
          String getColor();
          double getWidth();
}

ADT工具会自动生成ICat.java文件 ICat实现了IBinder和ICat两个接口

TelephonyManager电话管理器
TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);

SmsManager短信管理器
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage(对面号码,null,内容,PendingIntent.getActivity(this,0,new Intent(),0),null);
PendingIntent是可以发送到其他应用组件的Intent

授予发送短信的权限 
<uses-permission android:name="android.permission.SEND_SMS" />

AudioManager音频管理器
--播放外部音乐
MediaPlayer mediaPlayer = new MediaPlayer();
Uri uri = Uri.parse("http://xxxx/xx/xx.mp3");
mediaPlayer.setDataSource(this,uri);
-- 准备播放音乐
mediaPlayer.prepare();
-- 播放音乐
mediaPlayer.start();

VideoView播放视频 是一个标签 相当于 ImageView

SELECT * FROM THRSDEPTREQUEST FOR UPDATE ;

ServerSocket建立服务器
WebView浏览网页

Android内置了HttpClient可以很好的进行http请求和http响应

ServerSocket
--服务端
try {
			ServerSocket ss = new ServerSocket(3000);
      --监听3000端口是否有连接进来 如果有则写入你好！！
			while(true){
				Socket socket = ss.accept() ;
				OutputStream out = socket.getOutputStream();
				out.write("你好！！".getBytes());
				out.close() ;
				socket.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
--客户端
try {
			Socket s = new Socket("127.0.0.1", 3000);
			BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
			System.out.println(br.readLine());
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
}
添加访问互联网的权限

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

--加载网页信息
<WebView android:id="@+id/test" android:width="fill_parent" android:height="wrap_content">
WebView test = (WebView) findViewById(R.id.test);
test.loadUrl(url);


ImageView 来加载静态图片 也使用AnimationDrawable来开发逐逐帧动画
ImageView image ;
BitmapDrawable drawable = (BitmapDrawable)image.getDrawable();
--为ImageView设置图片资源
image.setImageBitmap(BitmapFactory.decodeStream(inputStream));

Bitmap bitmap = drawable.getBitmap();
--BitmapDrawable就是封装了Bitmap的drawable
BitmapDrawable drawable = new BitMapDrawable(bitmap);

Bitmap.createBitMap(BitMap source, int x,int y ,int width,int height);

--BitmapFactory是Bitmap一个工具类 可以从不同的数据源解析创建Bitmap对象
Bitmap bitmap = BitmapFactory.decodeResource(Resources res,int drawableId) ;从xml中解析图片资源
Bitmap bitmap = BitmapFactory.decodeFile(String pathName); 从文件路径获取Bitmap

assets目录管理器
AssetManager assetManager = getAssets();
String imageArr[] = assetManager.list();
InputStream inputStream = assetManager.open(imageArr[0]);
--为ImageView设置图片
ImageView.setImageBitmap(BitmapFactory.decodeStream(inputStream));

可以获得一张位图的某一块图片

绘图基础 Canvas Paint Path  Canvas是依附于View的画布

绘图应该继承View类 并重写onDraw(Canvas canvas)
Canvas对应的各种方法drawXxx() 可以绘制各种图形 比如直线 点 圆  
还提供了 旋转(rotate) 移动(translate) 缩放(scale) 倾斜(skew)

Paint代表的是在Canvas上的一个画笔 可以表示 填充颜色 风格 
Paint.setColor()
Paint.setStyle()

一个自定义View组件 需要重写View类的onDraw(Canvas canvas) 方法 把需要绘制的内容放在 onDraw方法中


TextView extends View{
         public TextView(Context context){
                // do something 
         }
         @Override
         public void onDraw(Canvas canvas){
                Paint paint = new Paint();
                canvas.drawTextOnPath();
                --画一张图片
                canvas.drawBitmap(bitMap,0,0,paint);
                canvas.drawPath(path,paint);
         }
}

--显示TextView
setContentView(new TextView(this));

动画其实就是不断重复调用View组件上的onDraw(Canvas canvas)方法
如果每次在View组件上绘制的图形不同 就成了动画的效果
每次View组件上的图形状态数据发生变化 都应该通知View组件重写调用onDraw(Canvas canvas)重写绘制图片
通知View重绘 可调用invalidate(在UI线程中)或postInvalidate(非UI线程中)


--创建菜单 
boolean onCreateOptionsMenu(Menu menu){
  MenuInflator inflator = new MenuInflator(this);
  //把定义好的菜单赋给menu
  inflator.inflate(R.menu.myMenu,menu);
  return onCreateOptionsMenu(menu);
}
--菜单选中 点中菜单时的响应
boolean onOptionsItemSelected(MenuItem item)

WindowManager windowManager = getWindowManager();
Display dis = windowManager.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
dis.getMetrics(metrics);
--获取屏幕宽度
int windowWidth = metrics.widthPixels;
--获取屏幕高度
int windowHeight = metrics.heightPixels;

final GameView gameView = new GameView(this);

setContentView(gameView);
Handler handler = new Handler(){
	@Override
  public void handleMessage(Message message){
  	if(message.what == 0x123){
    	--通知重写绘图
    	gameView.invalidate();
    }
  }
};


final Timer timer = new Timer();
timer.schedule(new TimerTask(){
	@Override
  public void run(){
  	ballX += xSpeed ;
    ballY += ySpeed ;
    handler.sendEmptyMessage(0x123);
  }
},0,300);
--图形组件类
public class GameView extends View{
       Paint paint = Paint();
       public GameView(Context context){
       	super(context);
        --使当前视图获得焦点
        setFocusable(true);
       }
       @Override
       public void onDraw(Canvas canvas){
       	paint.setStyle(Paint.Style.FILL);
        --设置去锯齿
        paint.setAntiAlias(true);
        if(isLose){
        	paint.setColor(Color.RED);
          paint.setTextSize(20);
          --生成一个已结束的Text
          canvas.drawText("游戏已结束",50,200,paint);
        }else{
          --绘制小球
          paint.setColor(Color.rgb(240,240,80));
          canvas.drawCircle(ballX,ballY,12,paint);
          --绘制球拍
          paint.setColor(Color.rgb(80,80,200));
          canvas.drawRect(racketX,racketY,racketX+RACKET_WIDTH,racketY+RACKET_HEIGHT,paint);
        }
       }
}

--对图形特效的处理
--对图形进行平移(setTranslate) 旋转(setRotate) 缩放 (setScale)
Matrix matrix = new Matrix();
--获得图片资源
BitMap bitmap = ((BitMapDrawable)getResources().getDrawable(R.drawable.xxx)).getBitMap();

--matrix设置
--旋转
matrix.setSkew(12,0);
--缩放  缩放比例
matrix.setScale(1.0f);

然后利用BitMap bitMap2 = BitMap.createBitmap(bitmap,0,0,width,height,matrix,true) 图片就会和matrix设置的内容进行变换
--画布重新绘制新位图资源
canvas.drawBitmap(bitMap2,matrix,null);


在onDraw方法中进行图片转换设置

按键事件的定义
SELECT * FROM thrsdeptrequest FOR UPDATE ;
gameView.setOnKeyListener(new OnKeyListener(){
	@Override
  public void onKey(View source,int keyCode,KeyEvent event){
         --按键时 对某些键进行绑定业务逻辑  如按A和D键分别做相应的事件
         switch(event.getKeyCode()){
              case KeyEvent.KEYCODE_A:
                --DO SOMETHING
               break ;
               case KeyEvent.KEYCODE_D:
                --DO SOMETHING
               break ;
         }
  }
});
ImageView 
--定时任务对象
final Timer timer = new Timer();
-- 每100毫秒执行一次
timer.schedule(new TimerTask(){
	@Override
  public void run(){
         handler.sendEmptyMessage(0x123);
  }
},0,100) ;
--handler的作用是重新绘制游戏界面的生成
final Handler handler = new Handler(){
      @Override
      public void handleMessage(Message message){
             if(message.what == 0x123){
                 --游戏界面重新绘制
             	   gameView.invalide();
             }
      }
};
--获取位图
Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(),R.drawable.plane);
--获取图片宽度
bitmap.getWidth();
--获取图片高度
bitmap.getHeight();

Canvas 还提供了对扭曲图的支持
invalidate();方法通知View组件进行重新绘制

drawBitmapMesh方法
--触摸屏幕事件
public void onTouchEvent(MotionEvent event){
       --获取点击处的 X Y坐标
       event.getX();
       event.getY();
       return true ;
}

逐帧(Frame)

在xml中定义逐帧动画用  xxx.xml
<animation-list android:oneshot="true|false"> oneshot 设置是否循环播放
	<item android:drawable="@drawable/test" android:duration="1"/> 定义每一帧的图片和持续的时间
</animation-list>

<item >

java代码中使用 AnimationDrawable 提供的两个方法 start和stop方法


ImageView imageView = (ImageView)findViewById(xxx);xxx表示xml的文件名称

AnimationDrawable animationDrawable = (AnimationDrawable)imageView.getBackground();

指定点爆炸 其实就是逐帧动画

加载音效  声音文件放置在raw文件夹下面
MediaPlayer boom = MediaPlayer.create(this,R.raw.boom); 
boom.start() --播放音乐

R.anim.blast 表示一个逐帧动画 逐帧动画一般放置在anim文件夹下面

imageView.setBackgroundResource(R.anim.blast);
imageView.setVisibility(View.INVISIBLE) ;
imageView.setVisibility(View.VISIBLE) ;
imageView.setLocation();

AnimationDrawable animationDrawable = (AnimationDrawable)imageView.getBackground();
animationDrawable.start(); --启动动画

FrameLayout frame = new FrameLayout(this);
frame.setBackgroundResource(R.drawable.xxx);

frame.addView(myView);
点击屏幕事件 frame.setOnTouchListener(new OnTouchListener(){
	                            @Override
                              public void onTouch(View source,TouchEvent event){
                                     if(event.getAction == TouchEvent.ACTION_DOWN){
                                     	  anim.stop();
                                     	  myView.setLocation(event.getX()-40,event.getY()-20);
                                        anim.start();
                                        --播放声音
                                        mediaPlayer.start();
                                     }
                              }
});

--少量数据的存储使用
SharedPrefences 是以key-value的形式存储数据 接口本身没有写入数据的能力
SharedPrefences.edit() -- > Editor对象来实现数据的修改
getXxx Xxx可以是int  double boolean float String
SharedPrefences是一个借口 所以只能通过getSharedPrefences("xxx",MODE_WORLD_READABLE);
SharedPrefences sp = getSharedPrefences("xxx",MODE_WORLD_READABLE);
sp.getString("xx","默认值"); 如果xx对应的值不存在 则获得 第二个参数 即设置的默认值
SharedPrefences.Editor editor = sp.edit();
editor.putString("xx","12345");
--提交所有值
editor.commit();
SharedPrefences总是以XML的格式保存数据
保存在路径 /data/data/<package name>/shared_prefes/ 目录下面

获取其他应用程序的SharedPrefences其实就是需要获得该应用程序的Context

Context context = createPackageContext("包名",Context.IGNORE_SECURITY);
SharedPrefences sp = context.getSharedPrefences("xxx",MODE_WORLD_READABLE);
sp.getInt("xxx",0);

--io 流

openFileInputStream(String name)
openFileOutputStream(String name)

--获得SD卡路径
File sdCardFile = Environment.getExternalStorageDirectory();
String sdPath = sdCardFile.getCanonicalPath();

--SD卡写入数据权限
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE">


--SQLite数据库 其实就是一个文件   /mnt/data/目录下

SQLite数据库其实是通过SQLiteDatabase来操作的
一般通过继承SQLiteOpenHelper来获得子类 然后通过getReadableDatabase() getWritableDatabase() 来获得 SQLiteDatabase实例

--SimpleAdapter 用法

List<Map<String,String>> list = new ArrayList<String,String>();
list.put("name1","");
list.put("name2","");
SimpleAdapter simpleAdapter = 
new SimpleAdapter(this,list,R.layout.listxx,new String[]{"name1","name2"},new int[]{R.id.name1xxx,R.id.name2xxx});
第三个参数是list整体样式
第四个参数是与list对应的key值
第五个参数是每个内容显示的样式信息

ListView listView = (ListView)findViewById(R.id.xx);
listView.setAdapter(simpleAdapter);

SQLiteDatabase database ;

Service继承Service类 然后在 AndroidManifest.xml中定义

Intent intent = new Intent();
intent.setAction("xxx.xx.First_Service");--参数是AndroidManifest.xml中设置service下的action名称
startService(intent);
<service android:name=".FirstService">
  <intent-filter>
  	<action android:name="xxx.xx.First_Service">
  </intent-filter>
</service>

stopService(intent);

service总是在后台运行而不显示在前天

绑定本地service与之通信

IntentService和Service的区别 就是 IntentService会调用单独的线程来处intent

IntentService只需要重写onHandleIntent(Intent intent)方法 不需要重写 onBind和onStartCommand方法
IntentService是使用单独的线程来完成耗时任务而不会阻塞前台线程 因此前台界面不会失去响应
IntentService会自动停止 而不需要调用stopSelf

IntentService是Service的子类 它有一些额外的功能
startService(intent) stopService(intent)

一些重要的系统Service
--电话service
TelephonyManager telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE) ;
--短信管理器SmsManager
SmsManager sManager = SmsManager.getDefault();
PendingIntent pendingIntent = PendingIntent.getActivity(this,0,new Intent(),0) ;
--发送短信
sManager.sendTextMessage(numberStr,null,contentStr,pendingIntent,null) ;
--发送短信需要设置权限 
<uses-permission android:name="android.permission.SEND_SMS">

--音频管理器
AudioManager audioManager = (AudioManager)getSystemService(Service.AUDIO_SERVICE) ;
--闹钟管理器
AlarmManager.set
--接收广播消息
BroadcastReceiver 专门负责监听各种应用程序发出的Broadcast
<receveiver android:name=".FirstReceveiver" >
	<intent-filter android:priority="0"> android:priority --指定优先等级 值越大优先级越高
  	<action android:name="xxx.xxx">
  </intent-filter>
</receveiver>

Intent intent = new Intent();
intent.setAction("xxx.xxx");
sendBroadcast(intent);--普通的Broadcast不能传给下一个消息接收者
sendOrderedBroadcast(intent);--排序的Broadcast可以传给下一个消息接收者 先后顺序可以用 android:priority来定义


SELECT * FROM THRSRESUME FOR UPDATE ;
SELECT * FROM TPUBCOUNTER FOR UPDATE;

BroadcastReceiver可以监听各个应用

IntentService是Service的子类 不是普通的Service 增加了些额外的功能

--Activity生命周期

1 onCreate  --第一次创建时
2 onStart   --用户可以看到界面时
3 onResume  --用户获取焦点时
4 onPause  --与用户失去焦点
5 onRestart --用户重新获得界面时
6 onStop   --界面用户不可见时
7 onDesdroy--调用finish方法时

--消息队列中存放两种信息的队列  有线程对象(Runnable)和消息对象(Message)

Handler handler = new Handler();
handler.post(runnable);
handler.postDelayed(runnable,3000);
Handler handler = new Handler(){
        public void handleMessage(Message msg){
               Bundle bundle = msg.getData();
               bundle.getString("");
        }
};
public MyHandler(Looper looper){
       this.looper = looper ;
}

Message msg = handler.obtainMessage();
Bundle bundle = new Bundle();
bundle.putString
bundle.putInt
handler.sendMessage(msg);

handleMessage(Message msg)

ListActivity
ListView
TabActivity
TabHost

setListAdapter(simpleAdapter);

handleMessage(Message msg)
msg.setData(bundle);
bundle.putString("paramName","paramValue");
bundle.putInt("paramName",paramValue);

-- 系统自带的线程处理类
HandlerThread thread = new HandlerThread();
MyHandler handler = new MyHandler(thread.getLooper());
Message message = handler.obtainMessage();
message.sendToTarget();

-- looper的作用就是使handler的线程与activity的线程分开 不会使main线程阻塞
singleTask 
如果在Task中存在
栈顶中如果存在该Activity实例则不重新创建
public MyHandler(Looper looper){
 super(looper);
}
public void handleMessage(Message msg){
   --处理逻辑
}

Context context = createPackageContext("xxx.io",xxx);
Context context = createPackageContext("xx.io",xxx);
SharedPreferences sharedPreferences = context.getSharedPreferences();
Editor editor = sharedPreferences.edit();


以键值对的形式保存在对应的XML中



SELECT TE.*,TD.DEPTNAME FROM THRSEMPLOY TE,TUSCDEPT TD WHERE TE.DEPTID = TD.DEPTID(+)


SELECT WM_CONCAT(ROWNUM) FROM DUAL CONNECT BY ROWNUM <= 10;


singleInstance 只会创建一个目标Activity实例 并会使用一个全新的Task栈 来装载Activity实例
singleTask 目标Activity在同一个Task中只含有一个实例 
1.如果不存在则会创建新的Activity实例 并放入栈顶
2.如果位于栈顶则不会创建新的Activity实例
3.如果实例存在但不在栈顶 则把上面的实例从Task栈中移除 使得该实例位于Task栈顶

singleTop 如果目标Activity实例位于Task栈顶 则不会新创建对应的实例 否则会创建新的Activity实例
standard 每次都会创建一个新的目标Activity实例 而不会创建一个新的Task 并把Activity加入到对应的Task中

WITH T1 AS
 (SELECT ROWNUM AS N1 FROM DUAL CONNECT BY ROWNUM < 10),
T2 AS
 (SELECT 5 AS N2 FROM DUAL)
SELECT T1.N1, T2.N2 FROM T1, T2 WHERE T1.N1 = T2.N2(+);


Looper使handler处理的线程不是与activity main线程同一个

SQLiteOpenHelper是抽象类所以要继承它 并必须重写构造函数

public DatabaseOpenHelper(Context context,String name,CursorFactory factory,int Version)

所继承的方法中有方法 onCreate onUpgrade 方法 分别是创建数据库还有升级数据库时调用的方法

调用getReadableDatabase()或getWritableDatabase()则创建一个数据库 会调用onCreate方法

如果 DatabaseOpenHelper helper = new DatabaseOpenHelper(this,"数据库名字",null,2); 当版本指定为2时说明是升级数据库 则会调用onUpgrade

SQLiteDatabase db = helper.getWritableDatebase();
db.execSQL("CREATE TABLE TEST (ID INT)");

ArrayAdapter adapter = new ArrayAdapter(this,R.layout.xxx,数组或list);
listView.setAdapter(adapter);

继承ListActivity 或者直接使用ListView标签进行使用
--插入操作
--键值对的对象 键是表示列名
ContentValues content = new ContentValues();
--key是表中的列名
content.put("id",1000);
--插入一条数据
db.insert("Test",null,content);

--更新数据
ContentValues content = new ContentValues();
content.put("name","9999")
db.update("Test",content,"id=?",new String[]{"1"});
--把id为1的name设置成9999

SQLiteDatabase db = helper.getReadableDatabase();
Cursor cursor = db.query("Test",new String[]{"name","id"},);
-- 遍历cursor
while(cursor.moveToNext()){
       String name = cursor.getString(cursor.getColumnIndex("name"));
       sysout(name);
}

ContentValues SQLiteOpenHelper  

Bundle bundle = new Bundle();
bundle.putString
bundle.putInt
bundle.putFloat
bundle.putDouble

                                                                                          
SELECT T.PID, COUNT(T2.N)
  FROM TEXMPAPER T, (SELECT 90 N FROM DUAL) T2
 WHERE T.PID = T2.N(+)
 GROUP BY T.PID;

SELECT WM_CONCAT(ROWNUM)  FROM DUAL CONNECT BY ROWNUM<=10 ;
--多行的同一列合并成同一行
SELECT WM_CONCAT(T.PID) FROM TEXMPAPER T ;

MediaPlayer提供下列方法进行对音频文件进行操作
start();
stop();
pause();
create();
setDatasource();
setDatasource调用该方法后并没有完全准备好 需要调用prepare()方法然后再调用start等方法
播放网络上的音频文件
MediaPlayer player = new MediaPlayer();
Uri uri = Uri.parse("http://xxx/xx.mp3");
player.setDatasource(context,uri);
--准备声音
player.prepare();
player.start();
--还有个准备方法 异步准备音频文件 不会阻塞UI线程
player.prepareAsync();

--播放视频
VideoView 和 MediaController
VideoView videoView = (VideoView)findViewById(R.id.xxx);
MediaController mController = new MediaController(this);
File file = new File("/mnt/xxx.mp4");
--把视频显示在VideoView组件上
videoView.setVideoPath(file.getAbsolutePath());
--把VideoView和MediaController结合起来
videoView.setMediaController(mController);
mController.setMediaPlayer(videoView);
--让视频获得焦点
videoView.requestFocus();


SELECT CONCAT(T.PID||'-',T.PNAME) FROM TEXMPAPER T ;

SELECT * FROM THRSINTERVIEW for update;

HandlerThread thread = new HandlerThread();
thread.getLooper();
thread.start();

MyDatabaseHelper handler = new MyDatabaseHelper();
Message msg = handler.obtainMessage();
msg.setData(bundle);
msg.sendToTarget();

MyDatabaseHelper extents SQLiteOpenHelper{
 public MyDatabaseHelper(Looper looper){
        super(looper);
 }
 public void handleMessage(Message message){
        
 }
}

handler.post(runnalbe);

Runnalbe runnable = new Runnable(){
         @Override
         public void run(){
                --do anything you want 
         }
};

handler.postDelayed(runnable,3000);

handler.post(runnable);

--post方法使消息队列中的任务得到处理

Filter when it is good at it 

OpenFileInput
OpenFileOutput

--资源图片转换成Bitmap对象
Bitmap bitmap = ((BitmapDrawable)context.getResources().getDrawable(R.id.xxxx)).getBitmap();
Bitmap bitmap = BitmapFactory.decodeResource(this.getResources(),R.drawable.xxxImg);

final Matrix matrix = new Matrix();
matrix.setTranslate();
--当前视图获得焦点
this.setFocusable(true);
--使得matrix对象重置
matrix.reset();
matrix.setScale(1.0f,1.0f);
Bitmap bitmap = Bitmap.createBitmap(bitmap,0,0,width,height,matrix,true);
BitmapFactory是一个工具类
createBitmap是Bitmap类的静态方法
canvas.drawBitmap(bitmap2,matrix,null);
handler不会因为处理业务逻辑的时间过长导致UI线程阻塞
HandlerThread thread = HandlerThread();
Looper looper = thread.getLooper();
public class MyHandler extends Handler{
       public MyHandler(Looper looper){
              super(looper);
       }
}
select * from test t for update ; 



ImageView imageView = (ImageView)findViewById(R.id.xxxImg);
--ImageView和Bitmap关联在一起时
imageView.setImageBitmap(BitmapFactory.decodeFile(filePath));
--通过ImageView获得Bitmap
BitmapDrawable bitmapDrawable = (BitmapDrawable)imageView.getDrawable();
Bitmap bitmapx = bitmapDrawable.getBitmap();

--AnimationDrawable逐帧动画 它是由ImageView通过getBackground方法来进行获得
AnimationDrawable ad = (AnimationDrawable)imageView.getBackground();
ad.start() 或 ad.stop();
imageView.setBackgroundResources(R.anim.blast);
blast.xml

<animation-list>
	<item android:drawable="@drawable/bom_01" android:duration="100"/>
  <item android:drawable="@drawable/bom_02" android:duration="100"/>
</animation-list>

Intent intent = new Intent();
intent.setAction("xxxxx.SecondActivity");
action是需要在清单文件 AndroidManifest.xml进行配置的
如:
<activity android:name=".SecondActivity" android:label="@drawable/secondLabel">
	<intent-filter> 
  	<action android:name="xxxxx.SecondActivity" />一个activity可以设置多个action name
    <action android:name="LSSDDD.XXXX" />
  </intent-filter>
</activity>
startActivity(intent)
Intent serviceIntent = new Intent();
serviceIntent.setAction("xxxService");
<service android:name='xx.xx.xxxService'>
	<intent-filter> 
  	<action android:name="xxxService" />为service设置ActionName
  </intent-filter>
</service>
startService(intent);

Service --->IntentService
int onStartCommand(Intent intent,int flag,int startId) --->void onHandleIntent(Intent intent)
select * from thrsinterview for update ;
SELECT * FROM thrsemploy FOR UPDATE ;
SELECT * FROM thrsemployeval FOR UPDATE ;
public class MyService extends Service{
       private int count ;
       private boolean quit = false ;
       private MyBinder binder = new MyBinder();
       public class MyBinder extends Binder{
              public int getCount(){
                     return count ;
              }
       }
       // 必须返回所绑定的对象
       @Override
       public IBinder onBinder(Intent intent){
              System.out.println("xxxxxxxx");
              return binder ;
       }
       @Override
       public void onCreate(){
              super.onCreate();
              new Thread(){
                  @Override
                  public void run(){
                         while(!quit){
                              count++;
                         }
                  }
              }.start();
       }
        @Override
        public void onDestroy(){
               super.onDestroy();
               this.quit = true ;
        }
}
public class MyBinderService extends Activity{
       MyService.MyBinder binder ;
       final Intent intent = new Intent();
       Button button ;
       intent.setAction("binderService");
       @Override 
       public void onCreate(Bundle dxx){
             super(dxx);
             //intent 通过参数来获得要启动的Service
             // conn 监听访问者与Service之间的连接
             // 第三个参数表示绑定时是否自动创建Service BIND_AUTO_CREATE表示自动创建
             bindService(intent,conn,Service.BIND_AUTO_CREATE);
             button = (Button)findViewById('xxxx');
             button.setOnClickListener(new OnClickListener(){
             	@Override
              public void onClick(View source){
              	Toast.makeText(this,"service中的值---->"+binder.getCount(),Toast.LENGTH_SHORT).show();
              }
             });
             unbindService(conn);
       }
       --只要activity和service一连接就获得对应的Binder对象 就可以通过该绑定对象可以获得service运行的值
       private ServiceConnection conn = new ServiceConnection(){
              @Override
              public void onServiceConnected(Intent intent ,IBinder bind)
              {
                     binder = (MyService.MyBinder)bind;
              }
       }
}
MyBinder extends Binder 就可以访问 MyService里面的值  而在Activity中获得Binder对象
则需要通过ServiceConntection
ServiceConntection connection = new ServiceConntection(){
	@Override
  public  void onServiceConnected(Intent intent,IBinder service){
          binder = (MyService.MyBinder)service ;
  }
}



当程序在调用unbindService(conn) 首先会调用onUnBind方法 然后再调用onDestroy方法