xref: /frameworks/ml/bordeaux/service/src/android/bordeaux/services/BordeauxSessionManager.java

/*
 * Copyright (C) 2012 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 android.bordeaux.services;

import android.bordeaux.services.IBordeauxLearner.ModelChangeCallback;
import android.content.Context;
import android.os.IBinder;
import android.util.Log;

import java.lang.NoSuchMethodException;
import java.lang.InstantiationException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

// This class manages the learning sessions from multiple applications.
// The learning sessions are automatically backed up to the storage.
//
class BordeauxSessionManager {

    static private final String TAG = "BordeauxSessionManager";
    private BordeauxSessionStorage mSessionStorage;

    static class Session {
        Class learnerClass;
        IBordeauxLearner learner;
        boolean modified = false;
    };

    static class SessionKey {
        String value;
    };

    // Thread to periodically save the sessions to storage
    class PeriodicSave extends Thread implements Runnable {
        long mSavingInterval = 60000; // 60 seconds
        boolean mQuit = false;
        PeriodicSave() {}
        public void run() {
            while (!mQuit) {
                try {
                    sleep(mSavingInterval);
                } catch (InterruptedException e) {
                    // thread waked up.
                    // ignore
                }
                saveSessions();
            }
        }
    }

    PeriodicSave mSavingThread = new PeriodicSave();

    private ConcurrentHashMap<String, Session> mSessions =
            new ConcurrentHashMap<String, Session>();

    public BordeauxSessionManager(final Context context) {
        mSessionStorage = new BordeauxSessionStorage(context);
        mSavingThread.start();
    }

    class LearningUpdateCallback implements ModelChangeCallback {
        private String mKey;

        public LearningUpdateCallback(String key) {
            mKey = key;
        }

        public void modelChanged(IBordeauxLearner learner) {
            // Save the session
            Session session = mSessions.get(mKey);
            if (session != null) {
                synchronized(session) {
                    if (session.learner != learner) {
                        throw new RuntimeException("Session data corrupted!");
                    }
                    session.modified = true;
                }
            }
        }
    }

    // internal unique key that identifies the learning instance.
    // Composed by the package id of the calling process, learning class name
    // and user specified name.
    public SessionKey getSessionKey(String callingUid, Class learnerClass, String name) {
        SessionKey key = new SessionKey();
        key.value = callingUid + "#" + "_" + name + "_" + learnerClass.getName();
        return key;
    }

    public IBinder getSessionBinder(Class learnerClass, SessionKey key) {
        if (mSessions.containsKey(key.value)) {
            return mSessions.get(key.value).learner.getBinder();
        }
        // not in memory cache
        try {
            // try to find it in the database
            Session stored = mSessionStorage.getSession(key.value);
            if (stored != null) {
                // set the callback, so that we can save the state
                stored.learner.setModelChangeCallback(new LearningUpdateCallback(key.value));
                // found session in the storage, put in the cache
                mSessions.put(key.value, stored);
                return stored.learner.getBinder();
            }

            // if session is not already stored, create a new one.
            Log.i(TAG, "create a new learning session: " + key.value);
            IBordeauxLearner learner =
                    (IBordeauxLearner) learnerClass.getConstructor().newInstance();
            // set the callback, so that we can save the state
            learner.setModelChangeCallback(new LearningUpdateCallback(key.value));
            Session session = new Session();
            session.learnerClass = learnerClass;
            session.learner = learner;
            mSessions.put(key.value, session);
            return learner.getBinder();
        } catch (Exception e) {
            throw new RuntimeException("Can't instantiate class: " +
                                       learnerClass.getName());
        }
    }

    public void saveSessions() {
        for (Map.Entry<String, Session> session : mSessions.entrySet()) {
            synchronized(session) {
                // Save the session if it's modified.
                if (session.getValue().modified) {
                    SessionKey skey = new SessionKey();
                    skey.value = session.getKey();
                    saveSession(skey);
                }
            }
        }
    }

    public boolean saveSession(SessionKey key) {
        Session session = mSessions.get(key.value);
        if (session != null) {
            synchronized(session) {
                byte[] model = session.learner.getModel();

                // write to database
                boolean res = mSessionStorage.saveSession(key.value, session.learnerClass, model);
                if (res)
                    session.modified = false;
                else {
                    Log.e(TAG, "Can't save session: " + key.value);
                }
                return res;
            }
        }
        Log.e(TAG, "Session not found: " + key.value);
        return false;
    }

    // Load all session data into memory.
    // The session data will be loaded into the memory from the database, even
    // if this method is not called.
    public void loadSessions() {
        synchronized(mSessions) {
            mSessionStorage.getAllSessions(mSessions);
            for (Map.Entry<String, Session> session : mSessions.entrySet()) {
                // set the callback, so that we can save the state
                session.getValue().learner.setModelChangeCallback(
                        new LearningUpdateCallback(session.getKey()));
            }
        }
    }

    public void removeAllSessionsFromCaller(String callingUid) {
        // remove in the hash table
        ArrayList<String> remove_keys = new ArrayList<String>();
        for (Map.Entry<String, Session> session : mSessions.entrySet()) {
            if (session.getKey().startsWith(callingUid + "#")) {
                remove_keys.add(session.getKey());
            }
        }
        for (String key : remove_keys) {
            mSessions.remove(key);
        }
        // remove all session data from the callingUid in database
        // % is used as wild match for the rest of the string in sql
        int nDeleted = mSessionStorage.removeSessions(callingUid + "#%");
        if (nDeleted > 0)
            Log.i(TAG, "Successfully deleted " + nDeleted + "sessions");
    }
}