Android语音播报的两种简单实现

a、两种方案

1、Android自带的语音播报(老版本手机Android6.0以下,不支持中文)

2、讯飞语音播报封装(直接用)

b、具体实现

一、Android自带的语音播报

查看手机是否支持中文语音播报,在测试的设备中打开‘设置’ –>找到 ‘语言和输入法’–>查看语音选项,是否支持中文,默认仅支持英文。

public class AndroidTTSActivity extends AppCompatActivity implements View.OnClickListener {

private TextToSpeech textToSpeech = null;//创建自带语音对象

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.android_tts_layout);
    findViewById(R.id.btn0).setOnClickListener(this);
    initTTS();
}

private void initTTS() {
    //实例化自带语音对象
    textToSpeech = new TextToSpeech(this, new TextToSpeech.OnInitListener() {
        @Override
        public void onInit(int status) {
            if (status == textToSpeech.SUCCESS) {
                // Toast.makeText(MainActivity.this,"成功输出语音",
                // Toast.LENGTH_SHORT).show();
                // Locale loc1=new Locale("us");
                // Locale loc2=new Locale("china");

                textToSpeech.setPitch(1.0f);//方法用来控制音调
                textToSpeech.setSpeechRate(1.0f);//用来控制语速

                //判断是否支持下面两种语言
                int result1 = textToSpeech.setLanguage(Locale.US);
                int result2 = textToSpeech.setLanguage(Locale.
                        SIMPLIFIED_CHINESE);
                boolean a = (result1 == TextToSpeech.LANG_MISSING_DATA || result1 == TextToSpeech.LANG_NOT_SUPPORTED);
                boolean b = (result2 == TextToSpeech.LANG_MISSING_DATA || result2 == TextToSpeech.LANG_NOT_SUPPORTED);

                Log.i("zhh_tts", "US支持否?--》" + a +
                        "\nzh-CN支持否》--》" + b);

            } else {
                Toast.makeText(AndroidTTSActivity.this, "数据丢失或不支持", Toast.LENGTH_SHORT).show();
            }

        }
    });
}

@Override
public void onClick(View v) {
    if (v.getId() == R.id.btn0) {
        startAuto("big sea");
    }

}

private void startAuto(String data) {
    // 设置音调,值越大声音越尖(女生),值越小则变成男声,1.0是常规
    textToSpeech.setPitch(1.0f);
    // 设置语速
    textToSpeech.setSpeechRate(0.3f);
    textToSpeech.speak(data,//输入中文,若不支持的设备则不会读出来
            TextToSpeech.QUEUE_FLUSH, null);

}

@Override
protected void onStop() {
    super.onStop();
    textToSpeech.stop(); // 不管是否正在朗读TTS都被打断
    textToSpeech.shutdown(); // 关闭,释放资源
}

}
补充工具类

/**

  • Created by RongGuang on 2014-11-21.
  • 中文朗读
    */
    public class ChineseToSpeech {
    private TextToSpeech textToSpeech; public ChineseToSpeech() {
    this.textToSpeech = new TextToSpeech(Application.getContext(), new TextToSpeech.OnInitListener() {
    @Override
    public void onInit(int status) {
    if (status == TextToSpeech.SUCCESS) {
    int result = textToSpeech.setLanguage(Locale.CHINA);
    if (result == TextToSpeech.LANG_MISSING_DATA
    || result == TextToSpeech.LANG_NOT_SUPPORTED) {
    new CoolToast(Application.getContext()).show(“不支持朗读功能”);
    }
    }
    }
    });
    } public void speech(String text) {
    textToSpeech.speak(text, TextToSpeech.QUEUE_FLUSH, null);
    } public void destroy() {
    if (textToSpeech != null) {
    textToSpeech.stop();
    textToSpeech.shutdown();
    }
    }
    }
    二、讯飞语音播报封装(直接用)

1.接入项目前准备:

1.申请APPID(步骤):

I.登录讯飞官网–>创建应用–>创建完成在”我的应用”中即可看见自己新建的项目&APPID–>

II.添加需要开通的服务:这里选择在线语音合成+sdk下载(so+jar文件),注意:so文件必须用你对应的项目的,用别人so文件,会导致与你的APPID不匹配,

2.使用说明+接入高频易发问题:

语音次数是有限制的,提高次数需要实名认证+上传项目
引入的so文件必须是你项目所对应的
不可多次初始化合成对象
3.接入项目(AndroidStudio):

 I.相关sdk文件引入,如图(再次说明:so文件用的是你新建项目的so文件,不要用他人so):

II.初始化语音播报(API>=23需要授权,所以先授权,再初始化,如下:)

public class StartActivity extends AppCompatActivity {

private List<String> permissionList = null;

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    SystemClock.sleep(1000);//延时加载
    requestPermissions();
}

private void openActivity(Class<? extends AppCompatActivity> clazz) {
    initTTS();
    startActivity(new Intent(this, clazz));
    finish();
}

//权限申请
private void requestPermissions() {
    // 版本判断。当手机系统大于 23 时,才有必要去判断权限是否获取
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        addListPermission();
        boolean isGranted = false;//是否全部授权
        // 权限是否已经 授权 GRANTED---授权  DINIED---拒绝
        Iterator<String> iterator = permissionList.iterator();
        while (iterator.hasNext()) {
            // 检查该权限是否已经获取
            int granted = ContextCompat.checkSelfPermission(this, iterator.next());
            if (granted == PackageManager.PERMISSION_GRANTED) {
                iterator.remove();//已授权则remove
            }
        }
        if (permissionList.size() > 0) {
            // 如果没有授予该权限,就去提示用户请求
            //将List转为数组
            String[] permissions = permissionList.toArray(new String[permissionList.size()]);
            // 开始提交请求权限
            ActivityCompat.requestPermissions(this, permissions, 0x10);
        } else {
            Log.i("zhh", "权限已申请");
            openActivity(MainActivity.class);
        }

    } else {
        openActivity(MainActivity.class);
    }
}

//初始化语音合成
private void initTTS() {
    //讯飞语音播报平台
    SpeechUtility.createUtility(this, "appid=");//=号后面写自己应用的APPID
    Setting.setShowLog(true); //设置日志开关(默认为true),设置成false时关闭语音云SDK日志打印
    TTSUtils.getInstance().init(); //初始化工具类
}


/**
 * 权限申请返回结果
 *
 * @param requestCode  请求码
 * @param permissions  权限数组
 * @param grantResults 申请结果数组,里面都是int类型的数
 */
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode) {
        case 0x10:
            if(grantResults.length>0&&ifGrantResult(grantResults)){
                Toast.makeText(this, "同意权限申请", Toast.LENGTH_SHORT).show();
                openActivity(MainActivity.class);
            }else{
                Toast.makeText(this, "权限被拒绝了", Toast.LENGTH_SHORT).show();
                finish();
            }
            break;
        default:
            break;
    }

}

private boolean ifGrantResult(int[] grants) {
    boolean isGrant = true;
    for (int grant : grants) {
        if (grant == PackageManager.PERMISSION_DENIED) {
            isGrant = false;
            break;
        }
    }
    return isGrant;
}


//敏感权限添加
private void addListPermission() {
    if (null == permissionList) {
        permissionList = new ArrayList<>();
        permissionList.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
        permissionList.add(Manifest.permission.READ_PHONE_STATE);
        permissionList.add(Manifest.permission.RECORD_AUDIO);
    }
}

}
 

III.语音播报封装(部分代码)

public class TTSUtils implements InitListener, SynthesizerListener {

private static volatile TTSUtils instance = null;
private boolean isInitSuccess = false;
private SpeechSynthesizer mTts;

//单例模式
public static TTSUtils getInstance() {
    if (instance == null) {
        synchronized (TTSUtils.class) {
            if (instance == null) {
                instance = new TTSUtils();
            }
        }
    }
    return instance;
}

public TTSUtils() {

}

// 初始化合成对象
public void init() {
    //判断进程是否已启动,初始化多次会报错
    //个人遇到问题:极光推送引入后,不加该条件回报错
    if (CourseUtils.resultProcess("com.zhanghai.ttsapp")) {

        mTts = SpeechSynthesizer.createSynthesizer(App.getContext(), this);
        // 清空参数
        mTts.setParameter(SpeechConstant.PARAMS, null);
        // 设置在线云端
        mTts.setParameter(SpeechConstant.ENGINE_TYPE,
                SpeechConstant.TYPE_CLOUD);

        // 设置发音人--发音人选择--具体见values-string
        mTts.setParameter(SpeechConstant.VOICE_NAME, "xiaoqi");

        // 设置发音语速
        mTts.setParameter(SpeechConstant.SPEED, "50");
        // 设置音调
        mTts.setParameter(SpeechConstant.PITCH, "50");
        // 设置合成音量
        mTts.setParameter(SpeechConstant.VOLUME, "100");
        // 设置播放器音频流类型
        mTts.setParameter(SpeechConstant.STREAM_TYPE, "3");
        // 设置播放合成音频打断音乐播放,默认为true
        mTts.setParameter(SpeechConstant.KEY_REQUEST_FOCUS, "true");
        // 设置音频保存路径,需要申请WRITE_EXTERNAL_STORAGE权限,如不需保存注释该行代码

// mTts.setParameter(SpeechConstant.TTS_AUDIO_PATH,”./sdcard/iflytek.pcm”);
Log.i(“zhh”, “–初始化成完成-“);
}

}

//开始合成
public void speak(String msg) {
    if (isInitSuccess) {
        if (mTts.isSpeaking()) {
            stop();
        }
        mTts.startSpeaking(msg, this);
    } else {
        init();
    }
}

}
IV:调用实例

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

private static final String TAG = MainActivity.class.getSimpleName();
private EditText et = null;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    et = findViewById(R.id.et);
    findViewById(R.id.btn0).setOnClickListener(this);
    findViewById(R.id.btn1).setOnClickListener(this);
    findViewById(R.id.btn2).setOnClickListener(this);
}


@Override
public void onClick(View v) {
    switch (v.getId()) {
        case R.id.btn0:
            TTSUtils.getInstance().speak("bigsea是大海");
            break;
        case R.id.btn1:
            String msg = et.getText().toString();
            TTSUtils.getInstance().speak(TextUtils.isEmpty(msg) ? "输入信息为空" : msg);
            break;
        case R.id.btn2:
            startActivity(new Intent(this, AndroidTTSActivity.class));
            break;
        default:
            break;
    }
}

@Override
protected void onResume() {
    //移动数据统计分析--不用可不用加入
    FlowerCollector.onResume(MainActivity.this);
    FlowerCollector.onPageStart(TAG);
    super.onResume();
}

@Override
protected void onPause() {
    //移动数据统计分析
    FlowerCollector.onPageEnd(TAG);
    FlowerCollector.onPause(MainActivity.this);
    super.onPause();
}


@Override
protected void onDestroy() {
    super.onDestroy();
    TTSUtils.getInstance().release();//释放资源
}

}
完!!!

原文地址:http://www.cnblogs.com/xxdh/p/9303377.html

下载地址:https://github.com/seastoneard/TTSApp
————————————————
版权声明:本文为CSDN博主「沧海龙腾LV」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/xialong_927/article/details/84256354

Android 轻松实现语音识别

