Android

Android项目实战---指尖翻译系列0x03

上次我们把悬浮窗的功能实现了,接下来我会带着大家把数据请求和处理的部分完成.

代码实现

首先我们使用的是有道翻译API,我们需要申请一个API key才可使用api,申请的步骤很简单,我就不多说了.下面是API的数据接口:

http://fanyi.youdao.com/openapi.do?keyfrom=&key=&type=data&doctype=&version=1.1&q=要翻译的文本

可以看到我们需要填入的参数有

  • keyfrom 我申请的keyfrom是fingertrans
  • key 申请的key是1372247841
  • doctype 返回的数据格式,这里我们选择json
  • q 是我们需要翻译的内容

接下来我们来看一下有道官方提供的返回数据的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
    "errorCode":0
    "query":"good",
    "translation":["好"], // 有道翻译
    "basic":{ // 有道词典-基本词典
        "phonetic":"gʊd"
        "uk-phonetic":"gʊd" //英式发音
        "us-phonetic":"ɡʊd" //美式发音
        "explains":[
            "好处",
            "好的"
            "好"
        ]
    },
    "web":[ // 有道词典-网络释义
        {
            "key":"good",
            "value":["良好","善","美好"]
        },
        {...}
    ]
}

根据返回的数据格式,我们只保留部分对我们有用的数据作为我们的数据对象,这里我们需要的是query,translation,basic这些属性的数据.下面我们就可以根据返回的数据构造我们的对象了,创建TransResult.java

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
/**
 * the json result
 */
public class TransResult {
    List<String> translation;
    TransBasic basic;
    String query;
   
    public List<String> getTranslation() {
        return translation;
    }

    public void setTranslation(List<String> translation) {
        this.translation = translation;
    }

    public TransBasic getBasic() {
        return basic;
    }

    public void setBasic(TransBasic basic) {
        this.basic = basic;
    }

    public String getQuery() {
        return query;
    }

    public void setQuery(String query) {
        this.query = query;
    }

}

TransBasic.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
 * the basic translation information
 */
public class TransBasic {
    
    List<String> explains;
    
    public List<String> getExplains() {
        return explains;
    }

    public void setExplains(List<String> explains) {
        this.explains = explains;
    }
}

最后我们再把网络的数据进行整合,创建TransInfo.java

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
/**
 * the popView data
 */
public class TransInfo {
    private String query;
    private String translations;
    private String explains;

    public TransInfo(String query, String translations, String explains) {
        this.query = query;
        this.translations = translations;
        this.explains = explains;
    }

    public String getQuery() {
        return query;
    }

    public void setQuery(String query) {
        this.query = query;
    }

    public String getTranslations() {
        return translations;
    }

    public void setTranslations(String translations) {
        this.translations = translations;
    }

    public String getExplains() {
        return explains;
    }

    public void setExplains(String explains) {
        this.explains = explains;
    }
}

有了数据对象后我们就可以进行数据请求的封装了,由于我们采用的是retrofit进行网络的数据请求,所以首先创建一个TranslateService.java,根据有道API的数据接口来构造我们的服务接口

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * the translate service
 */
public interface TranslateService {

    @GET("openapi.do")
    Observable<TransResult> translate(@Query("keyfrom") String keyfrom,
                                      @Query("key") String key,
                                      @Query("type") String type,
                                      @Query("doctype") String doctype,
                                      @Query("version") String version,
                                      @Query("q") String query);
}

如果对retrofit的使用不了解的话可以看一下我的另一篇博客Android学习笔记—开源工具Retrofit的基本使用.然后我们来将网络请求进行封装,创建HttpMethods.java

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
/**
 * the network utils class
 */
public class HttpMethods {
    private static final String BASE_URL = "http://fanyi.youdao.com/";
    private static final String KEY = "1372247841";
    private static final String KEY_FROM = "fingertrans";

    private static final int DEFAULT_TIMEOUT = 5;

    private Retrofit retrofit;
    private TranslateService translateService;

