iConcept : Dropbox Alternatives and Competitors: Dropbox vs Other Online File Sharing and Storage Tools

Dropbox Alternatives and Competitors: Dropbox vs Other Online File Sharing and Storage Tools

Dropbox is a big name in the online file sharing and storage market. But there are a lot of alternatives and competitors of dropbox present in the online file sharing and storage market.
As there are some security and safety concerns with dropbox, people are searching for alternatives to dropbox to store their data online. A lot of competitors of dropbox are there in software market. We will have a detailed discussion on various alternatives to dropbox and competitors of dropbox. We will mainly focus on the features of Microsoft Live Mesh, Spider Oak, SugarSync, Wuala, Amazon Cloud Drive, Box, Syncplicity, Cubby, Huddle,  Egnyte, ShareFile, TeamDrive, Cloudme, CX etc. These are giving very tough competition to dropbox in syncing data with various devices or networks, online storage space, security and safety settings, encrypted data backup and recovery, media streaming etc.
Here goes the list of Alternatives to Dropbox: Dropbox Competitors
1. Microsoft Live Mesh: Microsoft’s file syncing tool works really well in the background. You can use Live Mesh just for local syncing and/or 5GB of SkyDrive’s online storage space (out of SkyDrive’s 25GB max). As you might expect, Live Mesh has some unique benefits for Windows users: you can remote control your Live Sync connected Windows computer (similar to Remote Desktop Connection) and sync Microsoft Office and Internet Explorer program settings. SkyDrive is also where Office Web Apps online documents are stored, so you get that integration as well.
Storage: Up to 25 GB Free, per SkyDrive Account
Desktop Support: Windows Vista SP2 or later, Mac OSX 10.5 or later
Browser Support: IE 7 or later preferred
Mobile Clients: None
2. SpiderOak: Besides its really strong “zero knowledge” security features, SpiderOak is very versatile: it can sync not only your desktop or mobile device but your external drive or network volume as well—so you can use it to keep your desktop, laptop, and USB thumb drive in sync, for example. SpiderOak offers a lot of information about your backups, uploads, and syncs, so you always feel in control of your data. Refer a friend and you get an additional 1GB more free space (up to 50GB max for the free referral space).
Storage: 2 GB Free, with Personal and Enterprise Plans Available
Desktop Support: PCs with Windows XP or greater, Mac 10.5 or later, and the more popular Linux distributions
Browser Support: Most modern Web browsers
Mobile Clients: iPhone and iPad with iOS 4, Android 2 or later, Blackberry 4 or later
3. SugarSync: SugarSync does what Dropbox does, but lacks the LAN sync and strong API support. It makes up for that in more features for media streaming, mobile syncing (including auto syncing photos and folders from Android devices), and folders selection and permissions/passwords settings. SugarSync’s web interface has a bit more functionality than Dropbox, with its separation of photos from files and also a very useful direct editing feature where you can edit files from within the webapp. You get a generous 5GB free to start with and can earn 500MB more space for each referral.
Storage: 5 GB Free, with Personal and Enterprise Plans Available
Desktop Support: PCs with Windows XP or later and Mac Desktops 10.4 or later
Browser Support: IE, Firefox 3 or later, Safari 4 or later, Chrome
Mobile Clients: iOS 4, Android 2 or later, Blackberry OS 4 or later, Windows Phone 7, and Symbian
4. Wuala: From Swiss storage manufacturer LaCie, Wuala, like SpiderOak, offers locally encrypted data backup and syncing. Although the 1GB of free storage space is on the low end to start with, Wuala has a unique way to earn additional storage: you can buy more space or exchange unused storage on your computer (e.g., empty space on an external drive) for more storage on Wuala.
5. Amazon Cloud Drive: Amazon’s drive offering is particularly attractive if you’re looking for a way to store your music library. They recently added Safari support, so if you’re on an iPhone or iPad you can now use the service. If you’re already set up with a Cloud Drive account, and have some music in it, just point Safari to the Cloud Player sign in page and you’ll see the desktop interface on your iOS device. Sign into your account and you’ll see the desktop interface on your iOS device.
On the downside, there’s no sync service or automated way to add your non-music files. It’s all manual upload and download. This is a fair place to hold your music library, but not useful for much else, given the options available today. Also, being forced to manually upload files via a Web browser gives the product a rushed and unfinished feel. However, it’s hard to complain about a free place to store your music. If you’re looking for a good place to store and stream your music library and can use some rudimentary non-music file storage as well, then Amazon Cloud Drive may work for you.
Storage: 5 GB Free, or 20 GB free with purchase of an album from the Amazon MP3 store
Desktop Support: Any OS that supports Flash
Browser Support: Any browser with Flash 9 or 10, newest browser versions preferred but not required
Mobile Clients: Android 2 or later, and browser support for Apple devices with iOS 4
6. Box: Box.net offers 5 GB of free cloud storage with a 25-MB file size limit. Storage is accessible by only one user, and access to your data via mobile app also is free. Box.net provides paid options for 25 GB and 50 GB at $10 and $20 per month, respectively, with 1-GB file size limits each.
Box.net offers up to 500 GB of shared storage, the most among the products within this roundup, with a collaborative toolset and workspace for up to three users for $15 per user, per month. Enterprise customers with needs beyond three users are encouraged to call Box.net for pricing. The features and functionality offered here are best suited to enterprise customers. Box.net’s complete set of collaborative tools, larger shared storage allotments, and associated costs are geared toward businesses with distributed work teams.
Storage: 5 GB Free
Desktop Support: Windows Vista SP2 or later, Mac OSX 10.5 or later
Browser Support: Mobile browser–Web Kit compatible
Mobile Clients: iOS 4.0 or later, Android 2.0 or later
7. Syncplicity: Syncplicity offers the same sync and share features of Dropbox with a decided enterprise slant. For example, admins can control which devices can access cloud storage inside or outside the company. Data retention policies can help admins find and remove documents that violate company data protection policies.
In a nod to the existing data protection measures in a large enterprise that allows an admin to wipe the data on connected laptop, Syncplicity also provides a way to wipe a user account for computers and mobile devices. The service uses audited security encryption technologies such as SOC 1 and standards such as the Department of Defense’s DoD 5220.22. Finally, the admin console is more robust than some; accounts can be pre-configured for access to specific files and folders for employee groups.
8. Cubby: The name might not make you think of an industrial strength cloud service, but Cubby-from the same company that makes the LogMeIn remote access tool-is a sure step above Dropbox. All user files are protected using SSL encryption; each user gets a separate encryption key. (In a few weeks, Cubby will release a beta for an optional high-security mode that will store encryption keys off-line so that only the user has access to the key.) During a data transfer between users, encryption keys form a tight bond between the two endpoints.
One interesting differentiator for Cubby is that information is stored in a data center owned and operated by LogMeIn, not Amazon or another third party. Like LogMeIn itself, Cubby works on the desktop and through a mobile app in addition to working through any browser.
9. Huddle: Huddle is more than just a place to keep files. The new service, designed for the enterprise, is more like a collaborative environment. This is also one of the strengths of the service in terms of security; repositories are organized according to workgroups and for those inside and outside the company.
Because the service is not designed to be a cloud storage service, the system tracks all documents and transfers. Admins can look up the rights to any document, check who has ownership and see how the document has been distributed in the organization. They can even see a history of comments on documents. Like LogMeIn, Huddle uses a company-owned data center that is ISO 27001 certified. The company conducts regular penetration testing and use enterprise-class firewalls.
10. Egnyte: Like most of the cloud storage systems listed here, Egnyte includes the usual admin console and file encryption options, but several unique feature make this cloud storage portal worth considering. Admins can assign permissions on a more granular level-down to sub-folders within sub-folders.
While other storage tools provide desktop and mobile apps, Egnyte also provides a way to create a mapped network drive or access from FTP. There’s also a way to generate an audit report showing permission and encryption levels. An enterprise version provides up to 3TB of storage and an unlimited number of users, while a unique “server sync” feature creates a sync between a server and the cloud.
11. ShareFile: Another smart alternative to Dropbox, ShareFile (now owned by Citrix) is a stark departure from consumer-level features. IT admins can use a unique “poison pill” option that sets an expiration point for any file. They can also perform a remote data wipe for any computer or mobile device.
12. TeamDrive: TeamDrive is a more secure version of online file sharing services and it uses AES-256 algorithm for encryption plus the public key feature makes it totally reliable and one of the best Dropbox alternative. It is ideal for Private users, small companies, corporations and supports all the platforms like  iOS, Linux and Windows. You also get a a free storage advantage over Dropbox with it’s 10 GB free online storage space. In addition you can also choose between hosted services, your own server or pre-installed TeamDrive cloud.
13. Cloudme: The feature that distinguishes this DropBox alternative from other listed so far is the creative Web Desktop, that allows you to have your own Desktop in the Cloud. You can then customize and increase productivity of your own Web OS by installing apps and create a working environment. This also enables you to to directly listen to your own music, look at images and edit photos. The Cloudme.com supports all the platforms including iOS and Android which means you can also directly Back-up and share information from you smartphones and mobile devices. The email support, MSN, ICQ, Google Talk, Yahoo and AIM integration makes this best Dropbox alternatives which is further accentuated with its free 3GB stirage space.
14. CX: A more social and interactive way to share files using cloud service, the Cx.com provides a free 10GB storage and a neat interface. You can Sync your files to just about every platform including  iOS,Mac, Windows, Kindle and Android but that’s not what differentiates it from the rest of DropBox alternatives. The ability to comment on shared files, add friends, create groups, and then share your files publicly or privately is what makes this one of the best DropBox Alternatives.
Reference : Here
Thanks :), Keep Coding:)
Advertisements