苹果的iphone 有语音识别用的是Google 的技术,做为Google 力推的Android 自然会将其核心技术往Android 系统里面植入,并结合google 的云端技术将其发扬光大。 
所以Google Voice Recognition在Android 的实现就变得极其轻松。 
语音识别,借助于云端技术可以识别用户的语音输入,包括语音控制等技术,下面我们将利用Google 提供的Api 实现这一功能。 
功能点为:通过用户语音将用户输入的语音识别出来,并打印在列表上。 
用户通过点击speak按钮显示界面: 
用户说完话后,将提交到云端搜索: 
在云端搜索完成后,返回打印数据:

Android 轻松实现语音识别的完整代码    

* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
 
package com.example.android.apis.app;
 
import com.example.android.apis.R;
 
import android.app.Activity;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.speech.RecognizerIntent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
 
import java.util.ArrayList;
import java.util.List;
 
/**
* Sample code that invokes the speech recognition intent API.
*/
public class VoiceRecognition extends Activity implements OnClickListener {
 
private static final int VOICE_RECOGNITION_REQUEST_CODE = 1234;
 
private ListView mList;
 
/**
* Called with the activity is first created.
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
 
// Inflate our UI from its XML layout description.
setContentView(R.layout.voice_recognition);
 
// Get display items for later interaction
Button speakButton = (Button) findViewById(R.id.btn_speak);
 
mList = (ListView) findViewById(R.id.list);
 
// Check to see if a recognition activity is present
PackageManager pm = getPackageManager();
List activities = pm.queryIntentActivities(
new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);
if (activities.size() != 0) {
speakButton.setOnClickListener(this);
} else {
speakButton.setEnabled(false);
speakButton.setText("Recognizer not present");
}
}
 
/**
* Handle the click on the start recognition button.
*/
public void onClick(View v) {
if (v.getId() == R.id.btn_speak) {
startVoiceRecognitionActivity();
}
}
 
/**
* Fire an intent to start the speech recognition activity.
*/
private void startVoiceRecognitionActivity() {
Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
intent.putExtra(RecognizerIntent.EXTRA_PROMPT, "Speech recognition demo");
startActivityForResult(intent, VOICE_RECOGNITION_REQUEST_CODE);
}
 
/**
* Handle the results from the recognition activity.
*/
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == VOICE_RECOGNITION_REQUEST_CODE && resultCode == RESULT_OK) {
// Fill the list view with the strings the recognizer thought it could have heard
ArrayList matches = data.getStringArrayListExtra(
RecognizerIntent.EXTRA_RESULTS);
mList.setAdapter(new ArrayAdapter(this, android.R.layout.simple_list_item_1,
matches));
}
 
super.onActivityResult(requestCode, resultCode, data);
}
}

Google推出开源语音视频聊天软件WebRTC

天极网软件频道2011-06-22 09:30  分享到:我要吐槽

  Google近期推出了开源的语音视频聊天软件WebRTC。有消息称Google将把这款功能类似Skype的软件集成到Chrome浏览器中。

  WebRTC源于Google 2010年收购的互联网电话和视频会议公司Global IP Solutions(以下简称“GIPS”)。当Chrome浏览器集成WebRTC之后,Gmail的受益最明显。目前,Gmail拥有语音视频聊天功能,但用户需要安装Google私有的插件。随着Google VoIP业务的成熟,以及Gmail对Google Voice/Talk等的集成,Gmail聊天已经越来越重要。

  不过,Google对WebRTC有更高的期望。Google希望WebRTC能成为互联网视频会议和点对点通信的标准,并在此基础之上制定网 络通信协议。Google在官方博客中表示,WebRTC将是开源、无版权费的,Google还将就WebRTC与Mozilla和Opera等其他浏览器厂商合作。

  Google是网页应用和云计算的积极支持者。网页应用能够很方便地跨操作系统,不仅可以用于Windows和Mac OS X,也可以被智能手机使用。预计WebRTC将很快进入Chrome浏览器。

  Google GIPS一名程序员亨里克·安德里森(Henrik Andreasson)表示:“我们的目标是通过简单的Javascript应用程序接口,使Chrome拥有实时通信能力(RTC)。我们正在努力使Chrome全面支持RTC,从WebKit到语音视频通信功能。”

  WebRTC使用了GIPS的两款语音编解码器,包括用于宽带连接的iSAC和用于窄带连接的iLBC。视频部分,WebRTC使用了Google的VP8编解码器,这也是一项开源、无版权费的技术。

 几个常见的语音交互平台的简介和比较
分类: 多媒体技术 2014-01-19 16:04 2762人阅读 评论(0) 收藏 举报

目录(?)[+]
1.概述

最近做了两个与语音识别相关的项目,两个项目的主要任务虽然都是语音识别,或者更确切的说是关键字识别,但开发的平台不同, 一个是windows下的,另一个是android平台的,于是也就选用了不同的语音识别平台,前者选的是微软的Speech API开发的,后者则选用 的是CMU的pocketsphinx,本文主要将一些常见的语音交互平台进行简单的介绍和对比。

这里所说的语音交互包含语音识别(Speech Recognition,SR,也称为自动语音识别,Automatic Speech Recognition,ASR)和语音 合成(Speech Synthesis,SS,也称为Text-To-Speech,简记为TTS)两种技术,另外还会提到声纹识别(Voice Print Recognition, 简记为VPR)技术。

语音识别技术是将计算机接收、识别和理解语音信号转变为相应的文本文件或者命令的技术。它是一门涉及到语音语言学、信号处理、 模式识别、概率论和信息论、发声机理和听觉机理、人工智能的交叉学科。在语音识别系统的帮助下,即使用户不懂电脑或者无法使用 电脑,都可以通过语音识别系统对电脑进行操作。

语音合成,又称文语转换(Text to Speech)技术,能将任意文字信息实时转化为标准流畅的语音朗读出来,相当于给机器装上了人工 嘴巴。它涉及声学、语言学、数字信号处理、计算机科学等多个学科技术,是中文信息处理领域的一项前沿技术,解决的主要问题就是如何 将文字信息转化为可听的声音信息,也即让机器像人一样开口说话。

下面按平台是否开源来介绍几种常见的语音交互平台,关于语音识别和语音合成技术的相关原理请参见我接下来的其他文章。
2.商业化的语音交互平台
1)微软Speech API

微软的Speech API(简称为SAPI)是微软推出的包含语音识别(SR)和语音合成(SS)引擎的应用编程接口(API),在Windows下应用 广泛。目前,微软已发布了多个SAPI版本(最新的是SAPI 5.4版),这些版本要么作为于Speech SDK开发包发布,要么直接被包含在windows 操作系统中发布。SAPI支持多种语言的识别和朗读,包括英文、中文、日文等。SAPI的版本分为两个家族,1-4为一个家族,这四个版本彼此 相似,只是稍微添加了一些新的功能;第二个家族是SAPI5,这个系列的版本是全新的,与前四个版本截然不同。

最早的SAPI 1.0于1995年发布,支持Windows 95和Windows NT 3.51。这个版本的SAPI包含比较初级的直接语音识别和直接语音合成的API, 应用程序可以直接控制识别或合成引擎,并简化更高层次的语音命令和语音通话的API。SAPI3.0于97年发布,它添加了听写语音识别(非连续 语音识别)和一些应用程序实例。98年微软发布了SAPI4.0,这个版本不仅包含了核心的COM API,用C++类封装,使得用C++来编程更容易, 而且还有ActiveX控件,这个控件可以再VB中拖放。这个版本的SS引擎随Windows2000一起发布,而SR引擎和SS引擎又一起以SDK的形式发布。

SAPI5.0 于2000年发布,新的版本将严格将应用与引擎分离的理念体现得更为充分,所有的调用都是通过动态调用sapi.dll来实现的, 这样做的目的是使得API更为引擎独立化,防止应用依赖于某个具有特定特征的引擎,这种改变也意图通过将一些配置和初始化的代码放 到运行时来使得应用程序的开发更为容易。
2).IBM viaVoice

IBM是较早开始语音识别方面的研究的机构之一,早在20世纪50年代末期,IBM就开始了语音识别的研究,计算机被设计用来检测特定的语言 模式并得出声音和它对应的文字之间的统计相关性。在1964年的世界博览会上,IBM向世人展示了数字语音识别的“shoe box recognizer”。 1984年,IBM发布的语音识别系统在5000个词汇量级上达到了95%的识别率。

1992年,IBM引入了它的第一个听写系统,称为“IBM Speech Server Series (ISSS)”。1996年发布了新版的听写系统,成为“VoiceType3.0”, 这是viaVoice的原型,这个版本的语音识别系统不需要训练,可以实现孤立单词的听写和连续命令的识别。VoiceType3.0支持Windows95系统, 并被集成到了OS/2 WARP系统之中。与此同时,IBM还发布了世界上首个连续听写系统“MedSpeak Radiology”。最后,IBM及时的在假日购物季节 发布了大众化的实用的“VoiceType Simply Speaking”系统,它是世界上首个消费版的听写产品(the world’s first consumer dictation product).

1999年,IBM发布了VoiceType的一个免费版。2003年,IBM授权ScanSoft公司拥有基于ViaVoice的桌面产品的全球独家经销权,而ScanSoft公司 拥有颇具竞争力的产品“Dragon NaturallySpeaking”。两年后,ScanSoft与Nuance合并,并宣布公司正式更名为Nuance Communications,Inc。 现在很难找到IBM viaVoice SDK的下载地址了,它已淡出人们的视线,取而代之的是Nuance。
3)Nuance

Nuance通讯是一家跨国计算机软件技术公司,总部设在美国马萨诸塞州伯灵顿,主要提供语音和图像方面的解决方案和应用。目前的业务集中 在服务器和嵌入式语音识别,电话转向系统,自动电话目录服务,医疗转录软件与系统,光学字符识别软件,和台式机的成像软件等。

Nuance语音技术除了语音识别技术外,还包扩语音合成、声纹识别等技术。世界语音技术市场,有超过80%的语音识别是采用Nuance识别引擎技术, 其名下有超过1000个专利技术,公司研发的语音产品可以支持超过50种语言,在全球拥有超过20亿用户。据传,苹果的iPhone 4S的Siri语音识别中 应用了Nuance的语音识别服务。另外,据Nuance公司宣布的重磅消息,其汽车级龙驱动器Dragon Drive将在新奥迪A3上提供一个免提通讯接口, 可以实现信息的听说获取和传递。

Nuance Voice Platform(NVP)是Nuance公司推出的语音互联网平台。Nuance公司的NVP平台由三个功能块组成:Nuance Conversation Server 对话服务器,Nuance Application Environment (NAE)应用环境及Nuance Management Station管理站。Nuance Conversation Server对话服务 器包括了与Nuance语音识别模块集成在一起的VoiceXML解释器,文语转换器(TTS)以及声纹鉴别软件。NAE应用环境包括绘图式的开发工具, 使得语音应用的设计变得和应用框架的设计一样便利。Nuance Management Station管理站提供了非常强大的系统管理和分析能力,它们是为了 满足语音服务的独特需要而设计的。
4)科大讯飞——讯飞语音

提到科大讯飞,大家都不陌生,其全称是“安徽科大讯飞信息科技股份有限公司”,它的前身是安徽中科大讯飞信息科技有限公司,成立于99 年12月,07年变更为安徽科大讯飞信息科技股份有限公司,现在是一家专业从事智能语音及语音技术研究、软件及芯片产品开发、语音信息服务 的企业,在中国语音技术领域可谓独占鳌头,在世界范围内也具有相当的影响力。

