remi-andrake 0.1.0

data/examples/android/Translate/src/com/beust/android/translate/History.java

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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.beust.android.translate;
+
+import com.beust.android.translate.Languages.Language;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.util.Log;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This class handles the history of past translations.
+ */
+public class History {
+    private static final String HISTORY = "history";
+
+    /**
+     * Sort the translations by timestamp.
+     */
+    private static final Comparator<HistoryRecord> MOST_RECENT_COMPARATOR
+             = new Comparator<HistoryRecord>() {
+
+        public int compare(HistoryRecord object1, HistoryRecord object2) {
+            return (int) (object2.when - object1.when);
+        }
+    };
+
+    /**
+     * Sort the translations by destination language and then by input.
+     */
+    private static final Comparator<HistoryRecord> LANGUAGE_COMPARATOR
+            = new Comparator<HistoryRecord>() {
+
+        public int compare(HistoryRecord object1, HistoryRecord object2) {
+            int result = object1.to.getLongName().compareTo(object2.to.getLongName());
+            if (result == 0) {
+                result = object1.input.compareTo(object2.input);
+            }
+            return result;
+        }
+    };
+
+    private List<HistoryRecord> mHistoryRecords = Lists.newArrayList();
+    
+    public History(SharedPreferences prefs) {
+        mHistoryRecords = restoreHistory(prefs);
+    }
+
+    public static List<HistoryRecord> restoreHistory(SharedPreferences prefs) {
+        List<HistoryRecord> result = Lists.newArrayList();
+        boolean done = false;
+        int i = 0;
+        Map<String, ?> allKeys = prefs.getAll();
+        for (String key : allKeys.keySet()) {
+            if (key.startsWith(HISTORY)) {
+                String value = (String) allKeys.get(key);
+                result.add(HistoryRecord.decode(value));
+            }
+        }
+//        while (! done) {
+//            String history = prefs.getString(HISTORY + "-" + i++, null);
+//            if (history != null) {
+//                result.add(HistoryRecord.decode(history));
+//            } else {
+//                done = true;
+//            }
+//        }
+
+        return result;
+    }
+
+//    public void saveHistory(Editor edit) {
+//        log("Saving history");
+//        for (int i = 0; i < mHistoryRecords.size(); i++) {
+//            HistoryRecord hr = mHistoryRecords.get(i);
+//            edit.putString(HISTORY + "-" + i, hr.encode());
+//        }
+//    }
+    
+    public static void addHistoryRecord(Context context,
+        Language from, Language to, String input, String output) {
+        History historyRecord = new History(TranslateActivity.getPrefs(context));
+        HistoryRecord hr = new HistoryRecord(from, to, input, output, System.currentTimeMillis());
+        
+        // Find an empty key to add this history record
+        SharedPreferences prefs = TranslateActivity.getPrefs(context);
+        int i = 0;
+        while (true) {
+            String key = HISTORY + "-" + i; 
+            if (!prefs.contains(key)) {
+                Editor edit = prefs.edit();
+                edit.putString(key, hr.encode());
+                log("Committing " + key + " " + hr.encode());
+                edit.commit();
+                return;
+            } else {
+                i++;
+            }
+        }
+    }
+    
+//    public static void addHistoryRecord(Context context, List<HistoryRecord> result, HistoryRecord hr) {
+//        if (! result.contains(hr)) {
+//            result.add(hr);
+//        }
+//        Editor edit = getPrefs(context).edit();
+//    }
+
+    private static void log(String s) {
+        Log.d(TranslateActivity.TAG, "[History] " + s);
+    }
+    
+    
+    public List<HistoryRecord> getHistoryRecordsMostRecentFirst() {
+        Collections.sort(mHistoryRecords, MOST_RECENT_COMPARATOR);
+        return mHistoryRecords;
+    }
+    
+    public List<HistoryRecord> getHistoryRecordsByLanguages() {
+        Collections.sort(mHistoryRecords, LANGUAGE_COMPARATOR);
+        return mHistoryRecords;
+    }
+
+    public List<HistoryRecord> getHistoryRecords(Comparator<HistoryRecord> comparator) {
+        if (comparator != null) {
+            Collections.sort(mHistoryRecords, comparator);
+        }
+        return mHistoryRecords;
+    }
+
+    public void clear(Context context) {
+        int size = mHistoryRecords.size();
+        mHistoryRecords = Lists.newArrayList();
+        Editor edit = TranslateActivity.getPrefs(context).edit();
+        for (int i = 0; i < size; i++) {
+            String key = HISTORY + "-" + i;
+            log("Removing key " + key);
+            edit.remove(key);
+        }
+        edit.commit();
+    }
+
+
+}