iAndroid: Using SQLite on Android Application

iAndroid: Using SQLite on Android Application
Reference Source : Here
With a little care, SQLite can be used as a data store or full database on Android devices
As with most platforms, Android gives us a few options to store data so that it persists even after we’ve terminated the application. Of the various ways we can do this, text files — either stored in the application’s own files directory or to the phone’s SD card — represent one approach. Preferences are also frequently used to store data because they can be both hidden from the user and persist as long as the application is installed. And while not strictly speaking in the same category, Assets can be useful for storing read-only data, too. Assets are essentially files that you bundle into the application package prior to compilation in the project assets folder, which can be accessed at runtime. I will take a closer look at these later.Sometimes, however, we need to be able to carry out complex operations on persistent data, or the volume of data requires a more efficient method of management than a flat text file or preference entry will allow. This is where a mobile database comes in.

Android comes with SQLite (version 3.5.9+), which has been available on the platform since release 1.5 of the OS (the “Cupcake” release). For readers unfamiliar with SQLite, it is a self-contained, server-less, transactional SQL database. While it has its limitations, SQLite serves as a powerful tool in the Android developer’s arsenal.

What I’ll principally cover here is one way to use a SQLite database in Android, concentrating on its management; specifically, creation and update, rather than all the runtime operations.