科大讯飞作为中国最大的智能语音技术提供商,在智能语音技术领域有着长期的研究积累,并在中文语音合成、语音识别、口语评测等多项 技术上拥有国际领先的成果。03年,科大讯飞获迄今中国语音产业唯一的“国家科技进步奖(二等)”,05年获中国信息产业自主创新最高荣誉 “信息产业重大技术发明奖”。06年至11年,连续六届英文语音合成国际大赛(Blizzard Challenge)荣获第一名。08年获国际说话人识别评测 大赛(美国国家标准技术研究院—NIST 2008)桂冠,09年获得国际语种识别评测大赛(NIST 2009)高难度混淆方言测试指标冠军、通用测试 指标亚军。

科大讯飞提供语音识别、语音合成、声纹识别等全方位的语音交互平台。拥有自主知识产权的智能语音技术,科大讯飞已推出从大型电信级 应用到小型嵌入式应用,从电信、金融等行业到企业和家庭用户,从PC到手机到MP3/MP4/PMP和玩具,能够满足不同应用环境的多种产品,科大 讯飞占有中文语音技术市场60%以上市场份额,语音合成产品市场份额达到70%以上。
5)其他

其他的影响力较大商用语音交互平台有谷歌的语音搜索(Google Voice Search),百度和搜狗的语音输入法等等,这些平台相对于以上的4个 语音交互平台,应用范围相对较为局限,影响力也没有那么强,这里就不详细介绍了。
3.开源的语音交互平台
1)CMU-Sphinx

CMU-Sphinx也简称为Sphinx(狮身人面像),是卡内基 - 梅隆大学( Carnegie Mellon University,CMU)开发的一款开源的语音识别系统, 它包括一系列的语音识别器和声学模型训练工具。

Sphinx有多个版本,其中Sphinx1~3是C语言版本的,而Sphinx4是Java版的,另外还有针对嵌入式设备的精简优化版PocketSphinx。Sphinx-I 由李开复(Kai-Fu Lee)于1987年左右开发,使用了固定的HMM模型(含3个大小为256的codebook),它被号称为第一个高性能的连续语音识别 系统(在Resource Management数据库上准确率达到了90%+)。Sphinx-II由Xuedong Huang于1992年左右开发,使用了半连续的HMM模型, 其HMM模型是一个包含了5个状态的拓扑结构,并使用了N-gram的语言模型,使用了Fast lextree作为实时的解码器,在WSJ数据集上的识别率 也达到了90%+。

Sphinx-III主要由Eric Thayer 和Mosur Ravishankar于1996年左右开发,使用了完全连续的(也支持半连续的)HMM模型,具有灵活 的feature vector和灵活的HMM拓扑结构,包含可选的两种解码器:较慢的Flat search和较快的Lextree search。该版本在BN(98的测评数据 集)上的WER(word error ratio)为19%。Sphinx-III的最初版还有很多limitations,诸如只支持三音素文本、只支持Ngram模型(不 支持CFG/FSA/SCFG)、对所有的sound unit其HMM拓扑结构都是相同的、声学模型也是uniform的。Sphinx-III的最新版是09年初发布的0.8版, 在这些方面有很多的改进。

最新的Sphinx语音识别系统包含如下软件包:
? Pocketsphinx — recognizer library written in C.
? Sphinxbase — support library required by Pocketsphinx
? Sphinx4 — adjustable, modifiable recognizer written in Java
? CMUclmtk — language model tools
? Sphinxtrain — acoustic model training tools
这些软件包的可执行文件和源代码在sourceforge上都可以免费下载得到。
2)HTK

HTK是Hidden Markov Model Toolkit(隐马尔科夫模型工具包)的简称,HTK主要用于语音识别研究,现在已经被用于很多其他方面的研究, 包括语音合成、字符识别和DNA测序等。

HTK最初是由剑桥大学工程学院(Cambridge University Engineering Department ,CUED)的机器智能实验室(前语音视觉及机器人组) 于1989年开发的,它被用来构建CUED的大词汇量的语音识别系统。93年Entropic Research Laboratory Inc.获得了出售HTK的权利,并在95年 全部转让给了刚成立的Entropic Cambridge Research Laboratory Ltd,Entropic一直销售着HTK,直到99年微软收购了Entropic,微软重新 将HTK的版权授予CUED,并给CUED提供支持,这样CUED重新发布了HTK,并在网络上提供开发支持。

HTK的最新版本是09年发布的3.4.1版,关于HTK的实现原理和各个工具的使用方法可以参看HTK的文档HTKBook。
3)Julius

Julius是一个高性能、双通道的大词汇量连续语音识别(large vocabulary continues speech recognition,LVCSR)的开源项目, 适合于广大的研究人员和开发人员。它使用3-gram及上下文相关的HMM,在当前的PC机上能够实现实时的语音识别,单词量达到60k个。

Julius整合了主要的搜索算法,高度的模块化使得它的结构模型更加独立,它同时支持多种HMM模型(如shared-state triphones 和 tied-mixture models等),支持多种麦克风通道,支持多种模型和结构的组合。它采用标准的格式,这使得和其他工具箱交叉使用变得 更容易。它主要支持的平台包括Linux和其他类Unix系统,也适用于Windows。它是开源的,并使用BSD许可协议。

自97年后,Julius作为日本LVCSR研究的一个自由软件工具包的一部分而延续下来,后在2000年转由日本连续语音识别联盟(CSRC)经营。 从3.4版起,引入了被称为“Julian”的基于语法的识别解析器,Julian是一个改自Julius的以手工设计的DFA作为语言模型的版本,它可以 用来构建小词汇量的命令识别系统或语音对话系统。
4)RWTH ASR

该工具箱包含最新的自动语音识别技术的算法实现,它由 RWTH Aachen 大学的Human Language Technology and Pattern Recognition Group 开发。

RWTH ASR工具箱包括声学模型的构建、解析器等重要部分,还包括说话人自适应组件、说话人自适应训练组件、非监督训练组件、个性化 训练和单词词根处理组件等,它支持Linux和Mac OS等操作系统,其项目网站上有比较全面的文档和实例,还提供了现成的用于研究目的的 模型等。

该工具箱遵从一种从QPL发展而来的开源协议,只允许用于非商业用途。
5)其他

上面提到的开源工具箱主要都是用于语音识别的,其他的开源语音识别项目还有Kaldi 、simon 、iATROS-speech 、SHoUT 、 Zanzibar OpenIVR 等。

常见的语音合成的开源工具箱有MARY、SpeakRight、Festival 、FreeTTS 、Festvox 、eSpeak 、Flite 等。

常见的声纹识别的开源工具箱有Alize、openVP等。
4.小结

本文介绍了几种常见的语音交互平台,主要是语音识别、语音合成的软件或工具包,还顺便提到了声纹识别的内容, 下面做一个简单的总结:
以上总结的表格希望对读者有用!

参考文献

[1]语音识别-维基百科:http://zh.wikipedia.org/wiki/语音识别 
[2]语音合成-百度百科:http://baike.baidu.com/view/549184.htm 
[3] Microsoft Speech API:http://en.wikipedia.org/wiki/Speech_Application_Programming_Interface#SAPI_1 
[4] MSDN-SAPI:http://msdn.microsoft.com/zh-cn/library/ms723627.aspx 
[5] 微软语音技术 Windows 语音编程初步:http://blog.csdn.net/yincheng01/article/details/3511525 
[6]IBM Human Language Technologies History:http://www.research.ibm.com/hlt/html/history.html 
[7] Nuance: http://en.wikipedia.org/wiki/Nuance_Communications 
[8] 科大讯飞:http://baike.baidu.com/view/362434.htm 
[9] CMU-Sphinx: http://en.wikipedia.org/wiki/CMU_Sphinx 
[10] CMU Sphinx homepage:http://cmusphinx.sourceforge.net/wiki/ 
[11] HTK Toolkit:http://htk.eng.cam.ac.uk/ 
[12] Julius:http://en.wikipedia.org/wiki/Julius_(software) 
[13] RWTH ASR:http://en.wikipedia.org/wiki/RWTH_ASR 
[14] List of speech recognition software: http://en.wikipedia.org/wiki/List_of_speech_recognition_software 
[15] Speech recognition: http://en.wikipedia.org/wiki/Speech_recognition 
[16] Speech synthesis: http://en.wikipedia.org/wiki/Speech_synthesis 
[17] Speaker recognition: http://en.wikipedia.org/wiki/Speaker_recognition
 Sphinx-4一个完全采用Java开的语音识别器.
  http://cmusphinx.sourceforge.net/sphinx4/#what_is_sphinx4

Google推出开源语音视频聊天软件WebRTC

天极网软件频道2011-06-22 09:30  分享到:我要吐槽

  Google近期推出了开源的语音视频聊天软件WebRTC。有消息称Google将把这款功能类似Skype的软件集成到Chrome浏览器中。

  WebRTC源于Google 2010年收购的互联网电话和视频会议公司Global IP Solutions(以下简称“GIPS”)。当Chrome浏览器集成WebRTC之后,Gmail的受益最明显。目前,Gmail拥有语音视频聊天功能,但用户需要安装Google私有的插件。随着Google VoIP业务的成熟,以及Gmail对Google Voice/Talk等的集成,Gmail聊天已经越来越重要。

  不过,Google对WebRTC有更高的期望。Google希望WebRTC能成为互联网视频会议和点对点通信的标准,并在此基础之上制定网 络通信协议。Google在官方博客中表示,WebRTC将是开源、无版权费的,Google还将就WebRTC与Mozilla和Opera等其他浏览器厂商合作。

  Google是网页应用和云计算的积极支持者。网页应用能够很方便地跨操作系统,不仅可以用于Windows和Mac OS X,也可以被智能手机使用。预计WebRTC将很快进入Chrome浏览器。

  Google GIPS一名程序员亨里克·安德里森(Henrik Andreasson)表示:“我们的目标是通过简单的Javascript应用程序接口,使Chrome拥有实时通信能力(RTC)。我们正在努力使Chrome全面支持RTC,从WebKit到语音视频通信功能。”

  WebRTC使用了GIPS的两款语音编解码器,包括用于宽带连接的iSAC和用于窄带连接的iLBC。视频部分,WebRTC使用了Google的VP8编解码器,这也是一项开源、无版权费的技术。

一个简单语音识别系统:

http://www.cnblogs.com/zhuweisky/p/4059048.html

调用科大讯飞:

http://www.apkbus.com/android-170225-1-1.html

开源语音格式speex教程(for iOS):

http://www.cocoachina.com/industry/20121105/5029.html

关于Android Studio aapt2 的报错:AAPT2 process unexpectedly exit. Error output:

升级完as3.3之后 第一次打正式包, 遇到一个问题,打包时报错AAPT2 process unexpectedly exit. Error output: 又是个坑爹的问题, 没办法, 开始百度吧, 试了N种办法,比如在gradle-wrapper.properties中添加android.enableAapt2=false。 这个方式的意思是屏蔽as对aapt2的检测,而且这个方法在as3.1之后就被弃用了, 找了半天发现在app的 build文件下面加入
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile(‘proguard-android-optimize.txt’), ‘proguard-rules.pro’
aaptOptions.cruncherEnabled = false
aaptOptions.useNewCruncher = false
}
}

重点是aaptOptions.cruncherEnabled = false
aaptOptions.useNewCruncher = false

问题解决了, 虽然我也不清楚是什么原因。。。
————————————————
版权声明:本文为CSDN博主「萌新610521」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/wojiubugaosunihaha/article/details/89914796

2020年Android面试题大全(附答案)

面试题包含java基础,数据结构,网络,Android,设计模式,Jvm,Kotlin等。适合中高级工程师。

一:Java基础

1.Object

equals和==的区别?equals和hashcode的关系?

==:基本类型比较值,引用类型比较地址。

