एंड्रॉइड स्क्लाइट सिंगलटन डीबी फाइलस्ट्रीम अपडेट

Question

मेरे पास एक एप्लिकेशन एसक्लाइट डीबी का उपयोग करता है, पहले इंस्टॉल पर मैं जांचता हूं कि डेटाबेस फ़ोल्डर और न ही डीबी फाइल मौजूद है यदि अपडेट डीबी फ़ंक्शन नहीं है। लेकिन गैलेक्सी नोट 10.1 पर उदाहरण के लिए कुछ मामले यह मुझे त्रुटि देता है।

लोड पर;

this.dhn = DataHelper.getDataHelper(this); 

    File directory = new File(Environment.getDataDirectory() + File.separator + "data" + File.separator + "XXX" + File.separator + "databases"); 
    if(!directory.exists()) 
    { 
     directory.mkdirs(); 
     updateDB(); 
    } 

    try { 
     androidCheckout = this.dhn.Guid(); 

     if(this.dhn.getSettings("dbVersion") == null || Integer.parseInt(this.dhn.getSettings("dbVersion")) != Version || !this.dhn.isTableExists("UserInfo")) 
     { 
      updateDB(); 
     } 
    } 
    catch (SQLiteException e) 
    {    
    try { 
      updateDB(); 
      androidCheckout = this.dhn.Guid(); 
     } 
    catch (SQLiteException e11) 
     { 
      ManuelYukle(); 
     } 

    } 



    public void updateDB() 
    { 
     this.dhn.close(); 

     try { 
      InputStream myInput; 

       myInput = getAssets().open("XXX.db"); 

      // Path to the just created empty db 
      String outFileName = "/data/data/XXX/databases/" 
        + "XXX.db"; 

      // Open the empty db as the output stream 
      FileOutputStream myOutput = new FileOutputStream(outFileName); 

      // transfer bytes from the inputfile to the outputfile 
      byte[] buffer = new byte[1024]; 
      int length; 
      while ((length = myInput.read(buffer)) > 0) { 
       myOutput.write(buffer, 0, length); 
      } 

      myOutput.flush(); 
      myOutput.close(); 
      myInput.close(); 
      buffer = null; 
      outFileName = null; 
      this.dhn.close(); 
      this.dhn = null; 
      this.dhn = DataHelper.getDataHelper(this); <<<<<<<< HERE IT CRUSHS 
     } catch (IOException e1) { 
      e1.printStackTrace(); 
     } 
    } 

DBHELPER क्लास>

private static DataHelper singleton; 

    public static DataHelper getDataHelper(Context context) { 
      if (singleton == null) { 
        singleton = new DataHelper(context); 
        OpenHelper openHelper = new OpenHelper(singleton.context); 
        singleton.db = openHelper.getWritableDatabase(); 
      } 
      if(!singleton.db.isOpen()){ 
        OpenHelper openHelper = new OpenHelper(singleton.context); 
        singleton.db = openHelper.getWritableDatabase(); 
      } 
      singleton.context = context; 
      return singleton; 
    } 

    private DataHelper(Context context) { 
     this.context = context; 
} 

त्रुटि लॉग फ़ाइल>

12-09 19:11:15.772: I/SqliteDatabaseCpp(6271): sqlite returned: error code = 11, msg = database corruption at line 48171 of [ed759d5a9e], db=/data/data/XXX/databases/XXX_db 
12-09 19:11:15.772: I/SqliteDatabaseCpp(6271): sqlite returned: error code = 11, msg = database disk image is malformed, db=/data/data/XXX/databases/XXX_db 
12-09 19:11:15.772: E/SqliteDatabaseCpp(6271): sqlite3_exec - Failed to set synchronous mode = 1(Normal) 
12-09 19:11:15.772: I/SqliteDatabaseCpp(6271): sqlite returned: error code = 11, msg = database corruption at line 48171 of [ed759d5a9e], db=/data/data/XXX/databases/XXX_db 
12-09 19:11:15.772: I/SqliteDatabaseCpp(6271): sqlite returned: error code = 11, msg = database disk image is malformed, db=/data/data/XXX/databases/XXX_db 
12-09 19:11:15.772: E/SqliteDatabaseCpp(6271): CREATE TABLE android_metadata failed 
12-09 19:11:15.777: E/DefaultDatabaseErrorHandler(6271): Corruption reported by sqlite on database: /data/data/XXX/databases/XXX.db 
12-09 19:11:15.782: E/DefaultDatabaseErrorHandler(6271): deleting the database file: /data/data/XXX/databases/XXX.db 

