Android bases de données multiples ouvertes

Question

Je fais un client de messagerie instantanée pour Android et je travaille avec des bases de données pour stocker les contacts et autres informations ... Dans mon application, j'ai une activité et un service. J'ai besoin d'ouvrir trois bases de données en même temps sur le service et sur l'activité.

J'utilise trois bases de données parce que je veux que les bases de données soient gérées plus facilement sans avoir de problèmes avec la synchronisation de l'écriture dedans. (pour autant que je sache, j'ai besoin d'écrire dans la base de données de manière synchrone, car il pourrait écraser).

Pour gérer les bases de données du service et de l'activité dans le même temps, je pensais qu'un singleton ou une classe statique DatabaseHelper pourrait me aider ...

J'ai commencé à faire un test en en faisant deux objets global databasehelper dans l'activité, chacun ouvre une base de données différente, après avoir exécuté le projet j'ai remarqué que la dernière base de données ouverte reste ouverte dans les deux objets: ((, pourquoi cela se passe-t-il? moi comment puis-je faire ce travail? Merci!

L .E .: après plus de tests, j'ai créé un objet statique de databasehelper, ouvert un service à partir duquel je prends l'objet base de données de l'activité et en même temps j'en ai fait deux pour les instructions, une en activité et une en service à 3000 et ajoute des valeurs dans la même base de données, puis il lit la base de données. Après cette exécution j'ai remarqué que la base de données est toujours dans les pieds et fonctionne sans erreurs. La chose étrange est que le service pour est en cours d'exécution seulement après l'activité pour terminer le travail. Pourquoi donc? Merci!

Answer 1

J'ai une classe DatabaseAdapter qui contient deux bases de données qui sont ouvertes ensemble.

public class DatabaseAdapter { 
    /** Identifier for the internal database */ 
    public static final int    INTERNAL   = 0; 
    /** Identifier for the external database */ 
    public static final int    EXTERNAL    = 1; 

    private final SQLiteOpenHelper[] mDatabaseManager = new SQLiteOpenHelper[2]; 
    private final SQLiteDatabase[]  mDatabases   = new SQLiteDatabase[2]; 

    /** 
    * Constructs the database and open it. 
    */ 
    public DatabaseAdapter() { 
     // Open the internal_db 
     mDatabaseManager[INTERNAL] = new InternalDatabaseManager(MyApplication.getInstance()); 
     mDatabases[INTERNAL] = mDatabaseManager[INTERNAL].getWritableDatabase(); 
    } 

    /** 
    * Checks the database state and throws an {@link IllegalStateException} if database isn't open. 
    * Should always be used before starting to access the database. 
    * 
    * @param type Type of the database. Can be INTERNAL or EXTERNAL. 
    */ 
    public void checkDbState(int type) { 
     if (mDatabases[type] == null || !mDatabases[type].isOpen()) { 
      throw new IllegalStateException("The database has not been opened"); 
     } 
    } 

    /** 
    * Closes the database of the given type. 
    * 
    * @param type Type of the database. Can be INTERNAL or EXTERNAL. 
    */ 
    public void close(int type) { 
     if (mDatabases[type].isOpen()) { 
      mDatabases[type].close(); 
      mDatabases[type] = null; 
      if (mDatabaseManager[type] != null) { 
       mDatabaseManager[type].close(); 
       mDatabaseManager[type] = null; 
      } 
     } 
    } 

    /** 
    * @param type Type of the database. Can be INTERNAL or EXTERNAL. 
    * @return true if the database is open, false otherwise. 
    */ 
    public boolean isOpen(int type) { 
     return mDatabases[type] != null && mDatabases[type].isOpen(); 
    } 

    /** 
    * Opens the default database. 
    * 
    * @param type Type of the database. Can be INTERNAL or EXTERNAL. 
    */ 
    public void open(int type) { 
     switch (type) { 
      case INTERNAL: 
       mDatabaseManager[INTERNAL] = new InternalDatabaseManager(MyApplication.getInstance()); 
       if (!isOpen(INTERNAL)) { 
        mDatabases[INTERNAL] = mDatabaseManager[INTERNAL].getWritableDatabase(); 
       } 
      break; 
      case EXTERNAL: 
       mDatabaseManager[EXTERNAL] = new ExternalDatabaseManager(MyApplication.getInstance(), Constants.EXTERNAL_DB_PATH, 1); 
       if (!isOpen(EXTERNAL)) { 
        mDatabases[EXTERNAL] = mDatabaseManager[EXTERNAL].getWritableDatabase(); 
       } 
      break; 
     } 
    } 
} 

pour ajouter un troisième devrait être facile :)