equals:默认情况下,equals作为对象中的方法,比较的是地址,不过可以根据业务,修改equals方法,比如String就重写了equals方法。

默认情况下,equals相等,hashcode必相等,hashcode相等,equals不是必相等、hashcode基于内存地址计算得出,可能会相等,虽然几率微乎其微。

2.String

String,StringBuffer和StringBuilder的区别?

String:String属于不可变对象,每次修改都会生成新的对象。

StringBuilder:可变对象,非多线程安全,效率高于StringBuffer

StringBuffer:可变对象,多线程安全。

效率:StringBuilder>StringBuffer>String

3.面向对象的特征

java中抽象类和接口的特点?

共同点:

1.抽象类和接口都不能生成具体的实例。

2.都是作为上层使用。

不同点:

1.抽象类可以有属性和成员方法,接口不可以。

2.一个类只能继承一个类,但是可以实现多个接口。

3.抽象类中的变量是普通变量,接口中的变量是静态变量。

4.抽象类表达的是一种is-a的关系,即父类和派生子类在概念上的本质是相同的。

5.接口表达的是一种like-a的关系,即接口和实现类的关系只是实现了定义行为,并无本质上的联系。

关于多态的理解?

多态是面向对象的三大特性:继承,封装和多态之一。

多态的定义:允许不同类对同一消息做出响应。

多态存在的条件

1.要有继承。

2.要有复写。

3.父类引用指向子类对象。

java中多态的实现方式:接口实现,继承父类进行方法重写,同一个类中的方法重载。

4.集合

HashMap的特点是什么?HashMap的原理?

HashMap的特点:

1.通过键的Hash值确定数组的位置。

2.找到以后,如果该位置无节点,直接存放。

3.该位置有节点即位置发生冲突,遍历该节点以及后续的节点,比较key值,相等则覆盖。

4.没有就新增节点,默认使用链表,相连节点数超过8的时候,在jdk1.8中会变成红黑树。

5.如果Hashmap中的数组使用情况超过一定比例,就回扩容,默认扩容两倍。

这是存入的过程。需要注意的是:

key的hash值计算过程是高16位不变,低16位取抑或,让更多位参与进来,可以有效的减少碰撞的发生。

初始数组容量为16,默认不超过的比例为0.75.

5.泛型

泛型的本质是参数化类型,在不创建新的类型的情况下,通过泛型指定不同的类型来控制形参具体限制的类型。也就是说在泛型的使用中,操作的数据类型被指定为一个参数,这种参数可以被用在类,接口和方法中,分别被称为泛型类,泛型接口和泛型方法。

泛型是java中的一种语法糖,能够在代码编写的时候起到类型检测的作用,但是虚拟机是不支持这些语法的。

泛型的优点:

1.类型安全,避免类型的强转。

2.提高了代码的可读性,不必要等到运行的时候才去强制转换。

什么是类型擦除?

不管泛型的类型传入哪一种类型实参,对于java来说,都会被当成同一类处理,在内存中也只占用一块空间,通俗一点来说,就是泛型之作用于代码编译阶段,在编译过程中,对于正确检验泛型结果后,会将泛型的信息擦除,也就是说,成功编译过后的class文件时不包含任何泛型信息的。

6.反射

动态代理和静态代理

静态代理很简单,运用的就是代理模式:声明一个接口,再分别实现一个真实的主题类和代理主题类,通过让代理类持有真实主题类,从而控制用户对真实主题的访问。

动态代理指的是在运行时动态生成代理类,即代理类的字节码在运行时生成并载入当前的ClassLoader。

动态代理的原理是使用反射,思路和上面的一致。

使用动态代理的好处:

1.不需要为RealSubject写一个形式完全一样的代理类。

2.使用一些动态代理的方法可以在运行时制定代理类的逻辑,从而提升系统的灵活性。

java并发

java并发中考察频率较高的有线程,线程池,锁,线程间的等待和唤醒,线程特性和阻塞队列等。

1.线程

线程的状态有哪些?下图为一张状态转换图

线程中wait和sleep的区别?

wait方法即释放cpu,又释放锁。

sleep方法只释放cpu,但是不释放锁。

进程和线程的区别?

进程是资源分配的最小单位,线程是程序执行的最小单位,一个进程可以包含多个线程,在Android中,一个进程通常是一个App,App中会有一个主线程,主线程可以用来操作界面元素。如果有耗时操作,必须开启子线程执行。不然会导致ANR。进程间的数据是独立的,线程间的数据可以共享。

2.线程池

线程池地位十分重要,基本上涉及到跨线程的框架都是用到了线程池,比如OkHttp,RxJava,LiveData以及协程等。

与新建一个线程相比,线程池的特点?

1.节省开销,线程池中的线程可以重复利用。

2.速度快,任务来了就开始,省去创建线程的时间。

3.线程可控,线程数量可控和任务可控。

4.功能强大,可以定时和重复执行任务。

线程池中的几个参数是什么意思,线程池的种类有哪些?

线程池的构造函数如下:

publicThreadPoolExecutor(intcorePoolSize,

intmaximumPoolSize,

longkeepAliveTime,

TimeUnit unit,

BlockingQueue workQueue){

    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

             Executors.defaultThreadFactory(), defaultHandler);

}

参数含义:

corePoolize:核心线程数量,不会释放。

maximumPoolSize:允许使用的最大线程池数量,非核心线程数量,闲置时会释放。

keepAliveTime:闲置线程允许的最大闲置时间。

unit:闲置时间的单位。

workQueue:阻塞队列,不同的阻塞队列有不同的特性。

线程池分为四个类型:

CachedThreadPool:闲置线程超时会释放,没有闲置线程的情况下,每次都会创建新的线程。

FixedThreadPool:线程池只能存放指定数量的线程池,线程不会释放,可重复利用。

SingleThreadExecutor:单线程的线程池。

ScheduledThreadPool:可定时和重复执行的线程池。

线程池的工作流程?

1.任务来了,优先考虑核心线程。

2.核心线程满了,进入阻塞队列。

3.阻塞队列满了,考虑非核心线程。

4.非核心线程满了,再触发拒绝任务。

3.锁

死锁触发的四大条件?

1.互斥锁

2.请求与保持

3.不可剥夺

4.循环的请求与等待

synchronized关键字的使用?synchronized的参数放入对象和Class有什么区别?

synchronized关键字的用法:

1.修饰方法

2.修饰代码块,需要自己提供锁对象,锁对象包括对象本身,对象的Class和其他对象。

放入对象和Class的区别是:

1.锁住的对象不同:成员方法锁住的实例对象,静态方法锁住的是Class。

2.访问控制不同:如果锁住的是实例,只会针对同一个对象方法进行同步访问,多线程访问同一个对象的synchronized代码块是串行的,访问不同对象是并行的。如果锁住的是类,多线程访问的不管是同一对象还是不同对象的synchronized代码块都是串行的。

synchronized的原理?

任何一个对象都有一个monitor与之相关联,JVM基于进入和退出mointor对象来实现代码块同步和方法同步,两者实现细节不同:

1.代码块同步:在编译字节码的时候,代码块起始的地方插入monitorenter指令,异常和代码块结束处插入monitorexit指令,线程在执行monitorenter指令的时候尝试获取monitor对象的所有权。获取 不到的情况下就是阻塞。

2.方法同步:synchronized方法在method_info结构有AAC_synchronized标记,线程在执行的时候获取对应的锁,从而实现同步方法。

synchronized和Lock的区别 ?

主要区别:

1.synchronized是Java中的关键字,是Java的内置实现;Lock是Java中的接口。

2.synchronized遇到异常会释放锁;Lock需要在发生异常的时候调用成员方法Lock#unlock()方法。

3.synchronized是不可以中断的,Lock可中断。

4.synchronized不能去尝试获得锁,没有获得锁就会被阻塞;Lock可以去尝试获得锁,如果未获得可以尝试处理 其他逻辑。

5.synchronized多线程效率步入Lock,不过Java1.6以后已经对synchronized进行大量的优化,所以性能上来讲,其实差不了多少。

悲观锁和乐观锁的举例?以及他们的相关实现?

悲观锁和乐观锁的概念:

悲观锁:悲观锁会认为,修改共享数据的时候其他线程也会修改数据,因此只在不会受到其他线程干扰的情况下执行,这样会导致其他有需要锁的线程挂起,等到持有锁的线程释放锁。

乐观锁:每次不加锁,每次直接修改共享数据假设其他线程不会修改,如果发生冲突就直接重试,直到成功为止。

举例:

悲观锁:典型的悲观锁是独占锁,有synchronized,ReentrantLock。

乐观锁:典型的乐观锁是CAS,实现CAS的atomic为代表的一系列类。

CAS是什么?底层原理?

CAS全程Compare And Set,核心的三个元素是:内存位置,预期原值和新值,执行CAS的时候,会将内存位置的值与预期原值进行比较,如果一致,就将原值更新为新值,否则就不更新。

底层原理:是借助CPU底层指令cmpxchg实现原子操作。

4.线程间通讯

notify和notifyAll方法的区别?

notify随机唤醒一个线程,notifyAll唤醒所有等待的线程,让他们竞争锁。

wait/notify和Condition类实现的等待通知有什么区别?

synchronized与wait/notify结合的等待通知只有一个条件,而Condition类可以实现多个条件等待。

5.多线程间的特性

多线程间的有序性,可见性和原子性是什么意思?

原子性:执行一个或者多个操作的时候,要么全部执行,要么都不执行,并且中间过程中不会被打断。Java中的原子性可以通过独占锁和CAS去保证。

可见性:指多线程访问同一个变量的时候,一个线程修改了变量的值,其他线程能够立刻看得到修改的值。锁和volatile能够保证可见性。

有序性:程序执行的顺序按照代码先后的顺序执行。锁和volatile能够保证有序性。

happens-before原则有哪些?

Java内存模型具有一些先天的有序性,它通常叫做happens-before原则。

如果两个操作的先后顺序不能通过happens-before原则推倒出来,那就不能保证他们的先后执行顺序。虚拟机就可以随意打乱执行命令。happens-before原则有:

1.程序次序规则:单线程程序的执行结果得和看上去代码执行的结果要一致。

2.锁定规则:一个锁的lock操作一定发生在上一个unlock操作之后。

3.volatile规则:对volatile变量的写操作一定先行于后面对这个变量的对操作。

4.传递规则:A发生在B前面,B发生在C前面,那么A一定发生在C前面。

5.线程启动规则:线程的start方法先行发生于线程中的每个动作。

6.线程中断规则:对线程的interrup操作先行发生于中断线程的检测代码。

7.线程终结原则:线程中所有的操作都先行发生于线程的终止检测。

8.对象终止原则:一个对象的初始化先行发生于他的finalize()方法的执行。

前四条规则比较重要。

volatile的原理?

可见性:如果对声明了volatile的变量进行写操作的时候,JVM会向处理器发送一条Lock前缀的指令,将这个变量所在缓存行的数据写入到系统内存。

多处理器的环境下,其他处理器的缓存还是旧的,为了保证各个处理器一致,会通过嗅探在总线上传播的数据来检测自己的数据是否过期,如果过期,会强制重新将系统内存的数据读取到处理器缓存。

有序性:Lock前缀的指令相当于一个内存栅栏,它确保指令排序的时候,不会把后面的指令排到内存栅栏的前面,也不会吧把前面的指令排到内存栅栏的后面。

6.阻塞队列

通常的阻塞队列有哪几种?特点是什么?

ArrayBlockQueue:基于数组实现的有界的FIFO(先进先出)阻塞队列。

