贺祥 | 发表于 | 分类于

1.首先build.gradle文件中引用依赖库

1
2
3
4
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.3.0'
compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'io.reactivex:rxandroid:1.2.1'

2.通过Builder模式创建Retrofit对象

1
2
3
4
5
6
Retrofit retrofit = new Retrofit.Builder()
  .baseUrl("https://api.github.com")
  //通过Gson 解析实体
  .addConverterFactory(GsonConverterFactory.create())
  .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
  .build();

3.定义或者通过GsonFormat插件把Json字符串生成实体类(本例中的实体类Repo)

4.定义接口

1
2
3
4
5
6
7
/**
   * 定义接口
   */
  public interface GitHubService {
      @GET("users/{user}/repos")
      Observable<List<Repo>> listRepos(@Path("user") String user);
  }

5.创建接口实例，调用接口并通过观察者模式获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
GitHubService service = retrofit.create(GitHubService.class);
        service.listRepos("dz-hexiang")               //在IO线程进行网络请求
               .subscribeOn(Schedulers.newThread())//请求在新的线程中执行
               .observeOn(AndroidSchedulers.mainThread())         //请求完成后在主线程线程中执行，如更新ui
               .doOnNext(new Action1<List<Repo>>() {
                   @Override
                   public void call(List<Repo> repos) {
                       Log.w("retrofit","获取到的数据");
                   }
               })
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Subscriber<List<Repo>>() {
                   @Override
                   public void onCompleted() {
                       Log.w("retrofit","onCompleted");
                   }

                   @Override
                   public void onError(Throwable e) {
                       Log.w("retrofit","onError");
                   }

                   @Override
                   public void onNext(List<Repo> repos) {
                       /**
                        * 主线程中把得到的数据更新UI界面
                        */
                       // mTextMessage.setText(new Gson().toJson(repos));
                   }
               });

贺祥 | 发表于 | 分类于

1.创建View类继承View或者View的子类，并继承构造方法。

2.自定义属性

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="utf-8"?>
<resources>
<!--  名字随便起--> 
<declare-styleable name="MyViewStyleName" >
<attr name="des" format="string" />
<attr name="textColor" format="color"/>
<attr name="bgColor" format="color"/>
</declare-styleable>
</resources>

3.构造函数中获取属性，然后就可以使用属性在onDraw中绘画自己的View了，如设置画布背景颜色，字体颜色等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public MyView(Context context, AttributeSet attrs) {
	super(context, attrs);
	TypedArray typedArray = context.obtainStyledAttributes(attrs,R.styleable.MyViewStyleName);
		if(typedArray != null){
			/**
			 * 获取xml中自定义属性des
			 */
			mDes = typedArray.getString(R.styleable.MyViewStyleName_des);
			/**
			 * 获取xml中自定义属性bgColor
			 */
			mBackground = typedArray.getColor(R.styleable.MyViewStyleName_bgColor, Color.RED);
			/**
			 * 获取xml中自定义属性textColor
			 */
			mTextColor = typedArray.getColor(R.styleable.MyViewStyleName_textColor, Color.WHITE);
	
		}
		//initView();
	}

4.布局中使用自定义的View，并使用自己定义的属性

1
2
3
4
5
6
7
8
9
<com.example.testdemo.MyView 
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_centerInParent="true"
    app:des="这是自定义View内容"
	app:textColor="#ffffff"
	app:bgColor="#4cd964"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    />

贺祥 | 发表于 | 分类于

Android系统结构分为四层5大部门

本层分为Linux内核，及设备相关的驱动程序。

1.操作系统层-最底层（OS|Linux Kernel）

驱动包括显示驱动（Display Driver），照相机驱动（Camera Driver）、键盘驱动（KeyBoard Driver）、wifi驱动（WIFI Driver）、蓝牙驱动（Bluetooth Driver）、Flash内存驱动（Flash Memory Driver）、Bind IPC驱动（进程通信功能）、能源管理（Power Management）

2.各种库（Libraries）和RunTime中间层

本层分为各种库（Libraries）和Android运行环境（Dalvik虚拟机）

库的内容都是c语言实现的包括：C库、多媒体框架（MediaFramework）、SQLiter （数据库）、OpenGL ES（提供3D支持）、WebKit（浏览器核心 ）、SGL（2D图像引擎）、SSL（为数据提供安全支持，位于TCP/IP和应用层协议之间）、FreeType（为徒和矢量字体功能）
Dalvik虚拟机不是Java虚拟机（Java VM），Dalvik虚拟机执行.dex格式文件。Dalvik虚拟机是基于寄存器（Register-based）的虚拟机，Java VM是基于栈（Stack-based）

3.应用程序框架层（Application Framework）

本层是提供给开发者的API（都是Java开发的），一般Android开发常接触调用

