src/FShell_AppWidgetProviderInfoImpl.cpp

   1 //
   2 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file        FShell_AppWidgetProviderInfoImpl.cpp
  19  * @brief       This is the implementation for the _AppWidgetProviderInfoImpl class.
  20  */
  21
  22 #include <unique_ptr.h>
  23 #include <livebox-service/livebox-service.h>
  24 #include <FBase.h>
  25 #include <FBaseSysLog.h>
  26 #include <FBase_StringConverter.h>
  27 #include <FApp_AppInfo.h>
  28 #include <FAppPkg_PackageManagerImpl.h>
  29 #include <FAppPkg_PackageInfoImpl.h>
  30 #include <FShellAppWidgetProviderInfo.h>
  31 #include <FShellAppWidgetSizeInfo.h>
  32 #include "FShell_AppWidgetManagerImpl.h"
  33 #include "FShell_AppWidgetProviderInfoImpl.h"
  34 #include "FShell_AppWidgetSizeInfoImpl.h"
  35
  36 namespace Tizen { namespace Shell {
  37
  38 using namespace Tizen::App;
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Base::Collection;
  41 using namespace Tizen::Graphics;
  42
  43
  44 _AppWidgetProviderInfoImpl::_AppWidgetProviderInfoImpl(const Tizen::App::AppId& appId, const Tizen::Base::String& name)
  45         :__appId(appId)
  46         ,__name(name)
  47         ,__isDefault(false)
  48 {
  49         __providerId = _AppWidgetManagerImpl::MakeProviderName(appId, name);
  50
  51         std::unique_ptr<char[]> pProviderId(_StringConverter::CopyToCharArrayN(__providerId));
  52         __displayName = livebox_service_i18n_name(pProviderId.get(), null);
  53         __configurationAppControlAppId = livebox_service_setup_appid(pProviderId.get());
  54
  55         SysSecureLog(NID_SHELL, "appId(%ls), name(%ls), providerId(%ls), displayName(%ls), configuration(%ls)", appId.GetPointer(), name.GetPointer(), __providerId.GetPointer(), __displayName.GetPointer(), __configurationAppControlAppId.GetPointer() );
  56 }
  57
  58 /*_AppWidgetProviderInfoImpl::_AppWidgetProviderInfoImpl(const _AppWidgetProviderInfoImpl& rhs)
  59 {
  60         __appId = rhs.__appId;
  61         __name = rhs.__name;
  62         __providerId = rhs.__providerId;
  63 }
  64
  65 _AppWidgetProviderInfoImpl&
  66 _AppWidgetProviderInfoImpl::operator =(const _AppWidgetProviderInfoImpl& rhs)
  67 {
  68         __appId = rhs.__appId;
  69         __name = rhs.__name;
  70         __providerId = rhs.__providerId;
  71
  72         return *this;
  73 }*/
  74
  75 _AppWidgetProviderInfoImpl::~_AppWidgetProviderInfoImpl()
  76 {
  77 }
  78
  79 Tizen::App::AppId
  80 _AppWidgetProviderInfoImpl::GetAppId() const
  81 {
  82         return __appId;
  83 }
  84
  85 Tizen::Base::String
  86 _AppWidgetProviderInfoImpl::GetName() const
  87 {
  88         return __name;
  89 }
  90
  91 Tizen::Base::String
  92 _AppWidgetProviderInfoImpl::GetDisplayName() const
  93 {
  94 /*      std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(__providerId));
  95         __displayName = livebox_service_i18n_name(pPackageId.get(), null);*/
  96         return __displayName;
  97 }
  98
  99 Tizen::Base::String
 100 _AppWidgetProviderInfoImpl::GetIconPath() const
 101 {
 102         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(__providerId));
 103         String iconPath = livebox_service_i18n_icon(pPackageId.get(), null);
 104
 105         return iconPath;
 106 }
 107
 108 Tizen::Base::String
 109 _AppWidgetProviderInfoImpl::GetConfigurationAppControlAppId() const
 110 {
 111         return __configurationAppControlAppId;
 112 }
 113
 114 bool
 115 _AppWidgetProviderInfoImpl::IsDefault() const
 116 {
 117         return __isDefault;
 118 }
 119
 120 int
 121 _AppWidgetProviderInfoImpl::GetPrivilegeLevel(const AppId& appId)
 122 {
 123
 124         Package::_PackageManagerImpl* pPkg = Package::_PackageManagerImpl::GetInstance();
 125         SysTryReturn(NID_APP, pPkg != null, _API_VISIBILITY_PUBLIC, E_INVALID_STATE, "Invalid PackageManager instance.");
 126
 127         String pkgId = Package::_PackageManagerImpl::GetPackageIdByAppId(appId);
 128         SysTryReturn(NID_APP, !pkgId.IsEmpty(), _API_VISIBILITY_PUBLIC, E_INVALID_STATE, "Invalid appId(%ls).", appId.GetPointer() );
 129
 130         Package::PackageInfo* pInfo = pPkg->GetPackageInfoN(pkgId);
 131         SysTryReturn(NID_APP, pInfo != null, _API_VISIBILITY_PUBLIC, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 132
 133         const Package::_PackageInfoImpl* pPkgInfo = Package::_PackageInfoImpl::GetInstance(pInfo);
 134         SysTryReturn(NID_APP, pPkgInfo != null, _API_VISIBILITY_PUBLIC, E_INVALID_STATE, "Invalid PackageInfo instance.");
 135
 136         return pPkgInfo->GetApiVisibility();
 137 }
 138
 139 bool
 140 _AppWidgetProviderInfoImpl::IsValidSize(const AppId& appId, int w, int h)
 141 {
 142         if (appId.StartsWith("com.samsung.", 0) == true)
 143         {
 144                 return true;
 145         }
 146
 147 //      static const int UNIT_SIZE_BASE = 175;
 148         static const int UNIT_SIZE_2 = 354;// UNIT_SIZE_BASE*n + 4*(n-1)
 149 //      static const int UNIT_SIZE_4 = 712;
 150
 151         int privilegeLevel = GetPrivilegeLevel(appId);
 152         if( privilegeLevel == _API_VISIBILITY_PUBLIC || privilegeLevel == _API_VISIBILITY_PARTNER)
 153         {
 154                  if( h > UNIT_SIZE_2 || w > UNIT_SIZE_2)
 155                  {
 156                          SysLog(NID_SHELL, "%dx%d size is invalid for %d privilege", privilegeLevel);
 157                          return false;
 158                  }
 159         }
 160         /*else if( size.height > UNIT_SIZE_4 || size.width > UNIT_SIZE_4)
 161         {
 162                 return false;
 163         }*/
 164         return true;
 165 }
 166
 167 Tizen::Base::Collection::IList*
 168 _AppWidgetProviderInfoImpl::GetSizeInfoListN() const
 169 {
 170         static const int MAX_SUPPORTED_SIZE_TYPE = 6;//TODO: check this value.
 171
 172         int supportedSizeCount = MAX_SUPPORTED_SIZE_TYPE;
 173         int widthArray[MAX_SUPPORTED_SIZE_TYPE];
 174         int heightArray[MAX_SUPPORTED_SIZE_TYPE];
 175
 176         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(__providerId));
 177         livebox_service_get_supported_sizes(pPackageId.get(), &supportedSizeCount , widthArray, heightArray);
 178
 179         SysTryReturn(NID_SHELL, supportedSizeCount > 0, null, E_INVALID_ARG, "[E_INVALID_ARG] There is no appwidget of provider(%ls)",__providerId.GetPointer() );
 180
 181         std::unique_ptr<ArrayList> pSizes(new (std::nothrow) ArrayList);
 182         SysTryReturn(NID_SHELL, pSizes, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to allocate memory for ArrayList." );
 183
 184         pSizes->Construct();
 185         FloatDimension size(0, 0);
 186         String previewImagePath;
 187
 188         for(int i = 0; i < supportedSizeCount; i++)
 189         {
 190                 size.SetSize(widthArray[i], heightArray[i]);
 191                 previewImagePath  = livebox_service_preview(pPackageId.get(), livebox_service_size_type(static_cast<int>(size.width), static_cast<int>(size.height) ) );
 192
 193                 if( IsValidSize(__appId, size.width, size.height) == false )
 194                 {
 195                         continue;
 196                 }
 197
 198                 std::unique_ptr<AppWidgetSizeInfo> pAppWidgetSizeInfo(_AppWidgetSizeInfoImpl::CreateAppWidgetSizeInfo(size, previewImagePath) );
 199                 SysTryReturn(NID_SHELL, pAppWidgetSizeInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to allocate memory for AppWidgetSizeInfo." );
 200                 pSizes->Add( *pAppWidgetSizeInfo.release() );
 201         }
 202         return pSizes.release();
 203 }
 204
 205 AppWidgetProviderInfo*
 206 _AppWidgetProviderInfoImpl::GetAppWidgetProviderInfoN(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName)
 207 {
 208         std::unique_ptr<char[]> pProviderId(_StringConverter::CopyToCharArrayN(_AppWidgetManagerImpl::MakeProviderName(appId, providerName)));
 209
 210         bool isDefault = livebox_service_is_primary(pProviderId.get());
 211         return GetAppWidgetProviderInfoN(appId, providerName, isDefault);
 212 }
 213
 214 AppWidgetProviderInfo*
 215 _AppWidgetProviderInfoImpl::GetAppWidgetProviderInfoN(const Tizen::App::AppId& appId, const Tizen::Base::String& providerName, bool isDefault)
 216 {
 217         AppWidgetProviderInfo* pInfo = new (std::nothrow) AppWidgetProviderInfo(appId, providerName);
 218         SysTryReturn(NID_SHELL, pInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to allocate memory for AppWidgetProviderInfo." );
 219
 220         _AppWidgetProviderInfoImpl::GetImpl(*pInfo)->__isDefault = isDefault;
 221
 222         return pInfo;
 223 }
 224
 225 _AppWidgetProviderInfoImpl*
 226 _AppWidgetProviderInfoImpl::GetImpl(const AppWidgetProviderInfo& appwidgetProviderInfo)
 227 {
 228         return static_cast<_AppWidgetProviderInfoImpl*>(appwidgetProviderInfo.__pAppWidgetProviderInfoImpl);
 229 }
 230
 231 } /* namespace AppWidget */
 232 } /* namespace Samsung */