LinkedBlockQueue:基于链表实现的无界的FIFO(先进先出)阻塞队列。

SynchronousQueue:内部没有任何缓存的阻塞队列。

PriorityBlockingQueue:具有优先级的无限阻塞队列。

ConcurrentHashMap的原理

数据结构的实现跟HashMap一样,不做介绍。

JDK1.8之前采用的是分段锁,核心类是一个Segment,Segment继承了ReentrantLock,每个Segment对象管理若干个桶,多个线程访问同一个元素的时候只能去竞争获取锁。

JDK1.8采用了CAS+synchronized,插入键值对的时候如果当前桶中没有Node节点,使用CAS方式进行更新,如果有Node节点,则使用synchronized的方式进行更新。

二:网络基础知识

1.HTTP和HTTPS

HTTP是哪一层的协议,常见的HTTP状态码有那些?分别代表什么意思?

HTTP协议是应用层协议。

常见的HTTP状态码有:

1xx请求已经接收,继续处理

2xx服务器已经正确处理请求,比如200

3xx重定向,需要做进一步的处理才能完成请求

4xx服务器无法理解的请求,比如404,访问的资源不存在

5xx服务器收到请求以后,处理错误

HTTP1.1和HTTP2有什么区别?

HTTP2.0基于1.1,HTTP2.0增加了:

1.二进制格式:HTTP1.1使用纯文本进行通信,HTTP2.0使用二进制进行传输。

2.Head压缩:对已经发送的Header使用键值建立索引表,相同的Header使用索引表示。

3.服务器推送:服务器可以进行主动推送

4.多路复用:一个TCP连接可以划分成多个流,每个流都会分配Id,客户端可以借助流和服务端建立全双工进行通信,并且流具有优先级。

HTTP和HTTPS有什么区别?

简单来说,HTTP和HTTPS的关系是:HTTPS=HTTP+SSL/TLS

区别如下:

HTTP作用于应用层,使用80端口,起始地址是http://明文传输,消息容易被拦截,串改。

HTTPS作用域传输层,使用443端口,起始地址是https://,需要下载CA证书,传输的过程需要加密,安全性高。

SSL/TLS的握手过程?

这里借用《趣谈网络协议》的图片:

HTTPS传输过程中是如何处理进行加密的?为什么又对称加密的情况下仍然需要进行非对称加密?

过程和上图类似,一次获取证书,公钥,最后生成对称加密的钥匙进行对称加密。

对称加密可以保证加密效率,但是不能解决秘钥传输问题;非对称加密可以解决传输问题,但是效率不高。

2.TCP相关

TCP的三次握手过程,为什么需要三次,而不是两次或者四次?

只发送两次,服务端是不知道自己发送的消息能不能被客户端接收到。

因为TCP握手是三次,所以此时双方都已经知道自己发送的消息能够被对方收到,所以,第四次的发送就显得多余了。

TCP的四次挥手过程?

大致意思:

Client:我要断开连接了

Server:我收到你的消息了

Server:我也要断开连接了

Client:收到你要断开连接的消息了

之后Client等待两个MSL(数据包在网络上生存的最长时间),如果服务端没有回消息就彻底断开了。

TCP和UDP有什么区别?

TCP:基于字节流,面向连接,可靠,能够进行全双工通信,除此以外,还能进行流量控制和拥塞控制,不过效率略低。

UDP:基于报文,面向无连接,不可靠,但是传输效率高。

总的来说,TCP使用于传输效率要求低,准确性要求高或要求有连接。而UDP适用于对准确性要求低,传输效率要求较高的场景,比如语音通话,直播等。

TCP为什么是一种可靠的协议?如何做到流量控制和拥塞控制?

TCP可靠:是因为可以做到数据包发送的有序,无差错和无重复。

流量控制:是通过滑动窗口实现的,因为发送方和接收方消息发送速度和接收速度不一定对等,所以需要一个滑动窗口来平衡处理效率,并且保证没有差错和有序的接收数据包。

拥塞控制:慢开始和拥塞避免,快重传和快恢复算法,这些算法主要是为了适应网络中的带宽而做出的调整。

三:设计模式

1.六大原则

单一职责:合理分配类和函数的职责

开闭原则:开放扩展,关闭修改

里式替换:继承

依赖倒置:面向接口

接口隔离:控制接口的粒度

迪米特:一个类应该对其他的类了解最少

2.单例模式

单例的常用写法有哪几种?

懒汉模式:该模式主要问题是每次获取实例都需要同步,造成不必要的同步开销。

public classSingleInstance{

    private static SingleInstance instance;

    private SingleInstance(){}

    publicstaticsynchronizedSingleInstancegetInstance(){

        if(instance == null) {

            instance = new SingleInstance();

        }

        return instance;

    }

}

DCL模式:高并发环境下可能发生问题

public classSingleInstance{

    private static SingleInstance instance;

    privateSingleInstance(){}

    publicstaticSingleInstancegetInstance(){

        if(instance == null) {

            synchronized (SingleInstance.class) {

                if(instance == null) {

                    instance = new SingleInstance();

                }

            }

        }

        return instance;

    }

}

静态内部类单例

public classSingleInstance{

    privateSingleInstance(){}

    publicstaticSingleInstancegetInstance(){

        return SingleHolder.instance;

    }

    private static classSingleHolder{

        private static final SingleInstance instance = new SingleInstance();

    }

}

枚举单例

public enum SingletonEnum {

    INSTANCE

}

优点:线程安全和反序列化不会生成新的实例。

DCL模式会有什么问题?

对象生成实例的过程中,大概会经过以下过程:

1.为对象分配内存空间

2.初始化对象中的成员变量

3.将对象指向分配的内存空间(此时对象就不为null)

由于JVM会优化指令顺序,也就是说2和3的顺序是不能保证的。在多线程的情况下,当一个线程完成了1.3过程后,当前线程的时间片已用完,这个时候会切换到另一个线程,另一个线程调用这个单例,会使用这个还没初始化完成的实例。

解决方法是使用volatile关键字:

3.需要关注的设计模式

重点了解以下的几种常用的设计模式:

1.工厂模式和抽象工厂模式:注意他们的区别。

2.责任链模式:View的事件分发和OkHttp的调用过程都使用到了责任链模式。

3.观察者模式:重要性不言而喻。

4.代理模式:建议了解一下动态代理。

4.MVC/MVP/MVVM

MVC,MVP和MVVM应该是设计模式中考察频率最高的知识点了,严格意义上来说,他们不能算是设计模式,而是框架。

MVC、MVP和MVVM是什么?

MVC:Model-View-Controller,是一种分层解耦的框架,Model层提供本地数据和网络请求,View层处理视图,Controller处理逻辑,存在问题是Controller层的划分不明显,Model层和View层存在耦合。

MVP:Model_View_Presenter,是对MVC的升级,Model层和View层与MVC的意思一致,但Model层和View层不再存在耦合,而是通过Presenter层这个桥梁进行交流。

MVVM:Model_View_ViewModel:不同于上面的两个框架,ViewModel持有数据状态,当数据状态改变的时候,会自动通知View层进行更新。

MVC和MVP的区别是什么?

MVP是MVC的进一步解耦,简单来讲,在MVC中,View层既可以和Controller层交互,又可以和Model层交互,而在MVP中,View层只能和Presenter层交互,Model层也只能和Presenter层交互,减少了View层和Model层的耦合,更容易定位错误来源。

MVVM和MVP的最大区别在哪里?

MVP中的每个方法都需要你去主动调用,他其实是被动的,而MVVM中有数据驱动这个概念,当你的持有的数据状态发生变更的时候,你的View可以监听到这个变化,从而主动去更新,这其实是主动的。

ViewModel如何知道View层的生命周期?

事实上,如果你仅仅使用ViewModel,他是感知不了生命周期,他需要结合LiveData去感知生命周期,如果仅仅使用DataBinding去实现MVVM,它对数据源使用了弱引用,所以一定程度上可以避免内存泄露的发生。

四:Android基础

1.Activity

Activity的四大启动模式,以及应用场景?

standard:标准模式,每次都会在活动栈中生成一个新的Activity实例,通常我们使用的活动都是标准模式。

singleTop:栈顶复用,如果Activity实例已经存在栈顶,那么就不会再活动栈中创建新的实例。比较常见的场景就是给通知跳转的Activity设置,因为你肯定不想前台Activity已经是该Activity的情况下,点击通知,又创建一个同样的Activity。

singleTask:栈内复用,如果Activity实例在当前栈中已经存在,就会将当前Activity实例上面的其他Activity实例都移除出栈,常见于跳转到主界面。

singleInstance:单例模式,创建一个新的任务栈,这个活动实例独自处在这个活动栈中。

2.屏幕适配

使用的屏幕适配方案?原理是什么?

屏幕适配一般采用的头条的屏幕适配方案。简单来说,以屏幕的一边作为适配,通常是宽。

原理:设备像素px和设备独立像素dp之间的关系。

px = dp*density

假设UI给的设计图屏幕宽度基于360dp,那么设备宽的像素点已知,即px,dp也已知,360dp,所以density = px/dp,之后根据这个修改系统中跟density相关的知识点即可。

3.Android消息机制

Android消息机制介绍?

Android消息机制中的四大概念:

ThreadLocal:当前线程存储的数据仅能从当前线程取出。

MessageQueue:具有时间优先级的消息队列。

Looper:轮询消息队列,看是否有新的消息到来。

Handler:具体处理逻辑的地方。

过程:

1.准备工作:创建Handler,如果是在子线程中创建,还需要调用Looper#prepare(),在Handler的构造函数中,会绑定其中的Looper和MessageQueue。

2.发送消息:创建消息,使用Handler发送。

3.进入MessageQueue:因为Handler中绑定这消息队列,所以Message很自然的被放进消息队列。

4.Looper轮询消息队列:Looper是一个死循环,一直观察有没有新的消息到来,之后从Message取出绑定的Handler,最后调用Handler中的处理逻辑,这一切都发生在Looper循环的线程,这也是Handler能够在指定线程处理任务的原因。

Looper在主线程中死循环为什么没有导致界面的卡顿?

1.导致卡死的是在UI线程中执行耗时操作导致界面出现掉帧,甚至ANR。Looper.Loop()这个操作本身不会导致这个情况。

2.有人可能说,我在点击事件中设置死循环会导致界面卡死,同样都是死循环,不都一样吗?Looper会在没有消息的时候阻塞当前线程,释放CPU资源,等到有消息到来的时候,再唤醒主线程。

3.App进程中是需要死循环的,如果循环结束的话,App进程就结束了。

建议阅读:

《Android中为什么主线程不会因为Looper.loop()里的死循环卡死?》

https://www.zhihu.com/question/34652589

IdleHandler介绍?

IdleHandler是在Handler空闲时处理空闲任务的一种机制。

执行场景:

MessageQueue没有消息,队列为空的时候。

MessageQueue属于延迟消息,当前没有消息执行的时候。

会不会发生死循环:

肯定会,MessageQueue使用计数的方法保证一次调用MessageQueue#next方法只会使用一次的IdleHandler集合。

4.View事件分发机制和View绘制原理。

建议阅读《Android开发艺术探索》第三章,很详细。

5.Bitmap

Bitmap的内存计算方式?

在已知图片的长和宽的像素情况下,影响内存大小的因素会有资源文件位置和像素点大小。

常见的像素点有:

ARGB_8888:4个字节

ARGB_4444,ARGB_565:2个字节

资源文件位置:

不同dpi对应存放的文件夹

