I recently blogged about making a scopes in 5 minutes using youtube. I have seen also a fair amount of new scopes being created using RSS. By far, my favourite way to use scopecreator is Twitter.

If you want to check a few examples, I have published previously twitter-based scopes like breaking news, la liga and a few others. Today, I give you Formula One:

The interesting thing about twitter is that many brands upload minute by minute new updates, which make a really good source for scopes.

To create a Formula One scope,I started by going to twitter and creating a list under my scope account (you can use your personal account). The list contains several relevant “official” Formula One accounts.  Using Twitter, I can then update the sources by adding and removing accounts from the list without the user needing to download an update for the scope.

Again, it took me about 5 min to get a working version of the scope.  Here is what needed to do:

• First, we followed Chris’ instructions to install the scope creator tool.
• Once we had it set up on my laptop, I run:
  scopecreator create twitter vtuson f1
cd f1
• Next, I configured the scope. The configuration is done in a json file called manifest.json. This file describes the content of what you will publish later to the store. You need to care about: “title”, “description”, “version” and “mantainer”. The rest are values populated by the tool:
  scopecreator edit config
{
"description": "Formula One scope",
"framework": "ubuntu-sdk-14.10",
"architecture": "armhf",
"hooks": {
"f1": {
"scope": "f1",
"apparmor": "scope-security.json"
}
},
"icon": "icon",
"maintainer": "Your Name <yourname@packagedomain>",
"name": "f1.vtuson",
"title": "Formula One",
"version": "0.2"
}

• The following step was to set up the branding: Easy! Branding is define on an .ini file. “Display name” will be the name listed on the “manage” window once installed, and also will be the title of your scope if you don’t use a “PageHeader.Logo”. the [Appearance] section describes the colours and logos to use when banding a scope.
  scopecreator edit branding
[ScopeConfig]
ScopeRunner=./f1.vtuson_f1 --runtime %R --scope %S
DisplayName=Formula One
Description=This is an Ubuntu search plugin that enables information from Yelp $
Author=Canonical Ltd.
Art=
Icon=images/icon.png
SearchHint=Search
[Appearance]
PageHeader.Background=color:///#D51318
PageHeader.ForegroundColor=#FFFFFF
PreviewButtonColor=#D51318
• The final part is to define the departments (drop down menu) for the scope. This is also a json file and it is unique the twitter scope template. You can either use “list” or “account” (or both) as departments.  The id is the twitter handle for the list or the account. For lists you will need to specify in the configuration section what account holds the list. As I defined a single entry, the formula one scope will have no drop down menu.
  scopecreator edit channels
  {
  “departments”: [
  {
  “name”:”Formula One”,
  “type”:”list”,
  “id”:”f1″
  }
  ],
  “configuration”: {
  “list-account”:”canonical_scope”,
  “openontwitter”:”See in Twitter”,
  “openlink”:”Open”,
  “retweet”:”Retweet”,
  “favorite”: “Favourite”,
  “reply”:”Reply”
  }
  }

After this, the only thing left to do is replace the placeholder icon, with a relevant logo:
~/f1/f1/images/logo.png
And build, check and publish the scope:
scopecreator build

This last command generates the click file that you need to upload to the store. If you have a device (for example a Nexus4 or an emulator ), it can also install it so you can test it. If you get any issues getting the scope to run, you might want to check your json files on http://jsonlint.com/. It is a great web tool that will help you make sure your json doc is ship shaped!

It is super simple to create a scope for a twitter list! so what are you going to create next?

Hi,

I found myself trying to build a QML Ubuntu Touch app project that includes a qml c++ extension and I found that I some how stumble a bit along the way. So, here are some of my notes on how I got it done. Hope that helps.

Creating the project.

Using QtCreator, create a new project and select – QML Extension Library + Tabbed Touch.  I found that it was easier to change the QML side of things than start with an extension and then add the whole project structure.

Build and Run your project locally

In QtCreator click on projects.  In Build, I set up the build path as my project root path. In run,  the executable is “/usr/bin/qmlscene” (make sure there is no spaces trailing) and then Arguments is set to “-I  ../backend/modules $@ yourapp.qml”, with a working directory of “projectroot/app”

Now if you try to run your project it should build it locally and run your app. After that you are on a roll.

Build on target device

Click Ctrl+f11 should install the platform developer tools in your device. However, I how found that this lately does not work.

Instead from the terminal:

first we will need to make the image in your device writeable:
adb shell touch /userdata/.writable_image  --> and reboot the phone.
then:
cd /usr/share/qtcreator/ubuntu/scripts
adb devices
./device_developertools_install <device_id>

Now you are ready to build, so back to QtCreator:

Build>Ubuntu>Build Application on Device

This should build the application with only some test problems, but the main binaries would be created. To package your app you will need to get

/home/phablet/dev_tmp/<yourapp>/backend/modules/lib<yourlib>.so

Creating a click package

create a manifest standard manifest file. Manifest.json