Answer 1

मैं जब मैं जब वह खुद को अद्यतन करने गया था डेटाबेस का उपयोग करने के लिए कोशिश कर रहा था एक ही समस्या database disk image is malformed सामना करना पड़ा। तो, मैंने नीचे दिए गए तरीके का पालन किया।

1. DataBaseHelper

   import java.io.File; 
   import java.io.FileOutputStream; 
   import java.io.IOException; 
   import java.io.InputStream; 
   import java.io.OutputStream; 
   import android.content.Context; 
   import android.database.SQLException; 
   import android.database.sqlite.SQLiteDatabase; 
   import android.database.sqlite.SQLiteException; 
   import android.database.sqlite.SQLiteOpenHelper; 
   import android.util.Log; 
   
   public class DataBaseHelper extends SQLiteOpenHelper { 
   
        private static final String TAG = DataBaseHelper.class.getSimpleName(); 
        private static String DB_PATH = "/data/data/YOUR_PACKAGE/databases/"; 
        private static String DB_NAME = "XXX"; 
        private SQLiteDatabase mDataBase; 
        private final Context mContext; 
   
        public DataBaseHelper(Context context) { 
         super(context, DB_NAME, null, 1); 
         DB_PATH = "/data/data/" + context.getPackageName() + "/databases/"; 
         this.mContext = context; 
        } 
   
        public void createDataBase() throws IOException { 
         boolean mDataBaseExist = checkDataBase(); 
         if (!mDataBaseExist) { 
          this.getReadableDatabase(); 
          try { 
           copyDataBase(); 
          } catch (IOException mIOException) { 
           throw new Error("ErrorCopyingDataBase"); 
          } 
         } 
        } 
   
       private boolean checkDataBase() { 
        SQLiteDatabase mCheckDataBase = null; 
        try { 
         String mPath = DB_PATH + DB_NAME; 
         File pathFile = new File(mPath); 
         if(pathFile.exists()) { 
          mCheckDataBase = SQLiteDatabase.openDatabase(mPath, null, SQLiteDatabase.NO_LOCALIZED_COLLATORS); 
         } 
        } catch (SQLiteException mSQLiteException) { 
         Log.e(TAG, "DatabaseNotFound " + mSQLiteException.toString()); 
        } 
   
        if (mCheckDataBase != null) { 
         mCheckDataBase.close(); 
        } 
        return mCheckDataBase != null; 
       } 
   
       private void copyDataBase() throws IOException { 
        final InputStream mInput = mContext.getAssets().open(DB_NAME); 
        final String outFileName = DB_PATH + DB_NAME; 
        OutputStream mOutput = new FileOutputStream(outFileName); 
        byte[] mBuffer = new byte[1024]; 
        int mLength; 
        while ((mLength = mInput.read(mBuffer)) > 0) { 
         mOutput.write(mBuffer, 0, mLength); 
        } 
        mOutput.flush(); 
        mOutput.close(); 
        mInput.close(); 
       } 
   
       public boolean openDataBase() throws SQLException { 
        final String mPath = DB_PATH + DB_NAME; 
        mDataBase = SQLiteDatabase.openDatabase(mPath, null, 
        SQLiteDatabase.NO_LOCALIZED_COLLATORS); 
        return mDataBase != null; 
       } 
   
       @Override 
       public synchronized void close() { 
        if (mDataBase != null) 
         mDataBase.close(); 
        super.close(); 
       } 
   
       @Override 
       public void onCreate(SQLiteDatabase db) {} 
   
       @Override 
       public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {} 
   } 
   