比如一个一张图片的像素为180*180px,dpi(设备独立像素密度)为320,如果它仅仅存放在drawable-hdpi,则有

横向像素点=180*320/240+0.5f = 240px

纵向像素点=180*320/240+0.5f  = 240px

如果它仅仅存放在drawable-xxhdpi,则有

横向像素点=180*320/480+0.5f=120px

纵向像素点=180*320/480+0.5f=120px

所以,对于一张180*180px的图片,设备dpi为320,资源图片仅仅存在drawable-hdpi,像素点大小为ARGB_4444,最后生成的文件内存大小为:

横向像素点=180*320/240+0.5f=240px

纵向像素点=180*320/240+0.5f=240px

内存大小=240*240*2 = 115200 byte 越等于 112.5kb

建议阅读;

《Android Bitmap的内存大小是如何计算的?》

https://ivonhoe.github.io/2017/03/22/Bitmap&Memory/

Bitmap的高效加载?

Bitmap的高效加载在Glide中也用到了,思路:

1.获取需要的长和宽,一般获取控件的长和宽。

2.设置BitmapFactory.Options中的inJustDecodeBounds为true,可以帮助我们在不加载内存的方式获得Bitmap的长和宽。

3.对需要的长和宽和Bitmap的长和宽进行对比,从而获得压缩比例,放入BitmapFactory.Options中的inSampleSize属性。

4.设置BitmapFactory.Options中的inJustDecodeBounds为false,将图片加载进内存,进而设置到控件中。

五:Android进阶

Android进阶中重点考察Android Framework,性能优化和第三方框架。

1.Binder

Binder的介绍?与其他IPC方式的优缺点?

Binder是Android中特有的IPC方式,引用《Android开发艺术探索》中的话

从IPC角度来说,Binder是Android中的一种跨进程通信方式,Binder还可以理解为虚拟的物理设备,它的设备驱动是/dev/binder;从Android Frameword来讲,Binder是Service Manager连接各种Manager和对应的ManagerService的桥梁,从面向对象和CS模型来讲,Client通过Binder和远程的Server进行通讯。

基于Binder,Android还实现了其他的IPC方式,比如AIDL,Messenger和ContentProvider。与其他IPC比较:

效率高:出了内存共享外,其他IPC都需要进行两次数据拷贝,而因为Binder使用内存映射的关系,仅需要一次数据拷贝。

安全性好:接收方可以从数据包中获取发送发的进程Id和用户Id,方便验证发送方的身份,其他IPC想要实验只能够主动存入,但是这有可能在发送的过程中被修改。

Binder的通信过程?Binder的原理?

其实这个过程也可以从AIDL生成的代码中看出。

原理:

Binder的结构:

Client:服务的请求方。

Server:服务的提供方。

Service Manager:为Server提供Binder的注册服务,为Client提供Binder的查询服务,Server、Client和Service Manager的通讯都是通过Binder。

Binder驱动:负责Binder通信机制的建立,提供一系列底层支持。

从上图中,Binder通信的过程是这样的:

1.Server在Service Manager中注册:Server进程在创建的时候,也会创建对应的Binder实体,如果要提供服务给Client,就必须为Binder实体注册一个名字。

2.Client通过Service Manager获取服务:Client知道服务中Binder实体的名字后,通过名字从Service Manager获取Binder实体的引用。

3.Client使用服务与Server进行通信:Client通过调用Binder实体与Server进行通信。

更详细一点?

Binder通信的实质是利用内存映射,将用户进程的内存地址和内核的内存地址映射为同一块物理地址,也就是说他们使用的同一块物理空间,每次创建Binder的时候大概分配128的空间。数据进行传输的时候,从这个内存空间分配一点,用完了再释放即可。

2.序列化

Android有那些序列化方式?

为了解决Android中内存序列化速度过慢的问题,Android使用了Parcelable.

3.Framework

Zygote孕育进程过程?

Activity的启动过程?

建议阅读:

《3分钟看懂Activity启动流程》

https://www.jianshu.com/p/9ecea420eb52

App的启动过程?

介绍下App进程和System Server进程如何联系:

App进程

ActivityThread:依赖于UI线程,实际处理与AMS中交互的工作。

ActivityManagerService:负责Activity,Service等的生命周期工作。

ApplicationThread:System Server进程中ApplicationThreadProxy的服务端,帮助System Server进程跟App进程交流。

System Server:Android核心的进程,掌管着Android系统中各种重要的服务。

具体过程:

1.用户点击App图标,Lanuacher进程通过Binder联系到System Server进程发起startActivity。

2.System Server通过Socket联系到Zygote,fork出一个新的App进程。

3.创建一个新的App进程以后,Zygote启动App进程的ActivityThread#main()方法。

4.在ActivityThread中,调用AMS进行ApplicationThread的绑定。

5.AMS发送创建Application的消息给ApplicationThread,进而转交给ActivityThread中的H,他是一个Handler,接着进行Application的创建工作。

6.AMS以同样的方式创建Activity,接着就是大家熟悉的创建Activity的工作了。

APK的安装过程?

建议阅读:

《Android Apk安装过程分析》

https://www.jianshu.com/p/953475cea991

Activity启动过程跟Window的关系?

建议阅读:

《简析Window、Activity、DecorView以及ViewRoot之间的错综关系》

https://juejin.im/post/5dac6aa2518825630e5d17da

Activity,Window,ViewRoot和DecorView之间的关系?

建议阅读:

《总结UI原理和高级的UI优化方式》

https://www.jianshu.com/p/8766babc40e0

4.Context

关于Context的理解?

建议阅读:

《Android Context 上下文 你必须知道的一切》

https://blog.csdn.net/lmj623565791/article/details/40481055

5.断点续传

多线程断点续传?

基础知识:

1.Http基础:在Http请求中,可以加入请求头Range,下载特定区间的文件数。

2.RandomAccessFile:支持随机访问,可以从指定位置进行数据的读写。

6.性能优化

平时做了哪些性能优化?

建议阅读:

《Android 性能优化最佳实践》

https://juejin.im/post/5b50b017f265da0f7b2f649c

7.第三方库

一定要在熟练使用后再去查看原理。

Glide

Glide考察的频率挺高的,常见的问题有:

1.Glide和其他图片加载框架的比较?

2.如何设计一个图片加载框架?

3.Glide缓存实现机制?

4.Glide如何处理生命周期?

建议阅读:

《Glide最全解析》

https://blog.csdn.net/sinyu890807/category_9268670.html

《面试官:简历上最好不要写Glide,不是问源码那么简单》

https://juejin.im/post/5dbeda27e51d452a161e00c8

OkHttp

OkHttp常见知识点:

1.责任链模式

2.interceptors和networkInterceptors的区别?

建议看一遍源码,过程并不复杂。

Retrofit

Retrofit常见问题:

1.设计模式和封层解耦的理念

2.动态代理

建议看一遍源码,过程并不复杂。

RxJava

RxJava难在各种操作符,我们了解一下大致的设计思想即可。

建议阅读一些RxJava的文章。

Android Jetpack(非必须)

我们主要阅读了Android Jetpack中以下库的源码:

1.Lifecycle:观察者模式,组件生命周期中发送事件。

2.DataBinding:核心就是利用LiveData或者Observable xxx 实现的观察者模式,对16进制的状态位更新,之后根据这个状态位取更新对应的内容。

3.LiveData:观察者模式,事件的生产消费模型。

4.ViewModel:借用Activity异常销毁时存储隐藏Fragment的机制存储ViewModel,保证数据的生命周期尽可能的延长。

5.Paging:设计思想。

建议阅读:

《Android Jetpack源码分析系列》

https://blog.csdn.net/mq2553299/column/info/24151

作者:简雨山舍
链接:https://www.jianshu.com/p/554bb50385b7
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

Android编程简单实现九宫格示例

https://www.jb51.net/article/117464.htm

本文实例讲述了Android编程简单实现九宫格。分享给大家供大家参考,具体如下:

实现的步骤

1. 一个整体的容器部分。就是上图中包括整个图片项个各个部分,这里我们使用gridView(表格布局)来实现

2.整个界面里需要注意的是 “重复的部分”,就是 各个图片项和,图片下方显示的文字了。那么我们需要描述这个部分。在描述时,要说明图片位于上方,文字位于下方。

3.迭代,或者说重复的将各项 插入(放入)到容器内。
需要添加/修改3个文件:main.xml、meunitem.xml、activity

main.xml源代码如下,本身是个GirdView,用于装载Item:

123456789101112<?xml version="1.0" encoding="utf-8"?><GridView xmlns:Android="http://schemas.android.com/apk/res/android"android:id="@+id/GridView"android:layout_width="fill_parent"android:layout_height="fill_parent"android:numColumns="auto_fit"android:horizontalSpacing="10dp"android:verticalSpacing="10dp"android:columnWidth="90dp"android:stretchMode="columnWidth"android:gravity="center"></GridView>

在这里需要关注的属性是columnWidth,这里指定了列的宽度,一个列对象,对应一个 “可重复的子项”,这个子项就是我们 的图片项和图片下方文字显示的部分。如果不指定这个宽度的话,默认是每行(展示的行,界面)仅仅只显示一个 “可重复的子项”,而当指定了宽度时,本文指定为90dp,如果每行实际行尺寸大于90,他就会继续将下一个的“可重复的子项”,放置在本行。于是就呈现一种 一行显示多个子项的情况。numColumns属性,指定一个自动填充的值,指示了自动填充行。

2。指定“可重复的子项”,就是需要迭代显示的部分

Android:numColumns=”auto_fit” ,GridView的列数设置为自动
android:columnWidth=”90dp”,每列的宽度,也就是Item的宽度
android:stretchMode=”columnWidth”,缩放与列宽大小同步
android:verticalSpacing=”10dp”,两行之间的边距,如:行一(NO.0~NO.2)与行二(NO.3~NO.5)间距为10dp
android:horizontalSpacing=”10dp”,两列之间的边距。

接下来介绍 meunitem.xml,这个XML跟前面ListView的ImageItem.xml很类似:

12345678910111213141516<?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="fill_parent"android:layout_height="wrap_content"><ImageView android:layout_width="wrap_content"android:id="@+id/ItemImage"android:layout_height="wrap_content"android:layout_centerHorizontal="true"/><TextView  android:layout_width="wrap_content"android:layout_height="wrap_content"android:layout_below="@+id/ItemImage"android:id="@+id/ItemText"android:layout_centerHorizontal="true"/></RelativeLayout>

最后是JAVA的源代码