包括UI需要的各种控件（View System）、Activity Manager 、Window Manager 、Packge Manager四大组件、等各种API

4.应用层（Application）

用户界面，Java语言编写的一些APK应用
下面是架构图
enter image description here

贺祥 | 发表于 | 分类于

一、AsyncTask概念

AsyncTask是一个异步任务类，用来异步执行耗时操作，更新UI线程。
实际是封装了Thead+Handler

二、优点：

简单，方便

三、缺点：

Task实例必须在主线程中创建
execute方法必须在主线程中调用，并且只能执行一次

四、使用方法：

创建一个类继承AsyncTask
覆写doInBackground(Params…) 后台执行耗时操作
覆写onPostExecute(Result) 执行耗时操作后更新UI界面，在主线程中执行
覆写onProgressUpdate(Progress…)更新进度条，在主线程中进行，结果来自于publishProgress(Integer)

下面是实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class MyAsyncTask extends AsyncTask<Integer, Integer,Integer>{

    	/**
		 *  这个方法当创建线程后执行，准备工作
		 */
    	@Override
		protected void onPreExecute() {
			// TODO Auto-generated method stub
			super.onPreExecute();
		
		}
    	/**
		 * 这个方法执行耗时操作 这里是休眠
		 */
		@Override
		protected Integer doInBackground(Integer... params) {
			// TODO Auto-generated method stub
			try {
				/**
				 * 简单每睡眠1秒更新下进度
				 */
//				for (int i = 0; i < 10; i++) {
//					Thread.sleep(1*1000);
//					publishProgress(i);
//				}
				
				
			} catch (Exception e) {
				// TODO: handle exception
			}
			return null;
		}
		/**
		 *  这个方法主线程中执行，耗时操作完之后执行
		 * 更新UI界面
		 */
		@Override
		protected void onPostExecute(Integer result) {
			// TODO Auto-generated method stub
			super.onPostExecute(result);
			/**
			 * 最后执行完耗时操作更新ui界面
			 */
			//drawCavas(surfaceHolder,10);
			
		}
		/**
		 * 这个方法在主线程调用
		 */
		@Override
		protected void onProgressUpdate(Integer... values) {
			// TODO Auto-generated method stub
			super.onProgressUpdate(values);
		
			/**
			 * 把进度更新到SurfaceView中
			 */
			//drawCavas(surfaceHolder,values[0]);
		}
		
    	
    }

贺祥 | 发表于 | 分类于
1.主线程创建子线程
2.子线程执行耗时操作，执行完后通过Handler发送消息到给Message Queue，覆写handlerMessage()，处理Looper的回调。
3.实例

创建Handler实例覆写handlerMessage()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Handler mHandler=new Handler(){
   	@Override
   	public void handleMessage(Message msg) {
   		// TODO Auto-generated method stub
   		super.handleMessage(msg);
   		/**
   		 * Looper回调此方法，覆写这个方法
   		 */
   		switch (msg.what) {
		case RESULT_OK:
			/**
			 * 更新ui
			 */
			break;

		default:
			break;
		}
   	}
   };