data/examples/android/Translate/src/com/beust/android/translate/HistoryActivity.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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.beust.android.translate;
+
+import android.app.ListActivity;
+import android.content.SharedPreferences.Editor;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.SimpleAdapter;
+import android.widget.AdapterView.OnItemClickListener;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This activity displays the history of past translations.
+ *
+ * @author Cedric Beust
+ * @author Daniel Rall
+ */
+public class HistoryActivity extends ListActivity implements OnItemClickListener {
+    private SimpleAdapter mAdapter;
+    private List<Map<String, String>> mListData;
+    private History mHistory;
+
+    private static final String INPUT = "input";
+    private static final String OUTPUT = "output";
+    private static final String FROM = "from";
+    private static final String TO = "to";
+    private static final String FROM_SHORT_NAME = "from-short-name";
+    private static final String TO_SHORT_NAME = "to-short-name";
+
+    // These constants are used to bind the adapter to the list view
+    private static final String[] COLUMN_NAMES = { INPUT, OUTPUT, FROM, TO };
+    private static final int[] VIEW_IDS = { R.id.input, R.id.output, R.id.from, R.id.to };
+
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setContentView(R.layout.history_activity);
+        
+        mHistory = new History(TranslateActivity.getPrefs(this));
+        initializeAdapter(mHistory.getHistoryRecordsMostRecentFirst());
+        getListView().setEmptyView(findViewById(R.id.empty));
+    }
+    
+    private void initializeAdapter(List<HistoryRecord> historyRecords) {
+        mListData = Lists.newArrayList();
+        
+        for (HistoryRecord hr : historyRecords) {
+            Map<String, String> data = Maps.newHashMap();
+
+            // Values that are bound to views
+            data.put(INPUT, hr.input);
+            data.put(OUTPUT, hr.output);
+            data.put(FROM, hr.from.name().toLowerCase());
+            data.put(TO, hr.to.name().toLowerCase());
+
+            // Extra values we keep around for convenience
+            data.put(FROM_SHORT_NAME, hr.from.getShortName());
+            data.put(TO_SHORT_NAME, hr.to.getShortName());
+            mListData.add(data);
+        }
+        
+        mAdapter = new SimpleAdapter(this, mListData, R.layout.history_record,
+                COLUMN_NAMES, VIEW_IDS);
+        getListView().setAdapter(mAdapter);
+        getListView().setOnItemClickListener(this);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.history_activity_menu, menu);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch(item.getItemId()) {
+        case R.id.most_recent:
+            initializeAdapter(mHistory.getHistoryRecordsMostRecentFirst());
+            break;
+
+        case R.id.languages:
+            initializeAdapter(mHistory.getHistoryRecordsByLanguages());
+            break;
+
+        case R.id.clear_history:
+            mHistory.clear(this);
+            initializeAdapter(mHistory.getHistoryRecordsByLanguages());
+            break;
+        }
+        
+        return true;
+    }
+
+    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        Map<String, String> data = (Map<String, String>) parent.getItemAtPosition(position);
+        Editor edit = TranslateActivity.getPrefs(this).edit();
+        TranslateActivity.savePreferences(edit,
+                data.get(FROM_SHORT_NAME), data.get(TO_SHORT_NAME), 
+                data.get(INPUT), data.get(OUTPUT));
+        finish();
+    }
+}

data/examples/android/Translate/src/com/beust/android/translate/HistoryRecord.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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.beust.android.translate;
+
+import static com.beust.android.translate.Languages.Language;
+
+/**
+ * This class describes one entry in the history
+ */
+public class HistoryRecord {
+    private static final String SEPARATOR = "@";
+
+    public Language from;
+    public Language to;
+    public String input;
+    public String output;
+    public long when;
+
+    public HistoryRecord(Language from, Language to, String input, String output, long when) {
+        super();
+        this.from = from;
+        this.to = to;
+        this.input = input;
+        this.output = output;
+        this.when = when;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null) return false;
+        if (o == this) return true;
+        try {
+            HistoryRecord other = (HistoryRecord) o;
+            return other.from.equals(from) && other.to.equals(to) &&
+                    other.input.equals(input) && other.output.equals(output);
+        } catch(Exception ex) {
+            return false;
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return from.hashCode() ^ to.hashCode() ^ input.hashCode() ^ output.hashCode();
+    }
+
+    public String encode() {
+        return from.name() + SEPARATOR + to.name() + SEPARATOR + input
+                + SEPARATOR + output + SEPARATOR + new Long(when);
+    }
+    
+    @Override
+    public String toString() {
+        return encode();
+    }
+    
+    public static HistoryRecord decode(String s) {
+        Object[] o = s.split(SEPARATOR);
+        int i = 0;
+        Language from = Language.valueOf((String) o[i++]);
+        Language to = Language.valueOf((String) o[i++]);
+        String input = (String) o[i++];
+        String output = (String) o[i++];
+        Long when = Long.valueOf((String) o[i++]);
+        HistoryRecord result = new HistoryRecord(from, to, input, output, when);
+        return result;
+    }
+    
+}
+