12345678910111213141516171819202122232425@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.mainmenu);GridView gridview = (GridView) findViewById(R.id.GridView);ArrayList<HashMap<String, Object>> meumList = new ArrayList<HashMap<String, Object>>();for(int i = 1;i < 10;i++) {HashMap<String, Object> map = new HashMap<String, Object>();map.put("ItemImage", R.drawable.icon);map.put("ItemText", "NO."+i);meumList.add(map);}SimpleAdapter saMenuItem = new SimpleAdapter(this,meumList, //数据源R.layout.menuitem, //xml实现new String[]{"ItemImage","ItemText"}, //对应map的Keynew int[]{R.id.ItemImage,R.id.ItemText}); //对应R的Id//添加Item到网格中gridview.setAdapter(saMenuItem);gridview.setOnItemClickListener(new OnItemClickListener() {public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,long arg3) {System.out.println("click index:"+arg2);}});}

Android开发中保存数据的四种方法方法

     Android开发中我们会接触到四种数据存储方式,每种存储方式都各有不同;以下我分别列举了Android开发中的不同存储方式的特点
一,Preferences
Preferences 是一个较轻量级的存储数据的方法,具体使用方法:
在A中保存值:
———————————————————————————————
SharedPreferences.Editor sharedata = getSharedPreferences(“data”, 0).edit();  
  sharedata.putString(“name”,”shenrenkui”);  
  sharedata.commit();
———————————————————————————————
在B中取值:
———————————————————————————————
SharedPreferences sharedata = getSharedPreferences(“data”, 0);  
String data = sharedata.getString(“name”, null);  
Log.i(TAG,”data=”+data);
———————————————————————————————
注意,Context.getSharedPreferences(String name,int type)的参数更我们在创建数据的时候的数据权限属性是一样的,存储和取值的过程这有点像HashMap但是比HashMap更具人性化,getXXX(Object key,Object defualtReturnValue),第二个参数是当你所要的key对应没有时候返回的值。这就省去了很多逻辑判断。。。。

二,Files

在 Android上面没有的File就是J2se中的纯种File了,可见功能之强大,这里就算是走马观花地严重路过了。
———————————————————————————————
//创建文件
            file = new File(FILE_PATH , FILE_NAME);
            file.createNewFile();

            //打开文件file的OutputStream
            out = new FileOutputStream(file);
            String infoToWrite = “纸上得来终觉浅,绝知此事要躬行”;
            //将字符串转换成byte数组写入文件
            out.write(infoToWrite.getBytes());
            //关闭文件file的OutputStream
            out.close();

            //打开文件file的InputStream
            in = new FileInputStream(file);
            //将文件内容全部读入到byte数组
            int length = (int)file.length();
            byte[] temp = new byte[length];
            in.read(temp, 0, length);
            //将byte数组用UTF-8编码并存入display字符串中
            display =  EncodingUtils.getString(temp,TEXT_ENCODING);
            //关闭文件file的InputStream
            in.close();
        } catch (IOException e) {
            //将出错信息打印到Logcat
            Log.e(TAG, e.toString());
            this.finish();
        }
//从资源读取
InputStream is=getResources().getRawResource(R.raw.文件名)
———————————————————————————————
三,Databases

Android内嵌了功能比其他手机操作系统强大的关系型数据库 sqlite3,我们在大学时候学的SQL语句基本都可以使用,我们自己创建的数据可以用adb shell来操作。具体路径是/data/data/package_name/databases。如,这里演示一下进入 com.android.providers.media包下面的操作。

1,  adb shell

2,  cd /data/data/com.android.providers.media/databases

3,  ls(查看 com.android.providers.media下面的数据库)

4,  sqlite3 internal.db

5,  .help— 看看如何操作

6,  .table列出internal数据中的表

7,  select * from albums;
———————————————————————————————
DatabaseHelper mOpenHelper;
private static final String DATABASE_NAME = “dbForTest.db”;
private static final int DATABASE_VERSION = 1;
private static final String TABLE_NAME = “diary”;
private static final String TITLE = “title”;
private static final String BODY = “body”;
private static class DatabaseHelper extends SQLiteOpenHelper {
  DatabaseHelper(Context context) {
  super(context, DATABASE_NAME, null, DATABASE_VERSION);
  }
  @Override
  public void onCreate(SQLiteDatabase db) {
  String sql = “CREATE TABLE ” + TABLE_NAME + ” (” + TITLE
    + ” text not null, ” + BODY + ” text not null ” + “);”;
  Log.i(“haiyang:createDB=”, sql);
  db.execSQL(sql);
  }
  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  }
}
/*
  * 重新建立数据表
  */
private void CreateTable() {
  SQLiteDatabase db = mOpenHelper.getWritableDatabase();
  String sql = “CREATE TABLE ” + TABLE_NAME + ” (” + TITLE
    + ” text not null, ” + BODY + ” text not null ” + “);”;
  Log.i(“haiyang:createDB=”, sql);
  try {
  db.execSQL(“DROP TABLE IF EXISTS diary”);
  db.execSQL(sql);
  setTitle(” 数据表成功重建”);
  } catch (SQLException e) {
  setTitle(“数据表重建错误”);
  }
}
/*
  * 删除数据表
  */
private void dropTable() {
  SQLiteDatabase db = mOpenHelper.getWritableDatabase();
  String sql = “drop table ” + TABLE_NAME;
  try {
  db.execSQL(sql);
  setTitle(“数据表成功删除:” + sql);
  } catch (SQLException e) {
  setTitle(“数据表删除错误”);
  }
}
/*
  * 插入两条数据
  */
private void insertItem() {
  SQLiteDatabase db = mOpenHelper.getWritableDatabase();
  String sql1 = “insert into ” + TABLE_NAME + ” (” + TITLE + “, ” + BODY
    + “) values(‘haiyang’, ‘android的发展真是迅速啊’);”;
  String sql2 = “insert into ” + TABLE_NAME + ” (” + TITLE + “, ” + BODY
    + “) values(‘icesky’, ‘android的发展真是迅速啊’);”;
  try {
  Log.i(“haiyang:sql1=”, sql1);
  Log.i(“haiyang:sql2=”, sql2);
  db.execSQL(sql1);
  db.execSQL(sql2);
  setTitle(” 插入两条数据成功”);
  } catch (SQLException e) {
  setTitle(“插入两条数据失败”);
  }
}
/*
  * 删除其中的一条数据
  */