子线程执行异步耗时操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MyThread extends Thread{
   	@Override
   	public void run() {
   		// TODO Auto-generated method stub
   		try {
   			/**
   			 * 执行耗时操作，这里只是暂时睡眠6秒然后更新界面
   			 */
			Thread.sleep(6*10000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
   		/**
   		 * 发送消息给Message Queue
   		 */
   		mHandler.sendEmptyMessage(RESULT_OK);
   		super.run();
   	}
   	
   }

创建线程实例并启动线程

/**
 * 启动线程执行耗时操作
 */
new MyThread().start();

贺祥 | 发表于 | 分类于

Java泛型是什么？

泛型是参数化类型，操作的数据类型被指定为一个参数。传入什么类型就是什么类型。
泛型方法是什么？

一个在调用时可以接收不同类型的参数的方法

泛型方法声明规则

必定有一个类型参数用尖括号分隔，声明在方法返回类型之前
多个类型参数之间用逗号分割
类型参数能用来声明返回值类型
泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）

1.普通用法：参数可以是整形数据组、字符串数组、Double数组等
1
2
3
4
5
6
7
8
9
// 泛型方法 printArray
    public static < E > void printArray( E[] inputArray )
    {
        // 输出数组元素
        for ( E element : inputArray ){
            System.out.printf( "%s ", element );
        }
        System.out.println();
    }
2.有界的类型参数用法：

参数的名称，后跟extends关键字，最后紧跟它的上界
参数的名称，后跟super关键字，最后紧跟它的下界

下面这个例子的上界是T类型必须是实现了Comparable接口的类 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
     * 比较三个值并返回最大值
     * @param x
     * @param y
     * @param z
     * @param <T>
     * @return
     */
    public static <T extends Comparable<T>> T max(T x, T y, T z)
    {
        T max = x; // 假设x是初始最大值
        if ( y.compareTo( max ) > 0 ){
            max = y; //y 更大
        }
        if ( z.compareTo( max ) > 0 ){
            max = z; // 现在 z 更大
        }
        return max; // 返回最大对象
    }
3.类型通配符？使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
     * 任何类型
     * @param msg
     */
    public static void hello(List<?> msg) {
        System.out.println("hai :" + msg.get(0));
    }
	//类型通配符？加界限参数
    /**
     * 只能接受是继承了number的类
     * @param msg
     */
    public static  void helloExtends(List<? extends Number> msg) {
        System.out.println("hai :" + msg.get(0));
    }

    /**
     * 只能接受Number及其三层父类类型
     * @param msg
     */
    public static void helloSuper(List<? super Number> msg) {
        System.out.println("hai :" + msg.get(0));
    }

贺祥 | 发表于 | 分类于

一、概念：

SurfaceView本身是一个View，符合一切View的特性，需要通过Canvas画布绘制。

二、优点：

可以在另一个线程中更新界面
不会阻碍界面的交互

三、View和SurfaceView的区别

基于View的绘图效率不高，主要用于动画变化较少的程序
SurfaceView 绘图效率较高，用于界面更新频繁的程序，如相机预览。
SurfaceView 可以在另一个线程中更新界面。

四、SurfaceView 使用方式：

1.布局中放入SurfaceView
2.实现SurfaceHolder.Callback
3.绘制画布更新画布到SurfaceView（本例是在主线程中更新，可以另起一个线程更新）
通过lockCanvas()将返回绘制的canvas
绘制的过程中，对canvas的绘制不会立刻反应在界面上，直到执行unlockCanvasAndPost()提交刚才修改的界面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
SurfaceView surfaceView=(SurfaceView)findViewById(R.id.surfaceview);
        SurfaceHolder surfaceHolder=(SurfaceHolder) surfaceView.getHolder();
        surfaceHolder.addCallback(new SurfaceHolder.Callback() {
			
			@Override
			public void surfaceDestroyed(SurfaceHolder holder) {
				// TODO Auto-generated method stub
				
			}
			
			@Override
			public void surfaceCreated(SurfaceHolder holder) {
				// TODO Auto-generated method stub
				/**
				 * 获得canvas的大小并锁定canvas
				 */
				Canvas canvas=holder.lockCanvas();
				Bitmap bitmap=BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);
				canvas.drawBitmap(bitmap, 50, 50,new Paint());
				/**
				 * 提交更新canvas
				 */
				holder.unlockCanvasAndPost(canvas);
			}
			
			@Override
			public void surfaceChanged(SurfaceHolder holder, int format, int width,
					int height) {
				// TODO Auto-generated method stub
				
			}
		});

贺祥 | 发表于 | 分类于
MQTT即时通讯服务器安装，SIP电话服务器快速安装，已写成一个shell文件，运行即可安装，不用输入繁琐的命令
Mosquitto(MQTT即时通讯服务器)

Mosquitto一款实现了消息推送协议 MQTT v3.1 的开源消息代理软件，提供轻量级的，支持可发布/可订阅的的消息推送模式，使设备对设备之间的短消息通信变得简单，比如现在应用广泛的低功耗传感器，手机、嵌入式计算机、微型控制器等移动设备。

opensips(SIP电话服务器)

OpenSIPS是一个成熟的开源SIP服务器，除了提供基本的SIP代理及SIP路由功能外，还提供了一些应用级的功能。OpenSIPS的结构非常灵活，其核心路由功能完全通过脚本来实现，可灵活定制各种路由策略，可灵活应用于语音、视频通信、IM以及Presence等多种应用。

1
2
3
4
5
6
7
8
#!/bin/sh
#print hello world in the console window
echo -e "开始安装-----------------------------------------------------------"
echo -e "author:hexiang"
echo -e "name:dz.hexiang"
echo -e "mail:472482006@qq.com"
echo -e "初始设置请稍等..."
sleep 3s

阅读全文 »

贺祥 | 发表于 | 分类于
安装x264支持环境
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
yum -y install build-essential nasm
wget http://www.nasm.us/pub/nasm/releasebuilds/2.13/linux/nasm-2.13-0.fc24.i386.rpm
rpm -ivh nasm-2.13-0.fc24.i386.rpm

ln -s /usr/mengqc/mub1 /usr/liu/abc


cd /home/x264
NDK=/home/ndk
PLATFORM=$NDK/platforms/android-23/arch-arm
PREBUILT=$NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64
PREFIX=/home/android-ffmpeg

./configure --prefix=/home/android-ffmpeg --enable-static --enable-pic --disable-asm --disable-cli --host=arm-linux --cross-prefix=$PREBUILT/bin/arm-linux-androideabi- --sysroot=$PLATFORM

make -j8
sudo make install
sudo ldconfig