Managing SQLite

To begin with, we can manage SQLite using a class that extends SQLiteOpenHelper, which comes with a constructor and two required methods; onCreate and onUpgrade.

Naturally, the first of these is executed when the constructor is instantiated; it is here that, via the superclass, we provide four important pieces of data:

  • Context. This is the context of the application. It can be useful to set this in the constructor and store it locally for later use in other methods.
  • Database name. This is the filename (as a String) of the physical database file being accessed.
  • Cursor factory. The cursor factory in use, if any.
  • Database Version. This is the version of your database (as an integer), which I’ll discuss in more detail later. Your initial version should be 1.

For our example, we put these four pieces together and get the following:

1
2
3
4
5
6
7
8
9
10
11
class DB extends SQLiteOpenHelper {
    final static int DB_VERSION = 1;
final static String DB_NAME = "mydb.s3db";
    Context context;
    
    public DB(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
        // Store the context for later use
        this.context = context;
    }

The constructor does two things. First, it checks whether the database exists and, if not, will call the onCreate method. Second, if the database does exist, it will check whether the existing database version number differs from the one implemented in the constructor, so as to determine if the database has been updated. If it has, the onUpgrade method will be called.

Additionally, as we now know that the onCreate method is called only when the database does not exist, it can be used as a handy way to determine if you’re dealing with a first run of the application following installation. As such, you can use this method to call any other methods that you need executed only on the first run, such as EULA dialogs.

Let’s look at the database itself. For the purposes of this article, I’m just going to use a very simple employee database with a SQL creation script as follows:

1
2
3
4
5
6
7
CREATE TABLE employees (
 _id INTEGER PRIMARY KEY AUTOINCREMENT,
 name TEXT NOT NULL,
 ext TEXT NOT NULL,
 mob TEXT NOT NULL,
 age INTEGER NOT NULL DEFAULT '0'
);

We can easily construct this by hard-coding and executing the creation SQL, line by line, in our code as follows:

1
2
3
4
5
6
@Override
public void onCreate(SQLiteDatabase database) {
    database.execSQL(
        "CREATE TABLE employees ( _id INTEGER PRIMARY KEY "
    + "AUTOINCREMENT, name TEXT NOT NULL, ext TEXT NOT NULL, "
    + "mob TEXT NOT NULL, age INTEGER NOT NULL DEFAULT '0')");
}

As you can see, this can get quite unwieldy once the database reaches a certain size and complexity, so the ideal solution would be to bundle a SQL creation script as an asset file. To use this approach, you need to write a method that takes in a SQL script from the assets directory and parses it, executing it line by line:

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
@Override
public void onCreate(SQLiteDatabase database) {
executeSQLScript(database, "create.sql");
}
private void executeSQLScript(SQLiteDatabase database, 
                              String dbname) {
ByteArrayOutputStream outputStream = new  
                              ByteArrayOutputStream();
    byte buf[] = new byte[1024];
    int len;
        AssetManager assetManager = context.getAssets();
    InputStream inputStream = null;
        
    try{
        inputStream = assetManager.open(dbname);
        while ((len = inputStream.read(buf)) != -1) {
            outputStream.write(buf, 0, len);
        }
        outputStream.close();
        inputStream.close();
            
        String[] createScript = 
                   outputStream.toString().split(";");
        for (int i = 0; i < createScript.length; i++) {
                String sqlStatement = createScript[i].trim();
            // TODO You may want to parse out comments here
            if (sqlStatement.length() > 0) {
                    database.execSQL(sqlStatement + ";");
                }
        }
    } catch (IOException e){
        // TODO Handle Script Failed to Load
    } catch (SQLException e) {
        // TODO Handle Script Failed to Execute
    }
}

While this is a more complex approach than simply executing each SQL statement for very simple databases, it quickly pays dividends once the database becomes more complex or you need to pre-populate it. You’ll also see that I abstracted the creation into a separate method called executeSQLScript so that it can be reused in other situations.

Interacting with the Database

Now that the database is created, I want to be able to interact with it. Here’s a brief rundown:

The first step is to open the database and there are two ways to do this: usinggetReadableDatabase() and getWritableDatabase(). The former is faster and uses fewer resources. It should be used for anything that does not require writing or changing the database. The latter call is better suited to INSERTs, UPDATEs, and the like.

In Android, recordsets are returned from queries as Cursor objects. To carry out a query, use either the query() or rawQuery() method. For example, the following two calls return exactly the same data:

1
2
3
4
DB db = new DB(this);
SQLiteDatabase qdb = db.getReadableDatabase();
Cursor recordset1 = 
     qdb.query("mytable", null, null, null, null, null, null);
Cursor recordset2 = qdb.rawQuery("SELECT * FROM mytable", null);

The first call uses a bewildering number of parameters. They are the table name, a string array of the column names, the WHERE clause, the selection arguments, the GROUP BY clause, the HAVING clause, and the ORDER BY clause, respectively. You’ll note that setting many of these as null has the effect of their being treated as wildcards or omitted altogether.

Most of these parameters are fairly straightforward to anyone familiar with SQL. The selection arguments, however, require a little more explanation because they form a string array that interacts with the WHERE parameter, systematically replacing any “?” characters in the clause with a value from the array.

With the rawQuery() approach, there are only two parameters: the first is the SQL query, and the second is the selection argument — akin to those used in the query method. Selection arguments may be preferable to use with complex queries, such as those that use JOINs.

Similarly, INSERTUPDATEDELETE, and a range of other common operations are handled with methods similar to query(); or, as with rawQuery(), they can be executed as raw SQL code using execSQL().

Database Upgrades

Returning to management of the database, let’s look at the tricky scenario of database upgrades. Over time, an app will likely change. New functionality may be added, or it may be better optimized. These changes, in turn, may lead to a requirement to upgrade the database schema and change the value for DB_VERSION in the updated application code to reflect this.

One potential problem is that replacing our database with a new version will end up invalidating the previous version and lead to the loss of data that was present in existing user installations. A second problem is that, once our application has reached a point whereby more than two versions have been released, we cannot presume that the user has been diligently upgrading all along, so a simple upgrade from one version to the next may no longer work.

To deal with this, we already know that if we introduce a new database version, theonUpgrade() method will be called. So ideally, we can use our SQL script parser method and execute one or more update scripts.

Let’s look at what we intend to change in Version 2 of our database in the example:

  • Normalize the phone number data (extension, mobile) into a separate “numbers” table, which includes a numeric field to denote the type of phone number.
  • Add a salary field to the employee table.

Using the Version 1 schema as a starting point, this can be handled by writing a SQL script that updates the schema and then populates it with the data from the older version:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CREATE TABLE numbers (
   _id INTEGER PRIMARY KEY AUTOINCREMENT,
   employid INTEGER NOT NULL,
   number TEXT NOT NULL,
   ntype INTEGER NOT NULL DEFAULT '0'
);
CREATE INDEX employid ON numbers(employid);
INSERT INTO numbers (employid, number, ntype) SELECT _id, ext, 0
    FROM employees;
INSERT INTO numbers (employid, number, ntype) SELECT _id, mob, 1
    FROM employees;
CREATE TABLE temp (
     _id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT NOT NULL,
     salary INTEGER NOT NULL DEFAULT '0'
);
INSERT INTO temp (_id, name) SELECT _id, name FROM employees;
DROP TABLE employees;
ALTER TABLE temp RENAME TO employees;

Naturally, the more complex the changes in your database schema, the more complex the script you’ll need to write to handle this. SQLite has more limited support for SQL than many databases, so sometimes you’ll need to devise workarounds for these limitations. For example, in the aforementioned update script, I had to employ a temporary table as a workaround for the lack of DROP COLUMN functionality.

Now that I have the SQL upgrade script, I need to handle how it is executed when theonUpgrade method is called. One approach is to do the following:

1
2
3
4
5
6
7
8
9
10
11
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {     
if (newVersion > oldVersion) {
    switch (oldVersion) {
        case 1:
            executeSQLScript(database, "update_v2.sql");
        case 2:
            executeSQLScript(database, "update_v3.sql");
    }
}
}

There are two things to note in this code. The first is that I check to see whether the new database version is greater than the old one. I wrote the code this way because theonUpgrade() method will be called any time these two versions are different, leading to a situation in which version downgrades are also possible. Our code does not envisage this ever occurring, but an else clause and accompanying code could be added to handle this.

The second thing is that there are no break statements between the cases in our switch. This is because each script simply updates from one version to the next, meaning that an upgrade from Version 1 to 3 will first run the upgrade script from Version 1 to 2, then continue on to run the upgrade script from Version 2 to 3. If the database is already at Version 2, it will simply skip the first script and only run the upgrade script from Version 2 to 3.

Thus, each time you upgrade the database, you will only need to replace the create script with one that reflects the new schema (for new installs), and an update script (that handles only an update from the previous version) to handle all possible upgrades. Meanwhile, in our Java code, we need to update the value for DB_VERSION and, naturally, any operations that may be affected by the new database schema.

Conclusion

SQLite can be a very useful means to store and manage data in a persistent manner on Android devices. However, as with any database, care needs to be taken to administer it correctly, particularly with regard to version changes.

Using the script parser solution and saving this part of the application logic as a series of SQL scripts is an efficient and simple management technique to avoid having to write complex methods to the core application to handle each upgrade, thus allowing you to concentrate on the application’s business logic instead.

Thanks 🙂 Keep Coding 🙂

SolutionPointLogo