private void deleteItem() {
  try {
  SQLiteDatabase db = mOpenHelper.getWritableDatabase();
  db.delete(TABLE_NAME, ” title = ‘haiyang'”, null);
  setTitle(“删除title为haiyang的一条记录”);
  } catch (SQLException e) {
  }
}
/*
  * 在屏幕的title区域显示当前数据表当中的数据的条数。
  */
private void showItems() {
  SQLiteDatabase db = mOpenHelper.getReadableDatabase();
  String col[] = { TITLE, BODY };
  Cursor cur = db.query(TABLE_NAME, col, null, null, null, null, null);
  Integer num = cur.getCount();
  setTitle(Integer.toString(num) + ” 条记录”);
}
———————————————————————————————
四,Network

这是借助Internet来存储我们要的数据,这是CS结构的存储方式,也是点一下名了。

如何使用 Content Provider

下边是用户经常接触到的几个典型Content Provider应用:

    * Content Provider Name : Intended Data
    * Browser : Browser bookmarks, Browser history, etc.
    * CallLog : Missed calls, Call datails, etc.
    * Contacts : Contact details
    * MediaStore : Media files such as audio, Video and Images
    * Settings : Device Settings and Preferences

调用Content Provider资源的标准URI结构:
———————————————————————————————
<standard_prefix>://<authority>/<data_path>/<id>
———————————————————————————————
例如:
1) 取得浏览器所有“书签”信息: content://browser/bookmarks
2) 取得系统通讯录中的信息: content://contacts/people (如果取得某一个特定通讯记录,在路径URI的末端指定一个ID号:content://contacts/people/5
简单的实例片段:
———————————————————————————————
Uri allCalls = Uri.parse(“content://call_log/calls”);
Cursor c = managedQuery(allCalls, null, null, null, null);———————————

android click事件中获取 Button文本 从一个按钮开关中获取文本

android获取Button文本 从一个按钮开关中获取文本

在程序里可以从一个按钮中获取文本
String buttonText = button.getText();
也可以从按钮开关中获取id
int buttinID = view.getId();
但是如何从按钮开关中获取文本呢?这俩个怎么结合呢?
在onClick()中传递的视图就是你要找的button,需要强制转换一下。
public void onClick(View view) {
// 从按钮开关中获取文本
Button b = (Button)v;
String buttonText = b.getText().toString();
}

Android中定时执行任务的3种实现方法(推荐)

Android中定时执行任务的3种实现方法(推荐)_Android_脚本之家

在Android开发中,定时执行任务的3种实现方法:

一、采用Handler与线程的sleep(long)方法(不建议使用,Java的实现方式)

二、采用Handler的postDelayed(Runnable, long)方法(最简单的android实现)

三、采用Handler与timer及TimerTask结合的方法(比较多的任务时建议使用)

下面逐一介绍:

一、采用Handle与线程的sleep(long)方法

Handler主要用来处理接受到的消息。这只是最主要的方法,当然Handler里还有其他的方法供实现,有兴趣的可以去查API,这里不过多解释。

1. 定义一个Handler类,用于处理接受到的Message。?

123456Handler handler = new Handler() { public void handleMessage(Message msg) { // 要做的事情 super.handleMessage(msg); } };

Handler handler = new Handler() { public void handleMessage(Message msg) { // 要做的事情 super.handleMessage(msg); } };

2. 新建一个实现Runnable接口的线程类,如下:?

1234567891011121314151617public class MyThread implements Runnable { @Overridepublic void run() { // TODO Auto-generated method stub while (true) { try { Thread.sleep(10000);// 线程暂停10秒,单位毫秒 Message message = new Message(); message.what = 1; handler.sendMessage(message);// 发送消息 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }

public class MyThread implements Runnable { @Override public void run() { // TODO Auto-generated method stub while (true) { try { Thread.sleep(10000);// 线程暂停10秒,单位毫秒 Message message = new Message(); message.what = 1; handler.sendMessage(message);// 发送消息 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }

3. 在需要启动线程的地方加入下面语句:

new Thread(new MyThread()).start(); 

4. 启动线程后,线程每10s发送一次消息。

二、采用Handler的postDelayed(Runnable, long)方法

这个实现比较简单一些。

1. 定义一个Handler类
?

123456789Handler handler=new Handler(); Runnable runnable=new Runnable() { @Overridepublic void run() { // TODO Auto-generated method stub //要做的事情 handler.postDelayed(this, 2000); } };

Handler handler=new Handler(); Runnable runnable=new Runnable() { @Override public void run() { // TODO Auto-generated method stub //要做的事情 handler.postDelayed(this, 2000); } };

2. 启动计时器

handler.postDelayed(runnable, 2000);//每两秒执行一次runnable. 

3. 停止计时器

handler.removeCallbacks(runnable);  

三、采用Handler与timer及TimerTask结合的方法

1. 定义定时器、定时器任务及Handler句柄
?

12345678910private final Timer timer = new Timer(); private TimerTask task; Handler handler = new Handler() { @Overridepublic void handleMessage(Message msg) { // TODO Auto-generated method stub // 要做的事情 super.handleMessage(msg); } };

private final Timer timer = new Timer(); private TimerTask task; Handler handler = new Handler() { @Override public void handleMessage(Message msg) { // TODO Auto-generated method stub // 要做的事情 super.handleMessage(msg); } };

2. 初始化计时器任务?

123456789task = new TimerTask() { @Overridepublic void run() { // TODO Auto-generated method stub Message message = new Message(); message.what = 1; handler.sendMessage(message); } }; 

task = new TimerTask() { @Override public void run() { // TODO Auto-generated method stub Message message = new Message(); message.what = 1; handler.sendMessage(message); } };

3. 启动定时器

timer.schedule(task, 2000, 2000);  

4. 停止计时器

timer.cancel(); 

简要说一下上面三步提到的一些内容:

1. 定时器任务(TimerTask)顾名思义,就是说当定时器到达指定的时间时要做的工作,这里是想Handler发送一个消息,由Handler类进行处理。

2. java.util.Timer.schedule(TimerTask task, long delay):这个方法是说,dalay/1000秒后执行task.只执行一次。

java.util.Timer.schedule(TimerTask task, long delay, long period):这个方法是说,delay/1000秒后执行task,然后进过period/1000秒再次执行task,这个用于循环任务,执行无数次,当然,你可以用timer.cancel();取消计时器的执行。

每一个Timer仅对应唯一一个线程。

Timer不保证任务执行的十分精确。

Timer类的线程安全的。

Android实现获取系统应用列表

Android系统为我们提供了很多服务管理的类,包括ActivityManager、PowerManager(电源管理)、AudioManager(音频管理) 等。除此之外,还提供了一个PackageManger管理类,它的主要职责是管理应用程序包。 通过它,我们就可以获取应用程序信息。  

PackageManager的功能: 

•安装,卸载应用

•查询permission相关信息

•查询Application相关信息(application,activity,receiver,service,provider及相应属性等)

•查询已安装应用

•增加,删除permission

•清除用户数据、缓存,代码段等

我们可以用PackageManager来显示系统安装的应用程序列表或者系统程序列表  

相关类的介绍

PackageItemInfo类

说明: AndroidManifest.xml文件中所有节点的基类,提供了这些节点的基本信息:a label、icon、 meta-data。它并不 直接使用,而是由子类继承然后调用相应方法。

常用字段:

public int icon 获得该资源图片在R文件中的值 (对应于android:icon属性)

public int labelRes 获得该label在R文件中的值(对应于android:label属性)

public String name 获得该节点的name值 (对应于android:name属性)

public String packagename 获得该应用程序的包名 (对应于android:packagename属性)

常用方法:

Drawable loadIcon(PackageManager pm) 获得当前应用程序的图像

CharSequence loadLabel(PackageManager pm) 获得当前应用程序的label

ActivityInfo类

继承自 PackageItemInfo

说明: 获得应用程序中<activity/>或者 <receiver />节点的信息 。

我们可以通过它来获取我们设置的任何属性,包括 theme 、launchMode、launchmode等

常用方法继承至PackageItemInfo类中的loadIcon()和loadLabel()

ServiceInfo 类

说明: 同ActivityInfo类似 ,同样继承自 PackageItemInfo,只不过它表示的是<service>节点信息。

ApplicationInfo类

继承自 PackageItemInfo

说明:获取一个特定引用程序中<application>节点的信息。

字段说明:    

flags字段: FLAG_SYSTEM 系统应用程序        

FLAG_EXTERNAL_STORAGE 表示该应用安装在sdcard中

常用方法继承至PackageItemInfo类中的loadIcon()和loadLabel()

ResolveInfo类

说明:根据<intent>节点来获取其上一层目录的信息,通常是<activity>、<receiver>、<service>节点信息。

常用字段:

public ActivityInfo activityInfo 获取 ActivityInfo对象,即<activity>或<receiver >节点信息

public ServiceInfo serviceInfo 获取 ServiceInfo对象,即<activity>节点信息

常用方法:

Drawable loadIcon(PackageManager pm) 获得当前应用程序的图像

CharSequence loadLabel(PackageManager pm) 获得当前应用程序的label

PackageInfo类

说明:手动获取AndroidManifest.xml文件的信息 。

常用字段:

public String packageName 包名

public ActivityInfo[] activities 所有<activity>节点信息

public ApplicationInfo applicationInfo <application>节点信息,只有一个

public ActivityInfo[] receivers 所有<receiver>节点信息,多个

public ServiceInfo[] services 所有<service>节点信息 ,多个

PackageManger 类

说明: 获得已安装的应用程序信息 。

可以通过getPackageManager()方法获得。

常用方法:

public abstract PackageManager getPackageManager()

功能:获得一个PackageManger对象

public abstrac tDrawable getApplicationIcon(StringpackageName)

参数: packageName 包名

功能:返回给定包名的图标,否则返回null

public abstract ApplicationInfo getApplicationInfo(String packageName, int flags)

参数:packagename 包名 flags 该ApplicationInfo是此flags标记,通常可以直接赋予常数0即可

功能:返回该ApplicationInfo对象

public abstract List<ApplicationInfo> getInstalledApplications(int flags)

参数:flag为一般为GET_UNINSTALLED_PACKAGES,那么此时会返回所有ApplicationInfo。

我们可以对ApplicationInfo 的flags过滤,得到我们需要的。

功能:返回给定条件的所有PackageInfo

public abstract List<PackageInfo> getInstalledPackages(int flags)

参数如上

功能:返回给定条件的所有PackageInfo

public abstractResolveInfo resolveActivity(Intent intent, int flags)

参数: intent 查寻条件,Activity所配置的action和category flags: MATCH_DEFAULT_ONLY :Category必须带有CATEGORY_DEFAULT的Activity,才匹配 GET_INTENT_FILTERS :匹配Intent条件即可 GET_RESOLVED_FILTER :匹配Intent条件即可 功能 :返回给定条件的ResolveInfo对象(本质上是Activity)

public abstract List<ResolveInfo> queryIntentActivities(Intent intent, int flags)

参数同上

功能 :返回给定条件的所有ResolveInfo对象(本质上是Activity),集合对象

public abstract ResolveInfo resolveService(Intent intent, int flags)

参数同上

  功能 :返回给定条件的ResolveInfo对象(本质上是Service)

public abstract List<ResolveInfo> queryIntentServices(Intent intent, int flags)

参数同上

功能 :返回给定条件的所有ResolveInfo对象(本质上是Service),集合对象

  运行示例如下图所示:

示例代码:
项目工程结构图:

MainActivity:

package com.manager.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import android.app.Activity;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.TextView;

/**
* 使用PackManager示例
* @Description: 获取Android系统应用程序

* @FileName: MainActivity.java

* @Package com.manager.test

* @Version V1.0
*/
public class MainActivity extends Activity {
private ListView lv;
private MyAdapter adapter;
ArrayList<HashMap<String, Object>> items = new ArrayList<HashMap<String, Object>>();

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

lv = (ListView)findViewById(R.id.lv);

//得到PackageManager对象
PackageManager pm = getPackageManager();

//得到系统安装的所有程序包的PackageInfo对象
//List<ApplicationInfo> packs = pm.getInstalledApplications(0);
List<PackageInfo> packs = pm.getInstalledPackages(0);

for(PackageInfo pi:packs){
HashMap<String, Object> map = new HashMap<String, Object>();
////显示用户安装的应用程序,而不显示系统程序
// if((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM)==0&&
// (pi.applicationInfo.flags&ApplicationInfo.FLAG_UPDATED_SYSTEM_APP)==0){
////这将会显示所有安装的应用程序,包括系统应用程序
// map.put(“icon”, pi.applicationInfo.loadIcon(pm));//图标
// map.put(“appName”, pi.applicationInfo.loadLabel(pm));//应用程序名称
// map.put(“packageName”, pi.applicationInfo.packageName);//应用程序包名
//
////循环读取并存到HashMap中,再增加到ArrayList上,一个HashMap就是一项
// items.add(map);
// }

//这将会显示所有安装的应用程序,包括系统应用程序
map.put(“icon”, pi.applicationInfo.loadIcon(pm));//图标
map.put(“appName”, pi.applicationInfo.loadLabel(pm));//应用程序名称
map.put(“packageName”, pi.applicationInfo.packageName);//应用程序包名

//循环读取并存到HashMap中,再增加到ArrayList上,一个HashMap就是一项
items.add(map);
}

/**
* 参数:Context
* ArrayList(item的集合)
* item的layout
* 包含ArrayList中的HashMap的key的数组
* key所对应的值的相应的控件id
*/
adapter = new MyAdapter(this, items, R.layout.list_item,
new String[]{“icon”, “appName”, “packageName”},
new int[]{R.id.icon, R.id.appName, R.id.packageName});

lv.setAdapter(adapter);
}
}

/**
* 自定义适配器
* @Description:自定义适配器

* @FileName: MainActivity.java

* @Package com.manager.test

* @Author Hanyongjian

* @Date 2012-3-6 上午08:42:48

* @Version V1.0
*/
class MyAdapter extends SimpleAdapter
{
private int[] appTo;
private String[] appFrom;
private ViewBinder appViewBinder;
private List<? extends Map<String, ?>> appData;
private int appResource;
private LayoutInflater appInflater;

/**
* 构造器
* @param context
* @param data
* @param resource
* @param from
* @param to
*/
public MyAdapter(Context context, List<? extends Map<String, ?>> data,
int resource, String[] from, int[] to) {
super(context, data, resource, from, to);
appData = data;
appResource = resource;
appFrom = from;
appTo = to;
appInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}

public View getView(int position, View convertView, ViewGroup parent){
return createViewFromResource(position, convertView, parent, appResource);
}

private View createViewFromResource(int position, View convertView, ViewGroup parent, int resource){
View v;

if(convertView == null){
v = appInflater.inflate(resource, parent,false);
final int[] to = appTo;
final int count = to.length;
final View[] holder = new View[count];

for(int i = 0; i < count; i++){
holder[i] = v.findViewById(to[i]);
}

v.setTag(holder);
}else {
v = convertView;
}

bindView(position, v);
return v;
}

private void bindView(int position, View view){
final Map dataSet = appData.get(position);

if(dataSet == null){
return;
}

final ViewBinder binder = appViewBinder;
final View[] holder = (View[])view.getTag();
final String[] from = appFrom;
final int[] to = appTo;
final int count = to.length;

for(int i = 0; i < count; i++){
final View v = holder[i];

if(v != null){
final Object data = dataSet.get(from[i]);
String text = data == null ? “”:data.toString();

if(text == null){
text = “”;
}

boolean bound = false;

if(binder != null){
bound = binder.setViewValue(v, data, text);
}

if(!bound){
/**
* 自定义适配器,关在在这里,根据传递过来的控件以及值的数据类型,
* 执行相应的方法,可以根据自己需要自行添加if语句。另外,CheckBox等
* 集成自TextView的控件也会被识别成TextView,这就需要判断值的类型
*/
if(v instanceof TextView){
//如果是TextView控件,则调用SimpleAdapter自带的方法,设置文本
setViewText((TextView)v, text);
}else if(v instanceof ImageView){
//如果是ImageView控件,调用自己写的方法,设置图片
setViewImage((ImageView)v, (Drawable)data);
}else {
throw new IllegalStateException(v.getClass().getName() + ” is not a ” +
“view that can be bounds by this SimpleAdapter”);
}
}
}
}
}

public void setViewImage(ImageView v, Drawable value)
{
v.setImageDrawable(value);
}
}

main.xml:

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical” android:layout_width=”fill_parent”
android:layout_height=”fill_parent”>

<ListView
android:id=”@+id/lv”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”>
</ListView>

</LinearLayout>

Android代码通过包名调用系统卸载程序

/**
 * 卸载指定包名的应用
 * @param packageName
*/
public boolean uninstall(String packageName) {
    boolean b = checkApplication(packageName);
    Logger.d(TAG, "Test:check:"+b);
    if (b) {
        Uri packageURI = Uri.parse("package:".concat(packageName));
        Intent intent = new Intent(Intent.ACTION_DELETE);
        intent.setData(packageURI);
        startActivity(intent);
        return true;
    }
    return false;
}

/**
 * 判断该包名的应用是否安装
 *
 * @param packageName
* @return
*/
private boolean checkApplication(String packageName) {
    Logger.d(TAG, "Test,run");
    if (packageName == null || "".equals(packageName)) {
        return false;
    }
    try {
        getPackageManager().getApplicationInfo(packageName,
                PackageManager.MATCH_UNINSTALLED_PACKAGES);
        return true;
    } catch (PackageManager.NameNotFoundException e) {
        Logger.e(TAG, "Test:"+e.toString());
    }
    return false;
}