2. DBAdapter

   public class DBAdapter { 
   
       private static final String TAG = DBAdapter.class.getSimpleName(); 
       private final Context mContext; 
       private SQLiteDatabase mDb; 
       private final DataBaseHelper mDbHelper; 
   
       public DBAdapter(Context context) { 
        this.mContext = context; 
        mDbHelper = new DataBaseHelper(mContext); 
       } 
   
       public DBAdapter createDatabase() throws SQLException { 
        try { 
         mDbHelper.createDataBase(); 
        } catch (IOException mIOException) { 
         throw new Error("UnableToCreateDatabase"); 
        } 
        return this; 
       } 
   
       public DBAdapter open() throws SQLException { 
        try { 
         mDbHelper.openDataBase(); 
         mDbHelper.close(); 
         mDb = mDbHelper.getReadableDatabase(); 
        } catch (SQLException mSQLException) { 
         Log.e(TAG, mSQLException.toString()); 
         throw mSQLException; 
        } 
        return this; 
       } 
   
       public void close() { 
        mDbHelper.close(); 
       } 
   } 
   

3. Abhan विस्तारित आवेदन कक्षा

   public class Abhan extends Application { 
   
       public static final String TAG = Abhan.class.getSimpleName(); 
       public static final boolean DEBUG = true; 
       private int androidVersion = 4; 
       private DBAdapter dbAdapter = null; 
   
       @Override 
       public void onCreate() { 
        super.onCreate(); 
        setAndroidVersion(android.os.Build.VERSION.SDK_INT); 
   
        if(dbAdapter == null) { 
         dbAdapter = new DBAdapter(getBaseContext()); 
         dbAdapter.createDatabase(); 
        } 
       } 
   
       public int getAndroidVersion() { 
        return androidVersion; 
       } 
   
       public void setAndroidVersion(int androidVersion) { 
        this.androidVersion = androidVersion; 
       } 
   
       public DBAdapter getDBInstatnce() { 
        dbAdapter.open(); 
        return dbAdapter; 
       } 
   
       public void closeDataBase() { 
        dbAdapter.close(); 
        if(DEBUG) { 
         android.util.Log.d(TAG, "DataBase closed."); 
        } 
       } 
   } 
   

4. अपने AndroidManifest में, Abhan

   <application 
       android:name=".Abhan" 
       android:allowBackup="false" 
       android:icon="@drawable/ic_launcher" 
       android:label="@string/app_name" 
       android:theme="@style/AppTheme" > 
   

5. घोषित आपका Activity में, आपका डेटाबेस का उपयोग का उपयोग कर Application कक्षा

   private Abhan abhan; 
   

में onCreate

abhan = (Abhan) this.getApplication(); 

अब आप अपने तक पहुँचने इस तरह डेटाबेस लेनदेन विधि।

int currentDay = abhan.getDBInstatnce().getCurrentDay(); 

यहाँ, abhan.getDBInstatnce() अपने Database उदाहरण है, जिसमें अपने पूरे आवेदन भर में एक उदाहरण है और getCurrentDay() मेरी विधि, DBAdpater में घोषित जो मुझे एक वर्तमान दिन रिटर्न है देता है।

मुझे आशा है कि यह आपकी समस्या का समाधान कर सकता है। धन्यवाद।

Answer 2

जब मैं प्रीफ़िल्ल्ड डीबी का उपयोग कर रहा था तो मुझे इसी तरह का मुद्दा सामना करना पड़ा। मैंने बस इस तरह हल किया।

समस्या SQLite डेटाबेस में थी, मुझे लगता है कि यह sqlite3 पुराने संस्करणों में शायद एक बग था, शायद 3.6 से पहले। मैंने जो किया था, मैंने sqlite3 v3.7.11 के साथ डेटाबेस को फिर से बनाया और यह एक आकर्षण की तरह काम करता है - और, android_metadata table

यह मेरे लिए काम करता है, मुझे आशा है कि इससे आपकी मदद मिलेगी।