{
"description": "your text",
"framework": "ubuntu-sdk-13.10",
"hooks": {
"yourappname": {
"apparmor": "yourappname.json",
"desktop": "yourappname.desktop"
}
},
"maintainer": "your name<yourname@yourmail.com>",
"name": "com.ubuntu.developer.yourname.yourappname",
"title": "yourappname",
"version": "0.1",
"architecture": "armhf"
}


You will also need a yourapp.desktop file:

[Desktop Entry]
Name=yourappname
Comment=description
Exec=qmlscene -I plugin $@ yourapp.qml
Icon=icon.png
Terminal=false
Type=Application
X-Ubuntu-Touch=true

Note that Exec= has a -I plugin part to it. This is very important, will see later.

Now yourapp.json file that contains your confinement profile:

{
"policy_groups": [
"networking"
],
"policy_version": 1
}

Now time to setup a folder with all this stuff, not that the plugin folder is going to contain your lib which your are importing with -I option on the desktop file:
myproject>
-./click/
--icon.png
--manifest.json
--yourapp.json
--yourapp.desktop
--./plugin/
---./yourlib/
----lib(yourlibname).so
----qmldir

Now you are ready to build from your project root folder:
click build ./click

This should create a .click file in your project folder.

Installing in your device

adb pull your.click /home/phablet/
adb shell
su phablet
cd ~
pkcon -p install-local your.click

This should be enough, but sometimes I find that you need to restart unity:
pkill unity8 (you might need sudo)

It has been over 2 months since the Ubuntu Edge campaign concluded, and I haven’t really blogged about it.  I must say, driving something like this was great fun but also a fully immersive 24-7 experience. For that reason, I wanted some time to pass before write some conclusions about it.

One of the things that made the Ubuntu Edge campaign to stand out from previous crowd funding projects was the target: $32 Million. Other successful projects (I will focus only on products) had much lower targets (~$100K). So, why was this the case?

If your company has already raised capital via “standard” funding routes or you are actively pursuing it, a successful crowd funding campaign will reduce the overall amount of equity you have to give away. It can also attract that elusive VC investment.  In this situation, your objectives are:

• Proof the product viability 
• Remove doubts from future investors minds
• ensure your campaign and your product are perceived as a successes

An early achievement of your campaign target will tick all these boxes. A “sold out” effect in the first week will increase the confidence of future pledgers and investors. In that case, a campaign target of $100K can be the magic number for you. 

In the other hand, if crowd funding is your only or main avenue to finance your product, your objectives will be slightly different. These were ours:

• Proof the product viability
• Finance product design and factory tooling
• Finance a fix/minimum production run
• Market validation

An early achievement of your target is still desirable, but your main worry will be to raise enough money via the campaign to deliver on your promises to the pledgers.

Although we raised over $12 Million, we did not reach our intended target. The Ubuntu Edge was a unique proposition that was build on the premise of delivering the latest cutting edge technology.  Unfortunately, this meant that we could not pursue what I think is a better approach for 100% crowd funded products: a multi-campaign project.

In a crowd funding campaign, people contribute for different reasons:

• The Angels: Angels are interested in supporting new innovation. They might not even necessarily want to own your product, but they appreciate the disruption you are trying to bring to the market.  For these reason, they are willing to contributed from a little as $1 to thousands of dollars to see your project succeed.
• The Extended Team: These are passionate individuals that understand your product concept and they want one! Not only they are willing to part with some money to get one, but they are also willing to contribute their own time and energy to make your product successful. They are a great source of professional and amateur resources. The contributions we got for Ubuntu Edge ranged from advise on how to run the campaign by serious knowledge people, to PR (T-shirt designs, websites, ads) to product design.
• The Pragmatists:  Your product might look good, but your project might just be too risky. Crowd funding projects are developing a bit of a reputation for shipping late or even worst, never happening.  Pragmatist might be put off from contributing to your project is the perceived risk is too high.  Some key questions they would like answer to are: Who are you? What is your proven record? Do you have a proto-type working?  Do you have suppliers ready to go? but they all ultimately boil down to one: Can I trust you?
• The Shoppers: Although, it should be clear to everyone that crowd funding is not the same that shopping in Amazon, similar motivations may apply.  Shoppers will compare backing your project with buying a similar product online. Things they will care about: Are you offering a good deal? How long will it take for me get the product? What warranties do you offer?.

Pragmatists and shoppers form the bulk of the backer community out in the wild. If you are just getting started with your product development, you might find that addressing the concerns of pragmatists and shoppers is just not possible. In that case, financing your product development via multiple crowd funding projects might be a better option.

Target your first project to attract angels and extended-team. Set a campaign target that will allow you to build a prototype and start seriously talking to suppliers. Build up your credibility by delivering the first project on time.

For your second project, you will have had reduced the risk and the time to product delivery substantially. You might now be able to raise the rest of the funding or your might need a couple more iterations. Here is how the people at +Pool are doing it:

1. First project
2. second project