    private HttpMethods(){
        OkHttpClient.Builder builder=new OkHttpClient.Builder();
        builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

        retrofit = new Retrofit.Builder()
                .client(builder.build())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .baseUrl(BASE_URL)
                .build();
        translateService = retrofit.create(TranslateService.class);
    }


    /**
     * get the translation from the internet
     * @param subscriber the subscriber
     * @param query the word to translate
     */
    public void translate(Subscriber<TransResult> subscriber,String query){
        translateService.translate(KEY_FROM,KEY,"data","json","1.1",query)
                .subscribeOn(Schedulers.io())
                .unsubscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber);

    }

    public static HttpMethods getInstance()
    {
        return SingletonHolder.instance;
    }

    private static class SingletonHolder{
        private static final HttpMethods instance = new HttpMethods();
    }
}

这里采用了Retrofit + RxJava进行网络数据的请求,对于两者如何结合使用,我推荐大家看一下这篇文章RxJava 与 Retrofit 结合的最佳实践.
接下来我们就需要实现我们的Presenter来完成数据请求和UI界面的刷新了.创建PopPresenter.java

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
/**
 * the pop presenter
 */
public class PopPresenter implements PopContract.Presenter {

    private PopContract.View mView;

    public PopPresenter(PopContract.View view) {
        this.mView = view;

        mView.setPresenter(this);
    }

    @Override
    public void translate(String query) {
        Subscriber<TransResult> subscriber = new Subscriber<TransResult>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(TransResult transResult) {
                mView.showPopView(processResult(transResult));
            }
        };

        HttpMethods.getInstance().translate(subscriber, query);
    }

    /**
     *  process the web data
     * @param result the raw data
     * @return the popView content data
     */
    private TransInfo processResult(TransResult result) {
        String explain = null;
        if (result.getBasic() != null) {
            List<String> explains = result.getBasic().getExplains();
            explain = "";
            for (int i = 0; i < explains.size(); ++i) {
                explain += explains.get(i);
                if (i + 1 < explains.size())
                    explain += "\n";
            }
        }
        return new TransInfo(result.getQuery(), result.getTranslation().get(0), explain);
    }

    @Override
    public void start() {

    }
}

由于我们已经获取了数据,所以我们可以在悬浮窗上展现出来,在PopView.java文件中的showPopView()方法可以修改为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 @Override
public void showPopView(TransInfo info) {
    removePoppedView();
    if (mPopView == null) {
        mPopView = (LinearLayout) View.inflate(mContext, R.layout.pop_view, null);
        ButterKnife.bind(this, mPopView);
        mPopView.setOnClickListener(this);
     }

        tv_query.setText(info.getQuery());
        if (info.getExplains() == null) {
            tv_explain.setVisibility(View.GONE);
            tv_translation.setVisibility(View.VISIBLE);
            tv_translation.setText(info.getTranslations());

        } else {
            tv_translation.setVisibility(View.GONE);
            tv_explain.setVisibility(View.VISIBLE);
            tv_explain.setText(info.getExplains());
        }

        mWindowManager.addView(mPopView, getPopViewParams());
        isDismiss = false;
}

最后我们可以测试一下能否正常运行并得到我们想要的结果,MainActivity.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MainActivity extends AppCompatActivity implements ClipboardManager.OnPrimaryClipChangedListener {

    Clipboard clipboard;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        clipboard = Clipboard.getInstance();
        clipboard.setPrimaryClipChangedListener(this);
    }

    @Override
    public void onPrimaryClipChanged() {

        String text = clipboard.getText();
        Log.e("Text", "粘贴板的内容是:" + text);
        PopView view = new PopView(FingerApp.get());
        PopPresenter popPresenter = new PopPresenter(view);
        popPresenter.translate(text);
    }
}

最后别忘了添加网络权限

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

最后的效果是这样的
效果图

总结

本次指尖翻译基本功能的系列教程已经完成了,大家可以利用这个功能全继续完善自己的应用,希望这个教程能对大家的学习有所帮助.

本系列教程的完整代码我已经上传到我的Github,如果想对指尖翻译的完整项目有更多的了解可以到项目的Github地址.