data/examples/android/Translate/src/com/beust/android/translate/ITranslate.aidl

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * 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.beust.android.translate;
+
+/**
+ * AIDL for the TranslateService (generates ITranslate.java).
+ *
+ * @author Daniel Rall
+ */
+interface ITranslate {
+    String translate(in String text, in String from, in String to);
+    int getVersion();
+}

data/examples/android/Translate/src/com/beust/android/translate/ITranslate.java

@@ -0,0 +1,139 @@
+/*
+ * This file is auto-generated.  DO NOT MODIFY.
+ * Original file: /home/remi/projects/andrake/examples/android/Translate/src/com/beust/android/translate/ITranslate.aidl
+ */
+package com.beust.android.translate;
+import java.lang.String;
+import android.os.RemoteException;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Binder;
+import android.os.Parcel;
+/**
+ * AIDL for the TranslateService (generates ITranslate.java).
+ *
+ * @author Daniel Rall
+ */
+public interface ITranslate extends android.os.IInterface
+{
+/** Local-side IPC implementation stub class. */
+public static abstract class Stub extends android.os.Binder implements com.beust.android.translate.ITranslate
+{
+private static final java.lang.String DESCRIPTOR = "com.beust.android.translate.ITranslate";
+/** Construct the stub at attach it to the interface. */
+public Stub()
+{
+this.attachInterface(this, DESCRIPTOR);
+}
+/**
+ * Cast an IBinder object into an ITranslate interface,
+ * generating a proxy if needed.
+ */
+public static com.beust.android.translate.ITranslate asInterface(android.os.IBinder obj)
+{
+if ((obj==null)) {
+return null;
+}
+com.beust.android.translate.ITranslate in = (com.beust.android.translate.ITranslate)obj.queryLocalInterface(DESCRIPTOR);
+if ((in!=null)) {
+return in;
+}
+return new com.beust.android.translate.ITranslate.Stub.Proxy(obj);
+}
+public android.os.IBinder asBinder()
+{
+return this;
+}
+public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
+{
+switch (code)
+{
+case INTERFACE_TRANSACTION:
+{
+reply.writeString(DESCRIPTOR);
+return true;
+}
+case TRANSACTION_translate:
+{
+data.enforceInterface(DESCRIPTOR);
+java.lang.String _arg0;
+_arg0 = data.readString();
+java.lang.String _arg1;
+_arg1 = data.readString();
+java.lang.String _arg2;
+_arg2 = data.readString();
+java.lang.String _result = this.translate(_arg0, _arg1, _arg2);
+reply.writeNoException();
+reply.writeString(_result);
+return true;
+}
+case TRANSACTION_getVersion:
+{
+data.enforceInterface(DESCRIPTOR);
+int _result = this.getVersion();
+reply.writeNoException();
+reply.writeInt(_result);
+return true;
+}
+}
+return super.onTransact(code, data, reply, flags);
+}
+private static class Proxy implements com.beust.android.translate.ITranslate
+{
+private android.os.IBinder mRemote;
+Proxy(android.os.IBinder remote)
+{
+mRemote = remote;
+}
+public android.os.IBinder asBinder()
+{
+return mRemote;
+}
+public java.lang.String getInterfaceDescriptor()
+{
+return DESCRIPTOR;
+}
+public java.lang.String translate(java.lang.String text, java.lang.String from, java.lang.String to) throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+java.lang.String _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+_data.writeString(text);
+_data.writeString(from);
+_data.writeString(to);
+mRemote.transact(Stub.TRANSACTION_translate, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readString();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+public int getVersion() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+int _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_getVersion, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readInt();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+}
+static final int TRANSACTION_translate = (IBinder.FIRST_CALL_TRANSACTION + 0);
+static final int TRANSACTION_getVersion = (IBinder.FIRST_CALL_TRANSACTION + 1);
+}
+public java.lang.String translate(java.lang.String text, java.lang.String from, java.lang.String to) throws android.os.RemoteException;
+public int getVersion() throws android.os.RemoteException;
+}